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 |
|---|---|---|---|---|---|---|---|
clarify list type requirement | diff --git a/doc/source/user_guide/dsintro.rst b/doc/source/user_guide/dsintro.rst
index 9757a72f13fa8..bf831dc7b2215 100644
--- a/doc/source/user_guide/dsintro.rst
+++ b/doc/source/user_guide/dsintro.rst
@@ -418,7 +418,7 @@ can be passed into the DataFrame constructor.
Passing a list of dataclasses is equivalent to passing a list of dictionaries.
Please be aware, that all values in the list should be dataclasses, mixing
-types in the list would result in a ``TypeError``.
+types within the list would result in a ``TypeError``.
.. ipython:: python
| - [X] closes #58222
- [Doc] | https://api.github.com/repos/pandas-dev/pandas/pulls/58276 | 2024-04-16T11:02:18Z | 2024-04-16T17:00:43Z | null | 2024-04-16T17:00:43Z |
Avoid unnecessary re-opening of HDF5 files (Closes: #58248) | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 17328e6084cb4..237001df750c8 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -331,6 +331,7 @@ Performance improvements
- Performance improvement in :meth:`RangeIndex.reindex` returning a :class:`RangeIndex` instead of a :class:`Index` when possible. (:issue:`57647`, :issue:`57752`)
- Performance improvement in :meth:`RangeIndex.take` returning a :class:`RangeIndex` instead of a :class:`Index` when possible. (:issue:`57445`, :issue:`57752`)
- Performance improvement in :func:`merge` if hash-join can be used (:issue:`57970`)
+- Performance improvement in :meth:`to_hdf` avoid unnecessary reopenings of the HDF5 file to speedup data addition to files with a very large number of groups . (:issue:`58248`)
- Performance improvement in ``DataFrameGroupBy.__len__`` and ``SeriesGroupBy.__len__`` (:issue:`57595`)
- Performance improvement in indexing operations for string dtypes (:issue:`56997`)
- Performance improvement in unary methods on a :class:`RangeIndex` returning a :class:`RangeIndex` instead of a :class:`Index` when possible. (:issue:`57825`)
@@ -406,7 +407,6 @@ I/O
- Bug in :meth:`DataFrame.to_string` that raised ``StopIteration`` with nested DataFrames. (:issue:`16098`)
- Bug in :meth:`read_csv` raising ``TypeError`` when ``index_col`` is specified and ``na_values`` is a dict containing the key ``None``. (:issue:`57547`)
-
Period
^^^^^^
-
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 5ecf7e287ea58..3cfd740a51304 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -292,14 +292,14 @@ def to_hdf(
dropna=dropna,
)
- path_or_buf = stringify_path(path_or_buf)
- if isinstance(path_or_buf, str):
+ if isinstance(path_or_buf, HDFStore):
+ f(path_or_buf)
+ else:
+ path_or_buf = stringify_path(path_or_buf)
with HDFStore(
path_or_buf, mode=mode, complevel=complevel, complib=complib
) as store:
f(store)
- else:
- f(path_or_buf)
def read_hdf(
| - [X] closes #58248 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [X] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58275 | 2024-04-16T07:57:34Z | 2024-04-16T18:49:46Z | 2024-04-16T18:49:46Z | 2024-04-16T19:06:56Z |
Backport PR #58268 on branch 2.2.x (CI/TST: Unxfail test_slice_locs_negative_step Pyarrow test) | diff --git a/pandas/tests/indexes/object/test_indexing.py b/pandas/tests/indexes/object/test_indexing.py
index 443cacf94d239..ebf9dac715f8d 100644
--- a/pandas/tests/indexes/object/test_indexing.py
+++ b/pandas/tests/indexes/object/test_indexing.py
@@ -7,7 +7,6 @@
NA,
is_matching_na,
)
-from pandas.compat import pa_version_under16p0
import pandas.util._test_decorators as td
import pandas as pd
@@ -201,16 +200,7 @@ class TestSliceLocs:
(pd.IndexSlice["m":"m":-1], ""), # type: ignore[misc]
],
)
- def test_slice_locs_negative_step(self, in_slice, expected, dtype, request):
- if (
- not pa_version_under16p0
- and dtype == "string[pyarrow_numpy]"
- and in_slice == slice("a", "a", -1)
- ):
- request.applymarker(
- pytest.mark.xfail(reason="https://github.com/apache/arrow/issues/40642")
- )
-
+ def test_slice_locs_negative_step(self, in_slice, expected, dtype):
index = Index(list("bcdxy"), dtype=dtype)
s_start, s_stop = index.slice_locs(in_slice.start, in_slice.stop, in_slice.step)
| Backport PR #58268: CI/TST: Unxfail test_slice_locs_negative_step Pyarrow test | https://api.github.com/repos/pandas-dev/pandas/pulls/58269 | 2024-04-15T19:48:04Z | 2024-04-15T21:01:12Z | 2024-04-15T21:01:12Z | 2024-04-15T21:01:12Z |
CI/TST: Unxfail test_slice_locs_negative_step Pyarrow test | diff --git a/pandas/tests/indexes/object/test_indexing.py b/pandas/tests/indexes/object/test_indexing.py
index 34cc8eab4d812..039836da75cd5 100644
--- a/pandas/tests/indexes/object/test_indexing.py
+++ b/pandas/tests/indexes/object/test_indexing.py
@@ -7,7 +7,6 @@
NA,
is_matching_na,
)
-from pandas.compat import pa_version_under16p0
import pandas.util._test_decorators as td
import pandas as pd
@@ -202,16 +201,7 @@ class TestSliceLocs:
(pd.IndexSlice["m":"m":-1], ""), # type: ignore[misc]
],
)
- def test_slice_locs_negative_step(self, in_slice, expected, dtype, request):
- if (
- not pa_version_under16p0
- and dtype == "string[pyarrow_numpy]"
- and in_slice == slice("a", "a", -1)
- ):
- request.applymarker(
- pytest.mark.xfail(reason="https://github.com/apache/arrow/issues/40642")
- )
-
+ def test_slice_locs_negative_step(self, in_slice, expected, dtype):
index = Index(list("bcdxy"), dtype=dtype)
s_start, s_stop = index.slice_locs(in_slice.start, in_slice.stop, in_slice.step)
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/58268 | 2024-04-15T18:41:03Z | 2024-04-15T19:47:31Z | 2024-04-15T19:47:31Z | 2024-04-15T19:47:34Z |
REF: Clean up some iterator usages | diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index e36abdf0ad971..107608ec9f606 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -219,8 +219,7 @@ cdef _get_calendar(weekmask, holidays, calendar):
holidays = holidays + calendar.holidays().tolist()
except AttributeError:
pass
- holidays = [_to_dt64D(dt) for dt in holidays]
- holidays = tuple(sorted(holidays))
+ holidays = tuple(sorted(_to_dt64D(dt) for dt in holidays))
kwargs = {"weekmask": weekmask}
if holidays:
@@ -419,11 +418,10 @@ cdef class BaseOffset:
if "holidays" in all_paras and not all_paras["holidays"]:
all_paras.pop("holidays")
- exclude = ["kwds", "name", "calendar"]
- attrs = [(k, v) for k, v in all_paras.items()
- if (k not in exclude) and (k[0] != "_")]
- attrs = sorted(set(attrs))
- params = tuple([str(type(self))] + attrs)
+ exclude = {"kwds", "name", "calendar"}
+ attrs = {(k, v) for k, v in all_paras.items()
+ if (k not in exclude) and (k[0] != "_")}
+ params = tuple([str(type(self))] + sorted(attrs))
return params
@property
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index cd4812c3f78ae..b65a00db7d7df 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -2301,8 +2301,8 @@ def maybe_reorder(
exclude.update(index)
if any(exclude):
- arr_exclude = [x for x in exclude if x in arr_columns]
- to_remove = [arr_columns.get_loc(col) for col in arr_exclude]
+ arr_exclude = (x for x in exclude if x in arr_columns)
+ to_remove = {arr_columns.get_loc(col) for col in arr_exclude}
arrays = [v for i, v in enumerate(arrays) if i not in to_remove]
columns = columns.drop(exclude)
@@ -3705,7 +3705,7 @@ def transpose(
nv.validate_transpose(args, {})
# construct the args
- dtypes = list(self.dtypes)
+ first_dtype = self.dtypes.iloc[0] if len(self.columns) else None
if self._can_fast_transpose:
# Note: tests pass without this, but this improves perf quite a bit.
@@ -3723,11 +3723,11 @@ def transpose(
elif (
self._is_homogeneous_type
- and dtypes
- and isinstance(dtypes[0], ExtensionDtype)
+ and first_dtype is not None
+ and isinstance(first_dtype, ExtensionDtype)
):
new_values: list
- if isinstance(dtypes[0], BaseMaskedDtype):
+ if isinstance(first_dtype, BaseMaskedDtype):
# We have masked arrays with the same dtype. We can transpose faster.
from pandas.core.arrays.masked import (
transpose_homogeneous_masked_arrays,
@@ -3736,7 +3736,7 @@ def transpose(
new_values = transpose_homogeneous_masked_arrays(
cast(Sequence[BaseMaskedArray], self._iter_column_arrays())
)
- elif isinstance(dtypes[0], ArrowDtype):
+ elif isinstance(first_dtype, ArrowDtype):
# We have arrow EAs with the same dtype. We can transpose faster.
from pandas.core.arrays.arrow.array import (
ArrowExtensionArray,
@@ -3748,10 +3748,11 @@ def transpose(
)
else:
# We have other EAs with the same dtype. We preserve dtype in transpose.
- dtyp = dtypes[0]
- arr_typ = dtyp.construct_array_type()
+ arr_typ = first_dtype.construct_array_type()
values = self.values
- new_values = [arr_typ._from_sequence(row, dtype=dtyp) for row in values]
+ new_values = [
+ arr_typ._from_sequence(row, dtype=first_dtype) for row in values
+ ]
result = type(self)._from_arrays(
new_values,
@@ -5882,7 +5883,7 @@ def set_index(
else:
arrays.append(self.index)
- to_remove: list[Hashable] = []
+ to_remove: set[Hashable] = set()
for col in keys:
if isinstance(col, MultiIndex):
arrays.extend(col._get_level_values(n) for n in range(col.nlevels))
@@ -5909,7 +5910,7 @@ def set_index(
arrays.append(frame[col])
names.append(col)
if drop:
- to_remove.append(col)
+ to_remove.add(col)
if len(arrays[-1]) != len(self):
# check newest element against length of calling frame, since
@@ -5926,7 +5927,7 @@ def set_index(
raise ValueError(f"Index has duplicate keys: {duplicates}")
# use set to handle duplicate column names gracefully in case of drop
- for c in set(to_remove):
+ for c in to_remove:
del frame[c]
# clear up memory usage
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 523ca9de201bf..9686c081b5fb3 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -2045,7 +2045,7 @@ def __setstate__(self, state) -> None:
# e.g. say fill_value needing _mgr to be
# defined
meta = set(self._internal_names + self._metadata)
- for k in list(meta):
+ for k in meta:
if k in state and k != "_flags":
v = state[k]
object.__setattr__(self, k, v)
diff --git a/pandas/core/internals/construction.py b/pandas/core/internals/construction.py
index 73b93110c9018..cea52bf8c91b2 100644
--- a/pandas/core/internals/construction.py
+++ b/pandas/core/internals/construction.py
@@ -567,7 +567,7 @@ def _extract_index(data) -> Index:
if len(data) == 0:
return default_index(0)
- raw_lengths = []
+ raw_lengths = set()
indexes: list[list[Hashable] | Index] = []
have_raw_arrays = False
@@ -583,7 +583,7 @@ def _extract_index(data) -> Index:
indexes.append(list(val.keys()))
elif is_list_like(val) and getattr(val, "ndim", 1) == 1:
have_raw_arrays = True
- raw_lengths.append(len(val))
+ raw_lengths.add(len(val))
elif isinstance(val, np.ndarray) and val.ndim > 1:
raise ValueError("Per-column arrays must each be 1-dimensional")
@@ -596,24 +596,23 @@ def _extract_index(data) -> Index:
index = union_indexes(indexes, sort=False)
if have_raw_arrays:
- lengths = list(set(raw_lengths))
- if len(lengths) > 1:
+ if len(raw_lengths) > 1:
raise ValueError("All arrays must be of the same length")
if have_dicts:
raise ValueError(
"Mixing dicts with non-Series may lead to ambiguous ordering."
)
-
+ raw_length = raw_lengths.pop()
if have_series:
- if lengths[0] != len(index):
+ if raw_length != len(index):
msg = (
- f"array length {lengths[0]} does not match index "
+ f"array length {raw_length} does not match index "
f"length {len(index)}"
)
raise ValueError(msg)
else:
- index = default_index(lengths[0])
+ index = default_index(raw_length)
return ensure_index(index)
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index 2aeb1aff07a54..df7a6cdb1ea52 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -1124,18 +1124,18 @@ def f(value):
# we require at least Ymd
required = ["year", "month", "day"]
- req = sorted(set(required) - set(unit_rev.keys()))
+ req = set(required) - set(unit_rev.keys())
if len(req):
- _required = ",".join(req)
+ _required = ",".join(sorted(req))
raise ValueError(
"to assemble mappings requires at least that "
f"[year, month, day] be specified: [{_required}] is missing"
)
# keys we don't recognize
- excess = sorted(set(unit_rev.keys()) - set(_unit_map.values()))
+ excess = set(unit_rev.keys()) - set(_unit_map.values())
if len(excess):
- _excess = ",".join(excess)
+ _excess = ",".join(sorted(excess))
raise ValueError(
f"extra keys have been passed to the datetime assemblage: [{_excess}]"
)
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/58267 | 2024-04-15T18:29:27Z | 2024-04-16T18:28:30Z | 2024-04-16T18:28:30Z | 2024-04-16T18:28:33Z |
DOC: Enforce Numpy Docstring Validation for pandas.Float32Dtype and pandas.Float64Dtype | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 01baadab67dbd..66f6bfd7195f9 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -153,8 +153,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DatetimeTZDtype SA01" \
-i "pandas.DatetimeTZDtype.tz SA01" \
-i "pandas.DatetimeTZDtype.unit SA01" \
- -i "pandas.Float32Dtype SA01" \
- -i "pandas.Float64Dtype SA01" \
-i "pandas.Grouper PR02,SA01" \
-i "pandas.HDFStore.append PR01,SA01" \
-i "pandas.HDFStore.get SA01" \
diff --git a/pandas/core/arrays/floating.py b/pandas/core/arrays/floating.py
index 74b8cfb65cbc7..653e63e9d1e2d 100644
--- a/pandas/core/arrays/floating.py
+++ b/pandas/core/arrays/floating.py
@@ -135,6 +135,12 @@ class FloatingArray(NumericArray):
-------
None
+See Also
+--------
+CategoricalDtype : Type for categorical data with the categories and orderedness.
+IntegerDtype : An ExtensionDtype to hold a single size & kind of integer dtype.
+StringDtype : An ExtensionDtype for string data.
+
Examples
--------
For Float32Dtype:
| - [ ] xref #58067
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58266 | 2024-04-15T18:18:59Z | 2024-04-15T19:48:32Z | 2024-04-15T19:48:32Z | 2024-04-16T03:55:37Z |
DOC: Move whatsnew 3.0 elements | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index ca0285ade466d..5493320f803f0 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -339,19 +339,6 @@ Performance improvements
Bug fixes
~~~~~~~~~
-- Fixed bug in :class:`SparseDtype` for equal comparison with na fill value. (:issue:`54770`)
-- Fixed bug in :meth:`.DataFrameGroupBy.median` where nat values gave an incorrect result. (:issue:`57926`)
-- Fixed bug in :meth:`DataFrame.cumsum` which was raising ``IndexError`` if dtype is ``timedelta64[ns]`` (:issue:`57956`)
-- Fixed bug in :meth:`DataFrame.eval` and :meth:`DataFrame.query` which caused an exception when using NumPy attributes via ``@`` notation, e.g., ``df.eval("@np.floor(a)")``. (:issue:`58041`)
-- Fixed bug in :meth:`DataFrame.join` inconsistently setting result index name (:issue:`55815`)
-- Fixed bug in :meth:`DataFrame.to_string` that raised ``StopIteration`` with nested DataFrames. (:issue:`16098`)
-- Fixed bug in :meth:`DataFrame.transform` that was returning the wrong order unless the index was monotonically increasing. (:issue:`57069`)
-- Fixed bug in :meth:`DataFrame.update` bool dtype being converted to object (:issue:`55509`)
-- Fixed bug in :meth:`DataFrameGroupBy.apply` that was returning a completely empty DataFrame when all return values of ``func`` were ``None`` instead of returning an empty DataFrame with the original columns and dtypes. (:issue:`57775`)
-- Fixed bug in :meth:`Series.diff` allowing non-integer values for the ``periods`` argument. (:issue:`56607`)
-- Fixed bug in :meth:`Series.rank` that doesn't preserve missing values for nullable integers when ``na_option='keep'``. (:issue:`56976`)
-- Fixed bug in :meth:`Series.replace` and :meth:`DataFrame.replace` inconsistently replacing matching instances when ``regex=True`` and missing values are present. (:issue:`56599`)
-- Fixed bug in :meth:`read_csv` raising ``TypeError`` when ``index_col`` is specified and ``na_values`` is a dict containing the key ``None``. (:issue:`57547`)
Categorical
^^^^^^^^^^^
@@ -363,12 +350,12 @@ Datetimelike
- Bug in :class:`Timestamp` constructor failing to raise when ``tz=None`` is explicitly specified in conjunction with timezone-aware ``tzinfo`` or data (:issue:`48688`)
- Bug in :func:`date_range` where the last valid timestamp would sometimes not be produced (:issue:`56134`)
- Bug in :func:`date_range` where using a negative frequency value would not include all points between the start and end values (:issue:`56382`)
--
+- Bug in :func:`tseries.api.guess_datetime_format` would fail to infer time format when "%Y" == "%H%M" (:issue:`57452`)
Timedelta
^^^^^^^^^
- Accuracy improvement in :meth:`Timedelta.to_pytimedelta` to round microseconds consistently for large nanosecond based Timedelta (:issue:`57841`)
--
+- Bug in :meth:`DataFrame.cumsum` which was raising ``IndexError`` if dtype is ``timedelta64[ns]`` (:issue:`57956`)
Timezones
^^^^^^^^^
@@ -382,6 +369,7 @@ Numeric
Conversion
^^^^^^^^^^
+- Bug in :meth:`DataFrame.update` bool dtype being converted to object (:issue:`55509`)
- Bug in :meth:`Series.astype` might modify read-only array inplace when casting to a string dtype (:issue:`57212`)
- Bug in :meth:`Series.reindex` not maintaining ``float32`` type when a ``reindex`` introduces a missing value (:issue:`45857`)
@@ -412,10 +400,11 @@ MultiIndex
I/O
^^^
+- Bug in :class:`DataFrame` and :class:`Series` ``repr`` of :py:class:`collections.abc.Mapping`` elements. (:issue:`57915`)
- Bug in :meth:`DataFrame.to_excel` when writing empty :class:`DataFrame` with :class:`MultiIndex` on both axes (:issue:`57696`)
-- Now all ``Mapping`` s are pretty printed correctly. Before only literal ``dict`` s were. (:issue:`57915`)
--
--
+- Bug in :meth:`DataFrame.to_string` that raised ``StopIteration`` with nested DataFrames. (:issue:`16098`)
+- Bug in :meth:`read_csv` raising ``TypeError`` when ``index_col`` is specified and ``na_values`` is a dict containing the key ``None``. (:issue:`57547`)
+
Period
^^^^^^
@@ -430,23 +419,25 @@ Plotting
Groupby/resample/rolling
^^^^^^^^^^^^^^^^^^^^^^^^
- Bug in :meth:`.DataFrameGroupBy.groups` and :meth:`.SeriesGroupby.groups` that would not respect groupby argument ``dropna`` (:issue:`55919`)
+- Bug in :meth:`.DataFrameGroupBy.median` where nat values gave an incorrect result. (:issue:`57926`)
- Bug in :meth:`.DataFrameGroupBy.quantile` when ``interpolation="nearest"`` is inconsistent with :meth:`DataFrame.quantile` (:issue:`47942`)
- Bug in :meth:`DataFrame.ewm` and :meth:`Series.ewm` when passed ``times`` and aggregation functions other than mean (:issue:`51695`)
--
+- Bug in :meth:`DataFrameGroupBy.apply` that was returning a completely empty DataFrame when all return values of ``func`` were ``None`` instead of returning an empty DataFrame with the original columns and dtypes. (:issue:`57775`)
+
Reshaping
^^^^^^^^^
--
+- Bug in :meth:`DataFrame.join` inconsistently setting result index name (:issue:`55815`)
-
Sparse
^^^^^^
--
+- Bug in :class:`SparseDtype` for equal comparison with na fill value. (:issue:`54770`)
-
ExtensionArray
^^^^^^^^^^^^^^
-- Fixed bug in :meth:`api.types.is_datetime64_any_dtype` where a custom :class:`ExtensionDtype` would return ``False`` for array-likes (:issue:`57055`)
+- Bug in :meth:`api.types.is_datetime64_any_dtype` where a custom :class:`ExtensionDtype` would return ``False`` for array-likes (:issue:`57055`)
-
Styler
@@ -456,11 +447,15 @@ Styler
Other
^^^^^
- Bug in :class:`DataFrame` when passing a ``dict`` with a NA scalar and ``columns`` that would always return ``np.nan`` (:issue:`57205`)
-- Bug in :func:`tseries.api.guess_datetime_format` would fail to infer time format when "%Y" == "%H%M" (:issue:`57452`)
- Bug in :func:`unique` on :class:`Index` not always returning :class:`Index` (:issue:`57043`)
+- Bug in :meth:`DataFrame.eval` and :meth:`DataFrame.query` which caused an exception when using NumPy attributes via ``@`` notation, e.g., ``df.eval("@np.floor(a)")``. (:issue:`58041`)
- Bug in :meth:`DataFrame.sort_index` when passing ``axis="columns"`` and ``ignore_index=True`` and ``ascending=False`` not returning a :class:`RangeIndex` columns (:issue:`57293`)
+- Bug in :meth:`DataFrame.transform` that was returning the wrong order unless the index was monotonically increasing. (:issue:`57069`)
- Bug in :meth:`DataFrame.where` where using a non-bool type array in the function would return a ``ValueError`` instead of a ``TypeError`` (:issue:`56330`)
- Bug in :meth:`Index.sort_values` when passing a key function that turns values into tuples, e.g. ``key=natsort.natsort_key``, would raise ``TypeError`` (:issue:`56081`)
+- Bug in :meth:`Series.diff` allowing non-integer values for the ``periods`` argument. (:issue:`56607`)
+- Bug in :meth:`Series.rank` that doesn't preserve missing values for nullable integers when ``na_option='keep'``. (:issue:`56976`)
+- Bug in :meth:`Series.replace` and :meth:`DataFrame.replace` inconsistently replacing matching instances when ``regex=True`` and missing values are present. (:issue:`56599`)
- Bug in Dataframe Interchange Protocol implementation was returning incorrect results for data buffers' associated dtype, for string and datetime columns (:issue:`54781`)
.. ***DO NOT USE THIS SECTION***
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/58265 | 2024-04-15T17:38:54Z | 2024-04-15T18:41:50Z | 2024-04-15T18:41:50Z | 2024-04-15T18:41:53Z |
DOC: Reference Excel reader installation in the read and write tabular data tutorial | diff --git a/doc/source/getting_started/install.rst b/doc/source/getting_started/install.rst
index 3cd9e030d6b3c..cf5f15ceb8344 100644
--- a/doc/source/getting_started/install.rst
+++ b/doc/source/getting_started/install.rst
@@ -269,6 +269,8 @@ SciPy 1.10.0 computation Miscellaneous stati
xarray 2022.12.0 computation pandas-like API for N-dimensional data
========================= ================== =============== =============================================================
+.. _install.excel_dependencies:
+
Excel files
^^^^^^^^^^^
diff --git a/doc/source/getting_started/intro_tutorials/02_read_write.rst b/doc/source/getting_started/intro_tutorials/02_read_write.rst
index ae658ec6abbaf..aa032b186aeb9 100644
--- a/doc/source/getting_started/intro_tutorials/02_read_write.rst
+++ b/doc/source/getting_started/intro_tutorials/02_read_write.rst
@@ -111,6 +111,12 @@ strings (``object``).
My colleague requested the Titanic data as a spreadsheet.
+.. note::
+ If you want to use :func:`~pandas.to_excel` and :func:`~pandas.read_excel`,
+ you need to install an Excel reader as outlined in the
+ :ref:`Excel files <install.excel_dependencies>` section of the
+ installation documentation.
+
.. ipython:: python
titanic.to_excel("titanic.xlsx", sheet_name="passengers", index=False)
| Created a link to the Excel file recommended installation section and referenced it in the `How do I read and write tabular data?` tutorial.
- [x] closes #58246
The below are not applicable because I am just updating documentation.
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58261 | 2024-04-15T04:51:29Z | 2024-04-15T16:47:31Z | 2024-04-15T16:47:31Z | 2024-04-15T16:47:44Z |
DOC: replace deprecated frequency alias | diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index f4f076103d8c3..8ada9d88e08bc 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -1787,7 +1787,7 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
----------
freq : str or Offset
The frequency level to {op} the index to. Must be a fixed
- frequency like 'S' (second) not 'ME' (month end). See
+ frequency like 's' (second) not 'ME' (month end). See
:ref:`frequency aliases <timeseries.offset_aliases>` for
a list of possible `freq` values.
ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
| replace 'S' with 's'
Dreprecated since version 2.2.0 https://pandas.pydata.org/docs/whatsnew/v2.2.0.html#other-deprecations.
See https://github.com/pandas-dev/pandas/issues/52536
- ~~[ ] closes #xxxx (Replace xxxx with the GitHub issue number)~~
- ~~[ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature~~
- ~~[ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).~~
- ~~[ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.~~
- ~~[ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.~~
| https://api.github.com/repos/pandas-dev/pandas/pulls/58256 | 2024-04-14T14:11:16Z | 2024-04-16T17:12:19Z | 2024-04-16T17:12:19Z | 2024-04-16T17:12:29Z |
DEPR: logical ops with dtype-less sequences | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 50643454bbcec..f709bec842c86 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -208,6 +208,7 @@ Removal of prior version deprecations/changes
- :meth:`SeriesGroupBy.agg` no longer pins the name of the group to the input passed to the provided ``func`` (:issue:`51703`)
- All arguments except ``name`` in :meth:`Index.rename` are now keyword only (:issue:`56493`)
- All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`)
+- Disallow allowing logical operations (``||``, ``&``, ``^``) between pandas objects and dtype-less sequences (e.g. ``list``, ``tuple``); wrap the objects in :class:`Series`, :class:`Index`, or ``np.array`` first instead (:issue:`52264`)
- Disallow automatic casting to object in :class:`Series` logical operations (``&``, ``^``, ``||``) between series with mismatched indexes and dtypes other than ``object`` or ``bool`` (:issue:`52538`)
- Disallow calling :meth:`Series.replace` or :meth:`DataFrame.replace` without a ``value`` and with non-dict-like ``to_replace`` (:issue:`33302`)
- Disallow constructing a :class:`arrays.SparseArray` with scalar data (:issue:`53039`)
diff --git a/pandas/core/ops/array_ops.py b/pandas/core/ops/array_ops.py
index 810e30d369729..983a3df57e369 100644
--- a/pandas/core/ops/array_ops.py
+++ b/pandas/core/ops/array_ops.py
@@ -12,7 +12,6 @@
TYPE_CHECKING,
Any,
)
-import warnings
import numpy as np
@@ -29,7 +28,6 @@
is_supported_dtype,
is_unitless,
)
-from pandas.util._exceptions import find_stack_level
from pandas.core.dtypes.cast import (
construct_1d_object_array_from_listlike,
@@ -424,15 +422,13 @@ def fill_bool(x, left=None):
right = lib.item_from_zerodim(right)
if is_list_like(right) and not hasattr(right, "dtype"):
# e.g. list, tuple
- warnings.warn(
+ raise TypeError(
+ # GH#52264
"Logical ops (and, or, xor) between Pandas objects and dtype-less "
- "sequences (e.g. list, tuple) are deprecated and will raise in a "
- "future version. Wrap the object in a Series, Index, or np.array "
+ "sequences (e.g. list, tuple) are no longer supported. "
+ "Wrap the object in a Series, Index, or np.array "
"before operating instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
)
- right = construct_1d_object_array_from_listlike(right)
# NB: We assume extract_array has already been called on left and right
lvalues = ensure_wrapped_if_datetimelike(left)
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 00f48bf3b1d78..44bf3475b85a6 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -807,9 +807,6 @@ def test_series_ops_name_retention(self, flex, box, names, all_binary_operators)
r"Logical ops \(and, or, xor\) between Pandas objects and "
"dtype-less sequences"
)
- warn = None
- if box in [list, tuple] and is_logical:
- warn = FutureWarning
right = box(right)
if flex:
@@ -818,9 +815,12 @@ def test_series_ops_name_retention(self, flex, box, names, all_binary_operators)
return
result = getattr(left, name)(right)
else:
- # GH#37374 logical ops behaving as set ops deprecated
- with tm.assert_produces_warning(warn, match=msg):
- result = op(left, right)
+ if is_logical and box in [list, tuple]:
+ with pytest.raises(TypeError, match=msg):
+ # GH#52264 logical ops with dtype-less sequences deprecated
+ op(left, right)
+ return
+ result = op(left, right)
assert isinstance(result, Series)
if box in [Index, Series]:
diff --git a/pandas/tests/series/test_logical_ops.py b/pandas/tests/series/test_logical_ops.py
index dfc3309a8e449..f59eacea3fe6c 100644
--- a/pandas/tests/series/test_logical_ops.py
+++ b/pandas/tests/series/test_logical_ops.py
@@ -86,7 +86,7 @@ def test_logical_operators_int_dtype_with_float(self):
# GH#9016: support bitwise op for integer types
s_0123 = Series(range(4), dtype="int64")
- warn_msg = (
+ err_msg = (
r"Logical ops \(and, or, xor\) between Pandas objects and "
"dtype-less sequences"
)
@@ -97,9 +97,8 @@ def test_logical_operators_int_dtype_with_float(self):
with pytest.raises(TypeError, match=msg):
s_0123 & 3.14
msg = "unsupported operand type.+for &:"
- with pytest.raises(TypeError, match=msg):
- with tm.assert_produces_warning(FutureWarning, match=warn_msg):
- s_0123 & [0.1, 4, 3.14, 2]
+ with pytest.raises(TypeError, match=err_msg):
+ s_0123 & [0.1, 4, 3.14, 2]
with pytest.raises(TypeError, match=msg):
s_0123 & np.array([0.1, 4, 3.14, 2])
with pytest.raises(TypeError, match=msg):
@@ -108,7 +107,7 @@ def test_logical_operators_int_dtype_with_float(self):
def test_logical_operators_int_dtype_with_str(self):
s_1111 = Series([1] * 4, dtype="int8")
- warn_msg = (
+ err_msg = (
r"Logical ops \(and, or, xor\) between Pandas objects and "
"dtype-less sequences"
)
@@ -116,9 +115,8 @@ def test_logical_operators_int_dtype_with_str(self):
msg = "Cannot perform 'and_' with a dtyped.+array and scalar of type"
with pytest.raises(TypeError, match=msg):
s_1111 & "a"
- with pytest.raises(TypeError, match="unsupported operand.+for &"):
- with tm.assert_produces_warning(FutureWarning, match=warn_msg):
- s_1111 & ["a", "b", "c", "d"]
+ with pytest.raises(TypeError, match=err_msg):
+ s_1111 & ["a", "b", "c", "d"]
def test_logical_operators_int_dtype_with_bool(self):
# GH#9016: support bitwise op for integer types
@@ -129,17 +127,15 @@ def test_logical_operators_int_dtype_with_bool(self):
result = s_0123 & False
tm.assert_series_equal(result, expected)
- warn_msg = (
+ msg = (
r"Logical ops \(and, or, xor\) between Pandas objects and "
"dtype-less sequences"
)
- with tm.assert_produces_warning(FutureWarning, match=warn_msg):
- result = s_0123 & [False]
- tm.assert_series_equal(result, expected)
+ with pytest.raises(TypeError, match=msg):
+ s_0123 & [False]
- with tm.assert_produces_warning(FutureWarning, match=warn_msg):
- result = s_0123 & (False,)
- tm.assert_series_equal(result, expected)
+ with pytest.raises(TypeError, match=msg):
+ s_0123 & (False,)
result = s_0123 ^ False
expected = Series([False, True, True, True])
@@ -188,9 +184,8 @@ def test_logical_ops_bool_dtype_with_ndarray(self):
)
expected = Series([True, False, False, False, False])
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = left & right
- tm.assert_series_equal(result, expected)
+ with pytest.raises(TypeError, match=msg):
+ left & right
result = left & np.array(right)
tm.assert_series_equal(result, expected)
result = left & Index(right)
@@ -199,9 +194,8 @@ def test_logical_ops_bool_dtype_with_ndarray(self):
tm.assert_series_equal(result, expected)
expected = Series([True, True, True, True, True])
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = left | right
- tm.assert_series_equal(result, expected)
+ with pytest.raises(TypeError, match=msg):
+ left | right
result = left | np.array(right)
tm.assert_series_equal(result, expected)
result = left | Index(right)
@@ -210,9 +204,8 @@ def test_logical_ops_bool_dtype_with_ndarray(self):
tm.assert_series_equal(result, expected)
expected = Series([False, True, True, True, True])
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = left ^ right
- tm.assert_series_equal(result, expected)
+ with pytest.raises(TypeError, match=msg):
+ left ^ right
result = left ^ np.array(right)
tm.assert_series_equal(result, expected)
result = left ^ Index(right)
@@ -269,9 +262,8 @@ def test_scalar_na_logical_ops_corners(self):
r"Logical ops \(and, or, xor\) between Pandas objects and "
"dtype-less sequences"
)
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = s & list(s)
- tm.assert_series_equal(result, expected)
+ with pytest.raises(TypeError, match=msg):
+ s & list(s)
def test_scalar_na_logical_ops_corners_aligns(self):
s = Series([2, 3, 4, 5, 6, 7, 8, 9, datetime(2005, 1, 1)])
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58242 | 2024-04-12T21:20:54Z | 2024-04-14T19:13:24Z | 2024-04-14T19:13:24Z | 2024-04-15T15:28:55Z |
DEPR: object casting in Series logical ops in non-bool cases | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index e05cc87d1af14..50643454bbcec 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -208,6 +208,7 @@ Removal of prior version deprecations/changes
- :meth:`SeriesGroupBy.agg` no longer pins the name of the group to the input passed to the provided ``func`` (:issue:`51703`)
- All arguments except ``name`` in :meth:`Index.rename` are now keyword only (:issue:`56493`)
- All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`)
+- Disallow automatic casting to object in :class:`Series` logical operations (``&``, ``^``, ``||``) between series with mismatched indexes and dtypes other than ``object`` or ``bool`` (:issue:`52538`)
- Disallow calling :meth:`Series.replace` or :meth:`DataFrame.replace` without a ``value`` and with non-dict-like ``to_replace`` (:issue:`33302`)
- Disallow constructing a :class:`arrays.SparseArray` with scalar data (:issue:`53039`)
- Disallow non-standard (``np.ndarray``, :class:`Index`, :class:`ExtensionArray`, or :class:`Series`) to :func:`isin`, :func:`unique`, :func:`factorize` (:issue:`52986`)
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 0f796964eb56d..ab24b224b0957 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -5859,17 +5859,12 @@ def _align_for_op(self, right, align_asobject: bool = False):
object,
np.bool_,
):
- warnings.warn(
- "Operation between non boolean Series with different "
- "indexes will no longer return a boolean result in "
- "a future version. Cast both Series to object type "
- "to maintain the prior behavior.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
- # to keep original value's dtype for bool ops
- left = left.astype(object)
- right = right.astype(object)
+ pass
+ # GH#52538 no longer cast in these cases
+ else:
+ # to keep original value's dtype for bool ops
+ left = left.astype(object)
+ right = right.astype(object)
left, right = left.align(right)
diff --git a/pandas/tests/series/test_logical_ops.py b/pandas/tests/series/test_logical_ops.py
index b76b69289b72f..dfc3309a8e449 100644
--- a/pandas/tests/series/test_logical_ops.py
+++ b/pandas/tests/series/test_logical_ops.py
@@ -233,26 +233,22 @@ def test_logical_operators_int_dtype_with_bool_dtype_and_reindex(self):
# s_0123 will be all false now because of reindexing like s_tft
expected = Series([False] * 7, index=[0, 1, 2, 3, "a", "b", "c"])
- with tm.assert_produces_warning(FutureWarning):
- result = s_tft & s_0123
+ result = s_tft & s_0123
tm.assert_series_equal(result, expected)
- # GH 52538: Deprecate casting to object type when reindex is needed;
+ # GH#52538: no longer to object type when reindex is needed;
# matches DataFrame behavior
- expected = Series([False] * 7, index=[0, 1, 2, 3, "a", "b", "c"])
- with tm.assert_produces_warning(FutureWarning):
- result = s_0123 & s_tft
- tm.assert_series_equal(result, expected)
+ msg = r"unsupported operand type\(s\) for &: 'float' and 'bool'"
+ with pytest.raises(TypeError, match=msg):
+ s_0123 & s_tft
s_a0b1c0 = Series([1], list("b"))
- with tm.assert_produces_warning(FutureWarning):
- res = s_tft & s_a0b1c0
+ res = s_tft & s_a0b1c0
expected = s_tff.reindex(list("abc"))
tm.assert_series_equal(res, expected)
- with tm.assert_produces_warning(FutureWarning):
- res = s_tft | s_a0b1c0
+ res = s_tft | s_a0b1c0
expected = s_tft.reindex(list("abc"))
tm.assert_series_equal(res, expected)
@@ -405,27 +401,24 @@ def test_logical_ops_label_based(self, using_infer_string):
tm.assert_series_equal(result, expected)
# vs non-matching
- with tm.assert_produces_warning(FutureWarning):
- result = a & Series([1], ["z"])
+ result = a & Series([1], ["z"])
expected = Series([False, False, False, False], list("abcz"))
tm.assert_series_equal(result, expected)
- with tm.assert_produces_warning(FutureWarning):
- result = a | Series([1], ["z"])
+ result = a | Series([1], ["z"])
expected = Series([True, True, False, False], list("abcz"))
tm.assert_series_equal(result, expected)
# identity
# we would like s[s|e] == s to hold for any e, whether empty or not
- with tm.assert_produces_warning(FutureWarning):
- for e in [
- empty.copy(),
- Series([1], ["z"]),
- Series(np.nan, b.index),
- Series(np.nan, a.index),
- ]:
- result = a[a | e]
- tm.assert_series_equal(result, a[a])
+ for e in [
+ empty.copy(),
+ Series([1], ["z"]),
+ Series(np.nan, b.index),
+ Series(np.nan, a.index),
+ ]:
+ result = a[a | e]
+ tm.assert_series_equal(result, a[a])
for e in [Series(["z"])]:
warn = FutureWarning if using_infer_string else None
@@ -519,7 +512,6 @@ def test_logical_ops_df_compat(self):
tm.assert_frame_equal(s3.to_frame() | s4.to_frame(), exp_or1.to_frame())
tm.assert_frame_equal(s4.to_frame() | s3.to_frame(), exp_or.to_frame())
- @pytest.mark.xfail(reason="Will pass once #52839 deprecation is enforced")
def test_int_dtype_different_index_not_bool(self):
# GH 52500
ser1 = Series([1, 2, 3], index=[10, 11, 23], name="a")
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58241 | 2024-04-12T21:06:29Z | 2024-04-13T00:14:38Z | 2024-04-13T00:14:38Z | 2024-04-13T14:49:50Z |
API: Expose api.typing.FrozenList for typing | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index e05cc87d1af14..6e4fef387fdfb 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -28,6 +28,7 @@ enhancement2
Other enhancements
^^^^^^^^^^^^^^^^^^
+- :class:`pandas.api.typing.FrozenList` is available for typing the outputs of :attr:`MultiIndex.names`, :attr:`MultiIndex.codes` and :attr:`MultiIndex.levels` (:issue:`58237`)
- :func:`DataFrame.to_excel` now raises an ``UserWarning`` when the character count in a cell exceeds Excel's limitation of 32767 characters (:issue:`56954`)
- :func:`read_stata` now returns ``datetime64`` resolutions better matching those natively stored in the stata format (:issue:`55642`)
- :meth:`Styler.set_tooltips` provides alternative method to storing tooltips by using title attribute of td elements. (:issue:`56981`)
diff --git a/pandas/api/typing/__init__.py b/pandas/api/typing/__init__.py
index 9b5d2cb06b523..df6392bf692a2 100644
--- a/pandas/api/typing/__init__.py
+++ b/pandas/api/typing/__init__.py
@@ -9,6 +9,7 @@
DataFrameGroupBy,
SeriesGroupBy,
)
+from pandas.core.indexes.frozen import FrozenList
from pandas.core.resample import (
DatetimeIndexResamplerGroupby,
PeriodIndexResamplerGroupby,
@@ -38,6 +39,7 @@
"ExpandingGroupby",
"ExponentialMovingWindow",
"ExponentialMovingWindowGroupby",
+ "FrozenList",
"JsonReader",
"NaTType",
"NAType",
diff --git a/pandas/tests/api/test_api.py b/pandas/tests/api/test_api.py
index e32e5a268d46d..dd4c81a462b79 100644
--- a/pandas/tests/api/test_api.py
+++ b/pandas/tests/api/test_api.py
@@ -256,6 +256,7 @@ class TestApi(Base):
"ExpandingGroupby",
"ExponentialMovingWindow",
"ExponentialMovingWindowGroupby",
+ "FrozenList",
"JsonReader",
"NaTType",
"NAType",
| Since it was decided not to remove this in favor of `tuple` https://github.com/pandas-dev/pandas/pull/57788, exposing `FrozenList` in `.api.typing` instead | https://api.github.com/repos/pandas-dev/pandas/pulls/58237 | 2024-04-12T18:56:06Z | 2024-04-15T20:40:52Z | 2024-04-15T20:40:52Z | 2024-04-15T20:42:02Z |
DOC: Enforce Numpy Docstring Validation for pandas.ExcelFile, pandas.ExcelFile.parse and pandas.ExcelWriter | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 9c39fac13b230..70cc160cb4904 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -154,9 +154,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DatetimeTZDtype SA01" \
-i "pandas.DatetimeTZDtype.tz SA01" \
-i "pandas.DatetimeTZDtype.unit SA01" \
- -i "pandas.ExcelFile PR01,SA01" \
- -i "pandas.ExcelFile.parse PR01,SA01" \
- -i "pandas.ExcelWriter SA01" \
-i "pandas.Float32Dtype SA01" \
-i "pandas.Float64Dtype SA01" \
-i "pandas.Grouper PR02,SA01" \
diff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py
index a9da95054b81a..2b35cfa044ae9 100644
--- a/pandas/io/excel/_base.py
+++ b/pandas/io/excel/_base.py
@@ -979,6 +979,12 @@ class ExcelWriter(Generic[_WorkbookT]):
.. versionadded:: 1.3.0
+ See Also
+ --------
+ read_excel : Read an Excel sheet values (xlsx) file into DataFrame.
+ read_csv : Read a comma-separated values (csv) file into DataFrame.
+ read_fwf : Read a table of fixed-width formatted lines into DataFrame.
+
Notes
-----
For compatibility with CSV writers, ExcelWriter serializes lists
@@ -1434,6 +1440,7 @@ def inspect_excel_format(
return "zip"
+@doc(storage_options=_shared_docs["storage_options"])
class ExcelFile:
"""
Class for parsing tabular Excel sheets into DataFrame objects.
@@ -1472,19 +1479,27 @@ class ExcelFile:
- Otherwise if ``path_or_buffer`` is in xlsb format,
`pyxlsb <https://pypi.org/project/pyxlsb/>`_ will be used.
- .. versionadded:: 1.3.0
+ .. versionadded:: 1.3.0
- Otherwise if `openpyxl <https://pypi.org/project/openpyxl/>`_ is installed,
then ``openpyxl`` will be used.
- Otherwise if ``xlrd >= 2.0`` is installed, a ``ValueError`` will be raised.
- .. warning::
+ .. warning::
- Please do not report issues when using ``xlrd`` to read ``.xlsx`` files.
- This is not supported, switch to using ``openpyxl`` instead.
+ Please do not report issues when using ``xlrd`` to read ``.xlsx`` files.
+ This is not supported, switch to using ``openpyxl`` instead.
+ {storage_options}
engine_kwargs : dict, optional
Arbitrary keyword arguments passed to excel engine.
+ See Also
+ --------
+ DataFrame.to_excel : Write DataFrame to an Excel file.
+ DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
+ read_csv : Read a comma-separated values (csv) file into DataFrame.
+ read_fwf : Read a table of fixed-width formatted lines into DataFrame.
+
Examples
--------
>>> file = pd.ExcelFile("myfile.xlsx") # doctest: +SKIP
@@ -1595,11 +1610,134 @@ def parse(
Equivalent to read_excel(ExcelFile, ...) See the read_excel
docstring for more info on accepted parameters.
+ Parameters
+ ----------
+ sheet_name : str, int, list, or None, default 0
+ Strings are used for sheet names. Integers are used in zero-indexed
+ sheet positions (chart sheets do not count as a sheet position).
+ Lists of strings/integers are used to request multiple sheets.
+ Specify ``None`` to get all worksheets.
+ header : int, list of int, default 0
+ Row (0-indexed) to use for the column labels of the parsed
+ DataFrame. If a list of integers is passed those row positions will
+ be combined into a ``MultiIndex``. Use None if there is no header.
+ names : array-like, default None
+ List of column names to use. If file contains no header row,
+ then you should explicitly pass header=None.
+ index_col : int, str, list of int, default None
+ Column (0-indexed) to use as the row labels of the DataFrame.
+ Pass None if there is no such column. If a list is passed,
+ those columns will be combined into a ``MultiIndex``. If a
+ subset of data is selected with ``usecols``, index_col
+ is based on the subset.
+
+ Missing values will be forward filled to allow roundtripping with
+ ``to_excel`` for ``merged_cells=True``. To avoid forward filling the
+ missing values use ``set_index`` after reading the data instead of
+ ``index_col``.
+ usecols : str, list-like, or callable, default None
+ * If None, then parse all columns.
+ * If str, then indicates comma separated list of Excel column letters
+ and column ranges (e.g. "A:E" or "A,C,E:F"). Ranges are inclusive of
+ both sides.
+ * If list of int, then indicates list of column numbers to be parsed
+ (0-indexed).
+ * If list of string, then indicates list of column names to be parsed.
+ * If callable, then evaluate each column name against it and parse the
+ column if the callable returns ``True``.
+
+ Returns a subset of the columns according to behavior above.
+ converters : dict, default None
+ Dict of functions for converting values in certain columns. Keys can
+ either be integers or column labels, values are functions that take one
+ input argument, the Excel cell content, and return the transformed
+ content.
+ true_values : list, default None
+ Values to consider as True.
+ false_values : list, default None
+ Values to consider as False.
+ skiprows : list-like, int, or callable, optional
+ Line numbers to skip (0-indexed) or number of lines to skip (int) at the
+ start of the file. If callable, the callable function will be evaluated
+ against the row indices, returning True if the row should be skipped and
+ False otherwise. An example of a valid callable argument would be ``lambda
+ x: x in [0, 2]``.
+ nrows : int, default None
+ Number of rows to parse.
+ na_values : scalar, str, list-like, or dict, default None
+ Additional strings to recognize as NA/NaN. If dict passed, specific
+ per-column NA values.
+ parse_dates : bool, list-like, or dict, default False
+ The behavior is as follows:
+
+ * ``bool``. If True -> try parsing the index.
+ * ``list`` of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3
+ each as a separate date column.
+ * ``list`` of lists. e.g. If [[1, 3]] -> combine columns 1 and 3 and
+ parse as a single date column.
+ * ``dict``, e.g. {{'foo' : [1, 3]}} -> parse columns 1, 3 as date and call
+ result 'foo'
+
+ If a column or index contains an unparsable date, the entire column or
+ index will be returned unaltered as an object data type. If you
+ don`t want to parse some cells as date just change their type
+ in Excel to "Text".For non-standard datetime parsing, use
+ ``pd.to_datetime`` after ``pd.read_excel``.
+
+ Note: A fast-path exists for iso8601-formatted dates.
+ date_parser : function, optional
+ Function to use for converting a sequence of string columns to an array of
+ datetime instances. The default uses ``dateutil.parser.parser`` to do the
+ conversion. Pandas will try to call `date_parser` in three different ways,
+ advancing to the next if an exception occurs: 1) Pass one or more arrays
+ (as defined by `parse_dates`) as arguments; 2) concatenate (row-wise) the
+ string values from the columns defined by `parse_dates` into a single array
+ and pass that; and 3) call `date_parser` once for each row using one or
+ more strings (corresponding to the columns defined by `parse_dates`) as
+ arguments.
+
+ .. deprecated:: 2.0.0
+ Use ``date_format`` instead, or read in as ``object`` and then apply
+ :func:`to_datetime` as-needed.
+ date_format : str or dict of column -> format, default ``None``
+ If used in conjunction with ``parse_dates``, will parse dates
+ according to this format. For anything more complex,
+ please read in as ``object`` and then apply :func:`to_datetime` as-needed.
+ thousands : str, default None
+ Thousands separator for parsing string columns to numeric. Note that
+ this parameter is only necessary for columns stored as TEXT in Excel,
+ any numeric columns will automatically be parsed, regardless of display
+ format.
+ comment : str, default None
+ Comments out remainder of line. Pass a character or characters to this
+ argument to indicate comments in the input file. Any data between the
+ comment string and the end of the current line is ignored.
+ skipfooter : int, default 0
+ Rows at the end to skip (0-indexed).
+ dtype_backend : {{'numpy_nullable', 'pyarrow'}}, default 'numpy_nullable'
+ Back-end data type applied to the resultant :class:`DataFrame`
+ (still experimental). Behaviour is as follows:
+
+ * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
+ (default).
+ * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
+ DataFrame.
+
+ .. versionadded:: 2.0
+ **kwds : dict, optional
+ Arbitrary keyword arguments passed to excel engine.
+
Returns
-------
DataFrame or dict of DataFrames
DataFrame from the passed in Excel file.
+ See Also
+ --------
+ read_excel : Read an Excel sheet values (xlsx) file into DataFrame.
+ read_csv : Read a comma-separated values (csv) file into DataFrame.
+ read_fwf : Read a table of fixed-width formatted lines into DataFrame.
+
Examples
--------
>>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=["A", "B", "C"])
| - [ ] xref #58067
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58235 | 2024-04-12T16:55:51Z | 2024-04-15T16:29:03Z | 2024-04-15T16:29:03Z | 2024-04-15T18:27:28Z |
ASV: benchmark for DataFrame.Update | diff --git a/asv_bench/benchmarks/frame_methods.py b/asv_bench/benchmarks/frame_methods.py
index ce31d63f0b70f..6a2ab24df26fe 100644
--- a/asv_bench/benchmarks/frame_methods.py
+++ b/asv_bench/benchmarks/frame_methods.py
@@ -862,4 +862,28 @@ def time_last_valid_index(self, dtype):
self.df.last_valid_index()
+class Update:
+ def setup(self):
+ rng = np.random.default_rng()
+ self.df = DataFrame(rng.uniform(size=(1_000_000, 10)))
+
+ idx = rng.choice(range(1_000_000), size=1_000_000, replace=False)
+ self.df_random = DataFrame(self.df, index=idx)
+
+ idx = rng.choice(range(1_000_000), size=100_000, replace=False)
+ cols = rng.choice(range(10), size=2, replace=False)
+ self.df_sample = DataFrame(
+ rng.uniform(size=(100_000, 2)), index=idx, columns=cols
+ )
+
+ def time_to_update_big_frame_small_arg(self):
+ self.df.update(self.df_sample)
+
+ def time_to_update_random_indices(self):
+ self.df_random.update(self.df_sample)
+
+ def time_to_update_small_frame_big_arg(self):
+ self.df_sample.update(self.df)
+
+
from .pandas_vb_common import setup # noqa: F401 isort:skip
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
@rhshadrach and @datapythonista
Benchmarks for the DataFrame.Update method are implemented, as suggested on PR #57637 by @datapythonista and based on the manual tests done by @rhshadrach on #55634. By running ASV locally we measure the change in the performance due to the fix on #57637, as indicated below:
| Change | Main (2.2.1) [8da8b544] | PR (3.0) [93ea131f] | Ratio | Benchmark (Parameter) |
|----------|----------------------------|----------------------------------------|---------|---------------------------------------------------------|
| - | 1.13±0.02ms | 887±10μs | 0.78 | frame_methods.Update.time_to_update_random_indices |
| - | 1.19±0.02ms | 840±9μs | 0.71 | frame_methods.Update.time_to_update_small_frame_big_arg |
| - | 1.27±0.01ms | 859±9μs | 0.67 | frame_methods.Update.time_to_update_big_frame_small_arg |
Regards
| https://api.github.com/repos/pandas-dev/pandas/pulls/58228 | 2024-04-12T00:28:10Z | 2024-04-15T21:16:32Z | 2024-04-15T21:16:32Z | 2024-04-15T21:16:40Z |
REF: Use PyUnicode_AsUTF8AndSize instead of get_c_string_buf_and_size | diff --git a/pandas/_libs/hashtable_class_helper.pxi.in b/pandas/_libs/hashtable_class_helper.pxi.in
index e3a9102fec395..5c6254c6a1ec7 100644
--- a/pandas/_libs/hashtable_class_helper.pxi.in
+++ b/pandas/_libs/hashtable_class_helper.pxi.in
@@ -3,7 +3,7 @@ Template for each `dtype` helper function for hashtable
WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in
"""
-
+from cpython.unicode cimport PyUnicode_AsUTF8
{{py:
@@ -98,7 +98,6 @@ from pandas._libs.khash cimport (
# VectorData
# ----------------------------------------------------------------------
-from pandas._libs.tslibs.util cimport get_c_string
from pandas._libs.missing cimport C_NA
@@ -998,7 +997,7 @@ cdef class StringHashTable(HashTable):
cdef:
khiter_t k
const char *v
- v = get_c_string(val)
+ v = PyUnicode_AsUTF8(val)
k = kh_get_str(self.table, v)
if k != self.table.n_buckets:
@@ -1012,7 +1011,7 @@ cdef class StringHashTable(HashTable):
int ret = 0
const char *v
- v = get_c_string(key)
+ v = PyUnicode_AsUTF8(key)
k = kh_put_str(self.table, v, &ret)
if kh_exist_str(self.table, k):
@@ -1037,7 +1036,7 @@ cdef class StringHashTable(HashTable):
raise MemoryError()
for i in range(n):
val = values[i]
- v = get_c_string(val)
+ v = PyUnicode_AsUTF8(val)
vecs[i] = v
with nogil:
@@ -1071,11 +1070,11 @@ cdef class StringHashTable(HashTable):
val = values[i]
if isinstance(val, str):
- # GH#31499 if we have a np.str_ get_c_string won't recognize
+ # GH#31499 if we have a np.str_ PyUnicode_AsUTF8 won't recognize
# it as a str, even though isinstance does.
- v = get_c_string(<str>val)
+ v = PyUnicode_AsUTF8(<str>val)
else:
- v = get_c_string(self.na_string_sentinel)
+ v = PyUnicode_AsUTF8(self.na_string_sentinel)
vecs[i] = v
with nogil:
@@ -1109,11 +1108,11 @@ cdef class StringHashTable(HashTable):
val = values[i]
if isinstance(val, str):
- # GH#31499 if we have a np.str_ get_c_string won't recognize
+ # GH#31499 if we have a np.str_ PyUnicode_AsUTF8 won't recognize
# it as a str, even though isinstance does.
- v = get_c_string(<str>val)
+ v = PyUnicode_AsUTF8(<str>val)
else:
- v = get_c_string(self.na_string_sentinel)
+ v = PyUnicode_AsUTF8(self.na_string_sentinel)
vecs[i] = v
with nogil:
@@ -1195,9 +1194,9 @@ cdef class StringHashTable(HashTable):
else:
# if ignore_na is False, we also stringify NaN/None/etc.
try:
- v = get_c_string(<str>val)
+ v = PyUnicode_AsUTF8(<str>val)
except UnicodeEncodeError:
- v = get_c_string(<str>repr(val))
+ v = PyUnicode_AsUTF8(<str>repr(val))
vecs[i] = v
# compute
diff --git a/pandas/_libs/tslibs/np_datetime.pyx b/pandas/_libs/tslibs/np_datetime.pyx
index aa01a05d0d932..61095b3f034fd 100644
--- a/pandas/_libs/tslibs/np_datetime.pyx
+++ b/pandas/_libs/tslibs/np_datetime.pyx
@@ -18,6 +18,7 @@ from cpython.object cimport (
Py_LT,
Py_NE,
)
+from cpython.unicode cimport PyUnicode_AsUTF8AndSize
from libc.stdint cimport INT64_MAX
import_datetime()
@@ -44,7 +45,6 @@ from pandas._libs.tslibs.dtypes cimport (
npy_unit_to_abbrev,
npy_unit_to_attrname,
)
-from pandas._libs.tslibs.util cimport get_c_string_buf_and_size
cdef extern from "pandas/datetime/pd_datetime.h":
@@ -341,13 +341,13 @@ cdef int string_to_dts(
const char* format_buf
FormatRequirement format_requirement
- buf = get_c_string_buf_and_size(val, &length)
+ buf = PyUnicode_AsUTF8AndSize(val, &length)
if format is None:
format_buf = b""
format_length = 0
format_requirement = INFER_FORMAT
else:
- format_buf = get_c_string_buf_and_size(format, &format_length)
+ format_buf = PyUnicode_AsUTF8AndSize(format, &format_length)
format_requirement = <FormatRequirement>exact
return parse_iso_8601_datetime(buf, length, want_exc,
dts, out_bestunit, out_local, out_tzoffset,
diff --git a/pandas/_libs/tslibs/parsing.pyx b/pandas/_libs/tslibs/parsing.pyx
index 384df1cac95eb..85ef3fd93ff09 100644
--- a/pandas/_libs/tslibs/parsing.pyx
+++ b/pandas/_libs/tslibs/parsing.pyx
@@ -19,6 +19,7 @@ from cpython.datetime cimport (
from datetime import timezone
from cpython.object cimport PyObject_Str
+from cpython.unicode cimport PyUnicode_AsUTF8AndSize
from cython cimport Py_ssize_t
from libc.string cimport strchr
@@ -74,10 +75,7 @@ import_pandas_datetime()
from pandas._libs.tslibs.strptime import array_strptime
-from pandas._libs.tslibs.util cimport (
- get_c_string_buf_and_size,
- is_array,
-)
+from pandas._libs.tslibs.util cimport is_array
cdef extern from "pandas/portable.h":
@@ -175,7 +173,7 @@ cdef datetime _parse_delimited_date(
int day = 1, month = 1, year
bint can_swap = 0
- buf = get_c_string_buf_and_size(date_string, &length)
+ buf = PyUnicode_AsUTF8AndSize(date_string, &length)
if length == 10 and _is_delimiter(buf[2]) and _is_delimiter(buf[5]):
# parsing MM?DD?YYYY and DD?MM?YYYY dates
month = _parse_2digit(buf)
@@ -251,7 +249,7 @@ cdef bint _does_string_look_like_time(str parse_string):
Py_ssize_t length
int hour = -1, minute = -1
- buf = get_c_string_buf_and_size(parse_string, &length)
+ buf = PyUnicode_AsUTF8AndSize(parse_string, &length)
if length >= 4:
if buf[1] == b":":
# h:MM format
@@ -467,7 +465,7 @@ cpdef bint _does_string_look_like_datetime(str py_string):
char first
int error = 0
- buf = get_c_string_buf_and_size(py_string, &length)
+ buf = PyUnicode_AsUTF8AndSize(py_string, &length)
if length >= 1:
first = buf[0]
if first == b"0":
@@ -521,7 +519,7 @@ cdef datetime _parse_dateabbr_string(str date_string, datetime default,
pass
if 4 <= date_len <= 7:
- buf = get_c_string_buf_and_size(date_string, &date_len)
+ buf = PyUnicode_AsUTF8AndSize(date_string, &date_len)
try:
i = date_string.index("Q", 1, 6)
if i == 1:
diff --git a/pandas/_libs/tslibs/util.pxd b/pandas/_libs/tslibs/util.pxd
index a5822e57d3fa6..f144275e0ee6a 100644
--- a/pandas/_libs/tslibs/util.pxd
+++ b/pandas/_libs/tslibs/util.pxd
@@ -1,6 +1,5 @@
from cpython.object cimport PyTypeObject
-from cpython.unicode cimport PyUnicode_AsUTF8AndSize
cdef extern from "Python.h":
@@ -155,36 +154,6 @@ cdef inline bint is_nan(object val):
return is_complex_object(val) and val != val
-cdef inline const char* get_c_string_buf_and_size(str py_string,
- Py_ssize_t *length) except NULL:
- """
- Extract internal char* buffer of unicode or bytes object `py_string` with
- getting length of this internal buffer saved in `length`.
-
- Notes
- -----
- Python object owns memory, thus returned char* must not be freed.
- `length` can be NULL if getting buffer length is not needed.
-
- Parameters
- ----------
- py_string : str
- length : Py_ssize_t*
-
- Returns
- -------
- buf : const char*
- """
- # Note PyUnicode_AsUTF8AndSize() can
- # potentially allocate memory inside in unlikely case of when underlying
- # unicode object was stored as non-utf8 and utf8 wasn't requested before.
- return PyUnicode_AsUTF8AndSize(py_string, length)
-
-
-cdef inline const char* get_c_string(str py_string) except NULL:
- return get_c_string_buf_and_size(py_string, NULL)
-
-
cdef inline bytes string_encode_locale(str py_string):
"""As opposed to PyUnicode_Encode, use current system locale to encode."""
return PyUnicode_EncodeLocale(py_string, NULL)
| cc @WillAyd
| https://api.github.com/repos/pandas-dev/pandas/pulls/58227 | 2024-04-11T23:02:04Z | 2024-04-12T00:51:06Z | 2024-04-12T00:51:06Z | 2024-04-12T00:52:55Z |
BUG: Timestamp ignoring explicit tz=None | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index e05cc87d1af14..66f6c10e36bdc 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -357,6 +357,7 @@ Categorical
Datetimelike
^^^^^^^^^^^^
+- Bug in :class:`Timestamp` constructor failing to raise when ``tz=None`` is explicitly specified in conjunction with timezone-aware ``tzinfo`` or data (:issue:`48688`)
- Bug in :func:`date_range` where the last valid timestamp would sometimes not be produced (:issue:`56134`)
- Bug in :func:`date_range` where using a negative frequency value would not include all points between the start and end values (:issue:`56382`)
-
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index d4cd90613ca5b..82daa6d942095 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -1751,7 +1751,7 @@ class Timestamp(_Timestamp):
tzinfo_type tzinfo=None,
*,
nanosecond=None,
- tz=None,
+ tz=_no_input,
unit=None,
fold=None,
):
@@ -1783,6 +1783,10 @@ class Timestamp(_Timestamp):
_date_attributes = [year, month, day, hour, minute, second,
microsecond, nanosecond]
+ explicit_tz_none = tz is None
+ if tz is _no_input:
+ tz = None
+
if tzinfo is not None:
# GH#17690 tzinfo must be a datetime.tzinfo object, ensured
# by the cython annotation.
@@ -1883,6 +1887,11 @@ class Timestamp(_Timestamp):
if ts.value == NPY_NAT:
return NaT
+ if ts.tzinfo is not None and explicit_tz_none:
+ raise ValueError(
+ "Passed data is timezone-aware, incompatible with 'tz=None'."
+ )
+
return create_timestamp_from_ts(ts.value, ts.dts, ts.tzinfo, ts.fold, ts.creso)
def _round(self, freq, mode, ambiguous="raise", nonexistent="raise"):
diff --git a/pandas/tests/indexing/test_at.py b/pandas/tests/indexing/test_at.py
index d78694018749c..217ca74bd7fbd 100644
--- a/pandas/tests/indexing/test_at.py
+++ b/pandas/tests/indexing/test_at.py
@@ -136,7 +136,11 @@ def test_at_datetime_index(self, row):
class TestAtSetItemWithExpansion:
def test_at_setitem_expansion_series_dt64tz_value(self, tz_naive_fixture):
# GH#25506
- ts = Timestamp("2017-08-05 00:00:00+0100", tz=tz_naive_fixture)
+ ts = (
+ Timestamp("2017-08-05 00:00:00+0100", tz=tz_naive_fixture)
+ if tz_naive_fixture is not None
+ else Timestamp("2017-08-05 00:00:00+0100")
+ )
result = Series(ts)
result.at[1] = ts
expected = Series([ts, ts])
diff --git a/pandas/tests/scalar/timestamp/test_constructors.py b/pandas/tests/scalar/timestamp/test_constructors.py
index bbda9d3ee7dce..4ebdea3733484 100644
--- a/pandas/tests/scalar/timestamp/test_constructors.py
+++ b/pandas/tests/scalar/timestamp/test_constructors.py
@@ -621,7 +621,6 @@ def test_constructor_with_stringoffset(self):
]
timezones = [
- (None, 0),
("UTC", 0),
(pytz.utc, 0),
("Asia/Tokyo", 9),
@@ -1013,6 +1012,18 @@ def test_timestamp_constructed_by_date_and_tz(self, tz):
assert result.hour == expected.hour
assert result == expected
+ def test_explicit_tz_none(self):
+ # GH#48688
+ msg = "Passed data is timezone-aware, incompatible with 'tz=None'"
+ with pytest.raises(ValueError, match=msg):
+ Timestamp(datetime(2022, 1, 1, tzinfo=timezone.utc), tz=None)
+
+ with pytest.raises(ValueError, match=msg):
+ Timestamp("2022-01-01 00:00:00", tzinfo=timezone.utc, tz=None)
+
+ with pytest.raises(ValueError, match=msg):
+ Timestamp("2022-01-01 00:00:00-0400", tz=None)
+
def test_constructor_ambiguous_dst():
# GH 24329
diff --git a/pandas/tests/scalar/timestamp/test_formats.py b/pandas/tests/scalar/timestamp/test_formats.py
index b4493088acb31..e1299c272e5cc 100644
--- a/pandas/tests/scalar/timestamp/test_formats.py
+++ b/pandas/tests/scalar/timestamp/test_formats.py
@@ -118,7 +118,7 @@ def test_repr(self, date, freq, tz):
def test_repr_utcoffset(self):
# This can cause the tz field to be populated, but it's redundant to
# include this information in the date-string.
- date_with_utc_offset = Timestamp("2014-03-13 00:00:00-0400", tz=None)
+ date_with_utc_offset = Timestamp("2014-03-13 00:00:00-0400")
assert "2014-03-13 00:00:00-0400" in repr(date_with_utc_offset)
assert "tzoffset" not in repr(date_with_utc_offset)
assert "UTC-04:00" in repr(date_with_utc_offset)
| - [x] closes #48688(Replace xxxx with the GitHub issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58226 | 2024-04-11T22:24:18Z | 2024-04-15T17:12:09Z | 2024-04-15T17:12:09Z | 2024-04-15T17:17:12Z |
DOC: Pandas Case_When | diff --git a/.circleci/config.yml b/.circleci/config.yml
index ea93575ac9430..6f134c9a7a7bd 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -72,10 +72,6 @@ jobs:
no_output_timeout: 30m # Sometimes the tests won't generate any output, make sure the job doesn't get killed by that
command: |
pip3 install cibuildwheel==2.15.0
- # When this is a nightly wheel build, allow picking up NumPy 2.0 dev wheels:
- if [[ "$IS_SCHEDULE_DISPATCH" == "true" || "$IS_PUSH" != 'true' ]]; then
- export CIBW_ENVIRONMENT="PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple"
- fi
cibuildwheel --prerelease-pythons --output-dir wheelhouse
environment:
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index 470c044d2e99e..d6cfd3b0ad257 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -148,18 +148,6 @@ jobs:
CIBW_PRERELEASE_PYTHONS: True
CIBW_BUILD: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
- - name: Build nightly wheels (with NumPy pre-release)
- if: ${{ (env.IS_SCHEDULE_DISPATCH == 'true' && env.IS_PUSH != 'true') }}
- uses: pypa/cibuildwheel@v2.17.0
- with:
- package-dir: ./dist/${{ startsWith(matrix.buildplat[1], 'macosx') && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
- env:
- # The nightly wheels should be build witht he NumPy 2.0 pre-releases
- # which requires the additional URL.
- CIBW_ENVIRONMENT: PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple
- CIBW_PRERELEASE_PYTHONS: True
- CIBW_BUILD: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
-
- name: Set up Python
uses: mamba-org/setup-micromamba@v1
with:
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 41f1c4c6892a3..b8726e058a52b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -19,7 +19,7 @@ ci:
skip: [pylint, pyright, mypy]
repos:
- repo: https://github.com/astral-sh/ruff-pre-commit
- rev: v0.3.1
+ rev: v0.3.4
hooks:
- id: ruff
args: [--exit-non-zero-on-fix]
@@ -39,7 +39,7 @@ repos:
- id: ruff-format
exclude: ^scripts
- repo: https://github.com/jendrikseipp/vulture
- rev: 'v2.10'
+ rev: 'v2.11'
hooks:
- id: vulture
entry: python scripts/run_vulture.py
@@ -93,11 +93,11 @@ repos:
args: [--disable=all, --enable=redefined-outer-name]
stages: [manual]
- repo: https://github.com/PyCQA/isort
- rev: 5.12.0
+ rev: 5.13.2
hooks:
- id: isort
- repo: https://github.com/asottile/pyupgrade
- rev: v3.15.0
+ rev: v3.15.2
hooks:
- id: pyupgrade
args: [--py39-plus]
@@ -116,7 +116,7 @@ repos:
hooks:
- id: sphinx-lint
- repo: https://github.com/pre-commit/mirrors-clang-format
- rev: v17.0.6
+ rev: v18.1.2
hooks:
- id: clang-format
files: ^pandas/_libs/src|^pandas/_libs/include
diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 0c4e6641444f1..9c39fac13b230 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -84,7 +84,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.assign SA01" \
-i "pandas.DataFrame.at_time PR01" \
-i "pandas.DataFrame.axes SA01" \
- -i "pandas.DataFrame.backfill PR01,SA01" \
-i "pandas.DataFrame.bfill SA01" \
-i "pandas.DataFrame.columns SA01" \
-i "pandas.DataFrame.copy SA01" \
@@ -99,12 +98,10 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.kurt RT03,SA01" \
-i "pandas.DataFrame.kurtosis RT03,SA01" \
-i "pandas.DataFrame.last_valid_index SA01" \
- -i "pandas.DataFrame.mask RT03" \
-i "pandas.DataFrame.max RT03" \
-i "pandas.DataFrame.mean RT03,SA01" \
-i "pandas.DataFrame.median RT03,SA01" \
-i "pandas.DataFrame.min RT03" \
- -i "pandas.DataFrame.pad PR01,SA01" \
-i "pandas.DataFrame.plot PR02,SA01" \
-i "pandas.DataFrame.pop SA01" \
-i "pandas.DataFrame.prod RT03" \
@@ -119,19 +116,11 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.sparse.to_dense SA01" \
-i "pandas.DataFrame.std PR01,RT03,SA01" \
-i "pandas.DataFrame.sum RT03" \
- -i "pandas.DataFrame.swapaxes PR01,SA01" \
-i "pandas.DataFrame.swaplevel SA01" \
-i "pandas.DataFrame.to_feather SA01" \
-i "pandas.DataFrame.to_markdown SA01" \
-i "pandas.DataFrame.to_parquet RT03" \
- -i "pandas.DataFrame.to_period SA01" \
- -i "pandas.DataFrame.to_timestamp SA01" \
- -i "pandas.DataFrame.tz_convert SA01" \
- -i "pandas.DataFrame.tz_localize SA01" \
- -i "pandas.DataFrame.unstack RT03" \
- -i "pandas.DataFrame.value_counts RT03" \
-i "pandas.DataFrame.var PR01,RT03,SA01" \
- -i "pandas.DataFrame.where RT03" \
-i "pandas.DatetimeIndex.ceil SA01" \
-i "pandas.DatetimeIndex.date SA01" \
-i "pandas.DatetimeIndex.day SA01" \
@@ -226,7 +215,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Index.to_list RT03" \
-i "pandas.Index.union PR07,RT03,SA01" \
-i "pandas.Index.unique RT03" \
- -i "pandas.Index.value_counts RT03" \
-i "pandas.Index.view GL08" \
-i "pandas.Int16Dtype SA01" \
-i "pandas.Int32Dtype SA01" \
@@ -400,7 +388,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Series.list.flatten SA01" \
-i "pandas.Series.list.len SA01" \
-i "pandas.Series.lt PR07,SA01" \
- -i "pandas.Series.mask RT03" \
-i "pandas.Series.max RT03" \
-i "pandas.Series.mean RT03,SA01" \
-i "pandas.Series.median RT03,SA01" \
@@ -477,17 +464,10 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Series.to_frame SA01" \
-i "pandas.Series.to_list RT03" \
-i "pandas.Series.to_markdown SA01" \
- -i "pandas.Series.to_period SA01" \
-i "pandas.Series.to_string SA01" \
- -i "pandas.Series.to_timestamp RT03,SA01" \
-i "pandas.Series.truediv PR07" \
- -i "pandas.Series.tz_convert SA01" \
- -i "pandas.Series.tz_localize SA01" \
- -i "pandas.Series.unstack SA01" \
-i "pandas.Series.update PR07,SA01" \
- -i "pandas.Series.value_counts RT03" \
-i "pandas.Series.var PR01,RT03,SA01" \
- -i "pandas.Series.where RT03" \
-i "pandas.SparseDtype SA01" \
-i "pandas.Timedelta PR07,SA01" \
-i "pandas.Timedelta.as_unit SA01" \
@@ -681,60 +661,40 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.core.groupby.DataFrameGroupBy.__iter__ RT03,SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.agg RT03" \
-i "pandas.core.groupby.DataFrameGroupBy.aggregate RT03" \
- -i "pandas.core.groupby.DataFrameGroupBy.apply RT03" \
-i "pandas.core.groupby.DataFrameGroupBy.boxplot PR07,RT03,SA01" \
- -i "pandas.core.groupby.DataFrameGroupBy.cummax RT03" \
- -i "pandas.core.groupby.DataFrameGroupBy.cummin RT03" \
- -i "pandas.core.groupby.DataFrameGroupBy.cumprod RT03" \
- -i "pandas.core.groupby.DataFrameGroupBy.cumsum RT03" \
- -i "pandas.core.groupby.DataFrameGroupBy.filter RT03,SA01" \
+ -i "pandas.core.groupby.DataFrameGroupBy.filter SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.get_group RT03,SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.groups SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.hist RT03" \
-i "pandas.core.groupby.DataFrameGroupBy.indices SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.max SA01" \
- -i "pandas.core.groupby.DataFrameGroupBy.mean RT03" \
-i "pandas.core.groupby.DataFrameGroupBy.median SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.min SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.nth PR02" \
- -i "pandas.core.groupby.DataFrameGroupBy.nunique RT03,SA01" \
+ -i "pandas.core.groupby.DataFrameGroupBy.nunique SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.ohlc SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.plot PR02,SA01" \
-i "pandas.core.groupby.DataFrameGroupBy.prod SA01" \
- -i "pandas.core.groupby.DataFrameGroupBy.rank RT03" \
- -i "pandas.core.groupby.DataFrameGroupBy.resample RT03" \
-i "pandas.core.groupby.DataFrameGroupBy.sem SA01" \
- -i "pandas.core.groupby.DataFrameGroupBy.skew RT03" \
-i "pandas.core.groupby.DataFrameGroupBy.sum SA01" \
- -i "pandas.core.groupby.DataFrameGroupBy.transform RT03" \
-i "pandas.core.groupby.SeriesGroupBy.__iter__ RT03,SA01" \
-i "pandas.core.groupby.SeriesGroupBy.agg RT03" \
-i "pandas.core.groupby.SeriesGroupBy.aggregate RT03" \
- -i "pandas.core.groupby.SeriesGroupBy.apply RT03" \
- -i "pandas.core.groupby.SeriesGroupBy.cummax RT03" \
- -i "pandas.core.groupby.SeriesGroupBy.cummin RT03" \
- -i "pandas.core.groupby.SeriesGroupBy.cumprod RT03" \
- -i "pandas.core.groupby.SeriesGroupBy.cumsum RT03" \
- -i "pandas.core.groupby.SeriesGroupBy.filter PR01,RT03,SA01" \
+ -i "pandas.core.groupby.SeriesGroupBy.filter PR01,SA01" \
-i "pandas.core.groupby.SeriesGroupBy.get_group RT03,SA01" \
-i "pandas.core.groupby.SeriesGroupBy.groups SA01" \
-i "pandas.core.groupby.SeriesGroupBy.indices SA01" \
-i "pandas.core.groupby.SeriesGroupBy.is_monotonic_decreasing SA01" \
-i "pandas.core.groupby.SeriesGroupBy.is_monotonic_increasing SA01" \
-i "pandas.core.groupby.SeriesGroupBy.max SA01" \
- -i "pandas.core.groupby.SeriesGroupBy.mean RT03" \
-i "pandas.core.groupby.SeriesGroupBy.median SA01" \
-i "pandas.core.groupby.SeriesGroupBy.min SA01" \
-i "pandas.core.groupby.SeriesGroupBy.nth PR02" \
-i "pandas.core.groupby.SeriesGroupBy.ohlc SA01" \
-i "pandas.core.groupby.SeriesGroupBy.plot PR02,SA01" \
-i "pandas.core.groupby.SeriesGroupBy.prod SA01" \
- -i "pandas.core.groupby.SeriesGroupBy.rank RT03" \
- -i "pandas.core.groupby.SeriesGroupBy.resample RT03" \
-i "pandas.core.groupby.SeriesGroupBy.sem SA01" \
- -i "pandas.core.groupby.SeriesGroupBy.skew RT03" \
-i "pandas.core.groupby.SeriesGroupBy.sum SA01" \
- -i "pandas.core.groupby.SeriesGroupBy.transform RT03" \
-i "pandas.core.resample.Resampler.__iter__ RT03,SA01" \
-i "pandas.core.resample.Resampler.ffill RT03" \
-i "pandas.core.resample.Resampler.get_group RT03,SA01" \
diff --git a/doc/source/user_guide/groupby.rst b/doc/source/user_guide/groupby.rst
index 7f957a8b16787..8c222aff52fd7 100644
--- a/doc/source/user_guide/groupby.rst
+++ b/doc/source/user_guide/groupby.rst
@@ -416,6 +416,12 @@ You can also include the grouping columns if you want to operate on them.
grouped[["A", "B"]].sum()
+.. note::
+
+ The ``groupby`` operation in Pandas drops the ``name`` field of the columns Index object
+ after the operation. This change ensures consistency in syntax between different
+ column selection methods within groupby operations.
+
.. _groupby.iterating-label:
Iterating through groups
diff --git a/doc/source/user_guide/indexing.rst b/doc/source/user_guide/indexing.rst
index 24cdbad41fe60..fd843ca68a60b 100644
--- a/doc/source/user_guide/indexing.rst
+++ b/doc/source/user_guide/indexing.rst
@@ -262,6 +262,10 @@ The most robust and consistent way of slicing ranges along arbitrary axes is
described in the :ref:`Selection by Position <indexing.integer>` section
detailing the ``.iloc`` method. For now, we explain the semantics of slicing using the ``[]`` operator.
+ .. note::
+
+ When the :class:`Series` has float indices, slicing will select by position.
+
With Series, the syntax works exactly as with an ndarray, returning a slice of
the values and the corresponding labels:
diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 15e85d0f90c5e..4debd41de213f 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -207,6 +207,7 @@ Removal of prior version deprecations/changes
- :meth:`SeriesGroupBy.agg` no longer pins the name of the group to the input passed to the provided ``func`` (:issue:`51703`)
- All arguments except ``name`` in :meth:`Index.rename` are now keyword only (:issue:`56493`)
- All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`)
+- Disallow calling :meth:`Series.replace` or :meth:`DataFrame.replace` without a ``value`` and with non-dict-like ``to_replace`` (:issue:`33302`)
- Disallow non-standard (``np.ndarray``, :class:`Index`, :class:`ExtensionArray`, or :class:`Series`) to :func:`isin`, :func:`unique`, :func:`factorize` (:issue:`52986`)
- Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
- Disallow units other than "s", "ms", "us", "ns" for datetime64 and timedelta64 dtypes in :func:`array` (:issue:`53817`)
diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index 7f4e6f6666382..123dc679a83ea 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -210,7 +210,7 @@ def argmin(self, axis: AxisInt = 0, skipna: bool = True): # type: ignore[overri
# override base class by adding axis keyword
validate_bool_kwarg(skipna, "skipna")
if not skipna and self._hasna:
- raise NotImplementedError
+ raise ValueError("Encountered an NA value with skipna=False")
return nargminmax(self, "argmin", axis=axis)
# Signature of "argmax" incompatible with supertype "ExtensionArray"
@@ -218,7 +218,7 @@ def argmax(self, axis: AxisInt = 0, skipna: bool = True): # type: ignore[overri
# override base class by adding axis keyword
validate_bool_kwarg(skipna, "skipna")
if not skipna and self._hasna:
- raise NotImplementedError
+ raise ValueError("Encountered an NA value with skipna=False")
return nargminmax(self, "argmax", axis=axis)
def unique(self) -> Self:
@@ -296,13 +296,6 @@ def __getitem__(
result = self._from_backing_data(result)
return result
- def _fill_mask_inplace(
- self, method: str, limit: int | None, mask: npt.NDArray[np.bool_]
- ) -> None:
- # (for now) when self.ndim == 2, we assume axis=0
- func = missing.get_fill_func(method, ndim=self.ndim)
- func(self._ndarray.T, limit=limit, mask=mask.T)
-
def _pad_or_backfill(
self,
*,
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 76615704f2e33..1855bd1368251 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -885,7 +885,7 @@ def argmin(self, skipna: bool = True) -> int:
# 2. argmin itself : total control over sorting.
validate_bool_kwarg(skipna, "skipna")
if not skipna and self._hasna:
- raise NotImplementedError
+ raise ValueError("Encountered an NA value with skipna=False")
return nargminmax(self, "argmin")
def argmax(self, skipna: bool = True) -> int:
@@ -919,7 +919,7 @@ def argmax(self, skipna: bool = True) -> int:
# 2. argmax itself : total control over sorting.
validate_bool_kwarg(skipna, "skipna")
if not skipna and self._hasna:
- raise NotImplementedError
+ raise ValueError("Encountered an NA value with skipna=False")
return nargminmax(self, "argmax")
def interpolate(
@@ -2111,25 +2111,6 @@ def _where(self, mask: npt.NDArray[np.bool_], value) -> Self:
result[~mask] = val
return result
- # TODO(3.0): this can be removed once GH#33302 deprecation is enforced
- def _fill_mask_inplace(
- self, method: str, limit: int | None, mask: npt.NDArray[np.bool_]
- ) -> None:
- """
- Replace values in locations specified by 'mask' using pad or backfill.
-
- See also
- --------
- ExtensionArray.fillna
- """
- func = missing.get_fill_func(method)
- npvalues = self.astype(object)
- # NB: if we don't copy mask here, it may be altered inplace, which
- # would mess up the `self[mask] = ...` below.
- func(npvalues, limit=limit, mask=mask.copy())
- new_values = self._from_sequence(npvalues, dtype=self.dtype)
- self[mask] = new_values[mask]
-
def _rank(
self,
*,
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index bdcb3219a9875..2a96423017bb7 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -1623,13 +1623,13 @@ def _argmin_argmax(self, kind: Literal["argmin", "argmax"]) -> int:
def argmax(self, skipna: bool = True) -> int:
validate_bool_kwarg(skipna, "skipna")
if not skipna and self._hasna:
- raise NotImplementedError
+ raise ValueError("Encountered an NA value with skipna=False")
return self._argmin_argmax("argmax")
def argmin(self, skipna: bool = True) -> int:
validate_bool_kwarg(skipna, "skipna")
if not skipna and self._hasna:
- raise NotImplementedError
+ raise ValueError("Encountered an NA value with skipna=False")
return self._argmin_argmax("argmin")
# ------------------------------------------------------------------------
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 263265701691b..f5eefe1b4ab92 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -735,13 +735,8 @@ def argmax(
nv.validate_minmax_axis(axis)
skipna = nv.validate_argmax_with_skipna(skipna, args, kwargs)
- if skipna and len(delegate) > 0 and isna(delegate).all():
- raise ValueError("Encountered all NA values")
- elif not skipna and isna(delegate).any():
- raise ValueError("Encountered an NA value with skipna=False")
-
if isinstance(delegate, ExtensionArray):
- return delegate.argmax()
+ return delegate.argmax(skipna=skipna)
else:
result = nanops.nanargmax(delegate, skipna=skipna)
# error: Incompatible return value type (got "Union[int, ndarray]", expected
@@ -754,15 +749,10 @@ def argmin(
) -> int:
delegate = self._values
nv.validate_minmax_axis(axis)
- skipna = nv.validate_argmin_with_skipna(skipna, args, kwargs)
-
- if skipna and len(delegate) > 0 and isna(delegate).all():
- raise ValueError("Encountered all NA values")
- elif not skipna and isna(delegate).any():
- raise ValueError("Encountered an NA value with skipna=False")
+ skipna = nv.validate_argmax_with_skipna(skipna, args, kwargs)
if isinstance(delegate, ExtensionArray):
- return delegate.argmin()
+ return delegate.argmin(skipna=skipna)
else:
result = nanops.nanargmin(delegate, skipna=skipna)
# error: Incompatible return value type (got "Union[int, ndarray]", expected
@@ -924,6 +914,7 @@ def value_counts(
Returns
-------
Series
+ Series containing counts of unique values.
See Also
--------
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 50a93994dc76b..66a68755a2a09 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7162,7 +7162,7 @@ def value_counts(
dropna: bool = True,
) -> Series:
"""
- Return a Series containing the frequency of each distinct row in the Dataframe.
+ Return a Series containing the frequency of each distinct row in the DataFrame.
Parameters
----------
@@ -7175,13 +7175,14 @@ def value_counts(
ascending : bool, default False
Sort in ascending order.
dropna : bool, default True
- Don't include counts of rows that contain NA values.
+ Do not include counts of rows that contain NA values.
.. versionadded:: 1.3.0
Returns
-------
Series
+ Series containing the frequency of each distinct row in the DataFrame.
See Also
--------
@@ -7192,8 +7193,8 @@ def value_counts(
The returned Series will have a MultiIndex with one level per input
column but an Index (non-multi) for a single label. By default, rows
that contain any NA values are omitted from the result. By default,
- the resulting Series will be in descending order so that the first
- element is the most frequently-occurring row.
+ the resulting Series will be sorted by frequencies in descending order so that
+ the first element is the most frequently-occurring row.
Examples
--------
@@ -9658,6 +9659,8 @@ def unstack(
Returns
-------
Series or DataFrame
+ If index is a MultiIndex: DataFrame with pivoted index labels as new
+ inner-most level column labels, else Series.
See Also
--------
@@ -11494,7 +11497,7 @@ def any(
**kwargs,
) -> Series | bool: ...
- @doc(make_doc("any", ndim=2))
+ @doc(make_doc("any", ndim=1))
def any(
self,
*,
@@ -11540,7 +11543,7 @@ def all(
**kwargs,
) -> Series | bool: ...
- @doc(make_doc("all", ndim=2))
+ @doc(make_doc("all", ndim=1))
def all(
self,
axis: Axis | None = 0,
@@ -12479,7 +12482,9 @@ def to_timestamp(
copy: bool | lib.NoDefault = lib.no_default,
) -> DataFrame:
"""
- Cast to DatetimeIndex of timestamps, at *beginning* of period.
+ Cast PeriodIndex to DatetimeIndex of timestamps, at *beginning* of period.
+
+ This can be changed to the *end* of the period, by specifying `how="e"`.
Parameters
----------
@@ -12509,8 +12514,13 @@ def to_timestamp(
Returns
-------
- DataFrame
- The DataFrame has a DatetimeIndex.
+ DataFrame with DatetimeIndex
+ DataFrame with the PeriodIndex cast to DatetimeIndex.
+
+ See Also
+ --------
+ DataFrame.to_period: Inverse method to cast DatetimeIndex to PeriodIndex.
+ Series.to_timestamp: Equivalent method for Series.
Examples
--------
@@ -12566,7 +12576,8 @@ def to_period(
Convert DataFrame from DatetimeIndex to PeriodIndex.
Convert DataFrame from DatetimeIndex to PeriodIndex with desired
- frequency (inferred from index if not passed).
+ frequency (inferred from index if not passed). Either index of columns can be
+ converted, depending on `axis` argument.
Parameters
----------
@@ -12594,7 +12605,12 @@ def to_period(
Returns
-------
DataFrame
- The DataFrame has a PeriodIndex.
+ The DataFrame with the converted PeriodIndex.
+
+ See Also
+ --------
+ Series.to_period: Equivalent method for Series.
+ Series.dt.to_period: Convert DateTime column values.
Examples
--------
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 858d2ba82a969..99462917599e1 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -7319,17 +7319,8 @@ def replace(
inplace: bool = False,
regex: bool = False,
) -> Self | None:
- if value is lib.no_default and not is_dict_like(to_replace) and regex is False:
- # case that goes through _replace_single and defaults to method="pad"
- warnings.warn(
- # GH#33302
- f"{type(self).__name__}.replace without 'value' and with "
- "non-dict-like 'to_replace' is deprecated "
- "and will raise in a future version. "
- "Explicitly specify the new values instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
+ if not is_bool(regex) and to_replace is not None:
+ raise ValueError("'to_replace' must be 'None' if 'regex' is not a bool")
if not (
is_scalar(to_replace)
@@ -7342,6 +7333,15 @@ def replace(
f"{type(to_replace).__name__!r}"
)
+ if value is lib.no_default and not (
+ is_dict_like(to_replace) or is_dict_like(regex)
+ ):
+ raise ValueError(
+ # GH#33302
+ f"{type(self).__name__}.replace must specify either 'value', "
+ "a dict-like 'to_replace', or dict-like 'regex'."
+ )
+
inplace = validate_bool_kwarg(inplace, "inplace")
if inplace:
if not PYPY:
@@ -7352,41 +7352,10 @@ def replace(
stacklevel=2,
)
- if not is_bool(regex) and to_replace is not None:
- raise ValueError("'to_replace' must be 'None' if 'regex' is not a bool")
-
if value is lib.no_default:
- # GH#36984 if the user explicitly passes value=None we want to
- # respect that. We have the corner case where the user explicitly
- # passes value=None *and* a method, which we interpret as meaning
- # they want the (documented) default behavior.
-
- # passing a single value that is scalar like
- # when value is None (GH5319), for compat
- if not is_dict_like(to_replace) and not is_dict_like(regex):
- to_replace = [to_replace]
-
- if isinstance(to_replace, (tuple, list)):
- # TODO: Consider copy-on-write for non-replaced columns's here
- if isinstance(self, ABCDataFrame):
- from pandas import Series
-
- result = self.apply(
- Series._replace_single,
- args=(to_replace, inplace),
- )
- if inplace:
- return None
- return result
- return self._replace_single(to_replace, inplace)
-
if not is_dict_like(to_replace):
- if not is_dict_like(regex):
- raise TypeError(
- 'If "to_replace" and "value" are both None '
- 'and "to_replace" is not a list, then '
- "regex must be a mapping"
- )
+ # In this case we have checked above that
+ # 1) regex is dict-like and 2) to_replace is None
to_replace = regex
regex = True
@@ -7749,11 +7718,6 @@ def interpolate(
raise ValueError("'method' should be a string, not None.")
obj, should_transpose = (self.T, True) if axis == 1 else (self, False)
- # GH#53631
- if np.any(obj.dtypes == object):
- raise TypeError(
- f"{type(self).__name__} cannot interpolate with object dtype."
- )
if isinstance(obj.index, MultiIndex) and method != "linear":
raise ValueError(
@@ -9807,8 +9771,10 @@ def where(
Returns
-------
- Series or DataFrame unless ``inplace=True`` in which case
- returns None.
+ Series or DataFrame or None
+ When applied to a Series, the function will return a Series,
+ and when applied to a DataFrame, it will return a DataFrame;
+ if ``inplace=True``, it will return None.
See Also
--------
@@ -10423,6 +10389,11 @@ def tz_convert(
TypeError
If the axis is tz-naive.
+ See Also
+ --------
+ DataFrame.tz_localize: Localize tz-naive index of DataFrame to target time zone.
+ Series.tz_localize: Localize tz-naive index of Series to target time zone.
+
Examples
--------
Change to another time zone:
@@ -10485,10 +10456,10 @@ def tz_localize(
nonexistent: TimeNonexistent = "raise",
) -> Self:
"""
- Localize tz-naive index of a Series or DataFrame to target time zone.
+ Localize time zone naive index of a Series or DataFrame to target time zone.
This operation localizes the Index. To localize the values in a
- timezone-naive Series, use :meth:`Series.dt.tz_localize`.
+ time zone naive Series, use :meth:`Series.dt.tz_localize`.
Parameters
----------
@@ -10548,13 +10519,19 @@ def tz_localize(
Returns
-------
{klass}
- Same type as the input.
+ Same type as the input, with time zone naive or aware index, depending on
+ ``tz``.
Raises
------
TypeError
If the TimeSeries is tz-aware and tz is not None.
+ See Also
+ --------
+ Series.dt.tz_localize: Localize the values in a time zone naive Series.
+ Timestamp.tz_localize: Localize the Timestamp to a timezone.
+
Examples
--------
Localize local times:
@@ -11712,7 +11689,7 @@ def last_valid_index(self) -> Hashable:
skipna : bool, default True
Exclude NA/null values when computing the result.
numeric_only : bool, default False
- Include only float, int, boolean columns. Not implemented for Series.
+ Include only float, int, boolean columns.
{min_count}\
**kwargs
@@ -11881,9 +11858,9 @@ def last_valid_index(self) -> Hashable:
Returns
-------
-{name1} or {name2}
- If level is specified, then, {name2} is returned; otherwise, {name1}
- is returned.
+{name2} or {name1}
+ If axis=None, then a scalar boolean is returned.
+ Otherwise a Series is returned with index matching the index argument.
{see_also}
{examples}"""
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 361e9e87fadb8..0a048d11d0b4d 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -240,6 +240,7 @@ def apply(self, func, *args, **kwargs) -> Series:
Returns
-------
Series or DataFrame
+ A pandas object with the result of applying ``func`` to each group.
See Also
--------
@@ -600,6 +601,7 @@ def filter(self, func, dropna: bool = True, *args, **kwargs):
Returns
-------
Series
+ The filtered subset of the original Series.
Notes
-----
@@ -1078,6 +1080,7 @@ def skew(
Returns
-------
Series
+ Unbiased skew within groups.
See Also
--------
@@ -1941,6 +1944,7 @@ def filter(self, func, dropna: bool = True, *args, **kwargs) -> DataFrame:
Returns
-------
DataFrame
+ The filtered subset of the original DataFrame.
Notes
-----
@@ -2108,6 +2112,7 @@ def nunique(self, dropna: bool = True) -> DataFrame:
Returns
-------
nunique: DataFrame
+ Counts of unique elements in each position.
Examples
--------
@@ -2506,6 +2511,7 @@ def skew(
Returns
-------
DataFrame
+ Unbiased skew within groups.
See Also
--------
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index bd8e222831d0c..b313657d33b04 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -333,6 +333,8 @@ class providing the base-class of operations.
Returns
-------
%(klass)s
+ %(klass)s with the same indexes as the original object filled
+ with transformed values.
See Also
--------
@@ -1551,6 +1553,7 @@ def apply(self, func, *args, include_groups: bool = True, **kwargs) -> NDFrameT:
Returns
-------
Series or DataFrame
+ A pandas object with the result of applying ``func`` to each group.
See Also
--------
@@ -2245,6 +2248,7 @@ def mean(
Returns
-------
pandas.Series or pandas.DataFrame
+ Mean of values within each group. Same object type as the caller.
%(see_also)s
Examples
--------
@@ -3512,11 +3516,8 @@ def resample(self, rule, *args, include_groups: bool = True, **kwargs) -> Resamp
Returns
-------
- pandas.api.typing.DatetimeIndexResamplerGroupby,
- pandas.api.typing.PeriodIndexResamplerGroupby, or
- pandas.api.typing.TimedeltaIndexResamplerGroupby
- Return a new groupby object, with type depending on the data
- being resampled.
+ DatetimeIndexResampler, PeriodIndexResampler or TimdeltaResampler
+ Resampler object for the type of the index.
See Also
--------
@@ -4591,7 +4592,8 @@ def rank(
Returns
-------
- DataFrame with ranking of values within each group
+ DataFrame
+ The ranking of values within each group.
%(see_also)s
Examples
--------
@@ -4663,6 +4665,7 @@ def cumprod(self, *args, **kwargs) -> NDFrameT:
Returns
-------
Series or DataFrame
+ Cumulative product for each group. Same object type as the caller.
%(see_also)s
Examples
--------
@@ -4721,6 +4724,7 @@ def cumsum(self, *args, **kwargs) -> NDFrameT:
Returns
-------
Series or DataFrame
+ Cumulative sum for each group. Same object type as the caller.
%(see_also)s
Examples
--------
@@ -4783,6 +4787,7 @@ def cummin(
Returns
-------
Series or DataFrame
+ Cumulative min for each group. Same object type as the caller.
%(see_also)s
Examples
--------
@@ -4853,6 +4858,7 @@ def cummax(
Returns
-------
Series or DataFrame
+ Cumulative max for each group. Same object type as the caller.
%(see_also)s
Examples
--------
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 30cf6f0b866ee..a4b58445289ad 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -6953,11 +6953,11 @@ def argmin(self, axis=None, skipna: bool = True, *args, **kwargs) -> int:
nv.validate_minmax_axis(axis)
if not self._is_multi and self.hasnans:
- # Take advantage of cache
- if self._isnan.all():
- raise ValueError("Encountered all NA values")
- elif not skipna:
+ if not skipna:
raise ValueError("Encountered an NA value with skipna=False")
+ elif self._isnan.all():
+ raise ValueError("Encountered all NA values")
+
return super().argmin(skipna=skipna)
@Appender(IndexOpsMixin.argmax.__doc__)
@@ -6966,11 +6966,10 @@ def argmax(self, axis=None, skipna: bool = True, *args, **kwargs) -> int:
nv.validate_minmax_axis(axis)
if not self._is_multi and self.hasnans:
- # Take advantage of cache
- if self._isnan.all():
- raise ValueError("Encountered all NA values")
- elif not skipna:
+ if not skipna:
raise ValueError("Encountered an NA value with skipna=False")
+ elif self._isnan.all():
+ raise ValueError("Encountered all NA values")
return super().argmax(skipna=skipna)
def min(self, axis=None, skipna: bool = True, *args, **kwargs):
@@ -7135,17 +7134,22 @@ def maybe_sequence_to_range(sequence) -> Any | range:
-------
Any : input or range
"""
- if isinstance(sequence, (ABCSeries, Index, range, ExtensionArray)):
+ if isinstance(sequence, (range, ExtensionArray)):
return sequence
elif len(sequence) == 1 or lib.infer_dtype(sequence, skipna=False) != "integer":
return sequence
- elif len(sequence) == 0:
+ elif isinstance(sequence, (ABCSeries, Index)) and not (
+ isinstance(sequence.dtype, np.dtype) and sequence.dtype.kind == "i"
+ ):
+ return sequence
+ if len(sequence) == 0:
return range(0)
- diff = sequence[1] - sequence[0]
+ np_sequence = np.asarray(sequence, dtype=np.int64)
+ diff = np_sequence[1] - np_sequence[0]
if diff == 0:
return sequence
- elif len(sequence) == 2 or lib.is_sequence_range(np.asarray(sequence), diff):
- return range(sequence[0], sequence[-1] + diff, diff)
+ elif len(sequence) == 2 or lib.is_sequence_range(np_sequence, diff):
+ return range(np_sequence[0], np_sequence[-1] + diff, diff)
else:
return sequence
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 468ec32ce7760..7be1d5d95ffdf 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1388,12 +1388,10 @@ def interpolate(
# If there are no NAs, then interpolate is a no-op
return [self.copy(deep=False)]
- # TODO(3.0): this case will not be reachable once GH#53638 is enforced
if self.dtype == _dtype_obj:
- # only deal with floats
- # bc we already checked that can_hold_na, we don't have int dtype here
- # test_interp_basic checks that we make a copy here
- return [self.copy(deep=False)]
+ # GH#53631
+ name = {1: "Series", 2: "DataFrame"}[self.ndim]
+ raise TypeError(f"{name} cannot interpolate with object dtype.")
copy, refs = self._get_refs_and_copy(inplace)
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index a124e8679ae8e..9abe3f3564794 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -745,6 +745,10 @@ def nanmedian(values, *, axis: AxisInt | None = None, skipna: bool = True, mask=
>>> s = pd.Series([1, np.nan, 2, 2])
>>> nanops.nanmedian(s.values)
2.0
+
+ >>> s = pd.Series([np.nan, np.nan, np.nan])
+ >>> nanops.nanmedian(s.values)
+ nan
"""
# for floats without mask, the data already uses NaN as missing value
# indicator, and `mask` will be calculated from that below -> in those
@@ -763,6 +767,7 @@ def get_median(x, _mask=None):
warnings.filterwarnings(
"ignore", "All-NaN slice encountered", RuntimeWarning
)
+ warnings.filterwarnings("ignore", "Mean of empty slice", RuntimeWarning)
res = np.nanmedian(x[_mask])
return res
@@ -1428,20 +1433,15 @@ def _maybe_arg_null_out(
return result
if axis is None or not getattr(result, "ndim", False):
- if skipna:
- if mask.all():
- raise ValueError("Encountered all NA values")
- else:
- if mask.any():
- raise ValueError("Encountered an NA value with skipna=False")
+ if skipna and mask.all():
+ raise ValueError("Encountered all NA values")
+ elif not skipna and mask.any():
+ raise ValueError("Encountered an NA value with skipna=False")
else:
- na_mask = mask.all(axis)
- if na_mask.any():
+ if skipna and mask.all(axis).any():
raise ValueError("Encountered all NA values")
- elif not skipna:
- na_mask = mask.any(axis)
- if na_mask.any():
- raise ValueError("Encountered an NA value with skipna=False")
+ elif not skipna and mask.any(axis).any():
+ raise ValueError("Encountered an NA value with skipna=False")
return result
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index 0a2f7fe43b4b3..574e6839070be 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -35,6 +35,7 @@
factorize,
unique,
)
+from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
from pandas.core.arrays.categorical import factorize_from_iterable
from pandas.core.construction import ensure_wrapped_if_datetimelike
from pandas.core.frame import DataFrame
@@ -231,20 +232,31 @@ def arange_result(self) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.bool_]]:
return new_values, mask.any(0)
# TODO: in all tests we have mask.any(0).all(); can we rely on that?
- def get_result(self, values, value_columns, fill_value) -> DataFrame:
+ def get_result(self, obj, value_columns, fill_value) -> DataFrame:
+ values = obj._values
if values.ndim == 1:
values = values[:, np.newaxis]
if value_columns is None and values.shape[1] != 1: # pragma: no cover
raise ValueError("must pass column labels for multi-column data")
- values, _ = self.get_new_values(values, fill_value)
+ new_values, _ = self.get_new_values(values, fill_value)
columns = self.get_new_columns(value_columns)
index = self.new_index
- return self.constructor(
- values, index=index, columns=columns, dtype=values.dtype
+ result = self.constructor(
+ new_values, index=index, columns=columns, dtype=new_values.dtype, copy=False
)
+ if isinstance(values, np.ndarray):
+ base, new_base = values.base, new_values.base
+ elif isinstance(values, NDArrayBackedExtensionArray):
+ base, new_base = values._ndarray.base, new_values._ndarray.base
+ else:
+ base, new_base = 1, 2 # type: ignore[assignment]
+ if base is new_base:
+ # We can only get here if one of the dimensions is size 1
+ result._mgr.add_references(obj._mgr)
+ return result
def get_new_values(self, values, fill_value=None):
if values.ndim == 1:
@@ -532,9 +544,7 @@ def unstack(
unstacker = _Unstacker(
obj.index, level=level, constructor=obj._constructor_expanddim, sort=sort
)
- return unstacker.get_result(
- obj._values, value_columns=None, fill_value=fill_value
- )
+ return unstacker.get_result(obj, value_columns=None, fill_value=fill_value)
def _unstack_frame(
@@ -550,7 +560,7 @@ def _unstack_frame(
return obj._constructor_from_mgr(mgr, axes=mgr.axes)
else:
return unstacker.get_result(
- obj._values, value_columns=obj.columns, fill_value=fill_value
+ obj, value_columns=obj.columns, fill_value=fill_value
)
diff --git a/pandas/core/series.py b/pandas/core/series.py
index b0dc05fce7913..c5745ba2c4c34 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -97,7 +97,6 @@
algorithms,
base,
common as com,
- missing,
nanops,
ops,
roperator,
@@ -2788,9 +2787,9 @@ def diff(self, periods: int = 1) -> Series:
Notes
-----
For boolean dtypes, this uses :meth:`operator.xor` rather than
- :meth:`operator.sub`.
- The result is calculated according to current dtype in {klass},
- however dtype of the result is always float64.
+ :meth:`operator.sub` and the result's dtype is ``object``.
+ Otherwise, the result is calculated according to the current dtype in {klass},
+ however the dtype of the result is always float64.
Examples
--------
@@ -4257,6 +4256,10 @@ def unstack(
DataFrame
Unstacked Series.
+ See Also
+ --------
+ DataFrame.unstack : Pivot the MultiIndex of a DataFrame.
+
Notes
-----
Reference :ref:`the user guide <reshaping.stacking>` for more examples.
@@ -5112,40 +5115,6 @@ def info(
show_counts=show_counts,
)
- @overload
- def _replace_single(self, to_replace, inplace: Literal[False]) -> Self: ...
-
- @overload
- def _replace_single(self, to_replace, inplace: Literal[True]) -> None: ...
-
- @overload
- def _replace_single(self, to_replace, inplace: bool) -> Self | None: ...
-
- # TODO(3.0): this can be removed once GH#33302 deprecation is enforced
- def _replace_single(self, to_replace, inplace: bool) -> Self | None:
- """
- Replaces values in a Series using the fill method specified when no
- replacement value is given in the replace method
- """
- limit = None
- method = "pad"
-
- result = self if inplace else self.copy()
-
- values = result._values
- mask = missing.mask_missing(values, to_replace)
-
- if isinstance(values, ExtensionArray):
- # dispatch to the EA's _pad_mask_inplace method
- values._fill_mask_inplace(method, limit, mask)
- else:
- fill_f = missing.get_fill_func(method)
- fill_f(values, limit=limit, mask=mask)
-
- if inplace:
- return None
- return result
-
def memory_usage(self, index: bool = True, deep: bool = False) -> int:
"""
Return the memory usage of the Series.
@@ -5644,6 +5613,8 @@ def to_timestamp(
"""
Cast to DatetimeIndex of Timestamps, at *beginning* of period.
+ This can be changed to the *end* of the period, by specifying `how="e"`.
+
Parameters
----------
freq : str, default frequency of PeriodIndex
@@ -5671,6 +5642,12 @@ def to_timestamp(
Returns
-------
Series with DatetimeIndex
+ Series with the PeriodIndex cast to DatetimeIndex.
+
+ See Also
+ --------
+ Series.to_period: Inverse method to cast DatetimeIndex to PeriodIndex.
+ DataFrame.to_timestamp: Equivalent method for DataFrame.
Examples
--------
@@ -5744,6 +5721,11 @@ def to_period(
Series
Series with index converted to PeriodIndex.
+ See Also
+ --------
+ DataFrame.to_period: Equivalent method for DataFrame.
+ Series.dt.to_period: Convert DateTime column values.
+
Examples
--------
>>> idx = pd.DatetimeIndex(["2023", "2024", "2025"])
diff --git a/pandas/core/shared_docs.py b/pandas/core/shared_docs.py
index 2d8517693a2f8..38a443b56ee3d 100644
--- a/pandas/core/shared_docs.py
+++ b/pandas/core/shared_docs.py
@@ -608,24 +608,7 @@
4 None
dtype: object
- When ``value`` is not explicitly passed and `to_replace` is a scalar, list
- or tuple, `replace` uses the method parameter (default 'pad') to do the
- replacement. So this is why the 'a' values are being replaced by 10
- in rows 1 and 2 and 'b' in row 4 in this case.
-
- >>> s.replace('a')
- 0 10
- 1 10
- 2 10
- 3 b
- 4 b
- dtype: object
-
- .. deprecated:: 2.1.0
- The 'method' parameter and padding behavior are deprecated.
-
- On the other hand, if ``None`` is explicitly passed for ``value``, it will
- be respected:
+ If ``None`` is explicitly passed for ``value``, it will be respected:
>>> s.replace('a', None)
0 10
diff --git a/pandas/io/common.py b/pandas/io/common.py
index 35c3a24d8e8f6..4507a7d08c8ba 100644
--- a/pandas/io/common.py
+++ b/pandas/io/common.py
@@ -361,6 +361,16 @@ def _get_filepath_or_buffer(
stacklevel=find_stack_level(),
)
+ if "a" in mode and compression_method in ["zip", "tar"]:
+ # GH56778
+ warnings.warn(
+ "zip and tar do not support mode 'a' properly. "
+ "This combination will result in multiple files with same name "
+ "being added to the archive.",
+ RuntimeWarning,
+ stacklevel=find_stack_level(),
+ )
+
# Use binary mode when converting path-like objects to file-like objects (fsspec)
# except when text mode is explicitly requested. The original mode is returned if
# fsspec is not used.
diff --git a/pandas/io/html.py b/pandas/io/html.py
index b4f6a5508726b..42f5266e7649b 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -584,14 +584,8 @@ class _BeautifulSoupHtml5LibFrameParser(_HtmlFrameParser):
:class:`pandas.io.html._HtmlFrameParser`.
"""
- def __init__(self, *args, **kwargs) -> None:
- super().__init__(*args, **kwargs)
- from bs4 import SoupStrainer
-
- self._strainer = SoupStrainer("table")
-
def _parse_tables(self, document, match, attrs):
- element_name = self._strainer.name
+ element_name = "table"
tables = document.find_all(element_name, attrs=attrs)
if not tables:
raise ValueError("No tables found")
diff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py
index 7ecd8cd6d5012..70f9a68244164 100644
--- a/pandas/io/parsers/readers.py
+++ b/pandas/io/parsers/readers.py
@@ -194,6 +194,12 @@ class _read_shared(TypedDict, Generic[HashableT], total=False):
parameter ignores commented lines and empty lines if
``skip_blank_lines=True``, so ``header=0`` denotes the first line of
data rather than the first line of the file.
+
+ When inferred from the file contents, headers are kept distinct from
+ each other by renaming duplicate names with a numeric suffix of the form
+ ``".{{count}}"`` starting from 1, e.g. ``"foo"`` and ``"foo.1"``.
+ Empty headers are named ``"Unnamed: {{i}}"`` or ``"Unnamed: {{i}}_level_{{level}}"``
+ in the case of MultiIndex columns.
names : Sequence of Hashable, optional
Sequence of column labels to apply. If the file contains a header row,
then you should explicitly pass ``header=0`` to override the column names.
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index aa9d0d88ae69a..8c4c4bac884e5 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -473,8 +473,9 @@ def read_sql_query(
--------
>>> from sqlalchemy import create_engine # doctest: +SKIP
>>> engine = create_engine("sqlite:///database.db") # doctest: +SKIP
+ >>> sql_query = "SELECT int_column FROM test_data" # doctest: +SKIP
>>> with engine.connect() as conn, conn.begin(): # doctest: +SKIP
- ... data = pd.read_sql_table("data", conn) # doctest: +SKIP
+ ... data = pd.read_sql_query(sql_query, conn) # doctest: +SKIP
"""
check_dtype_backend(dtype_backend)
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index 26638c6160b7b..225a3301b8b8c 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -191,10 +191,10 @@ def test_argmax_argmin_no_skipna_notimplemented(self, data_missing_for_sorting):
# GH#38733
data = data_missing_for_sorting
- with pytest.raises(NotImplementedError, match=""):
+ with pytest.raises(ValueError, match="Encountered an NA value"):
data.argmin(skipna=False)
- with pytest.raises(NotImplementedError, match=""):
+ with pytest.raises(ValueError, match="Encountered an NA value"):
data.argmax(skipna=False)
@pytest.mark.parametrize(
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index 3b9c342f35a71..fb7ba2b7af38a 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -1264,13 +1264,8 @@ def test_replace_invalid_to_replace(self):
r"Expecting 'to_replace' to be either a scalar, array-like, "
r"dict or None, got invalid type.*"
)
- msg2 = (
- "DataFrame.replace without 'value' and with non-dict-like "
- "'to_replace' is deprecated"
- )
with pytest.raises(TypeError, match=msg):
- with tm.assert_produces_warning(FutureWarning, match=msg2):
- df.replace(lambda x: x.strip())
+ df.replace(lambda x: x.strip())
@pytest.mark.parametrize("dtype", ["float", "float64", "int64", "Int64", "boolean"])
@pytest.mark.parametrize("value", [np.nan, pd.NA])
diff --git a/pandas/tests/frame/methods/test_set_index.py b/pandas/tests/frame/methods/test_set_index.py
index 4fbc84cd1a66c..a1968c6c694d5 100644
--- a/pandas/tests/frame/methods/test_set_index.py
+++ b/pandas/tests/frame/methods/test_set_index.py
@@ -148,7 +148,7 @@ def test_set_index_dst(self):
def test_set_index(self, float_string_frame):
df = float_string_frame
- idx = Index(np.arange(len(df))[::-1])
+ idx = Index(np.arange(len(df) - 1, -1, -1, dtype=np.int64))
df = df.set_index(idx)
tm.assert_index_equal(df.index, idx)
diff --git a/pandas/tests/frame/methods/test_to_csv.py b/pandas/tests/frame/methods/test_to_csv.py
index 5b9ced8d47ed7..f87fa4137d62d 100644
--- a/pandas/tests/frame/methods/test_to_csv.py
+++ b/pandas/tests/frame/methods/test_to_csv.py
@@ -1405,3 +1405,20 @@ def test_to_csv_categorical_and_interval(self):
expected_rows = [",a", '0,"[2020-01-01 00:00:00, 2020-01-02 00:00:00]"']
expected = tm.convert_rows_list_to_csv_str(expected_rows)
assert result == expected
+
+ def test_to_csv_warn_when_zip_tar_and_append_mode(self):
+ # GH57875
+ df = DataFrame({"a": [1, 2, 3]})
+ msg = (
+ "zip and tar do not support mode 'a' properly. This combination will "
+ "result in multiple files with same name being added to the archive"
+ )
+ with tm.assert_produces_warning(
+ RuntimeWarning, match=msg, raise_on_extra_warnings=False
+ ):
+ df.to_csv("test.zip", mode="a")
+
+ with tm.assert_produces_warning(
+ RuntimeWarning, match=msg, raise_on_extra_warnings=False
+ ):
+ df.to_csv("test.tar", mode="a")
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index fd3dad37da1f9..bb79072d389db 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -1066,7 +1066,7 @@ def test_idxmin(self, float_frame, int_frame, skipna, axis):
frame.iloc[15:20, -2:] = np.nan
for df in [frame, int_frame]:
if (not skipna or axis == 1) and df is not int_frame:
- if axis == 1:
+ if skipna:
msg = "Encountered all NA values"
else:
msg = "Encountered an NA value"
@@ -1116,7 +1116,7 @@ def test_idxmax(self, float_frame, int_frame, skipna, axis):
frame.iloc[15:20, -2:] = np.nan
for df in [frame, int_frame]:
if (skipna is False or axis == 1) and df is frame:
- if axis == 1:
+ if skipna:
msg = "Encountered all NA values"
else:
msg = "Encountered an NA value"
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index 9078ca865042d..0cc8018ea6213 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -513,7 +513,6 @@ def test_read_write_reread_dta14(self, file, parsed_114, version, datapath):
written_and_read_again = self.read_dta(path)
expected = parsed_114.copy()
- expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
@pytest.mark.parametrize(
@@ -576,7 +575,6 @@ def test_numeric_column_names(self):
written_and_read_again.columns = map(convert_col_name, columns)
expected = original
- expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(expected, written_and_read_again)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
@@ -594,7 +592,6 @@ def test_nan_to_missing_value(self, version):
written_and_read_again = written_and_read_again.set_index("index")
expected = original
- expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(written_and_read_again, expected)
def test_no_index(self):
@@ -617,7 +614,6 @@ def test_string_no_dates(self):
written_and_read_again = self.read_dta(path)
expected = original
- expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
def test_large_value_conversion(self):
@@ -637,7 +633,6 @@ def test_large_value_conversion(self):
modified["s1"] = Series(modified["s1"], dtype=np.int16)
modified["s2"] = Series(modified["s2"], dtype=np.int32)
modified["s3"] = Series(modified["s3"], dtype=np.float64)
- modified.index = original.index.astype(np.int32)
tm.assert_frame_equal(written_and_read_again.set_index("index"), modified)
def test_dates_invalid_column(self):
@@ -713,7 +708,7 @@ def test_write_missing_strings(self):
expected = DataFrame(
[["1"], [""]],
- index=pd.Index([0, 1], dtype=np.int32, name="index"),
+ index=pd.RangeIndex(2, name="index"),
columns=["foo"],
)
@@ -746,7 +741,6 @@ def test_bool_uint(self, byteorder, version):
written_and_read_again = written_and_read_again.set_index("index")
expected = original
- expected.index = expected.index.astype(np.int32)
expected_types = (
np.int8,
np.int8,
@@ -1030,7 +1024,7 @@ def test_categorical_writing(self, version):
res = written_and_read_again.set_index("index")
expected = original
- expected.index = expected.index.set_names("index").astype(np.int32)
+ expected.index = expected.index.set_names("index")
expected["incompletely_labeled"] = expected["incompletely_labeled"].apply(str)
expected["unlabeled"] = expected["unlabeled"].apply(str)
@@ -1094,7 +1088,6 @@ def test_categorical_with_stata_missing_values(self, version):
new_cats = cat.remove_unused_categories().categories
cat = cat.set_categories(new_cats, ordered=True)
expected[col] = cat
- expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(res, expected)
@pytest.mark.parametrize("file", ["stata10_115", "stata10_117"])
@@ -1544,7 +1537,6 @@ def test_out_of_range_float(self):
original["ColumnTooBig"] = original["ColumnTooBig"].astype(np.float64)
expected = original
- expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(reread.set_index("index"), expected)
@pytest.mark.parametrize("infval", [np.inf, -np.inf])
@@ -1669,7 +1661,6 @@ def test_writer_117(self):
original["int32"] = original["int32"].astype(np.int32)
original["float32"] = Series(original["float32"], dtype=np.float32)
original.index.name = "index"
- original.index = original.index.astype(np.int32)
copy = original.copy()
with tm.ensure_clean() as path:
original.to_stata(
@@ -1962,7 +1953,7 @@ def test_read_write_ea_dtypes(self, dtype_backend):
# stata stores with ms unit, so unit does not round-trip exactly
"e": pd.date_range("2020-12-31", periods=3, freq="D", unit="ms"),
},
- index=pd.Index([0, 1, 2], name="index", dtype=np.int32),
+ index=pd.RangeIndex(range(3), name="index"),
)
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
@@ -2049,7 +2040,6 @@ def test_compression(compression, version, use_dict, infer, compression_to_exten
reread = read_stata(fp, index_col="index")
expected = df
- expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(reread, expected)
@@ -2075,7 +2065,6 @@ def test_compression_dict(method, file_ext):
reread = read_stata(fp, index_col="index")
expected = df
- expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(reread, expected)
@@ -2085,7 +2074,6 @@ def test_chunked_categorical(version):
df.index.name = "index"
expected = df.copy()
- expected.index = expected.index.astype(np.int32)
with tm.ensure_clean() as path:
df.to_stata(path, version=version)
@@ -2094,7 +2082,9 @@ def test_chunked_categorical(version):
block = block.set_index("index")
assert "cats" in block
tm.assert_series_equal(
- block.cats, expected.cats.iloc[2 * i : 2 * (i + 1)]
+ block.cats,
+ expected.cats.iloc[2 * i : 2 * (i + 1)],
+ check_index_type=len(block) > 1,
)
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index 048553330c1ce..73ac5d0d8f62e 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -171,9 +171,9 @@ def test_argminmax(self):
obj.argmin()
with pytest.raises(ValueError, match="Encountered all NA values"):
obj.argmax()
- with pytest.raises(ValueError, match="Encountered all NA values"):
+ with pytest.raises(ValueError, match="Encountered an NA value"):
obj.argmin(skipna=False)
- with pytest.raises(ValueError, match="Encountered all NA values"):
+ with pytest.raises(ValueError, match="Encountered an NA value"):
obj.argmax(skipna=False)
obj = Index([NaT, datetime(2011, 11, 1), datetime(2011, 11, 2), NaT])
@@ -189,9 +189,9 @@ def test_argminmax(self):
obj.argmin()
with pytest.raises(ValueError, match="Encountered all NA values"):
obj.argmax()
- with pytest.raises(ValueError, match="Encountered all NA values"):
+ with pytest.raises(ValueError, match="Encountered an NA value"):
obj.argmin(skipna=False)
- with pytest.raises(ValueError, match="Encountered all NA values"):
+ with pytest.raises(ValueError, match="Encountered an NA value"):
obj.argmax(skipna=False)
@pytest.mark.parametrize("op, expected_col", [["max", "a"], ["min", "b"]])
@@ -856,7 +856,8 @@ def test_idxmin(self):
# all NaNs
allna = string_series * np.nan
- with pytest.raises(ValueError, match="Encountered all NA values"):
+ msg = "Encountered all NA values"
+ with pytest.raises(ValueError, match=msg):
allna.idxmin()
# datetime64[ns]
@@ -888,7 +889,8 @@ def test_idxmax(self):
# all NaNs
allna = string_series * np.nan
- with pytest.raises(ValueError, match="Encountered all NA values"):
+ msg = "Encountered all NA values"
+ with pytest.raises(ValueError, match=msg):
allna.idxmax()
s = Series(date_range("20130102", periods=6))
@@ -1155,12 +1157,12 @@ def test_idxminmax_object_dtype(self, using_infer_string):
msg = "'>' not supported between instances of 'float' and 'str'"
with pytest.raises(TypeError, match=msg):
ser3.idxmax()
- with pytest.raises(ValueError, match="Encountered an NA value"):
+ with pytest.raises(TypeError, match=msg):
ser3.idxmax(skipna=False)
msg = "'<' not supported between instances of 'float' and 'str'"
with pytest.raises(TypeError, match=msg):
ser3.idxmin()
- with pytest.raises(ValueError, match="Encountered an NA value"):
+ with pytest.raises(TypeError, match=msg):
ser3.idxmin(skipna=False)
def test_idxminmax_object_frame(self):
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 1cd52ab1ae8b4..1a764cb505ead 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -2192,23 +2192,28 @@ def test_merge_on_indexes(self, how, sort, expected):
@pytest.mark.parametrize(
"index",
- [Index([1, 2], dtype=dtyp, name="index_col") for dtyp in tm.ALL_REAL_NUMPY_DTYPES]
+ [
+ Index([1, 2, 4], dtype=dtyp, name="index_col")
+ for dtyp in tm.ALL_REAL_NUMPY_DTYPES
+ ]
+ [
- CategoricalIndex(["A", "B"], categories=["A", "B"], name="index_col"),
- RangeIndex(start=0, stop=2, name="index_col"),
- DatetimeIndex(["2018-01-01", "2018-01-02"], name="index_col"),
+ CategoricalIndex(["A", "B", "C"], categories=["A", "B", "C"], name="index_col"),
+ RangeIndex(start=0, stop=3, name="index_col"),
+ DatetimeIndex(["2018-01-01", "2018-01-02", "2018-01-03"], name="index_col"),
],
ids=lambda x: f"{type(x).__name__}[{x.dtype}]",
)
def test_merge_index_types(index):
# gh-20777
# assert key access is consistent across index types
- left = DataFrame({"left_data": [1, 2]}, index=index)
- right = DataFrame({"right_data": [1.0, 2.0]}, index=index)
+ left = DataFrame({"left_data": [1, 2, 3]}, index=index)
+ right = DataFrame({"right_data": [1.0, 2.0, 3.0]}, index=index)
result = left.merge(right, on=["index_col"])
- expected = DataFrame({"left_data": [1, 2], "right_data": [1.0, 2.0]}, index=index)
+ expected = DataFrame(
+ {"left_data": [1, 2, 3], "right_data": [1.0, 2.0, 3.0]}, index=index
+ )
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index f750d5e7fa919..2ccb622c7a250 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -2703,3 +2703,16 @@ def test_pivot_table_with_margins_and_numeric_column_names(self):
index=Index(["a", "b", "All"], name=0),
)
tm.assert_frame_equal(result, expected)
+
+ @pytest.mark.parametrize("m", [1, 10])
+ def test_unstack_shares_memory(self, m):
+ # GH#56633
+ levels = np.arange(m)
+ index = MultiIndex.from_product([levels] * 2)
+ values = np.arange(m * m * 100).reshape(m * m, 100)
+ df = DataFrame(values, index, np.arange(100))
+ df_orig = df.copy()
+ result = df.unstack(sort=False)
+ assert np.shares_memory(df._values, result._values) is (m == 1)
+ result.iloc[0, 0] = -1
+ tm.assert_frame_equal(df, df_orig)
diff --git a/pandas/tests/series/methods/test_interpolate.py b/pandas/tests/series/methods/test_interpolate.py
index c5df1fd498938..1008c2c87dc9e 100644
--- a/pandas/tests/series/methods/test_interpolate.py
+++ b/pandas/tests/series/methods/test_interpolate.py
@@ -790,11 +790,9 @@ def test_interpolate_unsorted_index(self, ascending, expected_values):
def test_interpolate_asfreq_raises(self):
ser = Series(["a", None, "b"], dtype=object)
- msg2 = "Series cannot interpolate with object dtype"
- msg = "Invalid fill method"
- with pytest.raises(TypeError, match=msg2):
- with pytest.raises(ValueError, match=msg):
- ser.interpolate(method="asfreq")
+ msg = "Can not interpolate with method=asfreq"
+ with pytest.raises(ValueError, match=msg):
+ ser.interpolate(method="asfreq")
def test_interpolate_fill_value(self):
# GH#54920
diff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py
index 09a3469e73462..0a79bcea679a7 100644
--- a/pandas/tests/series/methods/test_replace.py
+++ b/pandas/tests/series/methods/test_replace.py
@@ -137,20 +137,15 @@ def test_replace_gh5319(self):
# API change from 0.12?
# GH 5319
ser = pd.Series([0, np.nan, 2, 3, 4])
- expected = ser.ffill()
msg = (
- "Series.replace without 'value' and with non-dict-like "
- "'to_replace' is deprecated"
+ "Series.replace must specify either 'value', "
+ "a dict-like 'to_replace', or dict-like 'regex'"
)
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = ser.replace([np.nan])
- tm.assert_series_equal(result, expected)
+ with pytest.raises(ValueError, match=msg):
+ ser.replace([np.nan])
- ser = pd.Series([0, np.nan, 2, 3, 4])
- expected = ser.ffill()
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = ser.replace(np.nan)
- tm.assert_series_equal(result, expected)
+ with pytest.raises(ValueError, match=msg):
+ ser.replace(np.nan)
def test_replace_datetime64(self):
# GH 5797
@@ -182,19 +177,16 @@ def test_replace_timedelta_td64(self):
def test_replace_with_single_list(self):
ser = pd.Series([0, 1, 2, 3, 4])
- msg2 = (
- "Series.replace without 'value' and with non-dict-like "
- "'to_replace' is deprecated"
+ msg = (
+ "Series.replace must specify either 'value', "
+ "a dict-like 'to_replace', or dict-like 'regex'"
)
- with tm.assert_produces_warning(FutureWarning, match=msg2):
- result = ser.replace([1, 2, 3])
- tm.assert_series_equal(result, pd.Series([0, 0, 0, 0, 4]))
+ with pytest.raises(ValueError, match=msg):
+ ser.replace([1, 2, 3])
s = ser.copy()
- with tm.assert_produces_warning(FutureWarning, match=msg2):
- return_value = s.replace([1, 2, 3], inplace=True)
- assert return_value is None
- tm.assert_series_equal(s, pd.Series([0, 0, 0, 0, 4]))
+ with pytest.raises(ValueError, match=msg):
+ s.replace([1, 2, 3], inplace=True)
def test_replace_mixed_types(self):
ser = pd.Series(np.arange(5), dtype="int64")
@@ -483,13 +475,8 @@ def test_replace_invalid_to_replace(self):
r"Expecting 'to_replace' to be either a scalar, array-like, "
r"dict or None, got invalid type.*"
)
- msg2 = (
- "Series.replace without 'value' and with non-dict-like "
- "'to_replace' is deprecated"
- )
with pytest.raises(TypeError, match=msg):
- with tm.assert_produces_warning(FutureWarning, match=msg2):
- series.replace(lambda x: x.strip())
+ series.replace(lambda x: x.strip())
@pytest.mark.parametrize("frame", [False, True])
def test_replace_nonbool_regex(self, frame):
diff --git a/pyproject.toml b/pyproject.toml
index 5f5b013ca8461..c9180cf04e7f5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,12 +6,9 @@ requires = [
"meson==1.2.1",
"wheel",
"Cython~=3.0.5", # Note: sync with setup.py, environment.yml and asv.conf.json
- # Any NumPy version should be fine for compiling. Users are unlikely
- # to get a NumPy<1.25 so the result will be compatible with all relevant
- # NumPy versions (if not it is presumably compatible with their version).
- # Pin <2.0 for releases until tested against an RC. But explicitly allow
- # testing the `.dev0` nightlies (which require the extra index).
- "numpy>1.22.4,<=2.0.0.dev0",
+ # Force numpy higher than 2.0rc1, so that built wheels are compatible
+ # with both numpy 1 and 2
+ "numpy>=2.0.0rc1",
"versioneer[toml]"
]
diff --git a/web/pandas/pdeps/0001-purpose-and-guidelines.md b/web/pandas/pdeps/0001-purpose-and-guidelines.md
index 24c91fbab0808..49a3bc4c871cd 100644
--- a/web/pandas/pdeps/0001-purpose-and-guidelines.md
+++ b/web/pandas/pdeps/0001-purpose-and-guidelines.md
@@ -6,7 +6,7 @@
[#51417](https://github.com/pandas-dev/pandas/pull/51417)
- Author: [Marc Garcia](https://github.com/datapythonista),
[Noa Tamir](https://github.com/noatamir)
-- Revision: 2
+- Revision: 3
## PDEP definition, purpose and scope
@@ -56,12 +56,24 @@ advisor on the PDEP when it is submitted to the PDEP repository.
### Workflow
+#### Rationale
+
+Our workflow was created to support and enable a consensus seeking process, and to provide clarity,
+for current and future authors, as well as voting members. It is not a strict policy, and we
+discourage any interpretation which seeks to take advantage of it in a way that could "force" or
+"sneak" decisions in one way or another. We expect and encourage transparency, active discussion,
+feedback, and compromise from all our community members.
+
+#### PDEP States
+
The possible states of a PDEP are:
+- Draft
- Under discussion
- Accepted
- Implemented
- Rejected
+- Withdrawn
Next is described the workflow that PDEPs can follow.
@@ -71,16 +83,75 @@ Proposing a PDEP is done by creating a PR adding a new file to `web/pdeps/`.
The file is a markdown file, you can use `web/pdeps/0001.md` as a reference
for the expected format.
-The initial status of a PDEP will be `Status: Under discussion`. This will be changed to
-`Status: Accepted` when the PDEP is ready and has the approval of the core team.
+The initial status of a PDEP will be `Status: Draft`. This will be changed to
+`Status: Under discussion` by the author(s), when they are ready to proceed with the decision
+making process.
-#### Accepted PDEP
+#### PDEP Discussion Timeline
+
+A PDEP discussion will remain open for up to 60 days. This period aims to enable participation
+from volunteers, who might not always be available to respond quickly, as well as provide ample
+time to make changes based on suggestions and considerations offered by the participants.
+Similarly, the following voting period will remain open for 15 days.
+
+To enable and encourage discussions on PDEPs, we follow a notification schedule. At each of the
+following steps, the pandas team, and the pandas-dev mailing list are notified via GitHub and
+E-mail:
+
+- Once a PDEP is ready for discussion.
+- After 30 days, with a note that there is at most 30 days remaining for discussion,
+ and that a vote will be called for if no discussion occurs in the next 15 days.
+- After 45 days, with a note that there is at most 15 days remaining for discussion,
+ and that a vote will be called for in 15 days.
+- Once the voting period starts, after 60 days or in case of an earlier vote, with 15 days
+ remaining for voting.
+- After 10 voting days, with 5 days remaining for voting.
+
+After 30 discussion days, in case 15 days passed without any new unaddressed comments,
+the authors may close the discussion period preemptively, by sending an early reminder
+of 15 days remaining until the voting period starts.
+
+#### Casting Votes
+
+As the voting period starts, a VOTE issue is created which links to the PDEP discussion pull request.
+Each voting member, including author(s) with voting rights, may cast a vote by adding one of the following comments:
+
+- +1: approve.
+- 0: abstain.
+ - Reason: A one sentence reason is required.
+- -1: disapprove
+ - Reason: A one sentence reason is required.
+
+A disapprove vote requires prior participation in the PDEP discussion issue.
-A PDEP can only be accepted by the core development team, if the proposal is considered
-worth implementing. Decisions will be made based on the process detailed in the
-[pandas governance document](https://github.com/pandas-dev/pandas-governance/blob/master/governance.md).
-In general, more than one approval will be needed before the PR is merged. And
-there should not be any `Request changes` review at the time of merging.
+Comments made on the public VOTE issue by non-voting members will be deleted.
+
+Once the voting period ends, any voter may tally the votes in a comment, using the format: w-x-y-z,
+where w stands for the total of approving, x of abstaining, y of disapproving votes cast, and z
+of number of voting members who did not respond to the VOTE issue. The tally of the votes will state
+if a quorum has been reached or not.
+
+#### Quorum and Majority
+
+For a PDEP vote to result in accepting the proposal, a quorum is required. All votes (including
+abstentions) are counted towards the quorum. The quorum is computed as the lower of these two
+values:
+
+- 11 voting members.
+- 50% of voting members.
+
+Given a quorum, a majority of 70% of the non-abstaining votes is required as well, i.e. 70% of
+the approving and disapproving votes must be in favor.
+
+Thus, abstaining votes count towards a quorum, but not towards a majority. A voting member might
+choose to abstain when they have participated in the discussion, have some objections to the
+proposal, but do not wish to stop the proposal from moving forward, nor indicate their full
+support.
+
+If a quorum was not reached by the end of the voting period, the PDEP is not accepted. Its status
+will change to rejected.
+
+#### Accepted PDEP
Once a PDEP is accepted, any contributions can be made toward the implementation of the PDEP,
with an open-ended completion timeline. Development of pandas is difficult to understand and
@@ -109,6 +180,17 @@ discussion. A PDEP can be rejected for different reasons, for example good ideas
that are not backward-compatible, and the breaking changes are not considered worth
implementing.
+The PDEP author(s) can also decide to withdraw the PDEP before a final decision
+is made (`Status: Withdrawn`), when the PDEP authors themselves have decided
+that the PDEP is actually a bad idea, or have accepted that it is not broadly
+supported or a competing proposal is a better alternative.
+
+The author(s) may choose to resubmit a rejected or withdrawn PDEP. We expect
+authors to use their judgement in that case, as to whether they believe more
+discussion, or an amended proposal has the potential to lead to a different
+result. A new PDEP is then created, which includes a link to the previously
+rejected PDEP.
+
#### Invalid PDEP
For submitted PDEPs that do not contain proper documentation, are out of scope, or
@@ -184,6 +266,7 @@ hope can help clarify our meaning here:
- 3 August 2022: Initial version ([GH-47938][47938])
- 15 February 2023: Version 2 ([GH-51417][51417]) clarifies the scope of PDEPs and adds examples
+- 09 June 2023: Version 3 ([GH-53576][53576]) defines a structured decision making process for PDEPs
[7217]: https://github.com/pandas-dev/pandas/pull/7217
[8074]: https://github.com/pandas-dev/pandas/issues/8074
| - [ ] closes #57245
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58224 | 2024-04-11T19:09:08Z | 2024-04-11T19:11:39Z | null | 2024-04-11T19:11:43Z |
DOC: Fix docstring error for pandas.DataFrame.axes | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 9c39fac13b230..b76ef69efa9f2 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -83,7 +83,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.__iter__ SA01" \
-i "pandas.DataFrame.assign SA01" \
-i "pandas.DataFrame.at_time PR01" \
- -i "pandas.DataFrame.axes SA01" \
-i "pandas.DataFrame.bfill SA01" \
-i "pandas.DataFrame.columns SA01" \
-i "pandas.DataFrame.copy SA01" \
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 6db1811a98dd3..0b386efb5a867 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -995,6 +995,11 @@ def axes(self) -> list[Index]:
It has the row axis labels and column axis labels as the only members.
They are returned in that order.
+ See Also
+ --------
+ DataFrame.index: The index (row labels) of the DataFrame.
+ DataFrame.columns: The column labels of the DataFrame.
+
Examples
--------
>>> df = pd.DataFrame({"col1": [1, 2], "col2": [3, 4]})
| - Fixes docstring error for pandas.DataFrame.axes method (https://github.com/pandas-dev/pandas/issues/58065).
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
Closed previous PR https://github.com/pandas-dev/pandas/pull/58102 and re-opened here. | https://api.github.com/repos/pandas-dev/pandas/pulls/58223 | 2024-04-11T17:57:55Z | 2024-04-11T19:10:12Z | 2024-04-11T19:10:12Z | 2024-04-11T19:10:19Z |
Revert "CI: Pin blosc to fix pytables" | diff --git a/ci/deps/actions-310.yaml b/ci/deps/actions-310.yaml
index 7402f6495c788..ed7dfe1a3c17e 100644
--- a/ci/deps/actions-310.yaml
+++ b/ci/deps/actions-310.yaml
@@ -24,8 +24,6 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
- # https://github.com/conda-forge/pytables-feedstock/issues/97
- - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/actions-311-downstream_compat.yaml b/ci/deps/actions-311-downstream_compat.yaml
index 15ff3d6dbe54c..dd1d341c70a9b 100644
--- a/ci/deps/actions-311-downstream_compat.yaml
+++ b/ci/deps/actions-311-downstream_compat.yaml
@@ -26,8 +26,6 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
- # https://github.com/conda-forge/pytables-feedstock/issues/97
- - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/actions-311.yaml b/ci/deps/actions-311.yaml
index 586cf26da7897..388116439f944 100644
--- a/ci/deps/actions-311.yaml
+++ b/ci/deps/actions-311.yaml
@@ -24,8 +24,6 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
- # https://github.com/conda-forge/pytables-feedstock/issues/97
- - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/actions-312.yaml b/ci/deps/actions-312.yaml
index 96abc7744d871..1d9f8aa3b092a 100644
--- a/ci/deps/actions-312.yaml
+++ b/ci/deps/actions-312.yaml
@@ -24,8 +24,6 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
- # https://github.com/conda-forge/pytables-feedstock/issues/97
- - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/actions-39-minimum_versions.yaml b/ci/deps/actions-39-minimum_versions.yaml
index 4756f1046054d..b760f27a3d4d3 100644
--- a/ci/deps/actions-39-minimum_versions.yaml
+++ b/ci/deps/actions-39-minimum_versions.yaml
@@ -27,8 +27,6 @@ dependencies:
# optional dependencies
- beautifulsoup4=4.11.2
- # https://github.com/conda-forge/pytables-feedstock/issues/97
- - c-blosc2=2.13.2
- blosc=1.21.3
- bottleneck=1.3.6
- fastparquet=2023.10.0
diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index 8154486ff53e1..8f235a836bb3d 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -24,8 +24,6 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
- # https://github.com/conda-forge/pytables-feedstock/issues/97
- - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/circle-310-arm64.yaml b/ci/deps/circle-310-arm64.yaml
index dc6adf175779f..ed4d139714e71 100644
--- a/ci/deps/circle-310-arm64.yaml
+++ b/ci/deps/circle-310-arm64.yaml
@@ -25,8 +25,6 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
- # https://github.com/conda-forge/pytables-feedstock/issues/97
- - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/environment.yml b/environment.yml
index ac4bd0568403b..186d7e1d703df 100644
--- a/environment.yml
+++ b/environment.yml
@@ -28,8 +28,6 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
- # https://github.com/conda-forge/pytables-feedstock/issues/97
- - c-blosc2=2.13.2
- blosc
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/scripts/generate_pip_deps_from_conda.py b/scripts/generate_pip_deps_from_conda.py
index 4e4e54c5be9a9..d54d35bc0171f 100755
--- a/scripts/generate_pip_deps_from_conda.py
+++ b/scripts/generate_pip_deps_from_conda.py
@@ -23,7 +23,7 @@
import tomli as tomllib
import yaml
-EXCLUDE = {"python", "c-compiler", "cxx-compiler", "c-blosc2"}
+EXCLUDE = {"python", "c-compiler", "cxx-compiler"}
REMAP_VERSION = {"tzdata": "2022.7"}
CONDA_TO_PIP = {
"pytables": "tables",
diff --git a/scripts/validate_min_versions_in_sync.py b/scripts/validate_min_versions_in_sync.py
index 59989aadf73ae..1001b00450354 100755
--- a/scripts/validate_min_versions_in_sync.py
+++ b/scripts/validate_min_versions_in_sync.py
@@ -36,7 +36,7 @@
SETUP_PATH = pathlib.Path("pyproject.toml").resolve()
YAML_PATH = pathlib.Path("ci/deps")
ENV_PATH = pathlib.Path("environment.yml")
-EXCLUDE_DEPS = {"tzdata", "blosc", "c-blosc2", "pyqt", "pyqt5"}
+EXCLUDE_DEPS = {"tzdata", "blosc", "pyqt", "pyqt5"}
EXCLUSION_LIST = frozenset(["python=3.8[build=*_pypy]"])
# pandas package is not available
# in pre-commit environment
@@ -225,9 +225,6 @@ def get_versions_from_ci(content: list[str]) -> tuple[dict[str, str], dict[str,
seen_required = True
elif "# optional dependencies" in line:
seen_optional = True
- elif "#" in line:
- # just a comment
- continue
elif "- pip:" in line:
continue
elif seen_required and line.strip():
| Reverts pandas-dev/pandas#58209 | https://api.github.com/repos/pandas-dev/pandas/pulls/58218 | 2024-04-11T12:24:43Z | 2024-04-11T15:21:49Z | 2024-04-11T15:21:49Z | 2024-04-11T15:22:15Z |
BUG: pandas.Series.unique() does not return correct unique values on non UTF8 enodeable strings | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 66c209efb740b..42715127b6d29 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -458,6 +458,7 @@ Other
- Bug in :meth:`DataFrame.sort_index` when passing ``axis="columns"`` and ``ignore_index=True`` and ``ascending=False`` not returning a :class:`RangeIndex` columns (:issue:`57293`)
- Bug in :meth:`DataFrame.where` where using a non-bool type array in the function would return a ``ValueError`` instead of a ``TypeError`` (:issue:`56330`)
- Bug in :meth:`Index.sort_values` when passing a key function that turns values into tuples, e.g. ``key=natsort.natsort_key``, would raise ``TypeError`` (:issue:`56081`)
+- Bug in :meth:`Series.unique` returning incorrect value for unique, non-UTF8 encodeable strings (:issue:`45929`)
- Bug in Dataframe Interchange Protocol implementation was returning incorrect results for data buffers' associated dtype, for string and datetime columns (:issue:`54781`)
.. ***DO NOT USE THIS SECTION***
diff --git a/pandas/_libs/hashtable.pyx b/pandas/_libs/hashtable.pyx
index 97fae1d6480ce..31c5db9ed3481 100644
--- a/pandas/_libs/hashtable.pyx
+++ b/pandas/_libs/hashtable.pyx
@@ -1,8 +1,13 @@
cimport cython
+from cpython.bytes cimport PyBytes_AsString
from cpython.ref cimport (
Py_INCREF,
PyObject,
)
+from cpython.unicode cimport (
+ PyUnicode_AsEncodedString,
+ PyUnicode_AsUTF8,
+)
from libc.stdlib cimport (
free,
malloc,
diff --git a/pandas/_libs/hashtable_class_helper.pxi.in b/pandas/_libs/hashtable_class_helper.pxi.in
index e3a9102fec395..987a9bd380e68 100644
--- a/pandas/_libs/hashtable_class_helper.pxi.in
+++ b/pandas/_libs/hashtable_class_helper.pxi.in
@@ -1172,6 +1172,7 @@ cdef class StringHashTable(HashTable):
const char **vecs
khiter_t k
bint use_na_value
+ list keep_bad_unicode_refs
if return_inverse:
labels = np.zeros(n, dtype=np.intp)
@@ -1182,6 +1183,8 @@ cdef class StringHashTable(HashTable):
vecs = <const char **>malloc(n * sizeof(char *))
if vecs is NULL:
raise MemoryError()
+ # https://cython.readthedocs.io/en/latest/src/userguide/language_basics.html#caveats-when-using-a-python-string-in-a-c-context
+ keep_bad_unicode_refs = []
for i in range(n):
val = values[i]
@@ -1195,9 +1198,11 @@ cdef class StringHashTable(HashTable):
else:
# if ignore_na is False, we also stringify NaN/None/etc.
try:
- v = get_c_string(<str>val)
+ v = PyUnicode_AsUTF8(<str>val)
except UnicodeEncodeError:
- v = get_c_string(<str>repr(val))
+ obj = PyUnicode_AsEncodedString(<str>val, "utf-8", "surrogatepass")
+ keep_bad_unicode_refs.append(obj)
+ v = PyBytes_AsString(obj)
vecs[i] = v
# compute
@@ -1223,6 +1228,8 @@ cdef class StringHashTable(HashTable):
idx = self.table.vals[k]
labels[i] = idx
+ keep_bad_unicode_refs.clear()
+ del keep_bad_unicode_refs
free(vecs)
# uniques
diff --git a/pandas/tests/base/test_unique.py b/pandas/tests/base/test_unique.py
index 3a8ed471f9dc0..790de180dd953 100644
--- a/pandas/tests/base/test_unique.py
+++ b/pandas/tests/base/test_unique.py
@@ -99,7 +99,6 @@ def test_nunique_null(null_obj, index_or_series_obj):
assert obj.nunique(dropna=False) == max(0, num_unique_values)
-@pytest.mark.single_cpu
@pytest.mark.xfail(using_pyarrow_string_dtype(), reason="decoding fails")
def test_unique_bad_unicode(index_or_series):
# regression test for #34550
@@ -116,6 +115,26 @@ def test_unique_bad_unicode(index_or_series):
tm.assert_numpy_array_equal(result, expected)
+def test_unique_bad_unicode2(index_or_series):
+ # regression test for #45929
+ data_list = [
+ "1 \udcd6a NY",
+ "2 \udcd6b NY",
+ "3 \ud800c NY",
+ "4 \udcd6d NY",
+ "5 \udcc3e NY",
+ ]
+
+ obj = index_or_series(data_list)
+ result = obj.unique()
+ if isinstance(obj, pd.Index):
+ expected = pd.Index(data_list, dtype=object)
+ tm.assert_index_equal(result, expected)
+ else:
+ expected = np.array(data_list, dtype=object)
+ tm.assert_numpy_array_equal(result, expected)
+
+
def test_nunique_dropna(dropna):
# GH37566
ser = pd.Series(["yes", "yes", pd.NA, np.nan, None, pd.NaT])
| - [ ] closes #45929 (Replace xxxx with the GitHub issue number)
Revival of https://github.com/pandas-dev/pandas/pull/55530 | https://api.github.com/repos/pandas-dev/pandas/pulls/58215 | 2024-04-10T22:30:52Z | 2024-04-12T00:59:34Z | null | 2024-04-12T13:12:24Z |
DOC: update DatetimeTZDtype unit limitation | diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index 2d8e490f02d52..98e689528744e 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -698,8 +698,8 @@ class DatetimeTZDtype(PandasExtensionDtype):
Parameters
----------
unit : str, default "ns"
- The precision of the datetime data. Currently limited
- to ``"ns"``.
+ The precision of the datetime data. Valid options are
+ ``"s"``, ``"ms"``, ``"us"``, ``"ns"``.
tz : str, int, or datetime.tzinfo
The timezone.
| - [x] closes #58212
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58213 | 2024-04-10T17:44:15Z | 2024-04-12T18:07:59Z | 2024-04-12T18:07:59Z | 2024-04-12T18:52:50Z |
Backport PR #58209: CI: Pin blosc to fix pytables | diff --git a/ci/deps/actions-310.yaml b/ci/deps/actions-310.yaml
index a3e44e6373145..ea2336ae78f81 100644
--- a/ci/deps/actions-310.yaml
+++ b/ci/deps/actions-310.yaml
@@ -24,6 +24,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2022.12.0
diff --git a/ci/deps/actions-311-downstream_compat.yaml b/ci/deps/actions-311-downstream_compat.yaml
index d6bf9ec7843de..8f84a53b58610 100644
--- a/ci/deps/actions-311-downstream_compat.yaml
+++ b/ci/deps/actions-311-downstream_compat.yaml
@@ -26,6 +26,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2022.12.0
diff --git a/ci/deps/actions-311.yaml b/ci/deps/actions-311.yaml
index 95cd1a4d46ef4..51a246ce73a11 100644
--- a/ci/deps/actions-311.yaml
+++ b/ci/deps/actions-311.yaml
@@ -24,6 +24,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2022.12.0
diff --git a/ci/deps/actions-312.yaml b/ci/deps/actions-312.yaml
index a442ed6feeb5d..7d2b9c39d2fe3 100644
--- a/ci/deps/actions-312.yaml
+++ b/ci/deps/actions-312.yaml
@@ -24,6 +24,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2022.12.0
diff --git a/ci/deps/actions-39-minimum_versions.yaml b/ci/deps/actions-39-minimum_versions.yaml
index 7067048c4434d..cedf4fb9dc867 100644
--- a/ci/deps/actions-39-minimum_versions.yaml
+++ b/ci/deps/actions-39-minimum_versions.yaml
@@ -27,6 +27,8 @@ dependencies:
# optional dependencies
- beautifulsoup4=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc=1.21.3
- bottleneck=1.3.6
- fastparquet=2022.12.0
diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index b162a78e7f115..85f2a74e849ee 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -24,6 +24,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2022.12.0
diff --git a/ci/deps/circle-310-arm64.yaml b/ci/deps/circle-310-arm64.yaml
index a19ffd485262d..c018ad94e7f30 100644
--- a/ci/deps/circle-310-arm64.yaml
+++ b/ci/deps/circle-310-arm64.yaml
@@ -25,6 +25,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2022.12.0
diff --git a/environment.yml b/environment.yml
index 58eb69ad1f070..7f2db06d4d50e 100644
--- a/environment.yml
+++ b/environment.yml
@@ -27,6 +27,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc
- bottleneck>=1.3.6
- fastparquet>=2022.12.0
diff --git a/scripts/generate_pip_deps_from_conda.py b/scripts/generate_pip_deps_from_conda.py
index 5fcf09cd073fe..bf38d2fa419d1 100755
--- a/scripts/generate_pip_deps_from_conda.py
+++ b/scripts/generate_pip_deps_from_conda.py
@@ -23,7 +23,7 @@
import tomli as tomllib
import yaml
-EXCLUDE = {"python", "c-compiler", "cxx-compiler"}
+EXCLUDE = {"python", "c-compiler", "cxx-compiler", "c-blosc2"}
REMAP_VERSION = {"tzdata": "2022.7"}
CONDA_TO_PIP = {
"pytables": "tables",
diff --git a/scripts/validate_min_versions_in_sync.py b/scripts/validate_min_versions_in_sync.py
index 7dd3e96e6ec18..62a92cdd10ebc 100755
--- a/scripts/validate_min_versions_in_sync.py
+++ b/scripts/validate_min_versions_in_sync.py
@@ -36,7 +36,7 @@
SETUP_PATH = pathlib.Path("pyproject.toml").resolve()
YAML_PATH = pathlib.Path("ci/deps")
ENV_PATH = pathlib.Path("environment.yml")
-EXCLUDE_DEPS = {"tzdata", "blosc", "pandas-gbq", "pyqt", "pyqt5"}
+EXCLUDE_DEPS = {"tzdata", "blosc", "c-blosc2", "pandas-gbq", "pyqt", "pyqt5"}
EXCLUSION_LIST = frozenset(["python=3.8[build=*_pypy]"])
# pandas package is not available
# in pre-commit environment
@@ -225,6 +225,9 @@ def get_versions_from_ci(content: list[str]) -> tuple[dict[str, str], dict[str,
seen_required = True
elif "# optional dependencies" in line:
seen_optional = True
+ elif "#" in line:
+ # just a comment
+ continue
elif "- pip:" in line:
continue
elif seen_required and line.strip():
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58211 | 2024-04-10T15:38:55Z | 2024-04-10T16:42:52Z | 2024-04-10T16:42:52Z | 2024-04-10T16:42:53Z |
CI: Pin blosc to fix pytables | diff --git a/ci/deps/actions-310.yaml b/ci/deps/actions-310.yaml
index ed7dfe1a3c17e..7402f6495c788 100644
--- a/ci/deps/actions-310.yaml
+++ b/ci/deps/actions-310.yaml
@@ -24,6 +24,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/actions-311-downstream_compat.yaml b/ci/deps/actions-311-downstream_compat.yaml
index dd1d341c70a9b..15ff3d6dbe54c 100644
--- a/ci/deps/actions-311-downstream_compat.yaml
+++ b/ci/deps/actions-311-downstream_compat.yaml
@@ -26,6 +26,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/actions-311.yaml b/ci/deps/actions-311.yaml
index 388116439f944..586cf26da7897 100644
--- a/ci/deps/actions-311.yaml
+++ b/ci/deps/actions-311.yaml
@@ -24,6 +24,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/actions-312.yaml b/ci/deps/actions-312.yaml
index 1d9f8aa3b092a..96abc7744d871 100644
--- a/ci/deps/actions-312.yaml
+++ b/ci/deps/actions-312.yaml
@@ -24,6 +24,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/actions-39-minimum_versions.yaml b/ci/deps/actions-39-minimum_versions.yaml
index b760f27a3d4d3..4756f1046054d 100644
--- a/ci/deps/actions-39-minimum_versions.yaml
+++ b/ci/deps/actions-39-minimum_versions.yaml
@@ -27,6 +27,8 @@ dependencies:
# optional dependencies
- beautifulsoup4=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc=1.21.3
- bottleneck=1.3.6
- fastparquet=2023.10.0
diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index 8f235a836bb3d..8154486ff53e1 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -24,6 +24,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/ci/deps/circle-310-arm64.yaml b/ci/deps/circle-310-arm64.yaml
index ed4d139714e71..dc6adf175779f 100644
--- a/ci/deps/circle-310-arm64.yaml
+++ b/ci/deps/circle-310-arm64.yaml
@@ -25,6 +25,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc>=1.21.3
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/environment.yml b/environment.yml
index 186d7e1d703df..ac4bd0568403b 100644
--- a/environment.yml
+++ b/environment.yml
@@ -28,6 +28,8 @@ dependencies:
# optional dependencies
- beautifulsoup4>=4.11.2
+ # https://github.com/conda-forge/pytables-feedstock/issues/97
+ - c-blosc2=2.13.2
- blosc
- bottleneck>=1.3.6
- fastparquet>=2023.10.0
diff --git a/scripts/generate_pip_deps_from_conda.py b/scripts/generate_pip_deps_from_conda.py
index d54d35bc0171f..4e4e54c5be9a9 100755
--- a/scripts/generate_pip_deps_from_conda.py
+++ b/scripts/generate_pip_deps_from_conda.py
@@ -23,7 +23,7 @@
import tomli as tomllib
import yaml
-EXCLUDE = {"python", "c-compiler", "cxx-compiler"}
+EXCLUDE = {"python", "c-compiler", "cxx-compiler", "c-blosc2"}
REMAP_VERSION = {"tzdata": "2022.7"}
CONDA_TO_PIP = {
"pytables": "tables",
diff --git a/scripts/validate_min_versions_in_sync.py b/scripts/validate_min_versions_in_sync.py
index 1001b00450354..59989aadf73ae 100755
--- a/scripts/validate_min_versions_in_sync.py
+++ b/scripts/validate_min_versions_in_sync.py
@@ -36,7 +36,7 @@
SETUP_PATH = pathlib.Path("pyproject.toml").resolve()
YAML_PATH = pathlib.Path("ci/deps")
ENV_PATH = pathlib.Path("environment.yml")
-EXCLUDE_DEPS = {"tzdata", "blosc", "pyqt", "pyqt5"}
+EXCLUDE_DEPS = {"tzdata", "blosc", "c-blosc2", "pyqt", "pyqt5"}
EXCLUSION_LIST = frozenset(["python=3.8[build=*_pypy]"])
# pandas package is not available
# in pre-commit environment
@@ -225,6 +225,9 @@ def get_versions_from_ci(content: list[str]) -> tuple[dict[str, str], dict[str,
seen_required = True
elif "# optional dependencies" in line:
seen_optional = True
+ elif "#" in line:
+ # just a comment
+ continue
elif "- pip:" in line:
continue
elif seen_required and line.strip():
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58209 | 2024-04-10T14:29:32Z | 2024-04-10T15:36:29Z | 2024-04-10T15:36:29Z | 2024-04-11T07:59:40Z |
Backport PR #58202: DOC/TST: Document numpy 2.0 support and add tests… | diff --git a/doc/source/whatsnew/v2.2.2.rst b/doc/source/whatsnew/v2.2.2.rst
index 0dac3660c76b2..856a31a5cf305 100644
--- a/doc/source/whatsnew/v2.2.2.rst
+++ b/doc/source/whatsnew/v2.2.2.rst
@@ -9,6 +9,21 @@ including other versions of pandas.
{{ header }}
.. ---------------------------------------------------------------------------
+
+.. _whatsnew_220.np2_compat:
+
+Pandas 2.2.2 is now compatible with numpy 2.0
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Pandas 2.2.2 is the first version of pandas that is generally compatible with the upcoming
+numpy 2.0 release, and wheels for pandas 2.2.2 will work with both numpy 1.x and 2.x.
+
+One major caveat is that arrays created with numpy 2.0's new ``StringDtype`` will convert
+to ``object`` dtyped arrays upon :class:`Series`/:class:`DataFrame` creation.
+Full support for numpy 2.0's StringDtype is expected to land in pandas 3.0.
+
+As usual please report any bugs discovered to our `issue tracker <https://github.com/pandas-dev/pandas/issues/new/choose>`_
+
.. _whatsnew_222.regressions:
Fixed regressions
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index acd0675fd43ec..cae2f6e81d384 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -24,6 +24,7 @@
from pandas._config import using_pyarrow_string_dtype
from pandas._libs import lib
+from pandas.compat.numpy import np_version_gt2
from pandas.errors import IntCastingNaNError
import pandas.util._test_decorators as td
@@ -3118,6 +3119,24 @@ def test_columns_indexes_raise_on_sets(self):
with pytest.raises(ValueError, match="columns cannot be a set"):
DataFrame(data, columns={"a", "b", "c"})
+ # TODO: make this not cast to object in pandas 3.0
+ @pytest.mark.skipif(
+ not np_version_gt2, reason="StringDType only available in numpy 2 and above"
+ )
+ @pytest.mark.parametrize(
+ "data",
+ [
+ {"a": ["a", "b", "c"], "b": [1.0, 2.0, 3.0], "c": ["d", "e", "f"]},
+ ],
+ )
+ def test_np_string_array_object_cast(self, data):
+ from numpy.dtypes import StringDType
+
+ data["a"] = np.array(data["a"], dtype=StringDType())
+ res = DataFrame(data)
+ assert res["a"].dtype == np.object_
+ assert (res["a"] == data["a"]).all()
+
def get1(obj): # TODO: make a helper in tm?
if isinstance(obj, Series):
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 4d3839553a0af..387be8398e4b2 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -2191,6 +2191,25 @@ def test_series_constructor_infer_multiindex(self, container, data):
multi = Series(data, index=indexes)
assert isinstance(multi.index, MultiIndex)
+ # TODO: make this not cast to object in pandas 3.0
+ @pytest.mark.skipif(
+ not np_version_gt2, reason="StringDType only available in numpy 2 and above"
+ )
+ @pytest.mark.parametrize(
+ "data",
+ [
+ ["a", "b", "c"],
+ ["a", "b", np.nan],
+ ],
+ )
+ def test_np_string_array_object_cast(self, data):
+ from numpy.dtypes import StringDType
+
+ arr = np.array(data, dtype=StringDType())
+ res = Series(arr)
+ assert res.dtype == np.object_
+ assert (res == data).all()
+
class TestSeriesConstructorInternals:
def test_constructor_no_pandas_array(self, using_array_manager):
| … for string array
- [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58208 | 2024-04-10T12:07:10Z | 2024-04-10T13:01:08Z | 2024-04-10T13:01:08Z | 2024-04-10T13:01:09Z |
Backport PR #58203 on branch 2.2.x (DOC: Add release date/contributors for 2.2.2) | diff --git a/doc/source/whatsnew/v2.2.1.rst b/doc/source/whatsnew/v2.2.1.rst
index 310dd921e44f6..4db0069ec4b95 100644
--- a/doc/source/whatsnew/v2.2.1.rst
+++ b/doc/source/whatsnew/v2.2.1.rst
@@ -87,4 +87,4 @@ Other
Contributors
~~~~~~~~~~~~
-.. contributors:: v2.2.0..v2.2.1|HEAD
+.. contributors:: v2.2.0..v2.2.1
diff --git a/doc/source/whatsnew/v2.2.2.rst b/doc/source/whatsnew/v2.2.2.rst
index 0dac3660c76b2..589a868c850d3 100644
--- a/doc/source/whatsnew/v2.2.2.rst
+++ b/doc/source/whatsnew/v2.2.2.rst
@@ -1,6 +1,6 @@
.. _whatsnew_222:
-What's new in 2.2.2 (April XX, 2024)
+What's new in 2.2.2 (April 10, 2024)
---------------------------------------
These are the changes in pandas 2.2.2. See :ref:`release` for a full changelog
@@ -40,3 +40,5 @@ Other
Contributors
~~~~~~~~~~~~
+
+.. contributors:: v2.2.1..v2.2.2|HEAD
| Backport PR #58203: DOC: Add release date/contributors for 2.2.2 | https://api.github.com/repos/pandas-dev/pandas/pulls/58206 | 2024-04-10T00:16:06Z | 2024-04-10T12:06:47Z | 2024-04-10T12:06:47Z | 2024-04-10T12:06:47Z |
GH: PDEP vote issue template | diff --git a/.github/ISSUE_TEMPLATE/pdep_vote.yaml b/.github/ISSUE_TEMPLATE/pdep_vote.yaml
new file mode 100644
index 0000000000000..6dcbd76eb0f74
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/pdep_vote.yaml
@@ -0,0 +1,74 @@
+name: PDEP Vote
+description: Call for a vote on a PDEP
+title: "VOTE: "
+labels: [Vote]
+
+body:
+ - type: markdown
+ attributes:
+ value: >
+ As per [PDEP-1](https://pandas.pydata.org/pdeps/0001-purpose-and-guidelines.html), the following issue template should be used when a
+ maintainer has opened a PDEP discussion and is ready to call for a vote.
+ - type: checkboxes
+ attributes:
+ label: Locked issue
+ options:
+ - label: >
+ I locked this voting issue so that only voting members are able to cast their votes or
+ comment on this issue.
+ required: true
+ - type: input
+ id: PDEP-name
+ attributes:
+ label: PDEP number and title
+ placeholder: >
+ PDEP-1: Purpose and guidelines
+ validations:
+ required: true
+ - type: input
+ id: PDEP-link
+ attributes:
+ label: Pull request with discussion
+ description: e.g. https://github.com/pandas-dev/pandas/pull/47444
+ validations:
+ required: true
+ - type: input
+ id: PDEP-rendered-link
+ attributes:
+ label: Rendered PDEP for easy reading
+ description: e.g. https://github.com/pandas-dev/pandas/pull/47444/files?short_path=7c449e6#diff-7c449e698132205b235c501f7e47ebba38da4d2b7f9492c98f16745dba787041
+ validations:
+ required: true
+ - type: input
+ id: PDEP-number-of-discussion-participants
+ attributes:
+ label: Discussion participants
+ description: >
+ You may find it useful to list or total the number of participating members in the
+ PDEP discussion PR. This would be the maximum possible disapprove votes.
+ placeholder: >
+ 14 voting members participated in the PR discussion thus far.
+ - type: input
+ id: PDEP-vote-end
+ attributes:
+ label: Voting will close in 15 days.
+ description: The voting period end date. ('Voting will close in 15 days.' will be automatically written)
+ - type: markdown
+ attributes:
+ value: ---
+ - type: textarea
+ id: Vote
+ attributes:
+ label: Vote
+ value: |
+ Cast your vote in a comment below.
+ * +1: approve.
+ * 0: abstain.
+ * Reason: A one sentence reason is required.
+ * -1: disapprove
+ * Reason: A one sentence reason is required.
+ A disapprove vote requires prior participation in the linked discussion PR.
+
+ @pandas-dev/pandas-core
+ validations:
+ required: true
diff --git a/web/pandas/pdeps/0001-purpose-and-guidelines.md b/web/pandas/pdeps/0001-purpose-and-guidelines.md
index 49a3bc4c871cd..bb15b8f997b11 100644
--- a/web/pandas/pdeps/0001-purpose-and-guidelines.md
+++ b/web/pandas/pdeps/0001-purpose-and-guidelines.md
@@ -79,8 +79,8 @@ Next is described the workflow that PDEPs can follow.
#### Submitting a PDEP
-Proposing a PDEP is done by creating a PR adding a new file to `web/pdeps/`.
-The file is a markdown file, you can use `web/pdeps/0001.md` as a reference
+Proposing a PDEP is done by creating a PR adding a new file to `web/pandas/pdeps/`.
+The file is a markdown file, you can use `web/pandas/pdeps/0001-purpose-and-guidelines.md` as a reference
for the expected format.
The initial status of a PDEP will be `Status: Draft`. This will be changed to
| Continuation of https://github.com/pandas-dev/pandas/pull/54469
Feel free to preview this by opening an issue in my fork | https://api.github.com/repos/pandas-dev/pandas/pulls/58204 | 2024-04-09T23:02:01Z | 2024-04-16T17:17:02Z | 2024-04-16T17:17:02Z | 2024-04-16T17:17:12Z |
DOC: Add release date/contributors for 2.2.2 | diff --git a/doc/source/whatsnew/v2.2.1.rst b/doc/source/whatsnew/v2.2.1.rst
index 310dd921e44f6..4db0069ec4b95 100644
--- a/doc/source/whatsnew/v2.2.1.rst
+++ b/doc/source/whatsnew/v2.2.1.rst
@@ -87,4 +87,4 @@ Other
Contributors
~~~~~~~~~~~~
-.. contributors:: v2.2.0..v2.2.1|HEAD
+.. contributors:: v2.2.0..v2.2.1
diff --git a/doc/source/whatsnew/v2.2.2.rst b/doc/source/whatsnew/v2.2.2.rst
index 0dac3660c76b2..589a868c850d3 100644
--- a/doc/source/whatsnew/v2.2.2.rst
+++ b/doc/source/whatsnew/v2.2.2.rst
@@ -1,6 +1,6 @@
.. _whatsnew_222:
-What's new in 2.2.2 (April XX, 2024)
+What's new in 2.2.2 (April 10, 2024)
---------------------------------------
These are the changes in pandas 2.2.2. See :ref:`release` for a full changelog
@@ -40,3 +40,5 @@ Other
Contributors
~~~~~~~~~~~~
+
+.. contributors:: v2.2.1..v2.2.2|HEAD
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58203 | 2024-04-09T22:40:02Z | 2024-04-10T00:15:38Z | 2024-04-10T00:15:38Z | 2024-04-10T00:15:39Z |
DOC/TST: Document numpy 2.0 support and add tests for string array | diff --git a/doc/source/whatsnew/v2.2.2.rst b/doc/source/whatsnew/v2.2.2.rst
index 0dac3660c76b2..856a31a5cf305 100644
--- a/doc/source/whatsnew/v2.2.2.rst
+++ b/doc/source/whatsnew/v2.2.2.rst
@@ -9,6 +9,21 @@ including other versions of pandas.
{{ header }}
.. ---------------------------------------------------------------------------
+
+.. _whatsnew_220.np2_compat:
+
+Pandas 2.2.2 is now compatible with numpy 2.0
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Pandas 2.2.2 is the first version of pandas that is generally compatible with the upcoming
+numpy 2.0 release, and wheels for pandas 2.2.2 will work with both numpy 1.x and 2.x.
+
+One major caveat is that arrays created with numpy 2.0's new ``StringDtype`` will convert
+to ``object`` dtyped arrays upon :class:`Series`/:class:`DataFrame` creation.
+Full support for numpy 2.0's StringDtype is expected to land in pandas 3.0.
+
+As usual please report any bugs discovered to our `issue tracker <https://github.com/pandas-dev/pandas/issues/new/choose>`_
+
.. _whatsnew_222.regressions:
Fixed regressions
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 12d8269b640fc..53476c2f7ce38 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -24,6 +24,7 @@
from pandas._config import using_pyarrow_string_dtype
from pandas._libs import lib
+from pandas.compat.numpy import np_version_gt2
from pandas.errors import IntCastingNaNError
from pandas.core.dtypes.common import is_integer_dtype
@@ -3052,6 +3053,24 @@ def test_from_dict_with_columns_na_scalar(self):
expected = DataFrame({"a": Series([pd.NaT, pd.NaT])})
tm.assert_frame_equal(result, expected)
+ # TODO: make this not cast to object in pandas 3.0
+ @pytest.mark.skipif(
+ not np_version_gt2, reason="StringDType only available in numpy 2 and above"
+ )
+ @pytest.mark.parametrize(
+ "data",
+ [
+ {"a": ["a", "b", "c"], "b": [1.0, 2.0, 3.0], "c": ["d", "e", "f"]},
+ ],
+ )
+ def test_np_string_array_object_cast(self, data):
+ from numpy.dtypes import StringDType
+
+ data["a"] = np.array(data["a"], dtype=StringDType())
+ res = DataFrame(data)
+ assert res["a"].dtype == np.object_
+ assert (res["a"] == data["a"]).all()
+
def get1(obj): # TODO: make a helper in tm?
if isinstance(obj, Series):
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 97faba532e94a..3f9d5bbe806bb 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -2176,6 +2176,25 @@ def test_series_constructor_infer_multiindex(self, container, data):
multi = Series(data, index=indexes)
assert isinstance(multi.index, MultiIndex)
+ # TODO: make this not cast to object in pandas 3.0
+ @pytest.mark.skipif(
+ not np_version_gt2, reason="StringDType only available in numpy 2 and above"
+ )
+ @pytest.mark.parametrize(
+ "data",
+ [
+ ["a", "b", "c"],
+ ["a", "b", np.nan],
+ ],
+ )
+ def test_np_string_array_object_cast(self, data):
+ from numpy.dtypes import StringDType
+
+ arr = np.array(data, dtype=StringDType())
+ res = Series(arr)
+ assert res.dtype == np.object_
+ assert (res == data).all()
+
class TestSeriesConstructorInternals:
def test_constructor_no_pandas_array(self):
| - [ ] closes #58104 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58202 | 2024-04-09T22:34:15Z | 2024-04-10T11:48:25Z | 2024-04-10T11:48:24Z | 2024-04-10T12:32:01Z |
CLN: Remove unused code | diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index 239d78b3b8b7a..124730e1b5ca9 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -263,7 +263,6 @@ def __init__(
self.sort = sort
self.dropna = dropna
- self._grouper_deprecated = None
self._indexer_deprecated: npt.NDArray[np.intp] | None = None
self.binner = None
self._grouper = None
@@ -292,10 +291,6 @@ def _get_grouper(
validate=validate,
dropna=self.dropna,
)
- # Without setting this, subsequent lookups to .groups raise
- # error: Incompatible types in assignment (expression has type "BaseGrouper",
- # variable has type "None")
- self._grouper_deprecated = grouper # type: ignore[assignment]
return grouper, obj
| This looks like a `mypy` error only, which passes now. | https://api.github.com/repos/pandas-dev/pandas/pulls/58201 | 2024-04-09T21:55:22Z | 2024-04-09T22:53:31Z | 2024-04-09T22:53:31Z | 2024-04-09T22:54:15Z |
CLN: Make iterators lazier | diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index e8df24850f7a8..832beeddcef3c 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -1710,9 +1710,9 @@ def normalize_keyword_aggregation(
# TODO: aggspec type: typing.Dict[str, List[AggScalar]]
aggspec = defaultdict(list)
order = []
- columns, pairs = list(zip(*kwargs.items()))
+ columns = tuple(kwargs.keys())
- for column, aggfunc in pairs:
+ for column, aggfunc in kwargs.values():
aggspec[column].append(aggfunc)
order.append((column, com.get_callable_name(aggfunc) or aggfunc))
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 97cf86d45812d..76df5c82e6239 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -6168,12 +6168,13 @@ class max type
names = self.index._get_default_index_names(names, default)
if isinstance(self.index, MultiIndex):
- to_insert = zip(self.index.levels, self.index.codes)
+ to_insert = zip(reversed(self.index.levels), reversed(self.index.codes))
else:
to_insert = ((self.index, None),)
multi_col = isinstance(self.columns, MultiIndex)
- for i, (lev, lab) in reversed(list(enumerate(to_insert))):
+ for j, (lev, lab) in enumerate(to_insert, start=1):
+ i = self.index.nlevels - j
if level is not None and i not in level:
continue
name = names[i]
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 8585ae3828247..0d88882c9b7ef 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -706,7 +706,7 @@ def groups(self) -> dict[Hashable, Index]:
return self.groupings[0].groups
result_index, ids = self.result_index_and_ids
values = result_index._values
- categories = Categorical(ids, categories=np.arange(len(result_index)))
+ categories = Categorical(ids, categories=range(len(result_index)))
result = {
# mypy is not aware that group has to be an integer
values[group]: self.axis.take(axis_ilocs) # type: ignore[call-overload]
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index a834d3e54d30b..c9b502add21e0 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -899,7 +899,7 @@ def __setitem__(self, key, value) -> None:
check_dict_or_set_indexers(key)
if isinstance(key, tuple):
- key = tuple(list(x) if is_iterator(x) else x for x in key)
+ key = (list(x) if is_iterator(x) else x for x in key)
key = tuple(com.apply_if_callable(x, self.obj) for x in key)
else:
maybe_callable = com.apply_if_callable(key, self.obj)
@@ -1177,7 +1177,7 @@ def _check_deprecated_callable_usage(self, key: Any, maybe_callable: T) -> T:
def __getitem__(self, key):
check_dict_or_set_indexers(key)
if type(key) is tuple:
- key = tuple(list(x) if is_iterator(x) else x for x in key)
+ key = (list(x) if is_iterator(x) else x for x in key)
key = tuple(com.apply_if_callable(x, self.obj) for x in key)
if self._is_scalar_access(key):
return self.obj._get_value(*key, takeable=self._takeable)
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
index 002efec1d8b52..4fba243f73536 100644
--- a/pandas/core/sorting.py
+++ b/pandas/core/sorting.py
@@ -172,8 +172,6 @@ def maybe_lift(lab, size: int) -> tuple[np.ndarray, int]:
for i, (lab, size) in enumerate(zip(labels, shape)):
labels[i], lshape[i] = maybe_lift(lab, size)
- labels = list(labels)
-
# Iteratively process all the labels in chunks sized so less
# than lib.i8max unique int ids will be required for each chunk
while True:
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/58200 | 2024-04-09T17:30:18Z | 2024-04-09T18:45:50Z | 2024-04-09T18:45:50Z | 2024-04-09T21:51:10Z |
Fix ASV with virtualenv | diff --git a/asv_bench/asv.conf.json b/asv_bench/asv.conf.json
index e02ff26ba14e9..30c692115eab1 100644
--- a/asv_bench/asv.conf.json
+++ b/asv_bench/asv.conf.json
@@ -41,6 +41,7 @@
// pip (with all the conda available packages installed first,
// followed by the pip installed packages).
"matrix": {
+ "pip+build": [],
"Cython": ["3.0"],
"matplotlib": [],
"sqlalchemy": [],
| The default remains conda, but this is needed if you ever change the default locally. Otherwise you get
STDERR -------->
/home/willayd/clones/pandas/asv_bench/env/7e437c4d615a12609229592196e74215/bin/python: No module named build | https://api.github.com/repos/pandas-dev/pandas/pulls/58199 | 2024-04-09T16:33:56Z | 2024-04-09T17:16:16Z | 2024-04-09T17:16:16Z | 2024-04-09T17:16:23Z |
Remove unused tslib function | diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index ee8ed762fdb6e..aecf9f2e46bd4 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -70,7 +70,6 @@ from pandas._libs.tslibs.conversion cimport (
from pandas._libs.tslibs.dtypes cimport npy_unit_to_abbrev
from pandas._libs.tslibs.nattype cimport (
NPY_NAT,
- c_NaT as NaT,
c_nat_strings as nat_strings,
)
from pandas._libs.tslibs.timestamps cimport _Timestamp
@@ -346,39 +345,6 @@ def array_with_unit_to_datetime(
return result, tz
-cdef _array_with_unit_to_datetime_object_fallback(ndarray[object] values, str unit):
- cdef:
- Py_ssize_t i, n = len(values)
- ndarray[object] oresult
- tzinfo tz = None
-
- # TODO: fix subtle differences between this and no-unit code
- oresult = cnp.PyArray_EMPTY(values.ndim, values.shape, cnp.NPY_OBJECT, 0)
- for i in range(n):
- val = values[i]
-
- if checknull_with_nat_and_na(val):
- oresult[i] = <object>NaT
- elif is_integer_object(val) or is_float_object(val):
-
- if val != val or val == NPY_NAT:
- oresult[i] = <object>NaT
- else:
- try:
- oresult[i] = Timestamp(val, unit=unit)
- except OutOfBoundsDatetime:
- oresult[i] = val
-
- elif isinstance(val, str):
- if len(val) == 0 or val in nat_strings:
- oresult[i] = <object>NaT
-
- else:
- oresult[i] = val
-
- return oresult, tz
-
-
@cython.wraparound(False)
@cython.boundscheck(False)
def first_non_null(values: ndarray) -> int:
| Flagged during compilation
[22/27] Compiling C object pandas/_libs/tslib.cpython-310-x86_64-linux-gnu.so.p/meson-generated_pandas__libs_tslib.pyx.c.o
pandas/_libs/tslib.cpython-310-x86_64-linux-gnu.so.p/pandas/_libs/tslib.pyx.c:27000:18: warning: '__pyx_f_6pandas_5_libs_5tslib__array_with_unit_to_datetime_object_fallback' defined but not used [-Wunused-function]
| https://api.github.com/repos/pandas-dev/pandas/pulls/58198 | 2024-04-09T16:28:14Z | 2024-04-09T17:15:43Z | 2024-04-09T17:15:43Z | 2024-04-09T17:15:50Z |
Add low-level create_dataframe_from_blocks helper function | diff --git a/pandas/api/internals.py b/pandas/api/internals.py
new file mode 100644
index 0000000000000..03d8992a87575
--- /dev/null
+++ b/pandas/api/internals.py
@@ -0,0 +1,62 @@
+import numpy as np
+
+from pandas._typing import ArrayLike
+
+from pandas import (
+ DataFrame,
+ Index,
+)
+from pandas.core.internals.api import _make_block
+from pandas.core.internals.managers import BlockManager as _BlockManager
+
+
+def create_dataframe_from_blocks(
+ blocks: list[tuple[ArrayLike, np.ndarray]], index: Index, columns: Index
+) -> DataFrame:
+ """
+ Low-level function to create a DataFrame from arrays as they are
+ representing the block structure of the resulting DataFrame.
+
+ Attention: this is an advanced, low-level function that should only be
+ used if you know that the below-mentioned assumptions are guaranteed.
+ If passing data that do not follow those assumptions, subsequent
+ subsequent operations on the resulting DataFrame might lead to strange
+ errors.
+ For almost all use cases, you should use the standard pd.DataFrame(..)
+ constructor instead. If you are planning to use this function, let us
+ know by opening an issue at https://github.com/pandas-dev/pandas/issues.
+
+ Assumptions:
+
+ - The block arrays are either a 2D numpy array or a pandas ExtensionArray
+ - In case of a numpy array, it is assumed to already be in the expected
+ shape for Blocks (2D, (cols, rows), i.e. transposed compared to the
+ DataFrame columns).
+ - All arrays are taken as is (no type inference) and expected to have the
+ correct size.
+ - The placement arrays have the correct length (equalling the number of
+ columns that its equivalent block array represents), and all placement
+ arrays together form a complete set of 0 to n_columns - 1.
+
+ Parameters
+ ----------
+ blocks : list of tuples of (block_array, block_placement)
+ This should be a list of tuples existing of (block_array, block_placement),
+ where:
+
+ - block_array is a 2D numpy array or a 1D ExtensionArray, following the
+ requirements listed above.
+ - block_placement is a 1D integer numpy array
+ index : Index
+ The Index object for the `index` of the resulting DataFrame.
+ columns : Index
+ The Index object for the `columns` of the resulting DataFrame.
+
+ Returns
+ -------
+ DataFrame
+ """
+ block_objs = [_make_block(*block) for block in blocks]
+ axes = [columns, index]
+ mgr = _BlockManager(block_objs, axes)
+ return DataFrame._from_mgr(mgr, mgr.axes)
diff --git a/pandas/core/internals/api.py b/pandas/core/internals/api.py
index d6e1e8b38dfe3..ef25d7ed5ae9e 100644
--- a/pandas/core/internals/api.py
+++ b/pandas/core/internals/api.py
@@ -18,10 +18,14 @@
from pandas.core.dtypes.common import pandas_dtype
from pandas.core.dtypes.dtypes import (
DatetimeTZDtype,
+ ExtensionDtype,
PeriodDtype,
)
-from pandas.core.arrays import DatetimeArray
+from pandas.core.arrays import (
+ DatetimeArray,
+ TimedeltaArray,
+)
from pandas.core.construction import extract_array
from pandas.core.internals.blocks import (
check_ndim,
@@ -32,11 +36,43 @@
)
if TYPE_CHECKING:
- from pandas._typing import Dtype
+ from pandas._typing import (
+ ArrayLike,
+ Dtype,
+ )
from pandas.core.internals.blocks import Block
+def _make_block(values: ArrayLike, placement: np.ndarray) -> Block:
+ """
+ This is an analogue to blocks.new_block(_2d) that ensures:
+ 1) correct dimension for EAs that support 2D (`ensure_block_shape`), and
+ 2) correct EA class for datetime64/timedelta64 (`maybe_coerce_values`).
+
+ The input `values` is assumed to be either numpy array or ExtensionArray:
+ - In case of a numpy array, it is assumed to already be in the expected
+ shape for Blocks (2D, (cols, rows)).
+ - In case of an ExtensionArray the input can be 1D, also for EAs that are
+ internally stored as 2D.
+
+ For the rest no preprocessing or validation is done, except for those dtypes
+ that are internally stored as EAs but have an exact numpy equivalent (and at
+ the moment use that numpy dtype), i.e. datetime64/timedelta64.
+ """
+ dtype = values.dtype
+ klass = get_block_type(dtype)
+ placement_obj = BlockPlacement(placement)
+
+ if (isinstance(dtype, ExtensionDtype) and dtype._supports_2d) or isinstance(
+ values, (DatetimeArray, TimedeltaArray)
+ ):
+ values = ensure_block_shape(values, ndim=2)
+
+ values = maybe_coerce_values(values)
+ return klass(values, ndim=2, placement=placement_obj)
+
+
def make_block(
values, placement, klass=None, ndim=None, dtype: Dtype | None = None
) -> Block:
diff --git a/pandas/tests/api/test_api.py b/pandas/tests/api/test_api.py
index e32e5a268d46d..5ee9932fbd051 100644
--- a/pandas/tests/api/test_api.py
+++ b/pandas/tests/api/test_api.py
@@ -248,6 +248,7 @@ class TestApi(Base):
"indexers",
"interchange",
"typing",
+ "internals",
]
allowed_typing = [
"DataFrameGroupBy",
diff --git a/pandas/tests/internals/test_api.py b/pandas/tests/internals/test_api.py
index 5bff1b7be3080..7ab8988521fdf 100644
--- a/pandas/tests/internals/test_api.py
+++ b/pandas/tests/internals/test_api.py
@@ -3,10 +3,14 @@
in core.internals
"""
+import datetime
+
+import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
+from pandas.api.internals import create_dataframe_from_blocks
from pandas.core import internals
from pandas.core.internals import api
@@ -71,3 +75,91 @@ def test_create_block_manager_from_blocks_deprecated():
)
with tm.assert_produces_warning(DeprecationWarning, match=msg):
internals.create_block_manager_from_blocks
+
+
+def test_create_dataframe_from_blocks(float_frame):
+ block = float_frame._mgr.blocks[0]
+ index = float_frame.index.copy()
+ columns = float_frame.columns.copy()
+
+ result = create_dataframe_from_blocks(
+ [(block.values, block.mgr_locs.as_array)], index=index, columns=columns
+ )
+ tm.assert_frame_equal(result, float_frame)
+
+
+def test_create_dataframe_from_blocks_types():
+ df = pd.DataFrame(
+ {
+ "int": list(range(1, 4)),
+ "uint": np.arange(3, 6).astype("uint8"),
+ "float": [2.0, np.nan, 3.0],
+ "bool": np.array([True, False, True]),
+ "boolean": pd.array([True, False, None], dtype="boolean"),
+ "string": list("abc"),
+ "datetime": pd.date_range("20130101", periods=3),
+ "datetimetz": pd.date_range("20130101", periods=3).tz_localize(
+ "Europe/Brussels"
+ ),
+ "timedelta": pd.timedelta_range("1 day", periods=3),
+ "period": pd.period_range("2012-01-01", periods=3, freq="D"),
+ "categorical": pd.Categorical(["a", "b", "a"]),
+ "interval": pd.IntervalIndex.from_tuples([(0, 1), (1, 2), (3, 4)]),
+ }
+ )
+
+ result = create_dataframe_from_blocks(
+ [(block.values, block.mgr_locs.as_array) for block in df._mgr.blocks],
+ index=df.index,
+ columns=df.columns,
+ )
+ tm.assert_frame_equal(result, df)
+
+
+def test_create_dataframe_from_blocks_datetimelike():
+ # extension dtypes that have an exact matching numpy dtype can also be
+ # be passed as a numpy array
+ index, columns = pd.RangeIndex(3), pd.Index(["a", "b", "c", "d"])
+
+ block_array1 = np.arange(
+ datetime.datetime(2020, 1, 1),
+ datetime.datetime(2020, 1, 7),
+ step=datetime.timedelta(1),
+ ).reshape((2, 3))
+ block_array2 = np.arange(
+ datetime.timedelta(1), datetime.timedelta(7), step=datetime.timedelta(1)
+ ).reshape((2, 3))
+ result = create_dataframe_from_blocks(
+ [(block_array1, np.array([0, 2])), (block_array2, np.array([1, 3]))],
+ index=index,
+ columns=columns,
+ )
+ expected = pd.DataFrame(
+ {
+ "a": pd.date_range("2020-01-01", periods=3, unit="us"),
+ "b": pd.timedelta_range("1 days", periods=3, unit="us"),
+ "c": pd.date_range("2020-01-04", periods=3, unit="us"),
+ "d": pd.timedelta_range("4 days", periods=3, unit="us"),
+ }
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "array",
+ [
+ pd.date_range("2020-01-01", periods=3),
+ pd.date_range("2020-01-01", periods=3, tz="UTC"),
+ pd.period_range("2012-01-01", periods=3, freq="D"),
+ pd.timedelta_range("1 day", periods=3),
+ ],
+)
+def test_create_dataframe_from_blocks_1dEA(array):
+ # ExtensionArrays can be passed as 1D even if stored under the hood as 2D
+ df = pd.DataFrame({"a": array})
+
+ block = df._mgr.blocks[0]
+ result = create_dataframe_from_blocks(
+ [(block.values[0], block.mgr_locs.as_array)], index=df.index, columns=df.columns
+ )
+ tm.assert_frame_equal(result, df)
diff --git a/scripts/validate_unwanted_patterns.py b/scripts/validate_unwanted_patterns.py
index a732d3f83a40a..ba3123a07df4b 100755
--- a/scripts/validate_unwanted_patterns.py
+++ b/scripts/validate_unwanted_patterns.py
@@ -54,6 +54,7 @@
# TODO(4.0): GH#55043 - remove upon removal of CoW option
"_get_option",
"_fill_limit_area_1d",
+ "_make_block",
}
| See my explanation at https://github.com/pandas-dev/pandas/issues/56815/
- [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58197 | 2024-04-09T15:40:41Z | 2024-04-15T17:37:16Z | 2024-04-15T17:37:16Z | 2024-04-15T19:21:52Z |
TST: Add tests for reading Stata dta files saved in big-endian format | diff --git a/pandas/tests/io/data/stata/stata-compat-be-105.dta b/pandas/tests/io/data/stata/stata-compat-be-105.dta
new file mode 100644
index 0000000000000..af75548c840d4
Binary files /dev/null and b/pandas/tests/io/data/stata/stata-compat-be-105.dta differ
diff --git a/pandas/tests/io/data/stata/stata-compat-be-108.dta b/pandas/tests/io/data/stata/stata-compat-be-108.dta
new file mode 100644
index 0000000000000..e3e5d85fca4ad
Binary files /dev/null and b/pandas/tests/io/data/stata/stata-compat-be-108.dta differ
diff --git a/pandas/tests/io/data/stata/stata-compat-be-111.dta b/pandas/tests/io/data/stata/stata-compat-be-111.dta
new file mode 100644
index 0000000000000..197decdcf0c2d
Binary files /dev/null and b/pandas/tests/io/data/stata/stata-compat-be-111.dta differ
diff --git a/pandas/tests/io/data/stata/stata-compat-be-113.dta b/pandas/tests/io/data/stata/stata-compat-be-113.dta
new file mode 100644
index 0000000000000..c69c32106114f
Binary files /dev/null and b/pandas/tests/io/data/stata/stata-compat-be-113.dta differ
diff --git a/pandas/tests/io/data/stata/stata-compat-be-114.dta b/pandas/tests/io/data/stata/stata-compat-be-114.dta
new file mode 100644
index 0000000000000..222bdb2b62784
Binary files /dev/null and b/pandas/tests/io/data/stata/stata-compat-be-114.dta differ
diff --git a/pandas/tests/io/data/stata/stata-compat-be-118.dta b/pandas/tests/io/data/stata/stata-compat-be-118.dta
new file mode 100644
index 0000000000000..0a5df1b321c2d
Binary files /dev/null and b/pandas/tests/io/data/stata/stata-compat-be-118.dta differ
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index 1bd71768d226e..65975bcc46f8e 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -1958,6 +1958,15 @@ def test_backward_compat(version, datapath):
tm.assert_frame_equal(old_dta, expected, check_dtype=False)
+@pytest.mark.parametrize("version", [105, 108, 111, 113, 114, 118])
+def test_bigendian(version, datapath):
+ ref = datapath("io", "data", "stata", f"stata-compat-{version}.dta")
+ big = datapath("io", "data", "stata", f"stata-compat-be-{version}.dta")
+ expected = read_stata(ref)
+ big_dta = read_stata(big)
+ tm.assert_frame_equal(big_dta, expected)
+
+
def test_direct_read(datapath, monkeypatch):
file_path = datapath("io", "data", "stata", "stata-compat-118.dta")
| - [x] closes #58194
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58195 | 2024-04-09T13:48:34Z | 2024-04-09T21:53:28Z | 2024-04-09T21:53:28Z | 2024-04-09T21:53:34Z |
CLN: enforce deprecation `resample` with `PeriodIndex` | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 99462917599e1..46110772f5ed0 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -8614,7 +8614,6 @@ def resample(
rule,
closed: Literal["right", "left"] | None = None,
label: Literal["right", "left"] | None = None,
- convention: Literal["start", "end", "s", "e"] | lib.NoDefault = lib.no_default,
kind: Literal["timestamp", "period"] | None | lib.NoDefault = lib.no_default,
on: Level | None = None,
level: Level | None = None,
@@ -8642,12 +8641,6 @@ def resample(
Which bin edge label to label bucket with. The default is 'left'
for all frequency offsets except for 'ME', 'YE', 'QE', 'BME',
'BA', 'BQE', and 'W' which all have a default of 'right'.
- convention : {{'start', 'end', 's', 'e'}}, default 'start'
- For `PeriodIndex` only, controls whether to use the start or
- end of `rule`.
-
- .. deprecated:: 2.2.0
- Convert PeriodIndex to DatetimeIndex before resampling instead.
kind : {{'timestamp', 'period'}}, optional, default None
Pass 'timestamp' to convert the resulting index to a
`DateTimeIndex` or 'period' to convert it to a `PeriodIndex`.
@@ -8959,25 +8952,13 @@ def resample(
else:
kind = None
- if convention is not lib.no_default:
- warnings.warn(
- f"The 'convention' keyword in {type(self).__name__}.resample is "
- "deprecated and will be removed in a future version. "
- "Explicitly cast PeriodIndex to DatetimeIndex before resampling "
- "instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
- else:
- convention = "start"
-
return get_resampler(
cast("Series | DataFrame", self),
- freq=rule,
+ freq=rule,
label=label,
closed=closed,
kind=kind,
- convention=convention,
+ convention="start",
key=on,
level=level,
origin=origin,
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 43077e7aeecb4..8d65cf66592de 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -11,7 +11,6 @@
no_type_check,
overload,
)
-import warnings
import numpy as np
@@ -32,10 +31,7 @@
Substitution,
doc,
)
-from pandas.util._exceptions import (
- find_stack_level,
- rewrite_warning,
-)
+from pandas.util._exceptions import rewrite_warning
from pandas.core.dtypes.dtypes import (
ArrowDtype,
@@ -1711,13 +1707,7 @@ class PeriodIndexResampler(DatetimeIndexResampler):
@property
def _resampler_for_grouping(self):
- warnings.warn(
- "Resampling a groupby with a PeriodIndex is deprecated. "
- "Cast to DatetimeIndex before resampling instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
- return PeriodIndexResamplerGroupby
+ raise TypeError("Resampling with a PeriodIndex is not supported.")
def _get_binner_for_time(self):
if self.kind == "timestamp":
@@ -2054,28 +2044,8 @@ def _get_resampler(self, obj: NDFrame, kind=None) -> Resampler:
gpr_index=ax,
)
elif isinstance(ax, PeriodIndex) or kind == "period":
- if isinstance(ax, PeriodIndex):
- # GH#53481
- warnings.warn(
- "Resampling with a PeriodIndex is deprecated. "
- "Cast index to DatetimeIndex before resampling instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
- else:
- warnings.warn(
- "Resampling with kind='period' is deprecated. "
- "Use datetime paths instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
- return PeriodIndexResampler(
- obj,
- timegrouper=self,
- kind=kind,
- group_keys=self.group_keys,
- gpr_index=ax,
- )
+ # GH#53481
+ raise TypeError("Resampling with a PeriodIndex is not supported.")
elif isinstance(ax, TimedeltaIndex):
return TimedeltaIndexResampler(
obj,
@@ -2086,7 +2056,7 @@ def _get_resampler(self, obj: NDFrame, kind=None) -> Resampler:
raise TypeError(
"Only valid with DatetimeIndex, "
- "TimedeltaIndex or PeriodIndex, "
+ "TimedeltaIndex, "
f"but got an instance of '{type(ax).__name__}'"
)
diff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py
index 9cd51b95d6efd..d275d6da1564a 100644
--- a/pandas/tests/resample/test_base.py
+++ b/pandas/tests/resample/test_base.py
@@ -11,7 +11,6 @@
DatetimeIndex,
Index,
MultiIndex,
- NaT,
PeriodIndex,
Series,
TimedeltaIndex,
@@ -75,19 +74,13 @@ def test_asfreq_fill_value(index):
[
timedelta_range("1 day", "10 day", freq="D"),
date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
- period_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
],
)
def test_resample_interpolate(index):
# GH#12925
df = DataFrame(range(len(index)), index=index)
- warn = None
- if isinstance(df.index, PeriodIndex):
- warn = FutureWarning
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(warn, match=msg):
- result = df.resample("1min").asfreq().interpolate()
- expected = df.resample("1min").interpolate()
+ result = df.resample("1min").asfreq().interpolate()
+ expected = df.resample("1min").interpolate()
tm.assert_frame_equal(result, expected)
@@ -95,7 +88,7 @@ def test_raises_on_non_datetimelike_index():
# this is a non datetimelike index
xp = DataFrame()
msg = (
- "Only valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, "
+ "Only valid with DatetimeIndex, TimedeltaIndex, "
"but got an instance of 'RangeIndex'"
)
with pytest.raises(TypeError, match=msg):
@@ -105,7 +98,6 @@ def test_raises_on_non_datetimelike_index():
@pytest.mark.parametrize(
"index",
[
- PeriodIndex([], freq="D", name="a"),
DatetimeIndex([], name="a"),
TimedeltaIndex([], name="a"),
],
@@ -127,12 +119,7 @@ def test_resample_empty_series(freq, index, resample_method):
# index is PeriodIndex, so convert to corresponding Period freq
freq = "M"
- warn = None
- if isinstance(ser.index, PeriodIndex):
- warn = FutureWarning
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(warn, match=msg):
- rs = ser.resample(freq)
+ rs = ser.resample(freq)
result = getattr(rs, resample_method)()
if resample_method == "ohlc":
@@ -150,40 +137,9 @@ def test_resample_empty_series(freq, index, resample_method):
assert result.index.freq == expected.index.freq
-@pytest.mark.parametrize(
- "freq",
- [
- pytest.param("ME", marks=pytest.mark.xfail(reason="Don't know why this fails")),
- "D",
- "h",
- ],
-)
-def test_resample_nat_index_series(freq, resample_method):
- # GH39227
-
- ser = Series(range(5), index=PeriodIndex([NaT] * 5, freq=freq))
-
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- rs = ser.resample(freq)
- result = getattr(rs, resample_method)()
-
- if resample_method == "ohlc":
- expected = DataFrame(
- [], index=ser.index[:0], columns=["open", "high", "low", "close"]
- )
- tm.assert_frame_equal(result, expected, check_dtype=False)
- else:
- expected = ser[:0].copy()
- tm.assert_series_equal(result, expected, check_dtype=False)
- tm.assert_index_equal(result.index, expected.index)
- assert result.index.freq == expected.index.freq
-
-
@pytest.mark.parametrize(
"index",
[
- PeriodIndex([], freq="D", name="a"),
DatetimeIndex([], name="a"),
TimedeltaIndex([], name="a"),
],
@@ -205,12 +161,7 @@ def test_resample_count_empty_series(freq, index, resample_method):
# index is PeriodIndex, so convert to corresponding Period freq
freq = "M"
- warn = None
- if isinstance(ser.index, PeriodIndex):
- warn = FutureWarning
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(warn, match=msg):
- rs = ser.resample(freq)
+ rs = ser.resample(freq)
result = getattr(rs, resample_method)()
@@ -221,9 +172,7 @@ def test_resample_count_empty_series(freq, index, resample_method):
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize(
- "index", [DatetimeIndex([]), TimedeltaIndex([]), PeriodIndex([], freq="D")]
-)
+@pytest.mark.parametrize("index", [DatetimeIndex([]), TimedeltaIndex([])])
@pytest.mark.parametrize("freq", ["ME", "D", "h"])
def test_resample_empty_dataframe(index, freq, resample_method):
# GH13212
@@ -241,12 +190,7 @@ def test_resample_empty_dataframe(index, freq, resample_method):
# index is PeriodIndex, so convert to corresponding Period freq
freq = "M"
- warn = None
- if isinstance(df.index, PeriodIndex):
- warn = FutureWarning
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(warn, match=msg):
- rs = df.resample(freq, group_keys=False)
+ rs = df.resample(freq, group_keys=False)
result = getattr(rs, resample_method)()
if resample_method == "ohlc":
# TODO: no tests with len(df.columns) > 0
@@ -269,9 +213,7 @@ def test_resample_empty_dataframe(index, freq, resample_method):
# test size for GH13212 (currently stays as df)
-@pytest.mark.parametrize(
- "index", [DatetimeIndex([]), TimedeltaIndex([]), PeriodIndex([], freq="D")]
-)
+@pytest.mark.parametrize("index", [DatetimeIndex([]), TimedeltaIndex([])])
@pytest.mark.parametrize("freq", ["ME", "D", "h"])
def test_resample_count_empty_dataframe(freq, index):
# GH28427
@@ -289,12 +231,7 @@ def test_resample_count_empty_dataframe(freq, index):
# index is PeriodIndex, so convert to corresponding Period freq
freq = "M"
- warn = None
- if isinstance(empty_frame_dti.index, PeriodIndex):
- warn = FutureWarning
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(warn, match=msg):
- rs = empty_frame_dti.resample(freq)
+ rs = empty_frame_dti.resample(freq)
result = rs.count()
index = _asfreq_compat(empty_frame_dti.index, freq)
@@ -326,24 +263,23 @@ def test_resample_size_empty_dataframe(freq, index):
freq = "M"
msg = "Resampling with a PeriodIndex"
- warn = None
if isinstance(empty_frame_dti.index, PeriodIndex):
- warn = FutureWarning
- with tm.assert_produces_warning(warn, match=msg):
+ msg = "Resampling with a PeriodIndex is not supported"
+ with pytest.raises(TypeError, match=msg):
+ empty_frame_dti.resample(freq)
+ else:
rs = empty_frame_dti.resample(freq)
- result = rs.size()
-
- index = _asfreq_compat(empty_frame_dti.index, freq)
+ result = rs.size()
- expected = Series([], dtype="int64", index=index)
+ index = _asfreq_compat(empty_frame_dti.index, freq)
+ expected = Series([], dtype="int64", index=index)
- tm.assert_series_equal(result, expected)
+ tm.assert_series_equal(result, expected)
@pytest.mark.parametrize(
"index",
[
- PeriodIndex([], freq="M", name="a"),
DatetimeIndex([], name="a"),
TimedeltaIndex([], name="a"),
],
@@ -354,16 +290,9 @@ def test_resample_empty_dtypes(index, dtype, resample_method):
# Empty series were sometimes causing a segfault (for the functions
# with Cython bounds-checking disabled) or an IndexError. We just run
# them to ensure they no longer do. (GH #10228)
- warn = None
- if isinstance(index, PeriodIndex):
- # GH#53511
- index = PeriodIndex([], freq="B", name=index.name)
- warn = FutureWarning
- msg = "Resampling with a PeriodIndex is deprecated"
-
empty_series_dti = Series([], index, dtype)
- with tm.assert_produces_warning(warn, match=msg):
- rs = empty_series_dti.resample("d", group_keys=False)
+
+ rs = empty_series_dti.resample("d", group_keys=False)
try:
getattr(rs, resample_method)()
except DataError:
@@ -397,19 +326,16 @@ def test_apply_to_empty_series(index, freq):
# index is PeriodIndex, so convert to corresponding Period freq
freq = "M"
- msg = "Resampling with a PeriodIndex"
- warn = None
if isinstance(ser.index, PeriodIndex):
- warn = FutureWarning
-
- with tm.assert_produces_warning(warn, match=msg):
+ msg = "Resampling with a PeriodIndex is not supported"
+ with pytest.raises(TypeError, match=msg):
+ rs = ser.resample(freq, group_keys=False)
+ else:
rs = ser.resample(freq, group_keys=False)
-
- result = rs.apply(lambda x: 1)
- with tm.assert_produces_warning(warn, match=msg):
+ result = rs.apply(lambda x: 1)
expected = ser.resample(freq).apply("sum")
- tm.assert_series_equal(result, expected, check_dtype=False)
+ tm.assert_series_equal(result, expected, check_dtype=False)
@pytest.mark.parametrize(
@@ -425,19 +351,20 @@ def test_resampler_is_iterable(index):
series = Series(range(len(index)), index=index)
freq = "h"
tg = Grouper(freq=freq, convention="start")
- msg = "Resampling with a PeriodIndex"
- warn = None
+
if isinstance(series.index, PeriodIndex):
- warn = FutureWarning
+ msg = "Resampling with a PeriodIndex is not supported"
+ with pytest.raises(TypeError, match=msg):
+ series.groupby(tg)
- with tm.assert_produces_warning(warn, match=msg):
+ with pytest.raises(TypeError, match=msg):
+ series.resample(freq)
+ else:
grouped = series.groupby(tg)
-
- with tm.assert_produces_warning(warn, match=msg):
resampled = series.resample(freq)
- for (rk, rv), (gk, gv) in zip(resampled, grouped):
- assert rk == gk
- tm.assert_series_equal(rv, gv)
+ for (rk, rv), (gk, gv) in zip(resampled, grouped):
+ assert rk == gk
+ tm.assert_series_equal(rv, gv)
@pytest.mark.parametrize(
@@ -454,14 +381,14 @@ def test_resample_quantile(index):
q = 0.75
freq = "h"
- msg = "Resampling with a PeriodIndex"
- warn = None
if isinstance(ser.index, PeriodIndex):
- warn = FutureWarning
- with tm.assert_produces_warning(warn, match=msg):
+ msg = "Resampling with a PeriodIndex is not supported"
+ with pytest.raises(TypeError, match=msg):
+ ser.resample(freq).quantile(q)
+ else:
result = ser.resample(freq).quantile(q)
expected = ser.resample(freq).agg(lambda x: x.quantile(q)).rename(ser.name)
- tm.assert_series_equal(result, expected)
+ tm.assert_series_equal(result, expected)
@pytest.mark.parametrize("how", ["first", "last"])
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index dd058ada60974..b9ec1cb5389c2 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -7,10 +7,7 @@
import pytest
import pytz
-from pandas._libs.tslibs.ccalendar import (
- DAYS,
- MONTHS,
-)
+from pandas._libs.tslibs.ccalendar import MONTHS
from pandas._libs.tslibs.period import IncompatibleFrequency
from pandas.errors import InvalidIndexError
@@ -31,10 +28,6 @@
from pandas.tseries import offsets
-pytestmark = pytest.mark.filterwarnings(
- "ignore:Resampling with a PeriodIndex is deprecated:FutureWarning"
-)
-
@pytest.fixture
def simple_period_range_series():
@@ -58,8 +51,8 @@ def _simple_period_range_series(start, end, freq="D"):
class TestPeriodIndex:
- @pytest.mark.parametrize("freq", ["2D", "1h", "2h"])
- @pytest.mark.parametrize("kind", ["period", None, "timestamp"])
+ @pytest.mark.parametrize("freq", ["2D"]) # , "1h", "2h"
+ @pytest.mark.parametrize("kind", [None, "timestamp"])
def test_asfreq(self, frame_or_series, freq, kind):
# GH 12884, 15944
# make sure .asfreq() returns PeriodIndex (except kind='timestamp')
@@ -72,9 +65,13 @@ def test_asfreq(self, frame_or_series, freq, kind):
end = (obj.index[-1] + obj.index.freq).to_timestamp(how="start")
new_index = date_range(start=start, end=end, freq=freq, inclusive="left")
expected = obj.to_timestamp().reindex(new_index).to_period(freq)
- msg = "The 'kind' keyword in (Series|DataFrame).resample is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = obj.resample(freq, kind=kind).asfreq()
+
+ msg2 = "The 'kind' keyword in (Series|DataFrame).resample is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg2):
+ if kind == "timestamp":
+ result = obj.to_timestamp(how="start").resample(freq, kind=kind).asfreq()
+ else:
+ result = obj.to_timestamp(how="start").resample(freq, kind=kind).asfreq().to_period()
tm.assert_almost_equal(result, expected)
def test_asfreq_fill_value(self):
@@ -82,28 +79,18 @@ def test_asfreq_fill_value(self):
index = period_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D")
s = Series(range(len(index)), index=index)
- new_index = date_range(
- s.index[0].to_timestamp(how="start"),
- (s.index[-1]).to_timestamp(how="start"),
- freq="1h",
- )
- expected = s.to_timestamp().reindex(new_index, fill_value=4.0)
msg = "The 'kind' keyword in Series.resample is deprecated"
with tm.assert_produces_warning(FutureWarning, match=msg):
- result = s.resample("1h", kind="timestamp").asfreq(fill_value=4.0)
- tm.assert_series_equal(result, expected)
+ msg2 = "Resampling with a PeriodIndex is not supported"
+ with pytest.raises(TypeError, match=msg2):
+ s.resample("1h", kind="timestamp").asfreq(fill_value=4.0)
frame = s.to_frame("value")
- new_index = date_range(
- frame.index[0].to_timestamp(how="start"),
- (frame.index[-1]).to_timestamp(how="start"),
- freq="1h",
- )
- expected = frame.to_timestamp().reindex(new_index, fill_value=3.0)
msg = "The 'kind' keyword in DataFrame.resample is deprecated"
with tm.assert_produces_warning(FutureWarning, match=msg):
- result = frame.resample("1h", kind="timestamp").asfreq(fill_value=3.0)
- tm.assert_frame_equal(result, expected)
+ msg2 = "Resampling with a PeriodIndex is not supported"
+ with pytest.raises(TypeError, match=msg2):
+ frame.resample("1h", kind="timestamp").asfreq(fill_value=3.0)
@pytest.mark.parametrize("freq", ["h", "12h", "2D", "W"])
@pytest.mark.parametrize("kind", [None, "period", "timestamp"])
@@ -127,27 +114,6 @@ def test_selection(self, freq, kind, kwargs):
with tm.assert_produces_warning(FutureWarning, match=depr_msg):
df.resample(freq, kind=kind, **kwargs)
- @pytest.mark.parametrize("month", MONTHS)
- @pytest.mark.parametrize("meth", ["ffill", "bfill"])
- @pytest.mark.parametrize("conv", ["start", "end"])
- @pytest.mark.parametrize(
- ("offset", "period"), [("D", "D"), ("B", "B"), ("ME", "M"), ("QE", "Q")]
- )
- def test_annual_upsample_cases(
- self, offset, period, conv, meth, month, simple_period_range_series
- ):
- ts = simple_period_range_series("1/1/1990", "12/31/1991", freq=f"Y-{month}")
- warn = FutureWarning if period == "B" else None
- msg = r"PeriodDtype\[B\] is deprecated"
- if warn is None:
- msg = "Resampling with a PeriodIndex is deprecated"
- warn = FutureWarning
- with tm.assert_produces_warning(warn, match=msg):
- result = getattr(ts.resample(period, convention=conv), meth)()
- expected = result.to_timestamp(period, how=conv)
- expected = expected.asfreq(offset, meth).to_period()
- tm.assert_series_equal(result, expected)
-
def test_basic_downsample(self, simple_period_range_series):
ts = simple_period_range_series("1/1/1990", "6/30/1995", freq="M")
result = ts.resample("Y-DEC").mean()
@@ -218,43 +184,6 @@ def test_annual_upsample2(self):
expected = ts.asfreq("M", how="start").reindex(ex_index, method="ffill")
tm.assert_series_equal(result, expected)
- @pytest.mark.parametrize("month", MONTHS)
- @pytest.mark.parametrize("convention", ["start", "end"])
- @pytest.mark.parametrize(
- ("offset", "period"), [("D", "D"), ("B", "B"), ("ME", "M")]
- )
- def test_quarterly_upsample(
- self, month, offset, period, convention, simple_period_range_series
- ):
- freq = f"Q-{month}"
- ts = simple_period_range_series("1/1/1990", "12/31/1995", freq=freq)
- warn = FutureWarning if period == "B" else None
- msg = r"PeriodDtype\[B\] is deprecated"
- if warn is None:
- msg = "Resampling with a PeriodIndex is deprecated"
- warn = FutureWarning
- with tm.assert_produces_warning(warn, match=msg):
- result = ts.resample(period, convention=convention).ffill()
- expected = result.to_timestamp(period, how=convention)
- expected = expected.asfreq(offset, "ffill").to_period()
- tm.assert_series_equal(result, expected)
-
- @pytest.mark.parametrize("target", ["D", "B"])
- @pytest.mark.parametrize("convention", ["start", "end"])
- def test_monthly_upsample(self, target, convention, simple_period_range_series):
- ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="M")
-
- warn = None if target == "D" else FutureWarning
- msg = r"PeriodDtype\[B\] is deprecated"
- if warn is None:
- msg = "Resampling with a PeriodIndex is deprecated"
- warn = FutureWarning
- with tm.assert_produces_warning(warn, match=msg):
- result = ts.resample(target, convention=convention).ffill()
- expected = result.to_timestamp(target, how=convention)
- expected = expected.asfreq(target, "ffill").to_period()
- tm.assert_series_equal(result, expected)
-
def test_resample_basic(self):
# GH3609
s = Series(
@@ -411,24 +340,6 @@ def test_fill_method_and_how_upsample(self):
both = s.resample("ME").ffill().resample("ME").last().astype("int64")
tm.assert_series_equal(last, both)
- @pytest.mark.parametrize("day", DAYS)
- @pytest.mark.parametrize("target", ["D", "B"])
- @pytest.mark.parametrize("convention", ["start", "end"])
- def test_weekly_upsample(self, day, target, convention, simple_period_range_series):
- freq = f"W-{day}"
- ts = simple_period_range_series("1/1/1990", "12/31/1995", freq=freq)
-
- warn = None if target == "D" else FutureWarning
- msg = r"PeriodDtype\[B\] is deprecated"
- if warn is None:
- msg = "Resampling with a PeriodIndex is deprecated"
- warn = FutureWarning
- with tm.assert_produces_warning(warn, match=msg):
- result = ts.resample(target, convention=convention).ffill()
- expected = result.to_timestamp(target, how=convention)
- expected = expected.asfreq(target, "ffill").to_period()
- tm.assert_series_equal(result, expected)
-
def test_resample_to_timestamps(self, simple_period_range_series):
ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="M")
@@ -489,7 +400,7 @@ def test_cant_fill_missing_dups(self):
s.resample("Y").ffill()
@pytest.mark.parametrize("freq", ["5min"])
- @pytest.mark.parametrize("kind", ["period", None, "timestamp"])
+ @pytest.mark.parametrize("kind", [None, "timestamp"])
def test_resample_5minute(self, freq, kind):
rng = period_range("1/1/2000", "1/5/2000", freq="min")
ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
@@ -574,8 +485,8 @@ def test_resample_tz_localized2(self):
# for good measure
msg = "The 'kind' keyword in Series.resample is deprecated"
with tm.assert_produces_warning(FutureWarning, match=msg):
- result = s.resample("D", kind="period").mean()
- ex_index = period_range("2001-09-20", periods=1, freq="D")
+ result = s.resample("D", kind="timestamp").mean()
+ ex_index = date_range("2001-09-20", periods=1, freq="D", tz="Australia/Sydney")
expected = Series([1.5], index=ex_index)
tm.assert_series_equal(result, expected)
@@ -808,7 +719,7 @@ def test_evenly_divisible_with_no_extra_bins2(self):
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("freq, period_mult", [("h", 24), ("12h", 2)])
- @pytest.mark.parametrize("kind", [None, "period"])
+ @pytest.mark.parametrize("kind", [None])
def test_upsampling_ohlc(self, freq, period_mult, kind):
# GH 13083
pi = period_range(start="2000", freq="D", periods=10)
@@ -824,59 +735,6 @@ def test_upsampling_ohlc(self, freq, period_mult, kind):
result = s.resample(freq, kind=kind).ohlc()
tm.assert_frame_equal(result, expected)
- @pytest.mark.parametrize(
- "periods, values",
- [
- (
- [
- pd.NaT,
- "1970-01-01 00:00:00",
- pd.NaT,
- "1970-01-01 00:00:02",
- "1970-01-01 00:00:03",
- ],
- [2, 3, 5, 7, 11],
- ),
- (
- [
- pd.NaT,
- pd.NaT,
- "1970-01-01 00:00:00",
- pd.NaT,
- pd.NaT,
- pd.NaT,
- "1970-01-01 00:00:02",
- "1970-01-01 00:00:03",
- pd.NaT,
- pd.NaT,
- ],
- [1, 2, 3, 5, 6, 8, 7, 11, 12, 13],
- ),
- ],
- )
- @pytest.mark.parametrize(
- "freq, expected_values",
- [
- ("1s", [3, np.nan, 7, 11]),
- ("2s", [3, (7 + 11) / 2]),
- ("3s", [(3 + 7) / 2, 11]),
- ],
- )
- def test_resample_with_nat(self, periods, values, freq, expected_values):
- # GH 13224
- index = PeriodIndex(periods, freq="s")
- frame = DataFrame(values, index=index)
-
- expected_index = period_range(
- "1970-01-01 00:00:00", periods=len(expected_values), freq=freq
- )
- expected = DataFrame(expected_values, index=expected_index)
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- rs = frame.resample(freq)
- result = rs.mean()
- tm.assert_frame_equal(result, expected)
-
def test_resample_with_only_nat(self):
# GH 13224
pi = PeriodIndex([pd.NaT] * 3, freq="s")
@@ -910,28 +768,9 @@ def test_resample_with_offset(self, start, end, start_freq, end_freq, offset):
# GH 23882 & 31809
pi = period_range(start, end, freq=start_freq)
ser = Series(np.arange(len(pi)), index=pi)
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- rs = ser.resample(end_freq, offset=offset)
- result = rs.mean()
- result = result.to_timestamp(end_freq)
-
- expected = ser.to_timestamp().resample(end_freq, offset=offset).mean()
- tm.assert_series_equal(result, expected)
-
- def test_resample_with_offset_month(self):
- # GH 23882 & 31809
- pi = period_range("19910905 12:00", "19910909 1:00", freq="h")
- ser = Series(np.arange(len(pi)), index=pi)
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- rs = ser.resample("M", offset="3h")
- result = rs.mean()
- result = result.to_timestamp("M")
- expected = ser.to_timestamp().resample("ME", offset="3h").mean()
- # TODO: is non-tick the relevant characteristic? (GH 33815)
- expected.index = expected.index._with_freq(None)
- tm.assert_series_equal(result, expected)
+ msg = "Resampling with a PeriodIndex is not supported."
+ with pytest.raises(TypeError, match=msg):
+ ser.resample(end_freq, offset=offset)
@pytest.mark.parametrize(
"first,last,freq,freq_to_offset,exp_first,exp_last",
@@ -965,21 +804,6 @@ def test_get_period_range_edges(
expected = (exp_first, exp_last)
assert result == expected
- def test_sum_min_count(self):
- # GH 19974
- index = date_range(start="2018", freq="ME", periods=6)
- data = np.ones(6)
- data[3:6] = np.nan
- s = Series(data, index).to_period()
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- rs = s.resample("Q")
- result = rs.sum(min_count=1)
- expected = Series(
- [3.0, np.nan], index=PeriodIndex(["2018Q1", "2018Q2"], freq="Q-DEC")
- )
- tm.assert_series_equal(result, expected)
-
def test_resample_t_l_deprecated(self):
# GH#52536
msg_t = "Invalid frequency: T"
@@ -1062,16 +886,6 @@ def test_resample_frequency_ME_QE_YE_error_message(frame_or_series, freq, freq_d
obj.resample(freq_depr)
-def test_corner_cases_period(simple_period_range_series):
- # miscellaneous test coverage
- len0pts = simple_period_range_series("2007-01", "2010-05", freq="M")[:0]
- # it works
- msg = "Resampling with a PeriodIndex is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = len0pts.resample("Y-DEC").mean()
- assert len(result) == 0
-
-
@pytest.mark.parametrize(
"freq_depr",
[
@@ -1089,3 +903,10 @@ def test_resample_frequency_invalid_freq(frame_or_series, freq_depr):
obj = frame_or_series(range(5), index=period_range("2020-01-01", periods=5))
with pytest.raises(ValueError, match=msg):
obj.resample(freq_depr)
+
+
+def test_resample_period_index_raises(frame_or_series):
+ obj = frame_or_series(range(5), index=period_range("2020-01-01", periods=5))
+ msg = "Resampling with a PeriodIndex is not supported"
+ with pytest.raises(TypeError, match=msg):
+ obj.resample("Y-DEC")
diff --git a/pandas/tests/resample/test_resample_api.py b/pandas/tests/resample/test_resample_api.py
index 9b442fa7dbd07..6891db6757869 100644
--- a/pandas/tests/resample/test_resample_api.py
+++ b/pandas/tests/resample/test_resample_api.py
@@ -674,7 +674,7 @@ def test_selection_api_validation():
# non DatetimeIndex
msg = (
- "Only valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, "
+ "Only valid with DatetimeIndex, TimedeltaIndex, "
"but got an instance of 'Index'"
)
with pytest.raises(TypeError, match=msg):
diff --git a/pandas/tests/resample/test_time_grouper.py b/pandas/tests/resample/test_time_grouper.py
index 11ad9240527d5..baf34c1af562f 100644
--- a/pandas/tests/resample/test_time_grouper.py
+++ b/pandas/tests/resample/test_time_grouper.py
@@ -96,8 +96,8 @@ def test_fails_on_no_datetime_index(index):
df = DataFrame({"a": range(len(index))}, index=index)
msg = (
- "Only valid with DatetimeIndex, TimedeltaIndex "
- f"or PeriodIndex, but got an instance of '{name}'"
+ "Only valid with DatetimeIndex, TimedeltaIndex, "
+ f"but got an instance of '{name}'"
)
with pytest.raises(TypeError, match=msg):
df.groupby(Grouper(freq="D"))
| enforced deprecation of `resample` with `PeriodIndex`
| https://api.github.com/repos/pandas-dev/pandas/pulls/58193 | 2024-04-09T13:11:08Z | 2024-04-10T12:40:53Z | null | 2024-04-10T12:40:53Z |
TST: Match dta format used for Stata test files with that implied by their filenames | diff --git a/pandas/tests/io/data/stata/stata10_115.dta b/pandas/tests/io/data/stata/stata10_115.dta
index b917dde5ad47d..bdca3b9b340c1 100644
Binary files a/pandas/tests/io/data/stata/stata10_115.dta and b/pandas/tests/io/data/stata/stata10_115.dta differ
diff --git a/pandas/tests/io/data/stata/stata4_114.dta b/pandas/tests/io/data/stata/stata4_114.dta
index c5d7de8b42295..f58cdb215332e 100644
Binary files a/pandas/tests/io/data/stata/stata4_114.dta and b/pandas/tests/io/data/stata/stata4_114.dta differ
diff --git a/pandas/tests/io/data/stata/stata9_115.dta b/pandas/tests/io/data/stata/stata9_115.dta
index 5ad6cd6a2c8ff..1b5c0042bebbe 100644
Binary files a/pandas/tests/io/data/stata/stata9_115.dta and b/pandas/tests/io/data/stata/stata9_115.dta differ
| - [x] closes #57693
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
A few of the Stata test data files were not saved in the format implied by their file names. As these are binary files they are harder to compare, so I have included Stata output detailing their contents below:
[dtatests_original.txt](https://github.com/pandas-dev/pandas/files/14918526/dtatests_original.txt)
[dtatests_updated.txt](https://github.com/pandas-dev/pandas/files/14918527/dtatests_updated.txt)
The Stata tests already include files in the formats that these were actually saved as, so converting them shouldn't lose any coverage.
After making the change I ran the following Stata script in the test directory, confirming that all the files now match their expected version:
```
local files : dir "." files "*.dta"
foreach file in `files' {
dtaversion `file'
}
```
```
(file "s4_educ1.dta" is .dta-format 105 from Stata 5)
(file "stata-compat-105.dta" is .dta-format 105 from Stata 5)
(file "stata-compat-108.dta" is .dta-format 108 from Stata 6)
(file "stata-compat-111.dta" is .dta-format 111 from Stata 7)
(file "stata-compat-113.dta" is .dta-format 113 from Stata 8 or 9)
(file "stata-compat-114.dta" is .dta-format 114 from Stata 10 or 11)
(file "stata-compat-118.dta" is .dta-format 118 from Stata 14, 15, 16, 17, or 18)
(file "stata-dta-partially-labeled.dta" is .dta-format 118 from Stata 14, 15, 16, 17, or 18)
(file "stata10_115.dta" is .dta-format 115 from Stata 12)
(file "stata10_117.dta" is .dta-format 117 from Stata 13)
(file "stata11_115.dta" is .dta-format 115 from Stata 12)
(file "stata11_117.dta" is .dta-format 117 from Stata 13)
(file "stata12_117.dta" is .dta-format 117 from Stata 13)
(file "stata13_dates.dta" is .dta-format 117 from Stata 13)
(file "stata14_118.dta" is .dta-format 118 from Stata 14, 15, 16, 17, or 18)
(file "stata15.dta" is .dta-format 118 from Stata 14, 15, 16, 17, or 18)
(file "stata16_118.dta" is .dta-format 118 from Stata 14, 15, 16, 17, or 18)
(file "stata1_114.dta" is .dta-format 114 from Stata 10 or 11)
(file "stata1_117.dta" is .dta-format 117 from Stata 13)
(file "stata1_encoding.dta" is .dta-format 114 from Stata 10 or 11)
(file "stata1_encoding_118.dta" is .dta-format 118 from Stata 14, 15, 16, 17, or 18)
(file "stata2_113.dta" is .dta-format 113 from Stata 8 or 9)
(file "stata2_114.dta" is .dta-format 114 from Stata 10 or 11)
(file "stata2_115.dta" is .dta-format 115 from Stata 12)
(file "stata2_117.dta" is .dta-format 117 from Stata 13)
(file "stata3_113.dta" is .dta-format 113 from Stata 8 or 9)
(file "stata3_114.dta" is .dta-format 114 from Stata 10 or 11)
(file "stata3_115.dta" is .dta-format 115 from Stata 12)
(file "stata3_117.dta" is .dta-format 117 from Stata 13)
(file "stata4_113.dta" is .dta-format 113 from Stata 8 or 9)
(file "stata4_114.dta" is .dta-format 114 from Stata 10 or 11)
(file "stata4_115.dta" is .dta-format 115 from Stata 12)
(file "stata4_117.dta" is .dta-format 117 from Stata 13)
(file "stata5_113.dta" is .dta-format 113 from Stata 8 or 9)
(file "stata5_114.dta" is .dta-format 114 from Stata 10 or 11)
(file "stata5_115.dta" is .dta-format 115 from Stata 12)
(file "stata5_117.dta" is .dta-format 117 from Stata 13)
(file "stata6_113.dta" is .dta-format 113 from Stata 8 or 9)
(file "stata6_114.dta" is .dta-format 114 from Stata 10 or 11)
(file "stata6_115.dta" is .dta-format 115 from Stata 12)
(file "stata6_117.dta" is .dta-format 117 from Stata 13)
(file "stata7_111.dta" is .dta-format 111 from Stata 7)
(file "stata7_115.dta" is .dta-format 115 from Stata 12)
(file "stata7_117.dta" is .dta-format 117 from Stata 13)
(file "stata8_113.dta" is .dta-format 113 from Stata 8 or 9)
(file "stata8_115.dta" is .dta-format 115 from Stata 12)
(file "stata8_117.dta" is .dta-format 117 from Stata 13)
(file "stata9_115.dta" is .dta-format 115 from Stata 12)
(file "stata9_117.dta" is .dta-format 117 from Stata 13)
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/58192 | 2024-04-09T12:46:24Z | 2024-04-09T16:43:19Z | 2024-04-09T16:43:19Z | 2024-04-09T16:43:26Z |
TST: catch exception for div/truediv operations between Timedelta and pd.NA | diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 73b2da0f7dd50..01e7ba52e58aa 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -11,6 +11,7 @@
import pytest
from pandas._libs import lib
+from pandas._libs.missing import NA
from pandas._libs.tslibs import (
NaT,
iNaT,
@@ -138,6 +139,19 @@ def test_truediv_numeric(self, td):
assert res._value == td._value / 2
assert res._creso == td._creso
+ def test_truediv_na_type_not_supported(self, td):
+ msg_td_floordiv_na = (
+ r"unsupported operand type\(s\) for /: 'Timedelta' and 'NAType'"
+ )
+ with pytest.raises(TypeError, match=msg_td_floordiv_na):
+ td / NA
+
+ msg_na_floordiv_td = (
+ r"unsupported operand type\(s\) for /: 'NAType' and 'Timedelta'"
+ )
+ with pytest.raises(TypeError, match=msg_na_floordiv_td):
+ NA / td
+
def test_floordiv_timedeltalike(self, td):
assert td // td == 1
assert (2.5 * td) // td == 2
@@ -182,6 +196,19 @@ def test_floordiv_numeric(self, td):
assert res._value == td._value // 2
assert res._creso == td._creso
+ def test_floordiv_na_type_not_supported(self, td):
+ msg_td_floordiv_na = (
+ r"unsupported operand type\(s\) for //: 'Timedelta' and 'NAType'"
+ )
+ with pytest.raises(TypeError, match=msg_td_floordiv_na):
+ td // NA
+
+ msg_na_floordiv_td = (
+ r"unsupported operand type\(s\) for //: 'NAType' and 'Timedelta'"
+ )
+ with pytest.raises(TypeError, match=msg_na_floordiv_td):
+ NA // td
+
def test_addsub_mismatched_reso(self, td):
# need to cast to since td is out of bounds for ns, so
# so we would raise OverflowError without casting
| - [x] closes #54315
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [Not applicable] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [Not applicable] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
This PR add a test to catch ``TypeError`` raised by div and true div operations between ``Timedelta`` and ``pd.NA``. | https://api.github.com/repos/pandas-dev/pandas/pulls/58188 | 2024-04-08T20:33:15Z | 2024-04-15T17:13:21Z | 2024-04-15T17:13:21Z | 2024-04-16T20:34:17Z |
Backport PR #58181 on branch 2.2.x (CI: correct error msg in test_view_index) | diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 1fa48f98942c2..b7204d7af1cbb 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -358,7 +358,10 @@ def test_view_with_args_object_array_raises(self, index):
with pytest.raises(NotImplementedError, match="i8"):
index.view("i8")
else:
- msg = "Cannot change data-type for object array"
+ msg = (
+ "Cannot change data-type for array of references|"
+ "Cannot change data-type for object array|"
+ )
with pytest.raises(TypeError, match=msg):
index.view("i8")
| Backport PR #58181: CI: correct error msg in test_view_index
| https://api.github.com/repos/pandas-dev/pandas/pulls/58187 | 2024-04-08T20:19:29Z | 2024-04-08T21:34:15Z | 2024-04-08T21:34:15Z | 2024-04-08T21:34:23Z |
Backport PR #58181 on branch 2.2.x (CI: correct error msg in test_view_index) | diff --git a/.circleci/config.yml b/.circleci/config.yml
index 90afb1ce29684..ea93575ac9430 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -3,7 +3,7 @@ version: 2.1
jobs:
test-arm:
machine:
- image: ubuntu-2004:2022.04.1
+ image: default
resource_class: arm.large
environment:
ENV_FILE: ci/deps/circle-310-arm64.yaml
@@ -46,7 +46,7 @@ jobs:
cibw-build:
type: string
machine:
- image: ubuntu-2004:2022.04.1
+ image: default
resource_class: arm.large
environment:
TRIGGER_SOURCE: << pipeline.trigger_source >>
diff --git a/.github/actions/run-tests/action.yml b/.github/actions/run-tests/action.yml
index b4778b74df335..fd7c3587f2254 100644
--- a/.github/actions/run-tests/action.yml
+++ b/.github/actions/run-tests/action.yml
@@ -1,16 +1,9 @@
name: Run tests and report results
-inputs:
- preload:
- description: Preload arguments for sanitizer
- required: false
- asan_options:
- description: Arguments for Address Sanitizer (ASAN)
- required: false
runs:
using: composite
steps:
- name: Test
- run: ${{ inputs.asan_options }} ${{ inputs.preload }} ci/run_tests.sh
+ run: ci/run_tests.sh
shell: bash -el {0}
- name: Publish test results
diff --git a/.github/workflows/code-checks.yml b/.github/workflows/code-checks.yml
index b49b9a67c4743..8e29d56f47dcf 100644
--- a/.github/workflows/code-checks.yml
+++ b/.github/workflows/code-checks.yml
@@ -4,11 +4,11 @@ on:
push:
branches:
- main
- - 2.1.x
+ - 2.2.x
pull_request:
branches:
- main
- - 2.1.x
+ - 2.2.x
env:
ENV_FILE: environment.yml
diff --git a/.github/workflows/docbuild-and-upload.yml b/.github/workflows/docbuild-and-upload.yml
index da232404e6ff5..73acd9acc129a 100644
--- a/.github/workflows/docbuild-and-upload.yml
+++ b/.github/workflows/docbuild-and-upload.yml
@@ -4,13 +4,13 @@ on:
push:
branches:
- main
- - 2.1.x
+ - 2.2.x
tags:
- '*'
pull_request:
branches:
- main
- - 2.1.x
+ - 2.2.x
env:
ENV_FILE: environment.yml
diff --git a/.github/workflows/package-checks.yml b/.github/workflows/package-checks.yml
index 04d8b8e006985..7c1da5678a2aa 100644
--- a/.github/workflows/package-checks.yml
+++ b/.github/workflows/package-checks.yml
@@ -4,11 +4,11 @@ on:
push:
branches:
- main
- - 2.1.x
+ - 2.2.x
pull_request:
branches:
- main
- - 2.1.x
+ - 2.2.x
types: [ labeled, opened, synchronize, reopened ]
permissions:
@@ -24,7 +24,7 @@ jobs:
runs-on: ubuntu-22.04
strategy:
matrix:
- extra: ["test", "performance", "computation", "fss", "aws", "gcp", "excel", "parquet", "feather", "hdf5", "spss", "postgresql", "mysql", "sql-other", "html", "xml", "plot", "output-formatting", "clipboard", "compression", "consortium-standard", "all"]
+ extra: ["test", "pyarrow", "performance", "computation", "fss", "aws", "gcp", "excel", "parquet", "feather", "hdf5", "spss", "postgresql", "mysql", "sql-other", "html", "xml", "plot", "output-formatting", "clipboard", "compression", "consortium-standard", "all"]
fail-fast: false
name: Install Extras - ${{ matrix.extra }}
concurrency:
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index 6ca4d19196874..bacc3d874a60d 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -4,11 +4,11 @@ on:
push:
branches:
- main
- - 2.1.x
+ - 2.2.x
pull_request:
branches:
- main
- - 2.1.x
+ - 2.2.x
paths-ignore:
- "doc/**"
- "web/**"
@@ -92,18 +92,10 @@ jobs:
- name: "Numpy Dev"
env_file: actions-311-numpydev.yaml
pattern: "not slow and not network and not single_cpu"
- test_args: "-W error::FutureWarning"
+ test_args: "-W error::DeprecationWarning -W error::FutureWarning"
- name: "Pyarrow Nightly"
env_file: actions-311-pyarrownightly.yaml
pattern: "not slow and not network and not single_cpu"
- - name: "ASAN / UBSAN"
- env_file: actions-311-sanitizers.yaml
- pattern: "not slow and not network and not single_cpu and not skip_ubsan"
- asan_options: "ASAN_OPTIONS=detect_leaks=0"
- preload: LD_PRELOAD=$(gcc -print-file-name=libasan.so)
- meson_args: --config-settings=setup-args="-Db_sanitize=address,undefined"
- cflags_adds: -fno-sanitize-recover=all
- pytest_workers: -1 # disable pytest-xdist as it swallows stderr from ASAN
fail-fast: false
name: ${{ matrix.name || format('ubuntu-latest {0}', matrix.env_file) }}
env:
@@ -190,18 +182,12 @@ jobs:
- name: Test (not single_cpu)
uses: ./.github/actions/run-tests
if: ${{ matrix.name != 'Pypy' }}
- with:
- preload: ${{ matrix.preload }}
- asan_options: ${{ matrix.asan_options }}
env:
# Set pattern to not single_cpu if not already set
PATTERN: ${{ env.PATTERN == '' && 'not single_cpu' || matrix.pattern }}
- name: Test (single_cpu)
uses: ./.github/actions/run-tests
- with:
- preload: ${{ matrix.preload }}
- asan_options: ${{ matrix.asan_options }}
env:
PATTERN: 'single_cpu'
PYTEST_WORKERS: 0
@@ -211,7 +197,8 @@ jobs:
timeout-minutes: 90
strategy:
matrix:
- os: [macos-latest, windows-latest]
+ # Note: Don't use macOS latest since macos 14 appears to be arm64 only
+ os: [macos-13, macos-14, windows-latest]
env_file: [actions-39.yaml, actions-310.yaml, actions-311.yaml, actions-312.yaml]
fail-fast: false
runs-on: ${{ matrix.os }}
@@ -224,8 +211,7 @@ jobs:
PANDAS_CI: 1
PYTEST_TARGET: pandas
PATTERN: "not slow and not db and not network and not single_cpu"
- # GH 47443: PYTEST_WORKERS > 0 crashes Windows builds with memory related errors
- PYTEST_WORKERS: ${{ matrix.os == 'macos-latest' && 'auto' || '0' }}
+ PYTEST_WORKERS: 'auto'
steps:
- name: Checkout
@@ -351,7 +337,8 @@ jobs:
strategy:
fail-fast: false
matrix:
- os: [ubuntu-22.04, macOS-latest, windows-latest]
+ # Separate out macOS 13 and 14, since macOS 14 is arm64 only
+ os: [ubuntu-22.04, macOS-13, macOS-14, windows-latest]
timeout-minutes: 90
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index 841559c8e9799..b9bfc766fb45c 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -94,7 +94,9 @@ jobs:
buildplat:
- [ubuntu-22.04, manylinux_x86_64]
- [ubuntu-22.04, musllinux_x86_64]
- - [macos-12, macosx_*]
+ - [macos-12, macosx_x86_64]
+ # Note: M1 images on Github Actions start from macOS 14
+ - [macos-14, macosx_arm64]
- [windows-2022, win_amd64]
# TODO: support PyPy?
python: [["cp39", "3.9"], ["cp310", "3.10"], ["cp311", "3.11"], ["cp312", "3.12"]]
@@ -128,7 +130,7 @@ jobs:
# Python version used to build sdist doesn't matter
# wheel will be built from sdist with the correct version
- name: Unzip sdist (macOS)
- if: ${{ matrix.buildplat[1] == 'macosx_*' }}
+ if: ${{ startsWith(matrix.buildplat[1], 'macosx') }}
run: |
tar -xzf ./dist/${{ env.sdist_name }} -C ./dist
@@ -137,20 +139,19 @@ jobs:
shell: bash -el {0}
run: echo "sdist_name=$(cd ./dist && ls -d */)" >> "$GITHUB_ENV"
- - name: Build normal wheels
- if: ${{ (env.IS_SCHEDULE_DISPATCH != 'true' || env.IS_PUSH == 'true') }}
- uses: pypa/cibuildwheel@v2.16.2
+ - name: Build wheels
+ uses: pypa/cibuildwheel@v2.17.0
with:
- package-dir: ./dist/${{ matrix.buildplat[1] == 'macosx_*' && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
+ package-dir: ./dist/${{ startsWith(matrix.buildplat[1], 'macosx') && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
env:
CIBW_PRERELEASE_PYTHONS: True
CIBW_BUILD: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
- name: Build nightly wheels (with NumPy pre-release)
if: ${{ (env.IS_SCHEDULE_DISPATCH == 'true' && env.IS_PUSH != 'true') }}
- uses: pypa/cibuildwheel@v2.16.2
+ uses: pypa/cibuildwheel@v2.17.0
with:
- package-dir: ./dist/${{ matrix.buildplat[1] == 'macosx_*' && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
+ package-dir: ./dist/${{ startsWith(matrix.buildplat[1], 'macosx') && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
env:
# The nightly wheels should be build witht he NumPy 2.0 pre-releases
# which requires the additional URL.
@@ -183,7 +184,7 @@ jobs:
$TST_CMD = @"
python -m pip install hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0;
python -m pip install `$(Get-Item pandas\wheelhouse\*.whl);
- python -c `'import pandas as pd; pd.test(extra_args=[\"`\"--no-strict-data-files`\"\", \"`\"-m not clipboard and not single_cpu and not slow and not network and not db`\"\"])`';
+ python -c `'import pandas as pd; pd.test(extra_args=[`\"--no-strict-data-files`\", `\"-m not clipboard and not single_cpu and not slow and not network and not db`\"])`';
"@
# add rc to the end of the image name if the Python version is unreleased
docker pull python:${{ matrix.python[1] == '3.12' && '3.12-rc' || format('{0}-windowsservercore', matrix.python[1]) }}
@@ -191,7 +192,7 @@ jobs:
- uses: actions/upload-artifact@v4
with:
- name: ${{ matrix.python[0] }}-${{ startsWith(matrix.buildplat[1], 'macosx') && 'macosx' || matrix.buildplat[1] }}
+ name: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
path: ./wheelhouse/*.whl
- name: Upload wheels & sdist
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 2a070e9a49b97..4b02ad7cf886f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -32,6 +32,8 @@ repos:
# TODO: remove autofixe-only rules when they are checked by ruff
name: ruff-selected-autofixes
alias: ruff-selected-autofixes
+ files: ^pandas
+ exclude: ^pandas/tests
args: [--select, "ANN001,ANN2", --fix-only, --exit-non-zero-on-fix]
- repo: https://github.com/jendrikseipp/vulture
rev: 'v2.10'
@@ -356,18 +358,6 @@ repos:
files: ^pandas/
exclude: ^(pandas/_libs/|pandas/tests/|pandas/errors/__init__.py$|pandas/_version.py)
types: [python]
- - id: future-annotations
- name: import annotations from __future__
- entry: 'from __future__ import annotations'
- language: pygrep
- args: [--negate]
- files: ^pandas/
- types: [python]
- exclude: |
- (?x)
- /(__init__\.py)|(api\.py)|(_version\.py)|(testing\.py)|(conftest\.py)$
- |/tests/
- |/_testing/
- id: check-test-naming
name: check that test names start with 'test'
entry: python -m scripts.check_test_naming
diff --git a/asv_bench/benchmarks/io/csv.py b/asv_bench/benchmarks/io/csv.py
index 9ac83db4f85b9..dae6107db4d92 100644
--- a/asv_bench/benchmarks/io/csv.py
+++ b/asv_bench/benchmarks/io/csv.py
@@ -408,6 +408,9 @@ def time_read_stringcsv(self, engine):
def time_read_bytescsv(self, engine):
read_csv(self.data(self.BytesIO_input), engine=engine)
+ def peakmem_read_csv(self, engine):
+ read_csv(self.data(self.BytesIO_input), engine=engine)
+
class ReadCSVCategorical(BaseIO):
fname = "__test__.csv"
diff --git a/ci/deps/actions-310.yaml b/ci/deps/actions-310.yaml
index 4b62ecc79e4ef..a3e44e6373145 100644
--- a/ci/deps/actions-310.yaml
+++ b/ci/deps/actions-310.yaml
@@ -14,13 +14,12 @@ dependencies:
- pytest>=7.3.2
- pytest-cov
- pytest-xdist>=2.2.0
- - pytest-localserver>=0.7.1
- pytest-qt>=4.2.0
- boto3
# required dependencies
- python-dateutil
- - numpy<2
+ - numpy
- pytz
# optional dependencies
@@ -61,3 +60,4 @@ dependencies:
- adbc-driver-postgresql>=0.8.0
- adbc-driver-sqlite>=0.8.0
- tzdata>=2022.7
+ - pytest-localserver>=0.7.1
diff --git a/ci/deps/actions-311-downstream_compat.yaml b/ci/deps/actions-311-downstream_compat.yaml
index 95c0319d6f5b8..d6bf9ec7843de 100644
--- a/ci/deps/actions-311-downstream_compat.yaml
+++ b/ci/deps/actions-311-downstream_compat.yaml
@@ -21,7 +21,7 @@ dependencies:
# required dependencies
- python-dateutil
- - numpy<2
+ - numpy
- pytz
# optional dependencies
diff --git a/ci/deps/actions-311-pyarrownightly.yaml b/ci/deps/actions-311-pyarrownightly.yaml
index 5455b9b84b034..d84063ac2a9ba 100644
--- a/ci/deps/actions-311-pyarrownightly.yaml
+++ b/ci/deps/actions-311-pyarrownightly.yaml
@@ -18,7 +18,7 @@ dependencies:
# required dependencies
- python-dateutil
- - numpy<2
+ - numpy
- pytz
- pip
diff --git a/ci/deps/actions-311-sanitizers.yaml b/ci/deps/actions-311-sanitizers.yaml
deleted file mode 100644
index dcd381066b0ea..0000000000000
--- a/ci/deps/actions-311-sanitizers.yaml
+++ /dev/null
@@ -1,32 +0,0 @@
-name: pandas-dev
-channels:
- - conda-forge
-dependencies:
- - python=3.11
-
- # build dependencies
- - versioneer[toml]
- - cython>=0.29.33
- - meson[ninja]=1.2.1
- - meson-python=0.13.1
-
- # test dependencies
- - pytest>=7.3.2
- - pytest-cov
- - pytest-xdist>=2.2.0
- - pytest-localserver>=0.7.1
- - pytest-qt>=4.2.0
- - boto3
- - hypothesis>=6.46.1
- - pyqt>=5.15.9
-
- # required dependencies
- - python-dateutil
- - numpy<2
- - pytz
-
- # pandas dependencies
- - pip
-
- - pip:
- - "tzdata>=2022.7"
diff --git a/ci/deps/actions-311.yaml b/ci/deps/actions-311.yaml
index 52074ae00ea18..95cd1a4d46ef4 100644
--- a/ci/deps/actions-311.yaml
+++ b/ci/deps/actions-311.yaml
@@ -14,13 +14,12 @@ dependencies:
- pytest>=7.3.2
- pytest-cov
- pytest-xdist>=2.2.0
- - pytest-localserver>=0.7.1
- pytest-qt>=4.2.0
- boto3
# required dependencies
- python-dateutil
- - numpy<2
+ - numpy
- pytz
# optional dependencies
@@ -60,4 +59,4 @@ dependencies:
- pip:
- adbc-driver-postgresql>=0.8.0
- adbc-driver-sqlite>=0.8.0
- - tzdata>=2022.7
+ - pytest-localserver>=0.7.1
diff --git a/ci/deps/actions-312.yaml b/ci/deps/actions-312.yaml
index 4c51e9e6029e3..a442ed6feeb5d 100644
--- a/ci/deps/actions-312.yaml
+++ b/ci/deps/actions-312.yaml
@@ -14,13 +14,12 @@ dependencies:
- pytest>=7.3.2
- pytest-cov
- pytest-xdist>=2.2.0
- - pytest-localserver>=0.7.1
- pytest-qt>=4.2.0
- boto3
# required dependencies
- python-dateutil
- - numpy<2
+ - numpy
- pytz
# optional dependencies
@@ -61,3 +60,4 @@ dependencies:
- adbc-driver-postgresql>=0.8.0
- adbc-driver-sqlite>=0.8.0
- tzdata>=2022.7
+ - pytest-localserver>=0.7.1
diff --git a/ci/deps/actions-39-minimum_versions.yaml b/ci/deps/actions-39-minimum_versions.yaml
index fd71315d2e7ac..7067048c4434d 100644
--- a/ci/deps/actions-39-minimum_versions.yaml
+++ b/ci/deps/actions-39-minimum_versions.yaml
@@ -22,7 +22,7 @@ dependencies:
# required dependencies
- python-dateutil=2.8.2
- - numpy=1.22.4, <2
+ - numpy=1.22.4
- pytz=2020.1
# optional dependencies
diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index cbe8f77c15730..b162a78e7f115 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -14,13 +14,12 @@ dependencies:
- pytest>=7.3.2
- pytest-cov
- pytest-xdist>=2.2.0
- - pytest-localserver>=0.7.1
- pytest-qt>=4.2.0
- boto3
# required dependencies
- python-dateutil
- - numpy<2
+ - numpy
- pytz
# optional dependencies
@@ -61,3 +60,4 @@ dependencies:
- adbc-driver-postgresql>=0.8.0
- adbc-driver-sqlite>=0.8.0
- tzdata>=2022.7
+ - pytest-localserver>=0.7.1
diff --git a/ci/deps/actions-pypy-39.yaml b/ci/deps/actions-pypy-39.yaml
index 5a5a01f7aec72..d9c8dd81b7c33 100644
--- a/ci/deps/actions-pypy-39.yaml
+++ b/ci/deps/actions-pypy-39.yaml
@@ -20,7 +20,7 @@ dependencies:
- hypothesis>=6.46.1
# required
- - numpy<2
+ - numpy
- python-dateutil
- pytz
- pip:
diff --git a/ci/deps/circle-310-arm64.yaml b/ci/deps/circle-310-arm64.yaml
index 8e106445cd4e0..a19ffd485262d 100644
--- a/ci/deps/circle-310-arm64.yaml
+++ b/ci/deps/circle-310-arm64.yaml
@@ -20,7 +20,7 @@ dependencies:
# required dependencies
- python-dateutil
- - numpy<2
+ - numpy
- pytz
# optional dependencies
diff --git a/ci/run_tests.sh b/ci/run_tests.sh
index 48ef21686a26f..39ab0890a32d1 100755
--- a/ci/run_tests.sh
+++ b/ci/run_tests.sh
@@ -10,7 +10,7 @@ echo PYTHONHASHSEED=$PYTHONHASHSEED
COVERAGE="-s --cov=pandas --cov-report=xml --cov-append --cov-config=pyproject.toml"
-PYTEST_CMD="MESONPY_EDITABLE_VERBOSE=1 PYTHONDEVMODE=1 PYTHONWARNDEFAULTENCODING=1 pytest -r fEs -n $PYTEST_WORKERS --dist=loadfile $TEST_ARGS $COVERAGE $PYTEST_TARGET"
+PYTEST_CMD="MESONPY_EDITABLE_VERBOSE=1 PYTHONDEVMODE=1 PYTHONWARNDEFAULTENCODING=1 pytest -r fE -n $PYTEST_WORKERS --dist=loadfile $TEST_ARGS $COVERAGE $PYTEST_TARGET"
if [[ "$PATTERN" ]]; then
PYTEST_CMD="$PYTEST_CMD -m \"$PATTERN\""
diff --git a/doc/source/getting_started/install.rst b/doc/source/getting_started/install.rst
index 1d7eca5223544..b9f7d64d4b2f8 100644
--- a/doc/source/getting_started/install.rst
+++ b/doc/source/getting_started/install.rst
@@ -21,7 +21,7 @@ Instructions for installing :ref:`from source <install.source>`,
Python version support
----------------------
-Officially Python 3.9, 3.10 and 3.11.
+Officially Python 3.9, 3.10, 3.11 and 3.12.
Installing pandas
-----------------
diff --git a/doc/source/reference/frame.rst b/doc/source/reference/frame.rst
index fefb02dd916cd..1d9019ff22c23 100644
--- a/doc/source/reference/frame.rst
+++ b/doc/source/reference/frame.rst
@@ -49,6 +49,7 @@ Conversion
DataFrame.infer_objects
DataFrame.copy
DataFrame.bool
+ DataFrame.to_numpy
Indexing, iteration
~~~~~~~~~~~~~~~~~~~
diff --git a/doc/source/reference/series.rst b/doc/source/reference/series.rst
index af262f9e6c336..d40f6e559b8fa 100644
--- a/doc/source/reference/series.rst
+++ b/doc/source/reference/series.rst
@@ -177,6 +177,7 @@ Reindexing / selection / label manipulation
:toctree: api/
Series.align
+ Series.case_when
Series.drop
Series.droplevel
Series.drop_duplicates
@@ -341,7 +342,6 @@ Datetime properties
Series.dt.tz
Series.dt.freq
Series.dt.unit
- Series.dt.normalize
Datetime methods
^^^^^^^^^^^^^^^^
diff --git a/doc/source/user_guide/copy_on_write.rst b/doc/source/user_guide/copy_on_write.rst
index 050c3901c3420..a083297925007 100644
--- a/doc/source/user_guide/copy_on_write.rst
+++ b/doc/source/user_guide/copy_on_write.rst
@@ -317,7 +317,7 @@ you are modifying one object inplace.
.. ipython:: python
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
- df2 = df.reset_index()
+ df2 = df.reset_index(drop=True)
df2.iloc[0, 0] = 100
This creates two objects that share data and thus the setitem operation will trigger a
@@ -328,7 +328,7 @@ held by the object.
.. ipython:: python
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
- df = df.reset_index()
+ df = df.reset_index(drop=True)
df.iloc[0, 0] = 100
No copy is necessary in this example.
diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index 6148086452d54..b3ad23e0d4104 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -3471,20 +3471,15 @@ saving a ``DataFrame`` to Excel. Generally the semantics are
similar to working with :ref:`csv<io.read_csv_table>` data.
See the :ref:`cookbook<cookbook.excel>` for some advanced strategies.
-.. warning::
-
- The `xlrd <https://xlrd.readthedocs.io/en/latest/>`__ package is now only for reading
- old-style ``.xls`` files.
+.. note::
- Before pandas 1.3.0, the default argument ``engine=None`` to :func:`~pandas.read_excel`
- would result in using the ``xlrd`` engine in many cases, including new
- Excel 2007+ (``.xlsx``) files. pandas will now default to using the
- `openpyxl <https://openpyxl.readthedocs.io/en/stable/>`__ engine.
+ When ``engine=None``, the following logic will be used to determine the engine:
- It is strongly encouraged to install ``openpyxl`` to read Excel 2007+
- (``.xlsx``) files.
- **Please do not report issues when using ``xlrd`` to read ``.xlsx`` files.**
- This is no longer supported, switch to using ``openpyxl`` instead.
+ - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),
+ then `odf <https://pypi.org/project/odfpy/>`_ will be used.
+ - Otherwise if ``path_or_buffer`` is an xls format, ``xlrd`` will be used.
+ - Otherwise if ``path_or_buffer`` is in xlsb format, ``pyxlsb`` will be used.
+ - Otherwise ``openpyxl`` will be used.
.. _io.excel_reader:
diff --git a/doc/source/user_guide/scale.rst b/doc/source/user_guide/scale.rst
index b262de5d71439..29df2994fbc35 100644
--- a/doc/source/user_guide/scale.rst
+++ b/doc/source/user_guide/scale.rst
@@ -156,7 +156,7 @@ fits in memory, you can work with datasets that are much larger than memory.
Chunking works well when the operation you're performing requires zero or minimal
coordination between chunks. For more complicated workflows, you're better off
- :ref:`using another library <scale.other_libraries>`.
+ :ref:`using other libraries <scale.other_libraries>`.
Suppose we have an even larger "logical dataset" on disk that's a directory of parquet
files. Each file in the directory represents a different year of the entire dataset.
@@ -219,160 +219,10 @@ different library that implements these out-of-core algorithms for you.
.. _scale.other_libraries:
-Use Dask
---------
+Use Other Libraries
+-------------------
-pandas is just one library offering a DataFrame API. Because of its popularity,
-pandas' API has become something of a standard that other libraries implement.
-The pandas documentation maintains a list of libraries implementing a DataFrame API
-in `the ecosystem page <https://pandas.pydata.org/community/ecosystem.html>`_.
-
-For example, `Dask`_, a parallel computing library, has `dask.dataframe`_, a
-pandas-like API for working with larger than memory datasets in parallel. Dask
-can use multiple threads or processes on a single machine, or a cluster of
-machines to process data in parallel.
-
-
-We'll import ``dask.dataframe`` and notice that the API feels similar to pandas.
-We can use Dask's ``read_parquet`` function, but provide a globstring of files to read in.
-
-.. ipython:: python
- :okwarning:
-
- import dask.dataframe as dd
-
- ddf = dd.read_parquet("data/timeseries/ts*.parquet", engine="pyarrow")
- ddf
-
-Inspecting the ``ddf`` object, we see a few things
-
-* There are familiar attributes like ``.columns`` and ``.dtypes``
-* There are familiar methods like ``.groupby``, ``.sum``, etc.
-* There are new attributes like ``.npartitions`` and ``.divisions``
-
-The partitions and divisions are how Dask parallelizes computation. A **Dask**
-DataFrame is made up of many pandas :class:`pandas.DataFrame`. A single method call on a
-Dask DataFrame ends up making many pandas method calls, and Dask knows how to
-coordinate everything to get the result.
-
-.. ipython:: python
-
- ddf.columns
- ddf.dtypes
- ddf.npartitions
-
-One major difference: the ``dask.dataframe`` API is *lazy*. If you look at the
-repr above, you'll notice that the values aren't actually printed out; just the
-column names and dtypes. That's because Dask hasn't actually read the data yet.
-Rather than executing immediately, doing operations build up a **task graph**.
-
-.. ipython:: python
- :okwarning:
-
- ddf
- ddf["name"]
- ddf["name"].value_counts()
-
-Each of these calls is instant because the result isn't being computed yet.
-We're just building up a list of computation to do when someone needs the
-result. Dask knows that the return type of a :class:`pandas.Series.value_counts`
-is a pandas :class:`pandas.Series` with a certain dtype and a certain name. So the Dask version
-returns a Dask Series with the same dtype and the same name.
-
-To get the actual result you can call ``.compute()``.
-
-.. ipython:: python
- :okwarning:
-
- %time ddf["name"].value_counts().compute()
-
-At that point, you get back the same thing you'd get with pandas, in this case
-a concrete pandas :class:`pandas.Series` with the count of each ``name``.
-
-Calling ``.compute`` causes the full task graph to be executed. This includes
-reading the data, selecting the columns, and doing the ``value_counts``. The
-execution is done *in parallel* where possible, and Dask tries to keep the
-overall memory footprint small. You can work with datasets that are much larger
-than memory, as long as each partition (a regular pandas :class:`pandas.DataFrame`) fits in memory.
-
-By default, ``dask.dataframe`` operations use a threadpool to do operations in
-parallel. We can also connect to a cluster to distribute the work on many
-machines. In this case we'll connect to a local "cluster" made up of several
-processes on this single machine.
-
-.. code-block:: python
-
- >>> from dask.distributed import Client, LocalCluster
-
- >>> cluster = LocalCluster()
- >>> client = Client(cluster)
- >>> client
- <Client: 'tcp://127.0.0.1:53349' processes=4 threads=8, memory=17.18 GB>
-
-Once this ``client`` is created, all of Dask's computation will take place on
-the cluster (which is just processes in this case).
-
-Dask implements the most used parts of the pandas API. For example, we can do
-a familiar groupby aggregation.
-
-.. ipython:: python
- :okwarning:
-
- %time ddf.groupby("name")[["x", "y"]].mean().compute().head()
-
-The grouping and aggregation is done out-of-core and in parallel.
-
-When Dask knows the ``divisions`` of a dataset, certain optimizations are
-possible. When reading parquet datasets written by dask, the divisions will be
-known automatically. In this case, since we created the parquet files manually,
-we need to supply the divisions manually.
-
-.. ipython:: python
- :okwarning:
-
- N = 12
- starts = [f"20{i:>02d}-01-01" for i in range(N)]
- ends = [f"20{i:>02d}-12-13" for i in range(N)]
-
- divisions = tuple(pd.to_datetime(starts)) + (pd.Timestamp(ends[-1]),)
- ddf.divisions = divisions
- ddf
-
-Now we can do things like fast random access with ``.loc``.
-
-.. ipython:: python
- :okwarning:
-
- ddf.loc["2002-01-01 12:01":"2002-01-01 12:05"].compute()
-
-Dask knows to just look in the 3rd partition for selecting values in 2002. It
-doesn't need to look at any other data.
-
-Many workflows involve a large amount of data and processing it in a way that
-reduces the size to something that fits in memory. In this case, we'll resample
-to daily frequency and take the mean. Once we've taken the mean, we know the
-results will fit in memory, so we can safely call ``compute`` without running
-out of memory. At that point it's just a regular pandas object.
-
-.. ipython:: python
- :okwarning:
-
- @savefig dask_resample.png
- ddf[["x", "y"]].resample("1D").mean().cumsum().compute().plot()
-
-.. ipython:: python
- :suppress:
-
- import shutil
-
- shutil.rmtree("data/timeseries")
-
-These Dask examples have all be done using multiple processes on a single
-machine. Dask can be `deployed on a cluster
-<https://docs.dask.org/en/latest/setup.html>`_ to scale up to even larger
-datasets.
-
-You see more dask examples at https://examples.dask.org.
-
-.. _Dask: https://dask.org
-.. _dask.dataframe: https://docs.dask.org/en/latest/dataframe.html
+There are other libraries which provide similar APIs to pandas and work nicely with pandas DataFrame,
+and can give you the ability to scale your large dataset processing and analytics
+by parallel runtime, distributed memory, clustering, etc. You can find more information
+in `the ecosystem page <https://pandas.pydata.org/community/ecosystem.html#out-of-core>`_.
diff --git a/doc/source/whatsnew/index.rst b/doc/source/whatsnew/index.rst
index ec024f36d78b1..34a2845290d5a 100644
--- a/doc/source/whatsnew/index.rst
+++ b/doc/source/whatsnew/index.rst
@@ -16,6 +16,8 @@ Version 2.2
.. toctree::
:maxdepth: 2
+ v2.2.2
+ v2.2.1
v2.2.0
Version 2.1
diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 51b4c4f297b07..d4eb5742ef928 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -432,7 +432,7 @@ In a future version, these will raise an error and you should cast to a common d
In [3]: ser[0] = 'not an int64'
FutureWarning:
- Setting an item of incompatible dtype is deprecated and will raise in a future error of pandas.
+ Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas.
Value 'not an int64' has dtype incompatible with int64, please explicitly cast to a compatible dtype first.
In [4]: ser
diff --git a/doc/source/whatsnew/v2.1.4.rst b/doc/source/whatsnew/v2.1.4.rst
index 57b83a294963b..73b1103c1bd37 100644
--- a/doc/source/whatsnew/v2.1.4.rst
+++ b/doc/source/whatsnew/v2.1.4.rst
@@ -42,4 +42,4 @@ Bug fixes
Contributors
~~~~~~~~~~~~
-.. contributors:: v2.1.3..v2.1.4|HEAD
+.. contributors:: v2.1.3..v2.1.4
diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index d1481639ca5a0..e015afb17dce5 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -1,7 +1,7 @@
.. _whatsnew_220:
-What's new in 2.2.0 (Month XX, 2024)
-------------------------------------
+What's new in 2.2.0 (January 19, 2024)
+--------------------------------------
These are the changes in pandas 2.2.0. See :ref:`release` for a full changelog
including other versions of pandas.
@@ -123,7 +123,7 @@ nullability handling.
with pg_dbapi.connect(uri) as conn:
df.to_sql("pandas_table", conn, index=False)
- # for roundtripping
+ # for round-tripping
with pg_dbapi.connect(uri) as conn:
df2 = pd.read_sql("pandas_table", conn)
@@ -176,7 +176,7 @@ leverage the ``dtype_backend="pyarrow"`` argument of :func:`~pandas.read_sql`
.. code-block:: ipython
- # for roundtripping
+ # for round-tripping
with pg_dbapi.connect(uri) as conn:
df2 = pd.read_sql("pandas_table", conn, dtype_backend="pyarrow")
@@ -188,6 +188,26 @@ For a full list of ADBC drivers and their development status, see the `ADBC Driv
Implementation Status <https://arrow.apache.org/adbc/current/driver/status.html>`_
documentation.
+.. _whatsnew_220.enhancements.case_when:
+
+Create a pandas Series based on one or more conditions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The :meth:`Series.case_when` function has been added to create a Series object based on one or more conditions. (:issue:`39154`)
+
+.. ipython:: python
+
+ import pandas as pd
+
+ df = pd.DataFrame(dict(a=[1, 2, 3], b=[4, 5, 6]))
+ default=pd.Series('default', index=df.index)
+ default.case_when(
+ caselist=[
+ (df.a == 1, 'first'), # condition, replacement
+ (df.a.gt(1) & df.b.eq(5), 'second'), # condition, replacement
+ ],
+ )
+
.. _whatsnew_220.enhancements.to_numpy_ea:
``to_numpy`` for NumPy nullable and Arrow types converts to suitable NumPy dtype
@@ -251,6 +271,14 @@ DataFrame. (:issue:`54938`)
)
series.struct.explode()
+Use :meth:`Series.struct.field` to index into a (possible nested)
+struct field.
+
+
+.. ipython:: python
+
+ series.struct.field("project")
+
.. _whatsnew_220.enhancements.list_accessor:
Series.list accessor for PyArrow list data
@@ -306,22 +334,23 @@ Other enhancements
- :meth:`~DataFrame.to_sql` with method parameter set to ``multi`` works with Oracle on the backend
- :attr:`Series.attrs` / :attr:`DataFrame.attrs` now uses a deepcopy for propagating ``attrs`` (:issue:`54134`).
- :func:`get_dummies` now returning extension dtypes ``boolean`` or ``bool[pyarrow]`` that are compatible with the input dtype (:issue:`56273`)
-- :func:`read_csv` now supports ``on_bad_lines`` parameter with ``engine="pyarrow"``. (:issue:`54480`)
+- :func:`read_csv` now supports ``on_bad_lines`` parameter with ``engine="pyarrow"`` (:issue:`54480`)
- :func:`read_sas` returns ``datetime64`` dtypes with resolutions better matching those stored natively in SAS, and avoids returning object-dtype in cases that cannot be stored with ``datetime64[ns]`` dtype (:issue:`56127`)
-- :func:`read_spss` now returns a :class:`DataFrame` that stores the metadata in :attr:`DataFrame.attrs`. (:issue:`54264`)
+- :func:`read_spss` now returns a :class:`DataFrame` that stores the metadata in :attr:`DataFrame.attrs` (:issue:`54264`)
- :func:`tseries.api.guess_datetime_format` is now part of the public API (:issue:`54727`)
+- :meth:`DataFrame.apply` now allows the usage of numba (via ``engine="numba"``) to JIT compile the passed function, allowing for potential speedups (:issue:`54666`)
- :meth:`ExtensionArray._explode` interface method added to allow extension type implementations of the ``explode`` method (:issue:`54833`)
- :meth:`ExtensionArray.duplicated` added to allow extension type implementations of the ``duplicated`` method (:issue:`55255`)
-- :meth:`Series.ffill`, :meth:`Series.bfill`, :meth:`DataFrame.ffill`, and :meth:`DataFrame.bfill` have gained the argument ``limit_area`` (:issue:`56492`)
+- :meth:`Series.ffill`, :meth:`Series.bfill`, :meth:`DataFrame.ffill`, and :meth:`DataFrame.bfill` have gained the argument ``limit_area``; 3rd party :class:`.ExtensionArray` authors need to add this argument to the method ``_pad_or_backfill`` (:issue:`56492`)
- Allow passing ``read_only``, ``data_only`` and ``keep_links`` arguments to openpyxl using ``engine_kwargs`` of :func:`read_excel` (:issue:`55027`)
-- DataFrame.apply now allows the usage of numba (via ``engine="numba"``) to JIT compile the passed function, allowing for potential speedups (:issue:`54666`)
+- Implement :meth:`Series.interpolate` and :meth:`DataFrame.interpolate` for :class:`ArrowDtype` and masked dtypes (:issue:`56267`)
- Implement masked algorithms for :meth:`Series.value_counts` (:issue:`54984`)
+- Implemented :meth:`Series.dt` methods and attributes for :class:`ArrowDtype` with ``pyarrow.duration`` type (:issue:`52284`)
- Implemented :meth:`Series.str.extract` for :class:`ArrowDtype` (:issue:`56268`)
-- Improved error message that appears in :meth:`DatetimeIndex.to_period` with frequencies which are not supported as period frequencies, such as "BMS" (:issue:`56243`)
-- Improved error message when constructing :class:`Period` with invalid offsets such as "QS" (:issue:`55785`)
+- Improved error message that appears in :meth:`DatetimeIndex.to_period` with frequencies which are not supported as period frequencies, such as ``"BMS"`` (:issue:`56243`)
+- Improved error message when constructing :class:`Period` with invalid offsets such as ``"QS"`` (:issue:`55785`)
- The dtypes ``string[pyarrow]`` and ``string[pyarrow_numpy]`` now both utilize the ``large_string`` type from PyArrow to avoid overflow for long columns (:issue:`56259`)
-
.. ---------------------------------------------------------------------------
.. _whatsnew_220.notable_bug_fixes:
@@ -386,6 +415,8 @@ index levels when joining on two indexes with different levels (:issue:`34133`).
left = pd.DataFrame({"left": 1}, index=pd.MultiIndex.from_tuples([("x", 1), ("x", 2)], names=["A", "B"]))
right = pd.DataFrame({"right": 2}, index=pd.MultiIndex.from_tuples([(1, 1), (2, 2)], names=["B", "C"]))
+ left
+ right
result = left.join(right)
*Old Behavior*
@@ -405,36 +436,67 @@ index levels when joining on two indexes with different levels (:issue:`34133`).
result
-.. ---------------------------------------------------------------------------
-.. _whatsnew_220.api_breaking:
-
-Backwards incompatible API changes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
.. _whatsnew_220.api_breaking.deps:
Increased minimum versions for dependencies
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Some minimum supported versions of dependencies were updated.
-If installed, we now require:
-
-+-----------------+-----------------+----------+---------+
-| Package | Minimum Version | Required | Changed |
-+=================+=================+==========+=========+
-| | | X | X |
-+-----------------+-----------------+----------+---------+
-
-For `optional libraries <https://pandas.pydata.org/docs/getting_started/install.html>`_ the general recommendation is to use the latest version.
-The following table lists the lowest version per library that is currently being tested throughout the development of pandas.
-Optional libraries below the lowest tested version may still work, but are not considered supported.
-
-+-----------------+-----------------+---------+
-| Package | Minimum Version | Changed |
-+=================+=================+=========+
-| mypy (dev) | 1.7.1 | X |
-+-----------------+-----------------+---------+
-| | | X |
-+-----------------+-----------------+---------+
+For `optional dependencies <https://pandas.pydata.org/docs/getting_started/install.html>`_ the general recommendation is to use the latest version.
+Optional dependencies below the lowest tested version may still work but are not considered supported.
+The following table lists the optional dependencies that have had their minimum tested version increased.
+
++-----------------+---------------------+
+| Package | New Minimum Version |
++=================+=====================+
+| beautifulsoup4 | 4.11.2 |
++-----------------+---------------------+
+| blosc | 1.21.3 |
++-----------------+---------------------+
+| bottleneck | 1.3.6 |
++-----------------+---------------------+
+| fastparquet | 2022.12.0 |
++-----------------+---------------------+
+| fsspec | 2022.11.0 |
++-----------------+---------------------+
+| gcsfs | 2022.11.0 |
++-----------------+---------------------+
+| lxml | 4.9.2 |
++-----------------+---------------------+
+| matplotlib | 3.6.3 |
++-----------------+---------------------+
+| numba | 0.56.4 |
++-----------------+---------------------+
+| numexpr | 2.8.4 |
++-----------------+---------------------+
+| qtpy | 2.3.0 |
++-----------------+---------------------+
+| openpyxl | 3.1.0 |
++-----------------+---------------------+
+| psycopg2 | 2.9.6 |
++-----------------+---------------------+
+| pyreadstat | 1.2.0 |
++-----------------+---------------------+
+| pytables | 3.8.0 |
++-----------------+---------------------+
+| pyxlsb | 1.0.10 |
++-----------------+---------------------+
+| s3fs | 2022.11.0 |
++-----------------+---------------------+
+| scipy | 1.10.0 |
++-----------------+---------------------+
+| sqlalchemy | 2.0.0 |
++-----------------+---------------------+
+| tabulate | 0.9.0 |
++-----------------+---------------------+
+| xarray | 2022.12.0 |
++-----------------+---------------------+
+| xlsxwriter | 3.0.5 |
++-----------------+---------------------+
+| zstandard | 0.19.0 |
++-----------------+---------------------+
+| pyqt5 | 5.15.8 |
++-----------------+---------------------+
+| tzdata | 2022.7 |
++-----------------+---------------------+
See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for more.
@@ -594,32 +656,33 @@ Other Deprecations
- Changed :meth:`Timedelta.resolution_string` to return ``h``, ``min``, ``s``, ``ms``, ``us``, and ``ns`` instead of ``H``, ``T``, ``S``, ``L``, ``U``, and ``N``, for compatibility with respective deprecations in frequency aliases (:issue:`52536`)
- Deprecated :attr:`offsets.Day.delta`, :attr:`offsets.Hour.delta`, :attr:`offsets.Minute.delta`, :attr:`offsets.Second.delta`, :attr:`offsets.Milli.delta`, :attr:`offsets.Micro.delta`, :attr:`offsets.Nano.delta`, use ``pd.Timedelta(obj)`` instead (:issue:`55498`)
- Deprecated :func:`pandas.api.types.is_interval` and :func:`pandas.api.types.is_period`, use ``isinstance(obj, pd.Interval)`` and ``isinstance(obj, pd.Period)`` instead (:issue:`55264`)
-- Deprecated :func:`pd.core.internals.api.make_block`, use public APIs instead (:issue:`40226`)
- Deprecated :func:`read_gbq` and :meth:`DataFrame.to_gbq`. Use ``pandas_gbq.read_gbq`` and ``pandas_gbq.to_gbq`` instead https://pandas-gbq.readthedocs.io/en/latest/api.html (:issue:`55525`)
- Deprecated :meth:`.DataFrameGroupBy.fillna` and :meth:`.SeriesGroupBy.fillna`; use :meth:`.DataFrameGroupBy.ffill`, :meth:`.DataFrameGroupBy.bfill` for forward and backward filling or :meth:`.DataFrame.fillna` to fill with a single value (or the Series equivalents) (:issue:`55718`)
+- Deprecated :meth:`DateOffset.is_anchored`, use ``obj.n == 1`` for non-Tick subclasses (for Tick this was always False) (:issue:`55388`)
- Deprecated :meth:`DatetimeArray.__init__` and :meth:`TimedeltaArray.__init__`, use :func:`array` instead (:issue:`55623`)
- Deprecated :meth:`Index.format`, use ``index.astype(str)`` or ``index.map(formatter)`` instead (:issue:`55413`)
- Deprecated :meth:`Series.ravel`, the underlying array is already 1D, so ravel is not necessary (:issue:`52511`)
- Deprecated :meth:`Series.resample` and :meth:`DataFrame.resample` with a :class:`PeriodIndex` (and the 'convention' keyword), convert to :class:`DatetimeIndex` (with ``.to_timestamp()``) before resampling instead (:issue:`53481`)
- Deprecated :meth:`Series.view`, use :meth:`Series.astype` instead to change the dtype (:issue:`20251`)
+- Deprecated :meth:`offsets.Tick.is_anchored`, use ``False`` instead (:issue:`55388`)
- Deprecated ``core.internals`` members ``Block``, ``ExtensionBlock``, and ``DatetimeTZBlock``, use public APIs instead (:issue:`55139`)
- Deprecated ``year``, ``month``, ``quarter``, ``day``, ``hour``, ``minute``, and ``second`` keywords in the :class:`PeriodIndex` constructor, use :meth:`PeriodIndex.from_fields` instead (:issue:`55960`)
- Deprecated accepting a type as an argument in :meth:`Index.view`, call without any arguments instead (:issue:`55709`)
- Deprecated allowing non-integer ``periods`` argument in :func:`date_range`, :func:`timedelta_range`, :func:`period_range`, and :func:`interval_range` (:issue:`56036`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_clipboard`. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_csv` except ``path_or_buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_dict`. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_excel` except ``excel_writer``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_gbq` except ``destination_table``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_hdf` except ``path_or_buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_html` except ``buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_json` except ``path_or_buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_latex` except ``buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_markdown` except ``buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_parquet` except ``path``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_pickle` except ``path``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_string` except ``buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_xml` except ``path_or_buffer``. (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_clipboard` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_csv` except ``path_or_buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_dict` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_excel` except ``excel_writer`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_gbq` except ``destination_table`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_hdf` except ``path_or_buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_html` except ``buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_json` except ``path_or_buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_latex` except ``buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_markdown` except ``buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_parquet` except ``path`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_pickle` except ``path`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_string` except ``buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_xml` except ``path_or_buffer`` (:issue:`54229`)
- Deprecated allowing passing :class:`BlockManager` objects to :class:`DataFrame` or :class:`SingleBlockManager` objects to :class:`Series` (:issue:`52419`)
- Deprecated behavior of :meth:`Index.insert` with an object-dtype index silently performing type inference on the result, explicitly call ``result.infer_objects(copy=False)`` for the old behavior instead (:issue:`51363`)
- Deprecated casting non-datetimelike values (mainly strings) in :meth:`Series.isin` and :meth:`Index.isin` with ``datetime64``, ``timedelta64``, and :class:`PeriodDtype` dtypes (:issue:`53111`)
@@ -652,6 +715,7 @@ Other Deprecations
- Deprecated the extension test classes ``BaseNoReduceTests``, ``BaseBooleanReduceTests``, and ``BaseNumericReduceTests``, use ``BaseReduceTests`` instead (:issue:`54663`)
- Deprecated the option ``mode.data_manager`` and the ``ArrayManager``; only the ``BlockManager`` will be available in future versions (:issue:`55043`)
- Deprecated the previous implementation of :class:`DataFrame.stack`; specify ``future_stack=True`` to adopt the future version (:issue:`53515`)
+-
.. ---------------------------------------------------------------------------
.. _whatsnew_220.performance:
@@ -692,37 +756,38 @@ Bug fixes
Categorical
^^^^^^^^^^^
- :meth:`Categorical.isin` raising ``InvalidIndexError`` for categorical containing overlapping :class:`Interval` values (:issue:`34974`)
-- Bug in :meth:`CategoricalDtype.__eq__` returning false for unordered categorical data with mixed types (:issue:`55468`)
--
+- Bug in :meth:`CategoricalDtype.__eq__` returning ``False`` for unordered categorical data with mixed types (:issue:`55468`)
+- Bug when casting ``pa.dictionary`` to :class:`CategoricalDtype` using a ``pa.DictionaryArray`` as categories (:issue:`56672`)
Datetimelike
^^^^^^^^^^^^
- Bug in :class:`DatetimeIndex` construction when passing both a ``tz`` and either ``dayfirst`` or ``yearfirst`` ignoring dayfirst/yearfirst (:issue:`55813`)
- Bug in :class:`DatetimeIndex` when passing an object-dtype ndarray of float objects and a ``tz`` incorrectly localizing the result (:issue:`55780`)
- Bug in :func:`Series.isin` with :class:`DatetimeTZDtype` dtype and comparison values that are all ``NaT`` incorrectly returning all-``False`` even if the series contains ``NaT`` entries (:issue:`56427`)
-- Bug in :func:`concat` raising ``AttributeError`` when concatenating all-NA DataFrame with :class:`DatetimeTZDtype` dtype DataFrame. (:issue:`52093`)
+- Bug in :func:`concat` raising ``AttributeError`` when concatenating all-NA DataFrame with :class:`DatetimeTZDtype` dtype DataFrame (:issue:`52093`)
- Bug in :func:`testing.assert_extension_array_equal` that could use the wrong unit when comparing resolutions (:issue:`55730`)
- Bug in :func:`to_datetime` and :class:`DatetimeIndex` when passing a list of mixed-string-and-numeric types incorrectly raising (:issue:`55780`)
- Bug in :func:`to_datetime` and :class:`DatetimeIndex` when passing mixed-type objects with a mix of timezones or mix of timezone-awareness failing to raise ``ValueError`` (:issue:`55693`)
+- Bug in :meth:`.Tick.delta` with very large ticks raising ``OverflowError`` instead of ``OutOfBoundsTimedelta`` (:issue:`55503`)
- Bug in :meth:`DatetimeIndex.shift` with non-nanosecond resolution incorrectly returning with nanosecond resolution (:issue:`56117`)
- Bug in :meth:`DatetimeIndex.union` returning object dtype for tz-aware indexes with the same timezone but different units (:issue:`55238`)
- Bug in :meth:`Index.is_monotonic_increasing` and :meth:`Index.is_monotonic_decreasing` always caching :meth:`Index.is_unique` as ``True`` when first value in index is ``NaT`` (:issue:`55755`)
- Bug in :meth:`Index.view` to a datetime64 dtype with non-supported resolution incorrectly raising (:issue:`55710`)
- Bug in :meth:`Series.dt.round` with non-nanosecond resolution and ``NaT`` entries incorrectly raising ``OverflowError`` (:issue:`56158`)
- Bug in :meth:`Series.fillna` with non-nanosecond resolution dtypes and higher-resolution vector values returning incorrect (internally-corrupted) results (:issue:`56410`)
-- Bug in :meth:`Tick.delta` with very large ticks raising ``OverflowError`` instead of ``OutOfBoundsTimedelta`` (:issue:`55503`)
- Bug in :meth:`Timestamp.unit` being inferred incorrectly from an ISO8601 format string with minute or hour resolution and a timezone offset (:issue:`56208`)
-- Bug in ``.astype`` converting from a higher-resolution ``datetime64`` dtype to a lower-resolution ``datetime64`` dtype (e.g. ``datetime64[us]->datetim64[ms]``) silently overflowing with values near the lower implementation bound (:issue:`55979`)
+- Bug in ``.astype`` converting from a higher-resolution ``datetime64`` dtype to a lower-resolution ``datetime64`` dtype (e.g. ``datetime64[us]->datetime64[ms]``) silently overflowing with values near the lower implementation bound (:issue:`55979`)
- Bug in adding or subtracting a :class:`Week` offset to a ``datetime64`` :class:`Series`, :class:`Index`, or :class:`DataFrame` column with non-nanosecond resolution returning incorrect results (:issue:`55583`)
- Bug in addition or subtraction of :class:`BusinessDay` offset with ``offset`` attribute to non-nanosecond :class:`Index`, :class:`Series`, or :class:`DataFrame` column giving incorrect results (:issue:`55608`)
- Bug in addition or subtraction of :class:`DateOffset` objects with microsecond components to ``datetime64`` :class:`Index`, :class:`Series`, or :class:`DataFrame` columns with non-nanosecond resolution (:issue:`55595`)
-- Bug in addition or subtraction of very large :class:`Tick` objects with :class:`Timestamp` or :class:`Timedelta` objects raising ``OverflowError`` instead of ``OutOfBoundsTimedelta`` (:issue:`55503`)
+- Bug in addition or subtraction of very large :class:`.Tick` objects with :class:`Timestamp` or :class:`Timedelta` objects raising ``OverflowError`` instead of ``OutOfBoundsTimedelta`` (:issue:`55503`)
- Bug in creating a :class:`Index`, :class:`Series`, or :class:`DataFrame` with a non-nanosecond :class:`DatetimeTZDtype` and inputs that would be out of bounds with nanosecond resolution incorrectly raising ``OutOfBoundsDatetime`` (:issue:`54620`)
- Bug in creating a :class:`Index`, :class:`Series`, or :class:`DataFrame` with a non-nanosecond ``datetime64`` (or :class:`DatetimeTZDtype`) from mixed-numeric inputs treating those as nanoseconds instead of as multiples of the dtype's unit (which would happen with non-mixed numeric inputs) (:issue:`56004`)
- Bug in creating a :class:`Index`, :class:`Series`, or :class:`DataFrame` with a non-nanosecond ``datetime64`` dtype and inputs that would be out of bounds for a ``datetime64[ns]`` incorrectly raising ``OutOfBoundsDatetime`` (:issue:`55756`)
- Bug in parsing datetime strings with nanosecond resolution with non-ISO8601 formats incorrectly truncating sub-microsecond components (:issue:`56051`)
- Bug in parsing datetime strings with sub-second resolution and trailing zeros incorrectly inferring second or millisecond resolution (:issue:`55737`)
- Bug in the results of :func:`to_datetime` with an floating-dtype argument with ``unit`` not matching the pointwise results of :class:`Timestamp` (:issue:`56037`)
+- Fixed regression where :func:`concat` would raise an error when concatenating ``datetime64`` columns with differing resolutions (:issue:`53641`)
Timedelta
^^^^^^^^^
@@ -738,15 +803,18 @@ Timezones
Numeric
^^^^^^^
- Bug in :func:`read_csv` with ``engine="pyarrow"`` causing rounding errors for large integers (:issue:`52505`)
+- Bug in :meth:`Series.__floordiv__` and :meth:`Series.__truediv__` for :class:`ArrowDtype` with integral dtypes raising for large divisors (:issue:`56706`)
+- Bug in :meth:`Series.__floordiv__` for :class:`ArrowDtype` with integral dtypes raising for large values (:issue:`56645`)
- Bug in :meth:`Series.pow` not filling missing values correctly (:issue:`55512`)
--
+- Bug in :meth:`Series.replace` and :meth:`DataFrame.replace` matching float ``0.0`` with ``False`` and vice versa (:issue:`55398`)
+- Bug in :meth:`Series.round` raising for nullable boolean dtype (:issue:`55936`)
Conversion
^^^^^^^^^^
- Bug in :meth:`DataFrame.astype` when called with ``str`` on unpickled array - the array might change in-place (:issue:`54654`)
- Bug in :meth:`DataFrame.astype` where ``errors="ignore"`` had no effect for extension types (:issue:`54654`)
- Bug in :meth:`Series.convert_dtypes` not converting all NA column to ``null[pyarrow]`` (:issue:`55346`)
--
+- Bug in :meth:``DataFrame.loc`` was not throwing "incompatible dtype warning" (see `PDEP6 <https://pandas.pydata.org/pdeps/0006-ban-upcasting.html>`_) when assigning a ``Series`` with a different dtype using a full column setter (e.g. ``df.loc[:, 'a'] = incompatible_value``) (:issue:`39584`)
Strings
^^^^^^^
@@ -756,6 +824,7 @@ Strings
- Bug in :meth:`Index.str.cat` always casting result to object dtype (:issue:`56157`)
- Bug in :meth:`Series.__mul__` for :class:`ArrowDtype` with ``pyarrow.string`` dtype and ``string[pyarrow]`` for the pyarrow backend (:issue:`51970`)
- Bug in :meth:`Series.str.find` when ``start < 0`` for :class:`ArrowDtype` with ``pyarrow.string`` (:issue:`56411`)
+- Bug in :meth:`Series.str.fullmatch` when ``dtype=pandas.ArrowDtype(pyarrow.string()))`` allows partial matches when regex ends in literal //$ (:issue:`56652`)
- Bug in :meth:`Series.str.replace` when ``n < 0`` for :class:`ArrowDtype` with ``pyarrow.string`` (:issue:`56404`)
- Bug in :meth:`Series.str.startswith` and :meth:`Series.str.endswith` with arguments of type ``tuple[str, ...]`` for :class:`ArrowDtype` with ``pyarrow.string`` dtype (:issue:`56579`)
- Bug in :meth:`Series.str.startswith` and :meth:`Series.str.endswith` with arguments of type ``tuple[str, ...]`` for ``string[pyarrow]`` (:issue:`54942`)
@@ -763,16 +832,17 @@ Strings
Interval
^^^^^^^^
-- Bug in :class:`Interval` ``__repr__`` not displaying UTC offsets for :class:`Timestamp` bounds. Additionally the hour, minute and second components will now be shown. (:issue:`55015`)
+- Bug in :class:`Interval` ``__repr__`` not displaying UTC offsets for :class:`Timestamp` bounds. Additionally the hour, minute and second components will now be shown (:issue:`55015`)
- Bug in :meth:`IntervalIndex.factorize` and :meth:`Series.factorize` with :class:`IntervalDtype` with datetime64 or timedelta64 intervals not preserving non-nanosecond units (:issue:`56099`)
- Bug in :meth:`IntervalIndex.from_arrays` when passed ``datetime64`` or ``timedelta64`` arrays with mismatched resolutions constructing an invalid ``IntervalArray`` object (:issue:`55714`)
+- Bug in :meth:`IntervalIndex.from_tuples` raising if subtype is a nullable extension dtype (:issue:`56765`)
- Bug in :meth:`IntervalIndex.get_indexer` with datetime or timedelta intervals incorrectly matching on integer targets (:issue:`47772`)
- Bug in :meth:`IntervalIndex.get_indexer` with timezone-aware datetime intervals incorrectly matching on a sequence of timezone-naive targets (:issue:`47772`)
- Bug in setting values on a :class:`Series` with an :class:`IntervalIndex` using a slice incorrectly raising (:issue:`54722`)
--
Indexing
^^^^^^^^
+- Bug in :meth:`DataFrame.loc` mutating a boolean indexer when :class:`DataFrame` has a :class:`MultiIndex` (:issue:`56635`)
- Bug in :meth:`DataFrame.loc` when setting :class:`Series` with extension dtype into NumPy dtype (:issue:`55604`)
- Bug in :meth:`Index.difference` not returning a unique set of values when ``other`` is empty or ``other`` is considered non-comparable (:issue:`55113`)
- Bug in setting :class:`Categorical` values into a :class:`DataFrame` with numpy dtypes raising ``RecursionError`` (:issue:`52927`)
@@ -781,25 +851,24 @@ Indexing
Missing
^^^^^^^
- Bug in :meth:`DataFrame.update` wasn't updating in-place for tz-aware datetime64 dtypes (:issue:`56227`)
--
MultiIndex
^^^^^^^^^^
- Bug in :meth:`MultiIndex.get_indexer` not raising ``ValueError`` when ``method`` provided and index is non-monotonic (:issue:`53452`)
--
I/O
^^^
-- Bug in :func:`read_csv` where ``engine="python"`` did not respect ``chunksize`` arg when ``skiprows`` was specified. (:issue:`56323`)
-- Bug in :func:`read_csv` where ``engine="python"`` was causing a ``TypeError`` when a callable ``skiprows`` and a chunk size was specified. (:issue:`55677`)
-- Bug in :func:`read_csv` where ``on_bad_lines="warn"`` would write to ``stderr`` instead of raise a Python warning. This now yields a :class:`.errors.ParserWarning` (:issue:`54296`)
+- Bug in :func:`read_csv` where ``engine="python"`` did not respect ``chunksize`` arg when ``skiprows`` was specified (:issue:`56323`)
+- Bug in :func:`read_csv` where ``engine="python"`` was causing a ``TypeError`` when a callable ``skiprows`` and a chunk size was specified (:issue:`55677`)
+- Bug in :func:`read_csv` where ``on_bad_lines="warn"`` would write to ``stderr`` instead of raising a Python warning; this now yields a :class:`.errors.ParserWarning` (:issue:`54296`)
- Bug in :func:`read_csv` with ``engine="pyarrow"`` where ``quotechar`` was ignored (:issue:`52266`)
-- Bug in :func:`read_csv` with ``engine="pyarrow"`` where ``usecols`` wasn't working with a csv with no headers (:issue:`54459`)
-- Bug in :func:`read_excel`, with ``engine="xlrd"`` (``xls`` files) erroring when file contains NaNs/Infs (:issue:`54564`)
+- Bug in :func:`read_csv` with ``engine="pyarrow"`` where ``usecols`` wasn't working with a CSV with no headers (:issue:`54459`)
+- Bug in :func:`read_excel`, with ``engine="xlrd"`` (``xls`` files) erroring when the file contains ``NaN`` or ``Inf`` (:issue:`54564`)
- Bug in :func:`read_json` not handling dtype conversion properly if ``infer_string`` is set (:issue:`56195`)
-- Bug in :meth:`DataFrame.to_excel`, with ``OdsWriter`` (``ods`` files) writing boolean/string value (:issue:`54994`)
+- Bug in :meth:`DataFrame.to_excel`, with ``OdsWriter`` (``ods`` files) writing Boolean/string value (:issue:`54994`)
- Bug in :meth:`DataFrame.to_hdf` and :func:`read_hdf` with ``datetime64`` dtypes with non-nanosecond resolution failing to round-trip correctly (:issue:`55622`)
-- Bug in :meth:`~pandas.read_excel` with ``engine="odf"`` (``ods`` files) when string contains annotation (:issue:`55200`)
+- Bug in :meth:`DataFrame.to_stata` raising for extension dtypes (:issue:`54671`)
+- Bug in :meth:`~pandas.read_excel` with ``engine="odf"`` (``ods`` files) when a string cell contains an annotation (:issue:`55200`)
- Bug in :meth:`~pandas.read_excel` with an ODS file without cached formatted cell for float values (:issue:`55219`)
- Bug where :meth:`DataFrame.to_json` would raise an ``OverflowError`` instead of a ``TypeError`` with unsupported NumPy types (:issue:`55403`)
@@ -808,29 +877,30 @@ Period
- Bug in :class:`PeriodIndex` construction when more than one of ``data``, ``ordinal`` and ``**fields`` are passed failing to raise ``ValueError`` (:issue:`55961`)
- Bug in :class:`Period` addition silently wrapping around instead of raising ``OverflowError`` (:issue:`55503`)
- Bug in casting from :class:`PeriodDtype` with ``astype`` to ``datetime64`` or :class:`DatetimeTZDtype` with non-nanosecond unit incorrectly returning with nanosecond unit (:issue:`55958`)
--
Plotting
^^^^^^^^
-- Bug in :meth:`DataFrame.plot.box` with ``vert=False`` and a matplotlib ``Axes`` created with ``sharey=True`` (:issue:`54941`)
-- Bug in :meth:`DataFrame.plot.scatter` discaring string columns (:issue:`56142`)
+- Bug in :meth:`DataFrame.plot.box` with ``vert=False`` and a Matplotlib ``Axes`` created with ``sharey=True`` (:issue:`54941`)
+- Bug in :meth:`DataFrame.plot.scatter` discarding string columns (:issue:`56142`)
- Bug in :meth:`Series.plot` when reusing an ``ax`` object failing to raise when a ``how`` keyword is passed (:issue:`55953`)
Groupby/resample/rolling
^^^^^^^^^^^^^^^^^^^^^^^^
-- Bug in :class:`.Rolling` where duplicate datetimelike indexes are treated as consecutive rather than equal with ``closed='left'`` and ``closed='neither'`` (:issue:`20712`)
- Bug in :meth:`.DataFrameGroupBy.idxmin`, :meth:`.DataFrameGroupBy.idxmax`, :meth:`.SeriesGroupBy.idxmin`, and :meth:`.SeriesGroupBy.idxmax` would not retain :class:`.Categorical` dtype when the index was a :class:`.CategoricalIndex` that contained NA values (:issue:`54234`)
- Bug in :meth:`.DataFrameGroupBy.transform` and :meth:`.SeriesGroupBy.transform` when ``observed=False`` and ``f="idxmin"`` or ``f="idxmax"`` would incorrectly raise on unobserved categories (:issue:`54234`)
-- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_count` could result in incorrect sorting if the columns of the DataFrame or name of the Series are integers (:issue:`55951`)
-- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_count` would not respect ``sort=False`` in :meth:`DataFrame.groupby` and :meth:`Series.groupby` (:issue:`55951`)
-- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_count` would sort by proportions rather than frequencies when ``sort=True`` and ``normalize=True`` (:issue:`55951`)
+- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_counts` could result in incorrect sorting if the columns of the DataFrame or name of the Series are integers (:issue:`55951`)
+- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_counts` would not respect ``sort=False`` in :meth:`DataFrame.groupby` and :meth:`Series.groupby` (:issue:`55951`)
+- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_counts` would sort by proportions rather than frequencies when ``sort=True`` and ``normalize=True`` (:issue:`55951`)
- Bug in :meth:`DataFrame.asfreq` and :meth:`Series.asfreq` with a :class:`DatetimeIndex` with non-nanosecond resolution incorrectly converting to nanosecond resolution (:issue:`55958`)
- Bug in :meth:`DataFrame.ewm` when passed ``times`` with non-nanosecond ``datetime64`` or :class:`DatetimeTZDtype` dtype (:issue:`56262`)
- Bug in :meth:`DataFrame.groupby` and :meth:`Series.groupby` where grouping by a combination of ``Decimal`` and NA values would fail when ``sort=True`` (:issue:`54847`)
+- Bug in :meth:`DataFrame.groupby` for DataFrame subclasses when selecting a subset of columns to apply the function to (:issue:`56761`)
- Bug in :meth:`DataFrame.resample` not respecting ``closed`` and ``label`` arguments for :class:`~pandas.tseries.offsets.BusinessDay` (:issue:`55282`)
- Bug in :meth:`DataFrame.resample` when resampling on a :class:`ArrowDtype` of ``pyarrow.timestamp`` or ``pyarrow.duration`` type (:issue:`55989`)
- Bug in :meth:`DataFrame.resample` where bin edges were not correct for :class:`~pandas.tseries.offsets.BusinessDay` (:issue:`55281`)
- Bug in :meth:`DataFrame.resample` where bin edges were not correct for :class:`~pandas.tseries.offsets.MonthBegin` (:issue:`55271`)
+- Bug in :meth:`DataFrame.rolling` and :meth:`Series.rolling` where duplicate datetimelike indexes are treated as consecutive rather than equal with ``closed='left'`` and ``closed='neither'`` (:issue:`20712`)
+- Bug in :meth:`DataFrame.rolling` and :meth:`Series.rolling` where either the ``index`` or ``on`` column was :class:`ArrowDtype` with ``pyarrow.timestamp`` type (:issue:`55849`)
Reshaping
^^^^^^^^^
@@ -839,50 +909,41 @@ Reshaping
- Bug in :func:`merge_asof` raising ``TypeError`` when ``by`` dtype is not ``object``, ``int64``, or ``uint64`` (:issue:`22794`)
- Bug in :func:`merge_asof` raising incorrect error for string dtype (:issue:`56444`)
- Bug in :func:`merge_asof` when using a :class:`Timedelta` tolerance on a :class:`ArrowDtype` column (:issue:`56486`)
+- Bug in :func:`merge` not raising when merging datetime columns with timedelta columns (:issue:`56455`)
- Bug in :func:`merge` not raising when merging string columns with numeric columns (:issue:`56441`)
+- Bug in :func:`merge` not sorting for new string dtype (:issue:`56442`)
- Bug in :func:`merge` returning columns in incorrect order when left and/or right is empty (:issue:`51929`)
- Bug in :meth:`DataFrame.melt` where an exception was raised if ``var_name`` was not a string (:issue:`55948`)
- Bug in :meth:`DataFrame.melt` where it would not preserve the datetime (:issue:`55254`)
- Bug in :meth:`DataFrame.pivot_table` where the row margin is incorrect when the columns have numeric names (:issue:`26568`)
- Bug in :meth:`DataFrame.pivot` with numeric columns and extension dtype for data (:issue:`56528`)
-- Bug in :meth:`DataFrame.stack` and :meth:`Series.stack` with ``future_stack=True`` would not preserve NA values in the index (:issue:`56573`)
+- Bug in :meth:`DataFrame.stack` with ``future_stack=True`` would not preserve NA values in the index (:issue:`56573`)
Sparse
^^^^^^
-- Bug in :meth:`SparseArray.take` when using a different fill value than the array's fill value (:issue:`55181`)
--
-
-ExtensionArray
-^^^^^^^^^^^^^^
--
--
-
-Styler
-^^^^^^
--
--
+- Bug in :meth:`arrays.SparseArray.take` when using a different fill value than the array's fill value (:issue:`55181`)
Other
^^^^^
+- :meth:`DataFrame.__dataframe__` did not support pyarrow large strings (:issue:`56702`)
- Bug in :func:`DataFrame.describe` when formatting percentiles in the resulting percentile 99.999% is rounded to 100% (:issue:`55765`)
+- Bug in :func:`api.interchange.from_dataframe` where it raised ``NotImplementedError`` when handling empty string columns (:issue:`56703`)
- Bug in :func:`cut` and :func:`qcut` with ``datetime64`` dtype values with non-nanosecond units incorrectly returning nanosecond-unit bins (:issue:`56101`)
- Bug in :func:`cut` incorrectly allowing cutting of timezone-aware datetimes with timezone-naive bins (:issue:`54964`)
- Bug in :func:`infer_freq` and :meth:`DatetimeIndex.inferred_freq` with weekly frequencies and non-nanosecond resolutions (:issue:`55609`)
- Bug in :meth:`DataFrame.apply` where passing ``raw=True`` ignored ``args`` passed to the applied function (:issue:`55009`)
- Bug in :meth:`DataFrame.from_dict` which would always sort the rows of the created :class:`DataFrame`. (:issue:`55683`)
- Bug in :meth:`DataFrame.sort_index` when passing ``axis="columns"`` and ``ignore_index=True`` raising a ``ValueError`` (:issue:`56478`)
-- Bug in rendering ``inf`` values inside a a :class:`DataFrame` with the ``use_inf_as_na`` option enabled (:issue:`55483`)
+- Bug in rendering ``inf`` values inside a :class:`DataFrame` with the ``use_inf_as_na`` option enabled (:issue:`55483`)
- Bug in rendering a :class:`Series` with a :class:`MultiIndex` when one of the index level's names is 0 not having that name displayed (:issue:`55415`)
- Bug in the error message when assigning an empty :class:`DataFrame` to a column (:issue:`55956`)
- Bug when time-like strings were being cast to :class:`ArrowDtype` with ``pyarrow.time64`` type (:issue:`56463`)
-
-.. ***DO NOT USE THIS SECTION***
-
--
--
+- Fixed a spurious deprecation warning from ``numba`` >= 0.58.0 when passing a numpy ufunc in :class:`core.window.Rolling.apply` with ``engine="numba"`` (:issue:`55247`)
.. ---------------------------------------------------------------------------
.. _whatsnew_220.contributors:
Contributors
~~~~~~~~~~~~
+
+.. contributors:: v2.1.4..v2.2.0
diff --git a/doc/source/whatsnew/v2.2.1.rst b/doc/source/whatsnew/v2.2.1.rst
new file mode 100644
index 0000000000000..310dd921e44f6
--- /dev/null
+++ b/doc/source/whatsnew/v2.2.1.rst
@@ -0,0 +1,90 @@
+.. _whatsnew_221:
+
+What's new in 2.2.1 (February 22, 2024)
+---------------------------------------
+
+These are the changes in pandas 2.2.1. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_221.enhancements:
+
+Enhancements
+~~~~~~~~~~~~
+- Added ``pyarrow`` pip extra so users can install pandas and pyarrow with pip with ``pip install pandas[pyarrow]`` (:issue:`54466`)
+
+.. _whatsnew_221.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+- Fixed memory leak in :func:`read_csv` (:issue:`57039`)
+- Fixed performance regression in :meth:`Series.combine_first` (:issue:`55845`)
+- Fixed regression causing overflow for near-minimum timestamps (:issue:`57150`)
+- Fixed regression in :func:`concat` changing long-standing behavior that always sorted the non-concatenation axis when the axis was a :class:`DatetimeIndex` (:issue:`57006`)
+- Fixed regression in :func:`merge_ordered` raising ``TypeError`` for ``fill_method="ffill"`` and ``how="left"`` (:issue:`57010`)
+- Fixed regression in :func:`pandas.testing.assert_series_equal` defaulting to ``check_exact=True`` when checking the :class:`Index` (:issue:`57067`)
+- Fixed regression in :func:`read_json` where an :class:`Index` would be returned instead of a :class:`RangeIndex` (:issue:`57429`)
+- Fixed regression in :func:`wide_to_long` raising an ``AttributeError`` for string columns (:issue:`57066`)
+- Fixed regression in :meth:`.DataFrameGroupBy.idxmin`, :meth:`.DataFrameGroupBy.idxmax`, :meth:`.SeriesGroupBy.idxmin`, :meth:`.SeriesGroupBy.idxmax` ignoring the ``skipna`` argument (:issue:`57040`)
+- Fixed regression in :meth:`.DataFrameGroupBy.idxmin`, :meth:`.DataFrameGroupBy.idxmax`, :meth:`.SeriesGroupBy.idxmin`, :meth:`.SeriesGroupBy.idxmax` where values containing the minimum or maximum value for the dtype could produce incorrect results (:issue:`57040`)
+- Fixed regression in :meth:`CategoricalIndex.difference` raising ``KeyError`` when other contains null values other than NaN (:issue:`57318`)
+- Fixed regression in :meth:`DataFrame.groupby` raising ``ValueError`` when grouping by a :class:`Series` in some cases (:issue:`57276`)
+- Fixed regression in :meth:`DataFrame.loc` raising ``IndexError`` for non-unique, masked dtype indexes where result has more than 10,000 rows (:issue:`57027`)
+- Fixed regression in :meth:`DataFrame.loc` which was unnecessarily throwing "incompatible dtype warning" when expanding with partial row indexer and multiple columns (see `PDEP6 <https://pandas.pydata.org/pdeps/0006-ban-upcasting.html>`_) (:issue:`56503`)
+- Fixed regression in :meth:`DataFrame.map` with ``na_action="ignore"`` not being respected for NumPy nullable and :class:`ArrowDtypes` (:issue:`57316`)
+- Fixed regression in :meth:`DataFrame.merge` raising ``ValueError`` for certain types of 3rd-party extension arrays (:issue:`57316`)
+- Fixed regression in :meth:`DataFrame.query` with all ``NaT`` column with object dtype (:issue:`57068`)
+- Fixed regression in :meth:`DataFrame.shift` raising ``AssertionError`` for ``axis=1`` and empty :class:`DataFrame` (:issue:`57301`)
+- Fixed regression in :meth:`DataFrame.sort_index` not producing a stable sort for a index with duplicates (:issue:`57151`)
+- Fixed regression in :meth:`DataFrame.to_dict` with ``orient='list'`` and datetime or timedelta types returning integers (:issue:`54824`)
+- Fixed regression in :meth:`DataFrame.to_json` converting nullable integers to floats (:issue:`57224`)
+- Fixed regression in :meth:`DataFrame.to_sql` when ``method="multi"`` is passed and the dialect type is not Oracle (:issue:`57310`)
+- Fixed regression in :meth:`DataFrame.transpose` with nullable extension dtypes not having F-contiguous data potentially causing exceptions when used (:issue:`57315`)
+- Fixed regression in :meth:`DataFrame.update` emitting incorrect warnings about downcasting (:issue:`57124`)
+- Fixed regression in :meth:`DataFrameGroupBy.idxmin`, :meth:`DataFrameGroupBy.idxmax`, :meth:`SeriesGroupBy.idxmin`, :meth:`SeriesGroupBy.idxmax` ignoring the ``skipna`` argument (:issue:`57040`)
+- Fixed regression in :meth:`DataFrameGroupBy.idxmin`, :meth:`DataFrameGroupBy.idxmax`, :meth:`SeriesGroupBy.idxmin`, :meth:`SeriesGroupBy.idxmax` where values containing the minimum or maximum value for the dtype could produce incorrect results (:issue:`57040`)
+- Fixed regression in :meth:`ExtensionArray.to_numpy` raising for non-numeric masked dtypes (:issue:`56991`)
+- Fixed regression in :meth:`Index.join` raising ``TypeError`` when joining an empty index to a non-empty index containing mixed dtype values (:issue:`57048`)
+- Fixed regression in :meth:`Series.astype` introducing decimals when converting from integer with missing values to string dtype (:issue:`57418`)
+- Fixed regression in :meth:`Series.pct_change` raising a ``ValueError`` for an empty :class:`Series` (:issue:`57056`)
+- Fixed regression in :meth:`Series.to_numpy` when dtype is given as float and the data contains NaNs (:issue:`57121`)
+- Fixed regression in addition or subtraction of :class:`DateOffset` objects with millisecond components to ``datetime64`` :class:`Index`, :class:`Series`, or :class:`DataFrame` (:issue:`57529`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_221.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+- Fixed bug in :func:`pandas.api.interchange.from_dataframe` which was raising for Nullable integers (:issue:`55069`)
+- Fixed bug in :func:`pandas.api.interchange.from_dataframe` which was raising for empty inputs (:issue:`56700`)
+- Fixed bug in :func:`pandas.api.interchange.from_dataframe` which wasn't converting columns names to strings (:issue:`55069`)
+- Fixed bug in :meth:`DataFrame.__getitem__` for empty :class:`DataFrame` with Copy-on-Write enabled (:issue:`57130`)
+- Fixed bug in :meth:`PeriodIndex.asfreq` which was silently converting frequencies which are not supported as period frequencies instead of raising an error (:issue:`56945`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_221.other:
+
+Other
+~~~~~
+
+.. note::
+
+ The ``DeprecationWarning`` that was raised when pandas was imported without PyArrow being
+ installed has been removed. This decision was made because the warning was too noisy for too
+ many users and a lot of feedback was collected about the decision to make PyArrow a required
+ dependency. Pandas is currently considering the decision whether or not PyArrow should be added
+ as a hard dependency in 3.0. Interested users can follow the discussion
+ `here <https://github.com/pandas-dev/pandas/issues/57073>`_.
+
+- Added the argument ``skipna`` to :meth:`DataFrameGroupBy.first`, :meth:`DataFrameGroupBy.last`, :meth:`SeriesGroupBy.first`, and :meth:`SeriesGroupBy.last`; achieving ``skipna=False`` used to be available via :meth:`DataFrameGroupBy.nth`, but the behavior was changed in pandas 2.0.0 (:issue:`57019`)
+- Added the argument ``skipna`` to :meth:`Resampler.first`, :meth:`Resampler.last` (:issue:`57019`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_221.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v2.2.0..v2.2.1|HEAD
diff --git a/doc/source/whatsnew/v2.2.2.rst b/doc/source/whatsnew/v2.2.2.rst
new file mode 100644
index 0000000000000..0dac3660c76b2
--- /dev/null
+++ b/doc/source/whatsnew/v2.2.2.rst
@@ -0,0 +1,42 @@
+.. _whatsnew_222:
+
+What's new in 2.2.2 (April XX, 2024)
+---------------------------------------
+
+These are the changes in pandas 2.2.2. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_222.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+- :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the a column's type was a pandas nullable on with missing values (:issue:`56702`)
+- :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the a column's type was a pyarrow nullable on with missing values (:issue:`57664`)
+- Avoid issuing a spurious ``DeprecationWarning`` when a custom :class:`DataFrame` or :class:`Series` subclass method is called (:issue:`57553`)
+- Fixed regression in precision of :func:`to_datetime` with string and ``unit`` input (:issue:`57051`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_222.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+- :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the column's type was nullable boolean (:issue:`55332`)
+- :meth:`DataFrame.__dataframe__` was showing bytemask instead of bitmask for ``'string[pyarrow]'`` validity buffer (:issue:`57762`)
+- :meth:`DataFrame.__dataframe__` was showing non-null validity buffer (instead of ``None``) ``'string[pyarrow]'`` without missing values (:issue:`57761`)
+- :meth:`DataFrame.to_sql` was failing to find the right table when using the schema argument (:issue:`57539`)
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_222.other:
+
+Other
+~~~~~
+-
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_222.contributors:
+
+Contributors
+~~~~~~~~~~~~
diff --git a/environment.yml b/environment.yml
index 74317d47e2e53..58eb69ad1f070 100644
--- a/environment.yml
+++ b/environment.yml
@@ -76,7 +76,7 @@ dependencies:
# code checks
- flake8=6.1.0 # run in subprocess over docstring examples
- - mypy=1.7.1 # pre-commit uses locally installed mypy
+ - mypy=1.8.0 # pre-commit uses locally installed mypy
- tokenize-rt # scripts/check_for_inconsistent_pandas_namespace.py
- pre-commit>=3.6.0
diff --git a/pandas/__init__.py b/pandas/__init__.py
index 7fab662ed2de4..ca2eba2043292 100644
--- a/pandas/__init__.py
+++ b/pandas/__init__.py
@@ -202,8 +202,8 @@
FutureWarning,
stacklevel=2,
)
-# Don't allow users to use pandas.os or pandas.warnings
-del os, warnings
+
+del warnings, os
# module level doc-string
__doc__ = """
diff --git a/pandas/_libs/algos_take_helper.pxi.in b/pandas/_libs/algos_take_helper.pxi.in
index 88c3abba506a3..385727fad3c50 100644
--- a/pandas/_libs/algos_take_helper.pxi.in
+++ b/pandas/_libs/algos_take_helper.pxi.in
@@ -184,6 +184,17 @@ def take_2d_axis1_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
fv = fill_value
+ {{if c_type_in == c_type_out != "object"}}
+ with nogil:
+ for i in range(n):
+ for j in range(k):
+ idx = indexer[j]
+ if idx == -1:
+ out[i, j] = fv
+ else:
+ out[i, j] = values[i, idx]
+
+ {{else}}
for i in range(n):
for j in range(k):
idx = indexer[j]
@@ -195,6 +206,7 @@ def take_2d_axis1_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
{{else}}
out[i, j] = values[i, idx]
{{endif}}
+ {{endif}}
@cython.wraparound(False)
diff --git a/pandas/_libs/groupby.pyi b/pandas/_libs/groupby.pyi
index 135828a23648a..a494b61fa7e3d 100644
--- a/pandas/_libs/groupby.pyi
+++ b/pandas/_libs/groupby.pyi
@@ -136,6 +136,7 @@ def group_last(
result_mask: npt.NDArray[np.bool_] | None = ...,
min_count: int = ..., # Py_ssize_t
is_datetimelike: bool = ...,
+ skipna: bool = ...,
) -> None: ...
def group_nth(
out: np.ndarray, # rank_t[:, ::1]
@@ -147,6 +148,7 @@ def group_nth(
min_count: int = ..., # int64_t
rank: int = ..., # int64_t
is_datetimelike: bool = ...,
+ skipna: bool = ...,
) -> None: ...
def group_rank(
out: np.ndarray, # float64_t[:, ::1]
diff --git a/pandas/_libs/groupby.pyx b/pandas/_libs/groupby.pyx
index 19d71b0a6fde3..b855d64d0be18 100644
--- a/pandas/_libs/groupby.pyx
+++ b/pandas/_libs/groupby.pyx
@@ -1424,6 +1424,7 @@ def group_last(
uint8_t[:, ::1] result_mask=None,
Py_ssize_t min_count=-1,
bint is_datetimelike=False,
+ bint skipna=True,
) -> None:
"""
Only aggregates on axis=0
@@ -1458,14 +1459,19 @@ def group_last(
for j in range(K):
val = values[i, j]
- if uses_mask:
- isna_entry = mask[i, j]
- else:
- isna_entry = _treat_as_na(val, is_datetimelike)
+ if skipna:
+ if uses_mask:
+ isna_entry = mask[i, j]
+ else:
+ isna_entry = _treat_as_na(val, is_datetimelike)
+ if isna_entry:
+ continue
- if not isna_entry:
- nobs[lab, j] += 1
- resx[lab, j] = val
+ nobs[lab, j] += 1
+ resx[lab, j] = val
+
+ if uses_mask and not skipna:
+ result_mask[lab, j] = mask[i, j]
_check_below_mincount(
out, uses_mask, result_mask, ncounts, K, nobs, min_count, resx
@@ -1486,6 +1492,7 @@ def group_nth(
int64_t min_count=-1,
int64_t rank=1,
bint is_datetimelike=False,
+ bint skipna=True,
) -> None:
"""
Only aggregates on axis=0
@@ -1520,15 +1527,19 @@ def group_nth(
for j in range(K):
val = values[i, j]
- if uses_mask:
- isna_entry = mask[i, j]
- else:
- isna_entry = _treat_as_na(val, is_datetimelike)
+ if skipna:
+ if uses_mask:
+ isna_entry = mask[i, j]
+ else:
+ isna_entry = _treat_as_na(val, is_datetimelike)
+ if isna_entry:
+ continue
- if not isna_entry:
- nobs[lab, j] += 1
- if nobs[lab, j] == rank:
- resx[lab, j] = val
+ nobs[lab, j] += 1
+ if nobs[lab, j] == rank:
+ resx[lab, j] = val
+ if uses_mask and not skipna:
+ result_mask[lab, j] = mask[i, j]
_check_below_mincount(
out, uses_mask, result_mask, ncounts, K, nobs, min_count, resx
@@ -1767,6 +1778,7 @@ def group_idxmin_idxmax(
Py_ssize_t i, j, N, K, lab
numeric_object_t val
numeric_object_t[:, ::1] group_min_or_max
+ uint8_t[:, ::1] seen
bint uses_mask = mask is not None
bint isna_entry
bint compute_max = name == "idxmax"
@@ -1780,13 +1792,10 @@ def group_idxmin_idxmax(
if numeric_object_t is object:
group_min_or_max = np.empty((<object>out).shape, dtype=object)
+ seen = np.zeros((<object>out).shape, dtype=np.uint8)
else:
group_min_or_max = np.empty_like(out, dtype=values.dtype)
- if N > 0 and K > 0:
- # When N or K is zero, we never use group_min_or_max
- group_min_or_max[:] = _get_min_or_max(
- values[0, 0], compute_max, is_datetimelike
- )
+ seen = np.zeros_like(out, dtype=np.uint8)
# When using transform, we need a valid value for take in the case
# a category is not observed; these values will be dropped
@@ -1802,6 +1811,7 @@ def group_idxmin_idxmax(
if not skipna and out[lab, j] == -1:
# Once we've hit NA there is no going back
continue
+
val = values[i, j]
if uses_mask:
@@ -1810,10 +1820,14 @@ def group_idxmin_idxmax(
isna_entry = _treat_as_na(val, is_datetimelike)
if isna_entry:
- if not skipna:
+ if not skipna or not seen[lab, j]:
out[lab, j] = -1
else:
- if compute_max:
+ if not seen[lab, j]:
+ seen[lab, j] = True
+ group_min_or_max[lab, j] = val
+ out[lab, j] = i
+ elif compute_max:
if val > group_min_or_max[lab, j]:
group_min_or_max[lab, j] = val
out[lab, j] = i
diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index 0dc139781f58d..ee6a11ddab004 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -96,6 +96,20 @@ cdef ndarray _get_bool_indexer(ndarray values, object val, ndarray mask = None):
return indexer.view(bool)
+cdef _maybe_resize_array(ndarray values, Py_ssize_t loc, Py_ssize_t max_length):
+ """
+ Resize array if loc is out of bounds.
+ """
+ cdef:
+ Py_ssize_t n = len(values)
+
+ if loc >= n:
+ while loc >= n:
+ n *= 2
+ values = np.resize(values, min(n, max_length))
+ return values
+
+
# Don't populate hash tables in monotonic indexes larger than this
_SIZE_CUTOFF = 1_000_000
@@ -281,7 +295,7 @@ cdef class IndexEngine:
values = self.values
self.monotonic_inc, self.monotonic_dec, is_strict_monotonic = \
self._call_monotonic(values)
- except TypeError:
+ except (TypeError, ValueError):
self.monotonic_inc = 0
self.monotonic_dec = 0
is_strict_monotonic = 0
@@ -450,27 +464,18 @@ cdef class IndexEngine:
# found
if val in d:
key = val
-
+ result = _maybe_resize_array(
+ result,
+ count + len(d[key]) - 1,
+ max_alloc
+ )
for j in d[key]:
-
- # realloc if needed
- if count >= n_alloc:
- n_alloc *= 2
- if n_alloc > max_alloc:
- n_alloc = max_alloc
- result = np.resize(result, n_alloc)
-
result[count] = j
count += 1
# value not found
else:
-
- if count >= n_alloc:
- n_alloc *= 2
- if n_alloc > max_alloc:
- n_alloc = max_alloc
- result = np.resize(result, n_alloc)
+ result = _maybe_resize_array(result, count, max_alloc)
result[count] = -1
count += 1
missing[count_missing] = i
@@ -1193,13 +1198,12 @@ cdef class MaskedIndexEngine(IndexEngine):
if PySequence_GetItem(target_mask, i):
if na_pos:
+ result = _maybe_resize_array(
+ result,
+ count + len(na_pos) - 1,
+ max_alloc,
+ )
for na_idx in na_pos:
- # realloc if needed
- if count >= n_alloc:
- n_alloc *= 2
- if n_alloc > max_alloc:
- n_alloc = max_alloc
-
result[count] = na_idx
count += 1
continue
@@ -1207,23 +1211,18 @@ cdef class MaskedIndexEngine(IndexEngine):
elif val in d:
# found
key = val
-
+ result = _maybe_resize_array(
+ result,
+ count + len(d[key]) - 1,
+ max_alloc,
+ )
for j in d[key]:
-
- # realloc if needed
- if count >= n_alloc:
- n_alloc *= 2
- if n_alloc > max_alloc:
- n_alloc = max_alloc
-
result[count] = j
count += 1
continue
# value not found
- if count >= n_alloc:
- n_alloc += 10_000
- result = np.resize(result, n_alloc)
+ result = _maybe_resize_array(result, count, max_alloc)
result[count] = -1
count += 1
missing[count_missing] = i
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index c483f35513a40..7656e8d986117 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -759,7 +759,7 @@ cpdef ndarray[object] ensure_string_array(
out = arr.astype(str).astype(object)
out[arr.isna()] = na_value
return out
- arr = arr.to_numpy()
+ arr = arr.to_numpy(dtype=object)
elif not util.is_array(arr):
arr = np.array(arr, dtype="object")
diff --git a/pandas/_libs/ops.pyx b/pandas/_libs/ops.pyx
index 9154e836b3477..567bfc02a2950 100644
--- a/pandas/_libs/ops.pyx
+++ b/pandas/_libs/ops.pyx
@@ -29,7 +29,7 @@ from pandas._libs.util cimport is_nan
@cython.wraparound(False)
@cython.boundscheck(False)
-def scalar_compare(object[:] values, object val, object op) -> ndarray:
+def scalar_compare(ndarray[object] values, object val, object op) -> ndarray:
"""
Compare each element of `values` array with the scalar `val`, with
the comparison operation described by `op`.
diff --git a/pandas/_libs/src/datetime/pd_datetime.c b/pandas/_libs/src/datetime/pd_datetime.c
index 19de51be6e1b2..4c1969f6d9f57 100644
--- a/pandas/_libs/src/datetime/pd_datetime.c
+++ b/pandas/_libs/src/datetime/pd_datetime.c
@@ -20,6 +20,9 @@ This file is derived from NumPy 1.7. See NUMPY_LICENSE.txt
#include <Python.h>
#include "datetime.h"
+/* Need to import_array for np_datetime.c (for NumPy 1.x support only) */
+#define PY_ARRAY_UNIQUE_SYMBOL PANDAS_DATETIME_NUMPY
+#include "numpy/ndarrayobject.h"
#include "pandas/datetime/pd_datetime.h"
#include "pandas/portable.h"
@@ -255,5 +258,6 @@ static struct PyModuleDef pandas_datetimemodule = {
PyMODINIT_FUNC PyInit_pandas_datetime(void) {
PyDateTime_IMPORT;
+ import_array();
return PyModuleDef_Init(&pandas_datetimemodule);
}
diff --git a/pandas/_libs/src/parser/tokenizer.c b/pandas/_libs/src/parser/tokenizer.c
index 0e4188bea4dc7..c9f7a796a9b1c 100644
--- a/pandas/_libs/src/parser/tokenizer.c
+++ b/pandas/_libs/src/parser/tokenizer.c
@@ -109,6 +109,14 @@ void parser_set_default_options(parser_t *self) {
parser_t *parser_new(void) { return (parser_t *)calloc(1, sizeof(parser_t)); }
+static void parser_clear_data_buffers(parser_t *self) {
+ free_if_not_null((void *)&self->stream);
+ free_if_not_null((void *)&self->words);
+ free_if_not_null((void *)&self->word_starts);
+ free_if_not_null((void *)&self->line_start);
+ free_if_not_null((void *)&self->line_fields);
+}
+
static void parser_cleanup(parser_t *self) {
// XXX where to put this
free_if_not_null((void *)&self->error_msg);
@@ -119,6 +127,7 @@ static void parser_cleanup(parser_t *self) {
self->skipset = NULL;
}
+ parser_clear_data_buffers(self);
if (self->cb_cleanup != NULL) {
self->cb_cleanup(self->source);
self->cb_cleanup = NULL;
diff --git a/pandas/_libs/src/vendored/numpy/datetime/np_datetime.c b/pandas/_libs/src/vendored/numpy/datetime/np_datetime.c
index 06e3251db8315..934c54fafb634 100644
--- a/pandas/_libs/src/vendored/numpy/datetime/np_datetime.c
+++ b/pandas/_libs/src/vendored/numpy/datetime/np_datetime.c
@@ -16,8 +16,6 @@ This file is derived from NumPy 1.7. See NUMPY_LICENSE.txt
// Licence at LICENSES/NUMPY_LICENSE
-#define NO_IMPORT
-
#ifndef NPY_NO_DEPRECATED_API
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#endif // NPY_NO_DEPRECATED_API
@@ -25,7 +23,10 @@ This file is derived from NumPy 1.7. See NUMPY_LICENSE.txt
#include <Python.h>
#include "pandas/vendored/numpy/datetime/np_datetime.h"
-#include <numpy/ndarraytypes.h>
+
+#define NO_IMPORT_ARRAY
+#define PY_ARRAY_UNIQUE_SYMBOL PANDAS_DATETIME_NUMPY
+#include <numpy/ndarrayobject.h>
#include <numpy/npy_common.h>
#if defined(_WIN32)
@@ -482,10 +483,20 @@ npy_datetime npy_datetimestruct_to_datetime(NPY_DATETIMEUNIT base,
if (base == NPY_FR_ns) {
int64_t nanoseconds;
- PD_CHECK_OVERFLOW(
- scaleMicrosecondsToNanoseconds(microseconds, &nanoseconds));
- PD_CHECK_OVERFLOW(
- checked_int64_add(nanoseconds, dts->ps / 1000, &nanoseconds));
+
+ // Minimum valid timestamp in nanoseconds (1677-09-21 00:12:43.145224193).
+ const int64_t min_nanoseconds = NPY_MIN_INT64 + 1;
+ if (microseconds == min_nanoseconds / 1000 - 1) {
+ // For values within one microsecond of min_nanoseconds, use it as base
+ // and offset it with nanosecond delta to avoid overflow during scaling.
+ PD_CHECK_OVERFLOW(checked_int64_add(
+ min_nanoseconds, (dts->ps - _NS_MIN_DTS.ps) / 1000, &nanoseconds));
+ } else {
+ PD_CHECK_OVERFLOW(
+ scaleMicrosecondsToNanoseconds(microseconds, &nanoseconds));
+ PD_CHECK_OVERFLOW(
+ checked_int64_add(nanoseconds, dts->ps / 1000, &nanoseconds));
+ }
return nanoseconds;
}
@@ -1060,5 +1071,8 @@ void pandas_timedelta_to_timedeltastruct(npy_timedelta td,
*/
PyArray_DatetimeMetaData
get_datetime_metadata_from_dtype(PyArray_Descr *dtype) {
- return (((PyArray_DatetimeDTypeMetaData *)dtype->c_metadata)->meta);
+#if NPY_ABI_VERSION < 0x02000000
+#define PyDataType_C_METADATA(dtype) ((dtype)->c_metadata)
+#endif
+ return ((PyArray_DatetimeDTypeMetaData *)PyDataType_C_METADATA(dtype))->meta;
}
diff --git a/pandas/_libs/src/vendored/ujson/python/objToJSON.c b/pandas/_libs/src/vendored/ujson/python/objToJSON.c
index 8bba95dd456de..fa91db5fe34e3 100644
--- a/pandas/_libs/src/vendored/ujson/python/objToJSON.c
+++ b/pandas/_libs/src/vendored/ujson/python/objToJSON.c
@@ -74,7 +74,6 @@ typedef struct __NpyArrContext {
npy_intp ndim;
npy_intp index[NPY_MAXDIMS];
int type_num;
- PyArray_GetItemFunc *getitem;
char **rowLabels;
char **columnLabels;
@@ -405,7 +404,6 @@ static void NpyArr_iterBegin(JSOBJ _obj, JSONTypeContext *tc) {
}
npyarr->array = (PyObject *)obj;
- npyarr->getitem = (PyArray_GetItemFunc *)PyArray_DESCR(obj)->f->getitem;
npyarr->dataptr = PyArray_DATA(obj);
npyarr->ndim = PyArray_NDIM(obj) - 1;
npyarr->curdim = 0;
@@ -447,8 +445,15 @@ static void NpyArrPassThru_iterEnd(JSOBJ obj, JSONTypeContext *tc) {
npyarr->curdim--;
npyarr->dataptr -= npyarr->stride * npyarr->index[npyarr->stridedim];
npyarr->stridedim -= npyarr->inc;
- npyarr->dim = PyArray_DIM(npyarr->array, npyarr->stridedim);
- npyarr->stride = PyArray_STRIDE(npyarr->array, npyarr->stridedim);
+
+ if (!PyArray_Check(npyarr->array)) {
+ PyErr_SetString(PyExc_TypeError,
+ "NpyArrayPassThru_iterEnd received a non-array object");
+ return;
+ }
+ const PyArrayObject *arrayobj = (const PyArrayObject *)npyarr->array;
+ npyarr->dim = PyArray_DIM(arrayobj, npyarr->stridedim);
+ npyarr->stride = PyArray_STRIDE(arrayobj, npyarr->stridedim);
npyarr->dataptr += npyarr->stride;
NpyArr_freeItemValue(obj, tc);
@@ -467,18 +472,25 @@ static int NpyArr_iterNextItem(JSOBJ obj, JSONTypeContext *tc) {
NpyArr_freeItemValue(obj, tc);
- if (PyArray_ISDATETIME(npyarr->array)) {
+ if (!PyArray_Check(npyarr->array)) {
+ PyErr_SetString(PyExc_TypeError,
+ "NpyArr_iterNextItem received a non-array object");
+ return 0;
+ }
+ PyArrayObject *arrayobj = (PyArrayObject *)npyarr->array;
+
+ if (PyArray_ISDATETIME(arrayobj)) {
GET_TC(tc)->itemValue = obj;
Py_INCREF(obj);
- ((PyObjectEncoder *)tc->encoder)->npyType = PyArray_TYPE(npyarr->array);
+ ((PyObjectEncoder *)tc->encoder)->npyType = PyArray_TYPE(arrayobj);
// Also write the resolution (unit) of the ndarray
- PyArray_Descr *dtype = PyArray_DESCR(npyarr->array);
+ PyArray_Descr *dtype = PyArray_DESCR(arrayobj);
((PyObjectEncoder *)tc->encoder)->valueUnit =
get_datetime_metadata_from_dtype(dtype).base;
((PyObjectEncoder *)tc->encoder)->npyValue = npyarr->dataptr;
((PyObjectEncoder *)tc->encoder)->npyCtxtPassthru = npyarr;
} else {
- GET_TC(tc)->itemValue = npyarr->getitem(npyarr->dataptr, npyarr->array);
+ GET_TC(tc)->itemValue = PyArray_GETITEM(arrayobj, npyarr->dataptr);
}
npyarr->dataptr += npyarr->stride;
@@ -505,8 +517,15 @@ static int NpyArr_iterNext(JSOBJ _obj, JSONTypeContext *tc) {
npyarr->curdim++;
npyarr->stridedim += npyarr->inc;
- npyarr->dim = PyArray_DIM(npyarr->array, npyarr->stridedim);
- npyarr->stride = PyArray_STRIDE(npyarr->array, npyarr->stridedim);
+ if (!PyArray_Check(npyarr->array)) {
+ PyErr_SetString(PyExc_TypeError,
+ "NpyArr_iterNext received a non-array object");
+ return 0;
+ }
+ const PyArrayObject *arrayobj = (const PyArrayObject *)npyarr->array;
+
+ npyarr->dim = PyArray_DIM(arrayobj, npyarr->stridedim);
+ npyarr->stride = PyArray_STRIDE(arrayobj, npyarr->stridedim);
npyarr->index[npyarr->stridedim] = 0;
((PyObjectEncoder *)tc->encoder)->npyCtxtPassthru = npyarr;
@@ -1610,7 +1629,14 @@ static void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
if (!values) {
goto INVALID;
}
- pc->columnLabelsLen = PyArray_DIM(pc->newObj, 0);
+
+ if (!PyArray_Check(pc->newObj)) {
+ PyErr_SetString(PyExc_TypeError,
+ "Object_beginTypeContext received a non-array object");
+ goto INVALID;
+ }
+ const PyArrayObject *arrayobj = (const PyArrayObject *)pc->newObj;
+ pc->columnLabelsLen = PyArray_DIM(arrayobj, 0);
pc->columnLabels = NpyArr_encodeLabels((PyArrayObject *)values, enc,
pc->columnLabelsLen);
if (!pc->columnLabels) {
diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index 017fdc4bc834f..dd23c2f27ca09 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -277,7 +277,7 @@ def array_with_unit_to_datetime(
bint is_raise = errors == "raise"
ndarray[int64_t] iresult
tzinfo tz = None
- float fval
+ double fval
assert is_ignore or is_coerce or is_raise
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index b3788b6003e67..c37a4b285daef 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -756,11 +756,14 @@ cdef class BaseOffset:
raise ValueError(f"{self} is a non-fixed frequency")
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.
+ # GH#55388
"""
Return boolean whether the frequency is a unit frequency (n=1).
+ .. deprecated:: 2.2.0
+ is_anchored is deprecated and will be removed in a future version.
+ Use ``obj.n == 1`` instead.
+
Examples
--------
>>> pd.DateOffset().is_anchored()
@@ -768,6 +771,12 @@ cdef class BaseOffset:
>>> pd.DateOffset(2).is_anchored()
False
"""
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use \'obj.n == 1\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return self.n == 1
# ------------------------------------------------------------------
@@ -954,6 +963,27 @@ cdef class Tick(SingleConstructorOffset):
return True
def is_anchored(self) -> bool:
+ # GH#55388
+ """
+ Return False.
+
+ .. deprecated:: 2.2.0
+ is_anchored is deprecated and will be removed in a future version.
+ Use ``False`` instead.
+
+ Examples
+ --------
+ >>> pd.offsets.Hour().is_anchored()
+ False
+ >>> pd.offsets.Hour(2).is_anchored()
+ False
+ """
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use False instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return False
# This is identical to BaseOffset.__hash__, but has to be redefined here
@@ -1428,13 +1458,22 @@ cdef class RelativeDeltaOffset(BaseOffset):
"minutes",
"seconds",
"microseconds",
+ "milliseconds",
}
# relativedelta/_offset path only valid for base DateOffset
if self._use_relativedelta and set(kwds).issubset(relativedelta_fast):
+ td_args = {
+ "days",
+ "hours",
+ "minutes",
+ "seconds",
+ "microseconds",
+ "milliseconds"
+ }
td_kwds = {
key: val
for key, val in kwds.items()
- if key in ["days", "hours", "minutes", "seconds", "microseconds"]
+ if key in td_args
}
if "weeks" in kwds:
days = td_kwds.get("days", 0)
@@ -1444,6 +1483,8 @@ cdef class RelativeDeltaOffset(BaseOffset):
delta = Timedelta(**td_kwds)
if "microseconds" in kwds:
delta = delta.as_unit("us")
+ elif "milliseconds" in kwds:
+ delta = delta.as_unit("ms")
else:
delta = delta.as_unit("s")
else:
@@ -1461,6 +1502,8 @@ cdef class RelativeDeltaOffset(BaseOffset):
delta = Timedelta(self._offset * self.n)
if "microseconds" in kwds:
delta = delta.as_unit("us")
+ elif "milliseconds" in kwds:
+ delta = delta.as_unit("ms")
else:
delta = delta.as_unit("s")
return delta
@@ -2663,6 +2706,13 @@ cdef class QuarterOffset(SingleConstructorOffset):
return f"{self._prefix}-{month}"
def is_anchored(self) -> bool:
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use \'obj.n == 1 "
+ f"and obj.startingMonth is not None\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return self.n == 1 and self.startingMonth is not None
def is_on_offset(self, dt: datetime) -> bool:
@@ -3308,6 +3358,13 @@ cdef class Week(SingleConstructorOffset):
self._cache = state.pop("_cache", {})
def is_anchored(self) -> bool:
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use \'obj.n == 1 "
+ f"and obj.weekday is not None\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return self.n == 1 and self.weekday is not None
@apply_wraps
@@ -3597,6 +3654,12 @@ cdef class FY5253Mixin(SingleConstructorOffset):
self.variation = state.pop("variation")
def is_anchored(self) -> bool:
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use \'obj.n == 1\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return (
self.n == 1 and self.startingMonth is not None and self.weekday is not None
)
@@ -4221,9 +4284,7 @@ cdef class CustomBusinessDay(BusinessDay):
@property
def _period_dtype_code(self):
# GH#52534
- raise TypeError(
- "CustomBusinessDay is not supported as period frequency"
- )
+ raise ValueError(f"{self.base} is not supported as period frequency")
_apply_array = BaseOffset._apply_array
@@ -4661,29 +4722,7 @@ _lite_rule_alias = {
"ns": "ns",
}
-_dont_uppercase = {
- "h",
- "bh",
- "cbh",
- "MS",
- "ms",
- "s",
- "me",
- "qe",
- "qe-dec",
- "qe-jan",
- "qe-feb",
- "qe-mar",
- "qe-apr",
- "qe-may",
- "qe-jun",
- "qe-jul",
- "qe-aug",
- "qe-sep",
- "qe-oct",
- "qe-nov",
- "ye",
-}
+_dont_uppercase = _dont_uppercase = {"h", "bh", "cbh", "MS", "ms", "s"}
INVALID_FREQ_ERR_MSG = "Invalid frequency: {0}"
@@ -4702,7 +4741,29 @@ def _get_offset(name: str) -> BaseOffset:
--------
_get_offset('EOM') --> BMonthEnd(1)
"""
- if name.lower() not in _dont_uppercase:
+ if (
+ name not in _lite_rule_alias
+ and (name.upper() in _lite_rule_alias)
+ and name != "ms"
+ ):
+ warnings.warn(
+ f"\'{name}\' is deprecated and will be removed "
+ f"in a future version, please use \'{name.upper()}\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ elif (
+ name not in _lite_rule_alias
+ and (name.lower() in _lite_rule_alias)
+ and name != "MS"
+ ):
+ warnings.warn(
+ f"\'{name}\' is deprecated and will be removed "
+ f"in a future version, please use \'{name.lower()}\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ if name not in _dont_uppercase:
name = name.upper()
name = _lite_rule_alias.get(name, name)
name = _lite_rule_alias.get(name.lower(), name)
@@ -4772,19 +4833,19 @@ cpdef to_offset(freq, bint is_period=False):
if freq is None:
return None
- if isinstance(freq, BaseOffset):
- return freq
-
if isinstance(freq, tuple):
raise TypeError(
f"to_offset does not support tuples {freq}, pass as a string instead"
)
+ if isinstance(freq, BaseOffset):
+ result = freq
+
elif PyDelta_Check(freq):
- return delta_to_tick(freq)
+ result = delta_to_tick(freq)
elif isinstance(freq, str):
- delta = None
+ result = None
stride_sign = None
try:
@@ -4795,40 +4856,61 @@ cpdef to_offset(freq, bint is_period=False):
tups = zip(split[0::4], split[1::4], split[2::4])
for n, (sep, stride, name) in enumerate(tups):
- if is_period is False and name in c_OFFSET_DEPR_FREQSTR:
+ if not is_period and name.upper() in c_OFFSET_DEPR_FREQSTR:
+ warnings.warn(
+ f"\'{name}\' is deprecated and will be removed "
+ f"in a future version, please use "
+ f"\'{c_OFFSET_DEPR_FREQSTR.get(name.upper())}\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ name = c_OFFSET_DEPR_FREQSTR[name.upper()]
+ if (not is_period and
+ name != name.upper() and
+ name.lower() not in {"s", "ms", "us", "ns"} and
+ name.upper().split("-")[0].endswith(("S", "E"))):
warnings.warn(
f"\'{name}\' is deprecated and will be removed "
f"in a future version, please use "
- f"\'{c_OFFSET_DEPR_FREQSTR.get(name)}\' instead.",
+ f"\'{name.upper()}\' instead.",
FutureWarning,
stacklevel=find_stack_level(),
)
- name = c_OFFSET_DEPR_FREQSTR[name]
- if is_period is True and name in c_REVERSE_OFFSET_DEPR_FREQSTR:
- if name.startswith("Y"):
+ name = name.upper()
+ if is_period and name.upper() in c_REVERSE_OFFSET_DEPR_FREQSTR:
+ if name.upper().startswith("Y"):
raise ValueError(
- f"for Period, please use \'Y{name[2:]}\' "
+ f"for Period, please use \'Y{name.upper()[2:]}\' "
f"instead of \'{name}\'"
)
- if (name.startswith("B") or
- name.startswith("S") or name.startswith("C")):
+ if (name.upper().startswith("B") or
+ name.upper().startswith("S") or
+ name.upper().startswith("C")):
raise ValueError(INVALID_FREQ_ERR_MSG.format(name))
else:
raise ValueError(
f"for Period, please use "
- f"\'{c_REVERSE_OFFSET_DEPR_FREQSTR.get(name)}\' "
+ f"\'{c_REVERSE_OFFSET_DEPR_FREQSTR.get(name.upper())}\' "
f"instead of \'{name}\'"
)
- elif is_period is True and name in c_OFFSET_DEPR_FREQSTR:
- if name.startswith("A"):
+ elif is_period and name.upper() in c_OFFSET_DEPR_FREQSTR:
+ if name.upper().startswith("A"):
warnings.warn(
f"\'{name}\' is deprecated and will be removed in a future "
- f"version, please use \'{c_DEPR_ABBREVS.get(name)}\' "
+ f"version, please use "
+ f"\'{c_DEPR_ABBREVS.get(name.upper())}\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ if name.upper() != name:
+ warnings.warn(
+ f"\'{name}\' is deprecated and will be removed in "
+ f"a future version, please use \'{name.upper()}\' "
f"instead.",
FutureWarning,
stacklevel=find_stack_level(),
)
- name = c_OFFSET_DEPR_FREQSTR.get(name)
+ name = c_OFFSET_DEPR_FREQSTR.get(name.upper())
if sep != "" and not sep.isspace():
raise ValueError("separator must be spaces")
@@ -4864,21 +4946,27 @@ cpdef to_offset(freq, bint is_period=False):
offset = _get_offset(prefix)
offset = offset * int(np.fabs(stride) * stride_sign)
- if delta is None:
- delta = offset
+ if result is None:
+ result = offset
else:
- delta = delta + offset
+ result = result + offset
except (ValueError, TypeError) as err:
raise ValueError(INVALID_FREQ_ERR_MSG.format(
f"{freq}, failed to parse with error message: {repr(err)}")
)
else:
- delta = None
+ result = None
- if delta is None:
+ if result is None:
raise ValueError(INVALID_FREQ_ERR_MSG.format(freq))
- return delta
+ if is_period and not hasattr(result, "_period_dtype_code"):
+ if isinstance(freq, str):
+ raise ValueError(f"{result.name} is not supported as period frequency")
+ else:
+ raise ValueError(f"{freq} is not supported as period frequency")
+
+ return result
# ----------------------------------------------------------------------
diff --git a/pandas/_libs/tslibs/tzconversion.pyx b/pandas/_libs/tslibs/tzconversion.pyx
index 2c4f0cd14db13..e3facd3d9599b 100644
--- a/pandas/_libs/tslibs/tzconversion.pyx
+++ b/pandas/_libs/tslibs/tzconversion.pyx
@@ -607,7 +607,8 @@ cdef ndarray[int64_t] _get_dst_hours(
ndarray[uint8_t, cast=True] mismatch
ndarray[int64_t] delta, dst_hours
ndarray[intp_t] switch_idxs, trans_idx, grp, a_idx, b_idx, one_diff
- list trans_grp
+ # TODO: Can uncomment when numpy >=2 is the minimum
+ # tuple trans_grp
intp_t switch_idx
int64_t left, right
diff --git a/pandas/_testing/__init__.py b/pandas/_testing/__init__.py
index 672c16a85086c..361998db8e38b 100644
--- a/pandas/_testing/__init__.py
+++ b/pandas/_testing/__init__.py
@@ -236,11 +236,18 @@
+ TIMEDELTA_PYARROW_DTYPES
+ BOOL_PYARROW_DTYPES
)
+ ALL_REAL_PYARROW_DTYPES_STR_REPR = (
+ ALL_INT_PYARROW_DTYPES_STR_REPR + FLOAT_PYARROW_DTYPES_STR_REPR
+ )
else:
FLOAT_PYARROW_DTYPES_STR_REPR = []
ALL_INT_PYARROW_DTYPES_STR_REPR = []
ALL_PYARROW_DTYPES = []
+ ALL_REAL_PYARROW_DTYPES_STR_REPR = []
+ALL_REAL_NULLABLE_DTYPES = (
+ FLOAT_NUMPY_DTYPES + ALL_REAL_EXTENSION_DTYPES + ALL_REAL_PYARROW_DTYPES_STR_REPR
+)
arithmetic_dunder_methods = [
"__add__",
diff --git a/pandas/_testing/_warnings.py b/pandas/_testing/_warnings.py
index f11dc11f6ac0d..c9a287942f2da 100644
--- a/pandas/_testing/_warnings.py
+++ b/pandas/_testing/_warnings.py
@@ -218,7 +218,12 @@ def _assert_raised_with_correct_stacklevel(
frame = inspect.currentframe()
for _ in range(4):
frame = frame.f_back # type: ignore[union-attr]
- caller_filename = inspect.getfile(frame) # type: ignore[arg-type]
+ try:
+ caller_filename = inspect.getfile(frame) # type: ignore[arg-type]
+ finally:
+ # See note in
+ # https://docs.python.org/3/library/inspect.html#inspect.Traceback
+ del frame
msg = (
"Warning not set with correct stacklevel. "
f"File where warning is raised: {actual_warning.filename} != "
diff --git a/pandas/_testing/asserters.py b/pandas/_testing/asserters.py
index e342f76dc724b..41d2a7344a4ed 100644
--- a/pandas/_testing/asserters.py
+++ b/pandas/_testing/asserters.py
@@ -4,11 +4,13 @@
from typing import (
TYPE_CHECKING,
Literal,
+ NoReturn,
cast,
)
import numpy as np
+from pandas._libs import lib
from pandas._libs.missing import is_matching_na
from pandas._libs.sparse import SparseIndex
import pandas._libs.testing as _testing
@@ -143,7 +145,7 @@ def assert_almost_equal(
)
-def _check_isinstance(left, right, cls):
+def _check_isinstance(left, right, cls) -> None:
"""
Helper method for our assert_* methods that ensures that
the two objects being compared have the right type before
@@ -576,7 +578,7 @@ def assert_timedelta_array_equal(
def raise_assert_detail(
obj, message, left, right, diff=None, first_diff=None, index_values=None
-):
+) -> NoReturn:
__tracebackhide__ = True
msg = f"""{obj} are different
@@ -664,7 +666,7 @@ def _get_base(obj):
if left_base is right_base:
raise AssertionError(f"{repr(left_base)} is {repr(right_base)}")
- def _raise(left, right, err_msg):
+ def _raise(left, right, err_msg) -> NoReturn:
if err_msg is None:
if left.shape != right.shape:
raise_assert_detail(
@@ -697,9 +699,9 @@ def assert_extension_array_equal(
right,
check_dtype: bool | Literal["equiv"] = True,
index_values=None,
- check_exact: bool = False,
- rtol: float = 1.0e-5,
- atol: float = 1.0e-8,
+ check_exact: bool | lib.NoDefault = lib.no_default,
+ rtol: float | lib.NoDefault = lib.no_default,
+ atol: float | lib.NoDefault = lib.no_default,
obj: str = "ExtensionArray",
) -> None:
"""
@@ -714,7 +716,12 @@ def assert_extension_array_equal(
index_values : Index | numpy.ndarray, default None
Optional index (shared by both left and right), used in output.
check_exact : bool, default False
- Whether to compare number exactly. Only takes effect for float dtypes.
+ Whether to compare number exactly.
+
+ .. versionchanged:: 2.2.0
+
+ Defaults to True for integer dtypes if none of
+ ``check_exact``, ``rtol`` and ``atol`` are specified.
rtol : float, default 1e-5
Relative tolerance. Only used when check_exact is False.
atol : float, default 1e-8
@@ -738,6 +745,23 @@ def assert_extension_array_equal(
>>> b, c = a.array, a.array
>>> tm.assert_extension_array_equal(b, c)
"""
+ if (
+ check_exact is lib.no_default
+ and rtol is lib.no_default
+ and atol is lib.no_default
+ ):
+ check_exact = (
+ is_numeric_dtype(left.dtype)
+ and not is_float_dtype(left.dtype)
+ or is_numeric_dtype(right.dtype)
+ and not is_float_dtype(right.dtype)
+ )
+ elif check_exact is lib.no_default:
+ check_exact = False
+
+ rtol = rtol if rtol is not lib.no_default else 1.0e-5
+ atol = atol if atol is not lib.no_default else 1.0e-8
+
assert isinstance(left, ExtensionArray), "left is not an ExtensionArray"
assert isinstance(right, ExtensionArray), "right is not an ExtensionArray"
if check_dtype:
@@ -783,10 +807,7 @@ def assert_extension_array_equal(
left_valid = left[~left_na].to_numpy(dtype=object)
right_valid = right[~right_na].to_numpy(dtype=object)
- if check_exact or (
- (is_numeric_dtype(left.dtype) and not is_float_dtype(left.dtype))
- or (is_numeric_dtype(right.dtype) and not is_float_dtype(right.dtype))
- ):
+ if check_exact:
assert_numpy_array_equal(
left_valid, right_valid, obj=obj, index_values=index_values
)
@@ -810,14 +831,14 @@ def assert_series_equal(
check_index_type: bool | Literal["equiv"] = "equiv",
check_series_type: bool = True,
check_names: bool = True,
- check_exact: bool = False,
+ check_exact: bool | lib.NoDefault = lib.no_default,
check_datetimelike_compat: bool = False,
check_categorical: bool = True,
check_category_order: bool = True,
check_freq: bool = True,
check_flags: bool = True,
- rtol: float = 1.0e-5,
- atol: float = 1.0e-8,
+ rtol: float | lib.NoDefault = lib.no_default,
+ atol: float | lib.NoDefault = lib.no_default,
obj: str = "Series",
*,
check_index: bool = True,
@@ -840,7 +861,12 @@ def assert_series_equal(
check_names : bool, default True
Whether to check the Series and Index names attribute.
check_exact : bool, default False
- Whether to compare number exactly. Only takes effect for float dtypes.
+ Whether to compare number exactly.
+
+ .. versionchanged:: 2.2.0
+
+ Defaults to True for integer dtypes if none of
+ ``check_exact``, ``rtol`` and ``atol`` are specified.
check_datetimelike_compat : bool, default False
Compare datetime-like which is comparable ignoring dtype.
check_categorical : bool, default True
@@ -876,6 +902,23 @@ def assert_series_equal(
>>> tm.assert_series_equal(a, b)
"""
__tracebackhide__ = True
+ check_exact_index = False if check_exact is lib.no_default else check_exact
+ if (
+ check_exact is lib.no_default
+ and rtol is lib.no_default
+ and atol is lib.no_default
+ ):
+ check_exact = (
+ is_numeric_dtype(left.dtype)
+ and not is_float_dtype(left.dtype)
+ or is_numeric_dtype(right.dtype)
+ and not is_float_dtype(right.dtype)
+ )
+ elif check_exact is lib.no_default:
+ check_exact = False
+
+ rtol = rtol if rtol is not lib.no_default else 1.0e-5
+ atol = atol if atol is not lib.no_default else 1.0e-8
if not check_index and check_like:
raise ValueError("check_like must be False if check_index is False")
@@ -902,7 +945,7 @@ def assert_series_equal(
right.index,
exact=check_index_type,
check_names=check_names,
- check_exact=check_exact,
+ check_exact=check_exact_index,
check_categorical=check_categorical,
check_order=not check_like,
rtol=rtol,
@@ -930,10 +973,7 @@ def assert_series_equal(
pass
else:
assert_attr_equal("dtype", left, right, obj=f"Attributes of {obj}")
- if check_exact or (
- (is_numeric_dtype(left.dtype) and not is_float_dtype(left.dtype))
- or (is_numeric_dtype(right.dtype) and not is_float_dtype(right.dtype))
- ):
+ if check_exact:
left_values = left._values
right_values = right._values
# Only check exact if dtype is numeric
@@ -948,9 +988,15 @@ def assert_series_equal(
obj=str(obj),
)
else:
+ # convert both to NumPy if not, check_dtype would raise earlier
+ lv, rv = left_values, right_values
+ if isinstance(left_values, ExtensionArray):
+ lv = left_values.to_numpy()
+ if isinstance(right_values, ExtensionArray):
+ rv = right_values.to_numpy()
assert_numpy_array_equal(
- left_values,
- right_values,
+ lv,
+ rv,
check_dtype=check_dtype,
obj=str(obj),
index_values=left.index,
@@ -1054,14 +1100,14 @@ def assert_frame_equal(
check_frame_type: bool = True,
check_names: bool = True,
by_blocks: bool = False,
- check_exact: bool = False,
+ check_exact: bool | lib.NoDefault = lib.no_default,
check_datetimelike_compat: bool = False,
check_categorical: bool = True,
check_like: bool = False,
check_freq: bool = True,
check_flags: bool = True,
- rtol: float = 1.0e-5,
- atol: float = 1.0e-8,
+ rtol: float | lib.NoDefault = lib.no_default,
+ atol: float | lib.NoDefault = lib.no_default,
obj: str = "DataFrame",
) -> None:
"""
@@ -1096,7 +1142,12 @@ def assert_frame_equal(
Specify how to compare internal data. If False, compare by columns.
If True, compare by blocks.
check_exact : bool, default False
- Whether to compare number exactly. Only takes effect for float dtypes.
+ Whether to compare number exactly.
+
+ .. versionchanged:: 2.2.0
+
+ Defaults to True for integer dtypes if none of
+ ``check_exact``, ``rtol`` and ``atol`` are specified.
check_datetimelike_compat : bool, default False
Compare datetime-like which is comparable ignoring dtype.
check_categorical : bool, default True
@@ -1151,6 +1202,9 @@ def assert_frame_equal(
>>> assert_frame_equal(df1, df2, check_dtype=False)
"""
__tracebackhide__ = True
+ _rtol = rtol if rtol is not lib.no_default else 1.0e-5
+ _atol = atol if atol is not lib.no_default else 1.0e-8
+ _check_exact = check_exact if check_exact is not lib.no_default else False
# instance validation
_check_isinstance(left, right, DataFrame)
@@ -1174,11 +1228,11 @@ def assert_frame_equal(
right.index,
exact=check_index_type,
check_names=check_names,
- check_exact=check_exact,
+ check_exact=_check_exact,
check_categorical=check_categorical,
check_order=not check_like,
- rtol=rtol,
- atol=atol,
+ rtol=_rtol,
+ atol=_atol,
obj=f"{obj}.index",
)
@@ -1188,11 +1242,11 @@ def assert_frame_equal(
right.columns,
exact=check_column_type,
check_names=check_names,
- check_exact=check_exact,
+ check_exact=_check_exact,
check_categorical=check_categorical,
check_order=not check_like,
- rtol=rtol,
- atol=atol,
+ rtol=_rtol,
+ atol=_atol,
obj=f"{obj}.columns",
)
diff --git a/pandas/_version.py b/pandas/_version.py
index 5d610b5e1ea7e..f8a960630126d 100644
--- a/pandas/_version.py
+++ b/pandas/_version.py
@@ -386,7 +386,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
return pieces
-def plus_or_dot(pieces):
+def plus_or_dot(pieces) -> str:
"""Return a + if we don't already have one, else return a ."""
if "+" in pieces.get("closest-tag", ""):
return "."
diff --git a/pandas/compat/__init__.py b/pandas/compat/__init__.py
index 738442fab8c70..eb890c8b8c0ab 100644
--- a/pandas/compat/__init__.py
+++ b/pandas/compat/__init__.py
@@ -30,6 +30,7 @@
pa_version_under13p0,
pa_version_under14p0,
pa_version_under14p1,
+ pa_version_under16p0,
)
if TYPE_CHECKING:
@@ -186,6 +187,7 @@ def get_bz2_file() -> type[pandas.compat.compressors.BZ2File]:
"pa_version_under13p0",
"pa_version_under14p0",
"pa_version_under14p1",
+ "pa_version_under16p0",
"IS64",
"ISMUSL",
"PY310",
diff --git a/pandas/compat/_optional.py b/pandas/compat/_optional.py
index 9d04d7c0a1216..2bc6cd46f09a7 100644
--- a/pandas/compat/_optional.py
+++ b/pandas/compat/_optional.py
@@ -120,9 +120,8 @@ def import_optional_dependency(
The imported module, when found and the version is correct.
None is returned when the package is not found and `errors`
is False, or when the package's version is too old and `errors`
- is ``'warn'``.
+ is ``'warn'`` or ``'ignore'``.
"""
-
assert errors in {"warn", "raise", "ignore"}
package_name = INSTALL_MAPPING.get(name)
@@ -163,5 +162,7 @@ def import_optional_dependency(
return None
elif errors == "raise":
raise ImportError(msg)
+ else:
+ return None
return module
diff --git a/pandas/compat/numpy/function.py b/pandas/compat/numpy/function.py
index a36e25a9df410..4df30f7f4a8a7 100644
--- a/pandas/compat/numpy/function.py
+++ b/pandas/compat/numpy/function.py
@@ -138,6 +138,7 @@ def validate_argmax_with_skipna(skipna: bool | ndarray | None, args, kwargs) ->
ARGSORT_DEFAULTS["kind"] = "quicksort"
ARGSORT_DEFAULTS["order"] = None
ARGSORT_DEFAULTS["kind"] = None
+ARGSORT_DEFAULTS["stable"] = None
validate_argsort = CompatValidator(
@@ -149,6 +150,7 @@ def validate_argmax_with_skipna(skipna: bool | ndarray | None, args, kwargs) ->
ARGSORT_DEFAULTS_KIND: dict[str, int | None] = {}
ARGSORT_DEFAULTS_KIND["axis"] = -1
ARGSORT_DEFAULTS_KIND["order"] = None
+ARGSORT_DEFAULTS_KIND["stable"] = None
validate_argsort_kind = CompatValidator(
ARGSORT_DEFAULTS_KIND, fname="argsort", max_fname_arg_count=0, method="both"
)
diff --git a/pandas/compat/pyarrow.py b/pandas/compat/pyarrow.py
index beb4814914101..a2dfa69bbf236 100644
--- a/pandas/compat/pyarrow.py
+++ b/pandas/compat/pyarrow.py
@@ -15,6 +15,7 @@
pa_version_under14p0 = _palv < Version("14.0.0")
pa_version_under14p1 = _palv < Version("14.0.1")
pa_version_under15p0 = _palv < Version("15.0.0")
+ pa_version_under16p0 = _palv < Version("16.0.0")
except ImportError:
pa_version_under10p1 = True
pa_version_under11p0 = True
@@ -23,3 +24,4 @@
pa_version_under14p0 = True
pa_version_under14p1 = True
pa_version_under15p0 = True
+ pa_version_under16p0 = True
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 983272d79081e..7c35dfdde90ba 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -190,10 +190,6 @@ def pytest_collection_modifyitems(items, config) -> None:
if is_doctest:
for item in items:
- # autouse=True for the add_doctest_imports can lead to expensive teardowns
- # since doctest_namespace is a session fixture
- item.add_marker(pytest.mark.usefixtures("add_doctest_imports"))
-
for path, message in ignored_doctest_warnings:
ignore_doctest_warning(item, path, message)
@@ -250,7 +246,14 @@ def pytest_collection_modifyitems(items, config) -> None:
)
-@pytest.fixture
+# ----------------------------------------------------------------
+# Autouse fixtures
+# ----------------------------------------------------------------
+
+
+# https://github.com/pytest-dev/pytest/issues/11873
+# Would like to avoid autouse=True, but cannot as of pytest 8.0.0
+@pytest.fixture(autouse=True)
def add_doctest_imports(doctest_namespace) -> None:
"""
Make `np` and `pd` names available for doctests.
@@ -259,9 +262,6 @@ def add_doctest_imports(doctest_namespace) -> None:
doctest_namespace["pd"] = pd
-# ----------------------------------------------------------------
-# Autouse fixtures
-# ----------------------------------------------------------------
@pytest.fixture(autouse=True)
def configure_tests() -> None:
"""
@@ -1642,6 +1642,38 @@ def any_numpy_dtype(request):
return request.param
+@pytest.fixture(params=tm.ALL_REAL_NULLABLE_DTYPES)
+def any_real_nullable_dtype(request):
+ """
+ Parameterized fixture for all real dtypes that can hold NA.
+
+ * float
+ * 'float32'
+ * 'float64'
+ * 'Float32'
+ * 'Float64'
+ * 'UInt8'
+ * 'UInt16'
+ * 'UInt32'
+ * 'UInt64'
+ * 'Int8'
+ * 'Int16'
+ * 'Int32'
+ * 'Int64'
+ * 'uint8[pyarrow]'
+ * 'uint16[pyarrow]'
+ * 'uint32[pyarrow]'
+ * 'uint64[pyarrow]'
+ * 'int8[pyarrow]'
+ * 'int16[pyarrow]'
+ * 'int32[pyarrow]'
+ * 'int64[pyarrow]'
+ * 'float[pyarrow]'
+ * 'double[pyarrow]'
+ """
+ return request.param
+
+
@pytest.fixture(params=tm.ALL_NUMERIC_DTYPES)
def any_numeric_dtype(request):
"""
diff --git a/pandas/core/array_algos/quantile.py b/pandas/core/array_algos/quantile.py
index ee6f00b219a15..5c933294fb944 100644
--- a/pandas/core/array_algos/quantile.py
+++ b/pandas/core/array_algos/quantile.py
@@ -102,7 +102,7 @@ def quantile_with_mask(
interpolation=interpolation,
)
- result = np.array(result, copy=False)
+ result = np.asarray(result)
result = result.T
return result
@@ -201,9 +201,9 @@ def _nanpercentile(
]
if values.dtype.kind == "f":
# preserve itemsize
- result = np.array(result, dtype=values.dtype, copy=False).T
+ result = np.asarray(result, dtype=values.dtype).T
else:
- result = np.array(result, copy=False).T
+ result = np.asarray(result).T
if (
result.dtype != values.dtype
and not mask.all()
diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index 9ece12cf51a7b..0da121c36644a 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -305,7 +305,12 @@ def _fill_mask_inplace(
func(self._ndarray.T, limit=limit, mask=mask.T)
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
mask = self.isna()
if mask.any():
@@ -315,7 +320,7 @@ def _pad_or_backfill(
npvalues = self._ndarray.T
if copy:
npvalues = npvalues.copy()
- func(npvalues, limit=limit, mask=mask.T)
+ func(npvalues, limit=limit, limit_area=limit_area, mask=mask.T)
npvalues = npvalues.T
if copy:
diff --git a/pandas/core/arrays/_utils.py b/pandas/core/arrays/_utils.py
index c75ec7f843ed2..6b46396d5efdf 100644
--- a/pandas/core/arrays/_utils.py
+++ b/pandas/core/arrays/_utils.py
@@ -44,7 +44,16 @@ def to_numpy_dtype_inference(
dtype_given = True
if na_value is lib.no_default:
- na_value = arr.dtype.na_value
+ if dtype is None or not hasna:
+ na_value = arr.dtype.na_value
+ elif dtype.kind == "f": # type: ignore[union-attr]
+ na_value = np.nan
+ elif dtype.kind == "M": # type: ignore[union-attr]
+ na_value = np.datetime64("nat")
+ elif dtype.kind == "m": # type: ignore[union-attr]
+ na_value = np.timedelta64("nat")
+ else:
+ na_value = arr.dtype.na_value
if not dtype_given and hasna:
try:
diff --git a/pandas/core/arrays/arrow/accessors.py b/pandas/core/arrays/arrow/accessors.py
index 7f88267943526..124f8fb6ad8bc 100644
--- a/pandas/core/arrays/arrow/accessors.py
+++ b/pandas/core/arrays/arrow/accessors.py
@@ -6,13 +6,18 @@
ABCMeta,
abstractmethod,
)
-from typing import TYPE_CHECKING
+from typing import (
+ TYPE_CHECKING,
+ cast,
+)
from pandas.compat import (
pa_version_under10p1,
pa_version_under11p0,
)
+from pandas.core.dtypes.common import is_list_like
+
if not pa_version_under10p1:
import pyarrow as pa
import pyarrow.compute as pc
@@ -267,15 +272,27 @@ def dtypes(self) -> Series:
names = [struct.name for struct in pa_type]
return Series(types, index=Index(names))
- def field(self, name_or_index: str | int) -> Series:
+ def field(
+ self,
+ name_or_index: list[str]
+ | list[bytes]
+ | list[int]
+ | pc.Expression
+ | bytes
+ | str
+ | int,
+ ) -> Series:
"""
Extract a child field of a struct as a Series.
Parameters
----------
- name_or_index : str | int
+ name_or_index : str | bytes | int | expression | list
Name or index of the child field to extract.
+ For list-like inputs, this will index into a nested
+ struct.
+
Returns
-------
pandas.Series
@@ -285,6 +302,19 @@ def field(self, name_or_index: str | int) -> Series:
--------
Series.struct.explode : Return all child fields as a DataFrame.
+ Notes
+ -----
+ The name of the resulting Series will be set using the following
+ rules:
+
+ - For string, bytes, or integer `name_or_index` (or a list of these, for
+ a nested selection), the Series name is set to the selected
+ field's name.
+ - For a :class:`pyarrow.compute.Expression`, this is set to
+ the string form of the expression.
+ - For list-like `name_or_index`, the name will be set to the
+ name of the final field selected.
+
Examples
--------
>>> import pyarrow as pa
@@ -314,27 +344,92 @@ def field(self, name_or_index: str | int) -> Series:
1 2
2 1
Name: version, dtype: int64[pyarrow]
+
+ Or an expression
+
+ >>> import pyarrow.compute as pc
+ >>> s.struct.field(pc.field("project"))
+ 0 pandas
+ 1 pandas
+ 2 numpy
+ Name: project, dtype: string[pyarrow]
+
+ For nested struct types, you can pass a list of values to index
+ multiple levels:
+
+ >>> version_type = pa.struct([
+ ... ("major", pa.int64()),
+ ... ("minor", pa.int64()),
+ ... ])
+ >>> s = pd.Series(
+ ... [
+ ... {"version": {"major": 1, "minor": 5}, "project": "pandas"},
+ ... {"version": {"major": 2, "minor": 1}, "project": "pandas"},
+ ... {"version": {"major": 1, "minor": 26}, "project": "numpy"},
+ ... ],
+ ... dtype=pd.ArrowDtype(pa.struct(
+ ... [("version", version_type), ("project", pa.string())]
+ ... ))
+ ... )
+ >>> s.struct.field(["version", "minor"])
+ 0 5
+ 1 1
+ 2 26
+ Name: minor, dtype: int64[pyarrow]
+ >>> s.struct.field([0, 0])
+ 0 1
+ 1 2
+ 2 1
+ Name: major, dtype: int64[pyarrow]
"""
from pandas import Series
+ def get_name(
+ level_name_or_index: list[str]
+ | list[bytes]
+ | list[int]
+ | pc.Expression
+ | bytes
+ | str
+ | int,
+ data: pa.ChunkedArray,
+ ):
+ if isinstance(level_name_or_index, int):
+ name = data.type.field(level_name_or_index).name
+ elif isinstance(level_name_or_index, (str, bytes)):
+ name = level_name_or_index
+ elif isinstance(level_name_or_index, pc.Expression):
+ name = str(level_name_or_index)
+ elif is_list_like(level_name_or_index):
+ # For nested input like [2, 1, 2]
+ # iteratively get the struct and field name. The last
+ # one is used for the name of the index.
+ level_name_or_index = list(reversed(level_name_or_index))
+ selected = data
+ while level_name_or_index:
+ # we need the cast, otherwise mypy complains about
+ # getting ints, bytes, or str here, which isn't possible.
+ level_name_or_index = cast(list, level_name_or_index)
+ name_or_index = level_name_or_index.pop()
+ name = get_name(name_or_index, selected)
+ selected = selected.type.field(selected.type.get_field_index(name))
+ name = selected.name
+ else:
+ raise ValueError(
+ "name_or_index must be an int, str, bytes, "
+ "pyarrow.compute.Expression, or list of those"
+ )
+ return name
+
pa_arr = self._data.array._pa_array
- if isinstance(name_or_index, int):
- index = name_or_index
- elif isinstance(name_or_index, str):
- index = pa_arr.type.get_field_index(name_or_index)
- else:
- raise ValueError(
- "name_or_index must be an int or str, "
- f"got {type(name_or_index).__name__}"
- )
+ name = get_name(name_or_index, pa_arr)
+ field_arr = pc.struct_field(pa_arr, name_or_index)
- pa_field = pa_arr.type[index]
- field_arr = pc.struct_field(pa_arr, [index])
return Series(
field_arr,
dtype=ArrowDtype(field_arr.type),
index=self._data.index,
- name=pa_field.name,
+ name=name,
)
def explode(self) -> DataFrame:
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 23b5448029dd9..f2b8aa75ca5bf 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -17,6 +17,7 @@
from pandas._libs import lib
from pandas._libs.tslibs import (
+ NaT,
Timedelta,
Timestamp,
timezones,
@@ -37,6 +38,7 @@
CategoricalDtype,
is_array_like,
is_bool_dtype,
+ is_float_dtype,
is_integer,
is_list_like,
is_numeric_dtype,
@@ -107,25 +109,50 @@
def cast_for_truediv(
arrow_array: pa.ChunkedArray, pa_object: pa.Array | pa.Scalar
- ) -> pa.ChunkedArray:
+ ) -> tuple[pa.ChunkedArray, pa.Array | pa.Scalar]:
# Ensure int / int -> float mirroring Python/Numpy behavior
# as pc.divide_checked(int, int) -> int
if pa.types.is_integer(arrow_array.type) and pa.types.is_integer(
pa_object.type
):
- return arrow_array.cast(pa.float64())
- return arrow_array
+ # GH: 56645.
+ # https://github.com/apache/arrow/issues/35563
+ return pc.cast(arrow_array, pa.float64(), safe=False), pc.cast(
+ pa_object, pa.float64(), safe=False
+ )
+
+ return arrow_array, pa_object
def floordiv_compat(
left: pa.ChunkedArray | pa.Array | pa.Scalar,
right: pa.ChunkedArray | pa.Array | pa.Scalar,
) -> pa.ChunkedArray:
- # Ensure int // int -> int mirroring Python/Numpy behavior
- # as pc.floor(pc.divide_checked(int, int)) -> float
- converted_left = cast_for_truediv(left, right)
- result = pc.floor(pc.divide(converted_left, right))
+ # TODO: Replace with pyarrow floordiv kernel.
+ # https://github.com/apache/arrow/issues/39386
if pa.types.is_integer(left.type) and pa.types.is_integer(right.type):
+ divided = pc.divide_checked(left, right)
+ if pa.types.is_signed_integer(divided.type):
+ # GH 56676
+ has_remainder = pc.not_equal(pc.multiply(divided, right), left)
+ has_one_negative_operand = pc.less(
+ pc.bit_wise_xor(left, right),
+ pa.scalar(0, type=divided.type),
+ )
+ result = pc.if_else(
+ pc.and_(
+ has_remainder,
+ has_one_negative_operand,
+ ),
+ # GH: 55561
+ pc.subtract(divided, pa.scalar(1, type=divided.type)),
+ divided,
+ )
+ else:
+ result = divided
result = result.cast(left.type)
+ else:
+ divided = pc.divide(left, right)
+ result = pc.floor(divided)
return result
ARROW_ARITHMETIC_FUNCS = {
@@ -135,8 +162,8 @@ def floordiv_compat(
"rsub": lambda x, y: pc.subtract_checked(y, x),
"mul": pc.multiply_checked,
"rmul": lambda x, y: pc.multiply_checked(y, x),
- "truediv": lambda x, y: pc.divide(cast_for_truediv(x, y), y),
- "rtruediv": lambda x, y: pc.divide(y, cast_for_truediv(x, y)),
+ "truediv": lambda x, y: pc.divide(*cast_for_truediv(x, y)),
+ "rtruediv": lambda x, y: pc.divide(*cast_for_truediv(y, x)),
"floordiv": lambda x, y: floordiv_compat(x, y),
"rfloordiv": lambda x, y: floordiv_compat(y, x),
"mod": NotImplemented,
@@ -155,6 +182,7 @@ def floordiv_compat(
AxisInt,
Dtype,
FillnaOptions,
+ InterpolateOptions,
Iterator,
NpDtype,
NumpySorter,
@@ -628,7 +656,9 @@ def __arrow_array__(self, type=None):
"""Convert myself to a pyarrow ChunkedArray."""
return self._pa_array
- def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: NpDtype | None = None, copy: bool | None = None
+ ) -> np.ndarray:
"""Correctly construct numpy arrays when passed to `np.asarray()`."""
return self.to_numpy(dtype=dtype)
@@ -998,13 +1028,18 @@ def dropna(self) -> Self:
return type(self)(pc.drop_null(self._pa_array))
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
if not self._hasna:
# TODO(CoW): Not necessary anymore when CoW is the default
return self.copy()
- if limit is None:
+ if limit is None and limit_area is None:
method = missing.clean_fill_method(method)
try:
if method == "pad":
@@ -1020,7 +1055,9 @@ def _pad_or_backfill(
# TODO(3.0): after EA.fillna 'method' deprecation is enforced, we can remove
# this method entirely.
- return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
+ return super()._pad_or_backfill(
+ method=method, limit=limit, limit_area=limit_area, copy=copy
+ )
@doc(ExtensionArray.fillna)
def fillna(
@@ -1313,6 +1350,11 @@ def _to_timedeltaarray(self) -> TimedeltaArray:
np_array = np_array.astype(np_dtype)
return TimedeltaArray._simple_new(np_array, dtype=np_dtype)
+ def _values_for_json(self) -> np.ndarray:
+ if is_numeric_dtype(self.dtype):
+ return np.asarray(self, dtype=object)
+ return super()._values_for_json()
+
@doc(ExtensionArray.to_numpy)
def to_numpy(
self,
@@ -1320,6 +1362,7 @@ def to_numpy(
copy: bool = False,
na_value: object = lib.no_default,
) -> np.ndarray:
+ original_na_value = na_value
dtype, na_value = to_numpy_dtype_inference(self, dtype, na_value, self._hasna)
pa_type = self._pa_array.type
if not self._hasna or isna(na_value) or pa.types.is_null(pa_type):
@@ -1345,7 +1388,14 @@ def to_numpy(
if dtype is not None and isna(na_value):
na_value = None
result = np.full(len(data), fill_value=na_value, dtype=dtype)
- elif not data._hasna or (pa.types.is_floating(pa_type) and na_value is np.nan):
+ elif not data._hasna or (
+ pa.types.is_floating(pa_type)
+ and (
+ na_value is np.nan
+ or original_na_value is lib.no_default
+ and is_float_dtype(dtype)
+ )
+ ):
result = data._pa_array.to_numpy()
if dtype is not None:
result = result.astype(dtype, copy=False)
@@ -1366,7 +1416,7 @@ def to_numpy(
def map(self, mapper, na_action=None):
if is_numeric_dtype(self.dtype):
- return map_array(self.to_numpy(), mapper, na_action=None)
+ return map_array(self.to_numpy(), mapper, na_action=na_action)
else:
return super().map(mapper, na_action)
@@ -2006,6 +2056,45 @@ def _maybe_convert_setitem_value(self, value):
raise TypeError(msg) from err
return value
+ def interpolate(
+ self,
+ *,
+ method: InterpolateOptions,
+ axis: int,
+ index,
+ limit,
+ limit_direction,
+ limit_area,
+ copy: bool,
+ **kwargs,
+ ) -> Self:
+ """
+ See NDFrame.interpolate.__doc__.
+ """
+ # NB: we return type(self) even if copy=False
+ mask = self.isna()
+ if self.dtype.kind == "f":
+ data = self._pa_array.to_numpy()
+ elif self.dtype.kind in "iu":
+ data = self.to_numpy(dtype="f8", na_value=0.0)
+ else:
+ raise NotImplementedError(
+ f"interpolate is not implemented for dtype={self.dtype}"
+ )
+
+ missing.interpolate_2d_inplace(
+ data,
+ method=method,
+ axis=0,
+ index=index,
+ limit=limit,
+ limit_direction=limit_direction,
+ limit_area=limit_area,
+ mask=mask,
+ **kwargs,
+ )
+ return type(self)(self._box_pa_array(pa.array(data, mask=mask)))
+
@classmethod
def _if_else(
cls,
@@ -2262,7 +2351,7 @@ def _str_match(
def _str_fullmatch(
self, pat, case: bool = True, flags: int = 0, na: Scalar | None = None
):
- if not pat.endswith("$") or pat.endswith("//$"):
+ if not pat.endswith("$") or pat.endswith("\\$"):
pat = f"{pat}$"
return self._str_match(pat, case, flags, na)
@@ -2489,6 +2578,92 @@ def _str_wrap(self, width: int, **kwargs):
result = self._apply_elementwise(predicate)
return type(self)(pa.chunked_array(result))
+ @property
+ def _dt_days(self):
+ return type(self)(
+ pa.array(self._to_timedeltaarray().days, from_pandas=True, type=pa.int32())
+ )
+
+ @property
+ def _dt_hours(self):
+ return type(self)(
+ pa.array(
+ [
+ td.components.hours if td is not NaT else None
+ for td in self._to_timedeltaarray()
+ ],
+ type=pa.int32(),
+ )
+ )
+
+ @property
+ def _dt_minutes(self):
+ return type(self)(
+ pa.array(
+ [
+ td.components.minutes if td is not NaT else None
+ for td in self._to_timedeltaarray()
+ ],
+ type=pa.int32(),
+ )
+ )
+
+ @property
+ def _dt_seconds(self):
+ return type(self)(
+ pa.array(
+ self._to_timedeltaarray().seconds, from_pandas=True, type=pa.int32()
+ )
+ )
+
+ @property
+ def _dt_milliseconds(self):
+ return type(self)(
+ pa.array(
+ [
+ td.components.milliseconds if td is not NaT else None
+ for td in self._to_timedeltaarray()
+ ],
+ type=pa.int32(),
+ )
+ )
+
+ @property
+ def _dt_microseconds(self):
+ return type(self)(
+ pa.array(
+ self._to_timedeltaarray().microseconds,
+ from_pandas=True,
+ type=pa.int32(),
+ )
+ )
+
+ @property
+ def _dt_nanoseconds(self):
+ return type(self)(
+ pa.array(
+ self._to_timedeltaarray().nanoseconds, from_pandas=True, type=pa.int32()
+ )
+ )
+
+ def _dt_to_pytimedelta(self):
+ data = self._pa_array.to_pylist()
+ if self._dtype.pyarrow_dtype.unit == "ns":
+ data = [None if ts is None else ts.to_pytimedelta() for ts in data]
+ return np.array(data, dtype=object)
+
+ def _dt_total_seconds(self):
+ return type(self)(
+ pa.array(self._to_timedeltaarray().total_seconds(), from_pandas=True)
+ )
+
+ def _dt_as_unit(self, unit: str):
+ if pa.types.is_date(self.dtype.pyarrow_dtype):
+ raise NotImplementedError("as_unit not implemented for date types")
+ pd_array = self._maybe_convert_datelike_array()
+ # Don't just cast _pa_array in order to follow pandas unit conversion rules
+ return type(self)(pa.array(pd_array.as_unit(unit), from_pandas=True))
+
@property
def _dt_year(self):
return type(self)(pc.year(self._pa_array))
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 59c6d911cfaef..abfe2369b0d0d 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -70,6 +70,7 @@
unique,
)
from pandas.core.array_algos.quantile import quantile_with_mask
+from pandas.core.missing import _fill_limit_area_1d
from pandas.core.sorting import (
nargminmax,
nargsort,
@@ -718,7 +719,10 @@ def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
return TimedeltaArray._from_sequence(self, dtype=dtype, copy=copy)
- return np.array(self, dtype=dtype, copy=copy)
+ if not copy:
+ return np.asarray(self, dtype=dtype)
+ else:
+ return np.array(self, dtype=dtype, copy=copy)
def isna(self) -> np.ndarray | ExtensionArraySupportsAnyAll:
"""
@@ -954,7 +958,12 @@ def interpolate(
)
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
"""
Pad or backfill values, used by Series/DataFrame ffill and bfill.
@@ -1012,6 +1021,12 @@ def _pad_or_backfill(
DeprecationWarning,
stacklevel=find_stack_level(),
)
+ if limit_area is not None:
+ raise NotImplementedError(
+ f"{type(self).__name__} does not implement limit_area "
+ "(added in pandas 2.2). 3rd-party ExtnsionArray authors "
+ "need to add this argument to _pad_or_backfill."
+ )
return self.fillna(method=method, limit=limit)
mask = self.isna()
@@ -1021,6 +1036,8 @@ def _pad_or_backfill(
meth = missing.clean_fill_method(method)
npmask = np.asarray(mask)
+ if limit_area is not None and not npmask.all():
+ _fill_limit_area_1d(npmask, limit_area)
if meth == "pad":
indexer = libalgos.get_fill_indexer(npmask, limit=limit)
return self.take(indexer, allow_fill=True)
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 065a942cae768..f191f7277743f 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -44,7 +44,9 @@
pandas_dtype,
)
from pandas.core.dtypes.dtypes import (
+ ArrowDtype,
CategoricalDtype,
+ CategoricalDtypeType,
ExtensionDtype,
)
from pandas.core.dtypes.generic import (
@@ -443,24 +445,32 @@ def __init__(
values = arr
if dtype.categories is None:
- if not isinstance(values, ABCIndex):
- # in particular RangeIndex xref test_index_equal_range_categories
- values = sanitize_array(values, None)
- try:
- codes, categories = factorize(values, sort=True)
- except TypeError as err:
- codes, categories = factorize(values, sort=False)
- if dtype.ordered:
- # raise, as we don't have a sortable data structure and so
- # the user should give us one by specifying categories
- raise TypeError(
- "'values' is not ordered, please "
- "explicitly specify the categories order "
- "by passing in a categories argument."
- ) from err
-
- # we're inferring from values
- dtype = CategoricalDtype(categories, dtype.ordered)
+ if isinstance(values.dtype, ArrowDtype) and issubclass(
+ values.dtype.type, CategoricalDtypeType
+ ):
+ arr = values._pa_array.combine_chunks()
+ categories = arr.dictionary.to_pandas(types_mapper=ArrowDtype)
+ codes = arr.indices.to_numpy()
+ dtype = CategoricalDtype(categories, values.dtype.pyarrow_dtype.ordered)
+ else:
+ if not isinstance(values, ABCIndex):
+ # in particular RangeIndex xref test_index_equal_range_categories
+ values = sanitize_array(values, None)
+ try:
+ codes, categories = factorize(values, sort=True)
+ except TypeError as err:
+ codes, categories = factorize(values, sort=False)
+ if dtype.ordered:
+ # raise, as we don't have a sortable data structure and so
+ # the user should give us one by specifying categories
+ raise TypeError(
+ "'values' is not ordered, please "
+ "explicitly specify the categories order "
+ "by passing in a categories argument."
+ ) from err
+
+ # we're inferring from values
+ dtype = CategoricalDtype(categories, dtype.ordered)
elif isinstance(values.dtype, CategoricalDtype):
old_codes = extract_array(values)._codes
@@ -1626,7 +1636,9 @@ def _validate_codes_for_dtype(cls, codes, *, dtype: CategoricalDtype) -> np.ndar
# -------------------------------------------------------------
@ravel_compat
- def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: NpDtype | None = None, copy: bool | None = None
+ ) -> np.ndarray:
"""
The numpy array interface.
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 11a0c7bf18fcb..1042a1b3fde61 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -92,6 +92,7 @@
pandas_dtype,
)
from pandas.core.dtypes.dtypes import (
+ ArrowDtype,
CategoricalDtype,
DatetimeTZDtype,
ExtensionDtype,
@@ -350,7 +351,9 @@ def _formatter(self, boxed: bool = False):
# ----------------------------------------------------------------
# Array-Like / EA-Interface Methods
- def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: NpDtype | None = None, copy: bool | None = None
+ ) -> np.ndarray:
# used for Timedelta/DatetimeArray, overwritten by PeriodArray
if is_object_dtype(dtype):
return np.array(list(self), dtype=object)
@@ -2531,7 +2534,7 @@ def _validate_inferred_freq(
return freq
-def dtype_to_unit(dtype: DatetimeTZDtype | np.dtype) -> str:
+def dtype_to_unit(dtype: DatetimeTZDtype | np.dtype | ArrowDtype) -> str:
"""
Return the unit str corresponding to the dtype's resolution.
@@ -2546,4 +2549,8 @@ def dtype_to_unit(dtype: DatetimeTZDtype | np.dtype) -> str:
"""
if isinstance(dtype, DatetimeTZDtype):
return dtype.unit
+ elif isinstance(dtype, ArrowDtype):
+ if dtype.kind not in "mM":
+ raise ValueError(f"{dtype=} does not have a resolution.")
+ return dtype.pyarrow_dtype.unit
return np.datetime_data(dtype)[0]
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 6b7ddc4a72957..a146220d249e2 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -39,10 +39,7 @@
tz_convert_from_utc,
tzconversion,
)
-from pandas._libs.tslibs.dtypes import (
- abbrev_to_npy_unit,
- freq_to_period_freqstr,
-)
+from pandas._libs.tslibs.dtypes import abbrev_to_npy_unit
from pandas.errors import PerformanceWarning
from pandas.util._exceptions import find_stack_level
from pandas.util._validators import validate_inclusive
@@ -638,12 +635,12 @@ def _resolution_obj(self) -> Resolution:
# ----------------------------------------------------------------
# Array-Like / EA-Interface Methods
- def __array__(self, dtype=None) -> np.ndarray:
+ def __array__(self, dtype=None, copy=None) -> np.ndarray:
if dtype is None and self.tz:
# The default for tz-aware is object, to preserve tz info
dtype = object
- return super().__array__(dtype=dtype)
+ return super().__array__(dtype=dtype, copy=copy)
def __iter__(self) -> Iterator:
"""
@@ -1232,8 +1229,10 @@ def to_period(self, freq=None) -> PeriodArray:
if freq is None:
freq = self.freqstr or self.inferred_freq
- if isinstance(self.freq, BaseOffset):
- freq = freq_to_period_freqstr(self.freq.n, self.freq.name)
+ if isinstance(self.freq, BaseOffset) and hasattr(
+ self.freq, "_period_dtype_code"
+ ):
+ freq = PeriodDtype(self.freq)._freqstr
if freq is None:
raise ValueError(
@@ -2394,7 +2393,7 @@ def objects_to_datetime64(
assert errors in ["raise", "ignore", "coerce"]
# if str-dtype, convert
- data = np.array(data, copy=False, dtype=np.object_)
+ data = np.asarray(data, dtype=np.object_)
result, tz_parsed = tslib.array_to_datetime(
data,
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index a19b304529383..91db7f11bcbe0 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -79,6 +79,7 @@
unique,
value_counts_internal as value_counts,
)
+from pandas.core.arrays import ArrowExtensionArray
from pandas.core.arrays.base import (
ExtensionArray,
_extension_array_shared_docs,
@@ -370,11 +371,18 @@ def _ensure_simple_new_inputs(
right = ensure_wrapped_if_datetimelike(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()
+ if isinstance(left, ArrowExtensionArray) or isinstance(
+ right, ArrowExtensionArray
+ ):
+ pass
+ else:
+ lbase = getattr(left, "_ndarray", left)
+ lbase = getattr(lbase, "_data", lbase).base
+ rbase = getattr(right, "_ndarray", right)
+ rbase = getattr(rbase, "_data", rbase).base
+ if lbase is not None and lbase is rbase:
+ # If these share data, then setitem could corrupt our IA
+ right = right.copy()
dtype = IntervalDtype(left.dtype, closed=closed)
@@ -890,11 +898,18 @@ def max(self, *, axis: AxisInt | None = None, skipna: bool = True) -> IntervalOr
return obj[indexer]
def _pad_or_backfill( # pylint: disable=useless-parent-delegation
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
# TODO(3.0): after EA.fillna 'method' deprecation is enforced, we can remove
# this method entirely.
- return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
+ return super()._pad_or_backfill(
+ method=method, limit=limit, limit_area=limit_area, copy=copy
+ )
def fillna(
self, value=None, method=None, limit: int | None = None, copy: bool = True
@@ -1552,7 +1567,9 @@ def is_non_overlapping_monotonic(self) -> bool:
# ---------------------------------------------------------------------
# Conversion
- def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: NpDtype | None = None, copy: bool | None = 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 03c09c5b2fd18..d7e816b9d3781 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -22,6 +22,7 @@
AxisInt,
DtypeObj,
FillnaOptions,
+ InterpolateOptions,
NpDtype,
PositionalIndexer,
Scalar,
@@ -98,6 +99,7 @@
NumpySorter,
NumpyValueArrayLike,
)
+ from pandas.core.arrays import FloatingArray
from pandas.compat.numpy import function as nv
@@ -192,7 +194,12 @@ def __getitem__(self, item: PositionalIndexer) -> Self | Any:
return self._simple_new(self._data[item], newmask)
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
mask = self._mask
@@ -204,7 +211,21 @@ def _pad_or_backfill(
if copy:
npvalues = npvalues.copy()
new_mask = new_mask.copy()
+ elif limit_area is not None:
+ mask = mask.copy()
func(npvalues, limit=limit, mask=new_mask)
+
+ if limit_area is not None and not mask.all():
+ mask = mask.T
+ neg_mask = ~mask
+ first = neg_mask.argmax()
+ last = len(neg_mask) - neg_mask[::-1].argmax() - 1
+ if limit_area == "inside":
+ new_mask[:first] |= mask[:first]
+ new_mask[last + 1 :] |= mask[last + 1 :]
+ elif limit_area == "outside":
+ new_mask[first + 1 : last] |= mask[first + 1 : last]
+
if copy:
return self._simple_new(npvalues.T, new_mask.T)
else:
@@ -384,6 +405,8 @@ def round(self, decimals: int = 0, *args, **kwargs):
DataFrame.round : Round values of a DataFrame.
Series.round : Round values of a Series.
"""
+ if self.dtype.kind == "b":
+ return self
nv.validate_round(args, kwargs)
values = np.round(self._data, decimals=decimals, **kwargs)
@@ -407,6 +430,9 @@ def __abs__(self) -> Self:
# ------------------------------------------------------------------
+ def _values_for_json(self) -> np.ndarray:
+ return np.asarray(self, dtype=object)
+
def to_numpy(
self,
dtype: npt.DTypeLike | None = None,
@@ -475,6 +501,8 @@ def to_numpy(
"""
hasna = self._hasna
dtype, na_value = to_numpy_dtype_inference(self, dtype, na_value, hasna)
+ if dtype is None:
+ dtype = object
if hasna:
if (
@@ -565,7 +593,9 @@ def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
__array_priority__ = 1000 # higher than ndarray so ops dispatch to us
- def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: NpDtype | None = None, copy: bool | None = None
+ ) -> np.ndarray:
"""
the array interface, return my values
We return an object array here to preserve our scalar values
@@ -1305,7 +1335,7 @@ def max(self, *, skipna: bool = True, axis: AxisInt | None = 0, **kwargs):
return self._wrap_reduction_result("max", result, skipna=skipna, axis=axis)
def map(self, mapper, na_action=None):
- return map_array(self.to_numpy(), mapper, na_action=None)
+ return map_array(self.to_numpy(), mapper, na_action=na_action)
def any(self, *, skipna: bool = True, axis: AxisInt | None = 0, **kwargs):
"""
@@ -1470,6 +1500,58 @@ def all(self, *, skipna: bool = True, axis: AxisInt | None = 0, **kwargs):
else:
return self.dtype.na_value
+ def interpolate(
+ self,
+ *,
+ method: InterpolateOptions,
+ axis: int,
+ index,
+ limit,
+ limit_direction,
+ limit_area,
+ copy: bool,
+ **kwargs,
+ ) -> FloatingArray:
+ """
+ See NDFrame.interpolate.__doc__.
+ """
+ # NB: we return type(self) even if copy=False
+ if self.dtype.kind == "f":
+ if copy:
+ data = self._data.copy()
+ mask = self._mask.copy()
+ else:
+ data = self._data
+ mask = self._mask
+ elif self.dtype.kind in "iu":
+ copy = True
+ data = self._data.astype("f8")
+ mask = self._mask.copy()
+ else:
+ raise NotImplementedError(
+ f"interpolate is not implemented for dtype={self.dtype}"
+ )
+
+ missing.interpolate_2d_inplace(
+ data,
+ method=method,
+ axis=0,
+ index=index,
+ limit=limit,
+ limit_direction=limit_direction,
+ limit_area=limit_area,
+ mask=mask,
+ **kwargs,
+ )
+ if not copy:
+ return self # type: ignore[return-value]
+ if self.dtype.kind == "f":
+ return type(self)._simple_new(data, mask) # type: ignore[return-value]
+ else:
+ from pandas.core.arrays import FloatingArray
+
+ return FloatingArray._simple_new(data, mask)
+
def _accumulate(
self, name: str, *, skipna: bool = True, **kwargs
) -> BaseMaskedArray:
@@ -1541,13 +1623,24 @@ def transpose_homogeneous_masked_arrays(
same dtype. The caller is responsible for ensuring validity of input data.
"""
masked_arrays = list(masked_arrays)
+ dtype = masked_arrays[0].dtype
+
values = [arr._data.reshape(1, -1) for arr in masked_arrays]
- transposed_values = np.concatenate(values, axis=0)
+ transposed_values = np.concatenate(
+ values,
+ axis=0,
+ out=np.empty(
+ (len(masked_arrays), len(masked_arrays[0])),
+ order="F",
+ dtype=dtype.numpy_dtype,
+ ),
+ )
masks = [arr._mask.reshape(1, -1) for arr in masked_arrays]
- transposed_masks = np.concatenate(masks, axis=0)
+ transposed_masks = np.concatenate(
+ masks, axis=0, out=np.empty_like(transposed_values, dtype=bool)
+ )
- dtype = masked_arrays[0].dtype
arr_type = dtype.construct_array_type()
transposed_arrays: list[BaseMaskedArray] = []
for i in range(transposed_values.shape[1]):
diff --git a/pandas/core/arrays/numeric.py b/pandas/core/arrays/numeric.py
index 210450e868698..68fa7fcb6573c 100644
--- a/pandas/core/arrays/numeric.py
+++ b/pandas/core/arrays/numeric.py
@@ -159,7 +159,10 @@ def _coerce_to_data_and_mask(
return values, mask, dtype, inferred_type
original = values
- values = np.array(values, copy=copy)
+ if not copy:
+ values = np.asarray(values)
+ else:
+ values = np.array(values, copy=copy)
inferred_type = None
if values.dtype == object or is_string_dtype(values.dtype):
inferred_type = lib.infer_dtype(values, skipna=True)
@@ -168,7 +171,10 @@ def _coerce_to_data_and_mask(
raise TypeError(f"{values.dtype} cannot be converted to {name}")
elif values.dtype.kind == "b" and checker(dtype):
- values = np.array(values, dtype=default_dtype, copy=copy)
+ if not copy:
+ values = np.asarray(values, dtype=default_dtype)
+ else:
+ values = np.array(values, dtype=default_dtype, copy=copy)
elif values.dtype.kind not in "iuf":
name = dtype_cls.__name__.strip("_")
@@ -207,9 +213,9 @@ def _coerce_to_data_and_mask(
inferred_type not in ["floating", "mixed-integer-float"]
and not mask.any()
):
- values = np.array(original, dtype=dtype, copy=False)
+ values = np.asarray(original, dtype=dtype)
else:
- values = np.array(original, dtype="object", copy=False)
+ values = np.asarray(original, dtype="object")
# we copy as need to coerce here
if mask.any():
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index d83a37088daec..07eb91e0cb13b 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -150,7 +150,9 @@ def dtype(self) -> NumpyEADtype:
# ------------------------------------------------------------------------
# NumPy Array Interface
- def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: NpDtype | None = None, copy: bool | None = None
+ ) -> np.ndarray:
return np.asarray(self._ndarray, dtype=dtype)
def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 2930b979bfe78..c1229e27ab51a 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -256,7 +256,10 @@ def __init__(
raise raise_on_incompatible(values, dtype.freq)
values, dtype = values._ndarray, values.dtype
- values = np.array(values, dtype="int64", copy=copy)
+ if not copy:
+ values = np.asarray(values, dtype="int64")
+ else:
+ values = np.array(values, dtype="int64", copy=copy)
if dtype is None:
raise ValueError("dtype is not specified and cannot be inferred")
dtype = cast(PeriodDtype, dtype)
@@ -400,7 +403,9 @@ def freq(self) -> BaseOffset:
def freqstr(self) -> str:
return freq_to_period_freqstr(self.freq.n, self.freq.name)
- def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: NpDtype | None = None, copy: bool | None = None
+ ) -> np.ndarray:
if dtype == "i8":
return self.asi8
elif dtype == bool:
@@ -733,8 +738,8 @@ def asfreq(self, freq=None, how: str = "E") -> Self:
'2015-01'], dtype='period[M]')
"""
how = libperiod.validate_end_alias(how)
- if isinstance(freq, BaseOffset):
- freq = freq_to_period_freqstr(freq.n, freq.name)
+ if isinstance(freq, BaseOffset) and hasattr(freq, "_period_dtype_code"):
+ freq = PeriodDtype(freq)._freqstr
freq = Period._maybe_convert_freq(freq)
base1 = self._dtype._dtype_code
@@ -810,12 +815,19 @@ def searchsorted(
return m8arr.searchsorted(npvalue, side=side, sorter=sorter)
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
# view as dt64 so we get treated as timelike in core.missing,
# similar to dtl._period_dispatch
dta = self.view("M8[ns]")
- result = dta._pad_or_backfill(method=method, limit=limit, copy=copy)
+ result = dta._pad_or_backfill(
+ method=method, limit=limit, limit_area=limit_area, copy=copy
+ )
if copy:
return cast("Self", result.view(self.dtype))
else:
@@ -1179,12 +1191,7 @@ def dt64arr_to_periodarr(
reso = get_unit_from_dtype(data.dtype)
freq = Period._maybe_convert_freq(freq)
- try:
- base = freq._period_dtype_code
- except (AttributeError, TypeError):
- # AttributeError: _period_dtype_code might not exist
- # TypeError: _period_dtype_code might intentionally raise
- raise TypeError(f"{freq.name} is not supported as period frequency")
+ base = freq._period_dtype_code
return c_dt64arr_to_periodarr(data.view("i8"), base, tz, reso=reso), freq
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 5db77db2a9c66..82fcfa74ec7d2 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -551,7 +551,9 @@ def from_spmatrix(cls, data: spmatrix) -> Self:
return cls._simple_new(arr, index, dtype)
- def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: NpDtype | None = None, copy: bool | None = None
+ ) -> np.ndarray:
fill_value = self.fill_value
if self.sp_index.ngaps == 0:
@@ -716,11 +718,18 @@ def isna(self) -> Self: # type: ignore[override]
return type(self)(mask, fill_value=False, dtype=dtype)
def _pad_or_backfill( # pylint: disable=useless-parent-delegation
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
# TODO(3.0): We can remove this method once deprecation for fillna method
# keyword is enforced.
- return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
+ return super()._pad_or_backfill(
+ method=method, limit=limit, limit_area=limit_area, copy=copy
+ )
def fillna(
self,
diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index d5a76811a12e6..e8f614ff855c0 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -433,7 +433,7 @@ def _str_match(
def _str_fullmatch(
self, pat, case: bool = True, flags: int = 0, na: Scalar | None = None
):
- if not pat.endswith("$") or pat.endswith("//$"):
+ if not pat.endswith("$") or pat.endswith("\\$"):
pat = f"{pat}$"
return self._str_match(pat, case, flags, na)
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 1b885a2bdcd47..e9260a3ec50a2 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -1072,7 +1072,10 @@ def sequence_to_td64ns(
# This includes datetime64-dtype, see GH#23539, GH#29794
raise TypeError(f"dtype {data.dtype} cannot be converted to timedelta64[ns]")
- data = np.array(data, copy=copy)
+ if not copy:
+ data = np.asarray(data)
+ else:
+ data = np.array(data, copy=copy)
assert data.dtype.kind == "m"
assert data.dtype != "m8" # i.e. not unit-less
@@ -1150,7 +1153,7 @@ def _objects_to_td64ns(data, unit=None, errors: DateTimeErrorChoices = "raise"):
higher level.
"""
# coerce Index to np.ndarray, converting string-dtype if necessary
- values = np.array(data, dtype=np.object_, copy=False)
+ values = np.asarray(data, dtype=np.object_)
result = array_to_timedelta64(values, unit=unit, errors=errors)
return result.view("timedelta64[ns]")
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 7d864e02be54e..9f024498d66ed 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -233,6 +233,8 @@ def asarray_tuplesafe(values: Iterable, dtype: NpDtype | None = None) -> ArrayLi
values = list(values)
elif isinstance(values, ABCIndex):
return values._values
+ elif isinstance(values, ABCSeries):
+ return values._values
if isinstance(values, list) and dtype in [np.object_, object]:
return construct_1d_object_array_from_listlike(values)
diff --git a/pandas/core/computation/expr.py b/pandas/core/computation/expr.py
index 4770f403b1bdb..b5861fbaebe9c 100644
--- a/pandas/core/computation/expr.py
+++ b/pandas/core/computation/expr.py
@@ -695,8 +695,8 @@ def visit_Call(self, node, side=None, **kwargs):
if not isinstance(key, ast.keyword):
# error: "expr" has no attribute "id"
raise ValueError(
- "keyword error in function call " # type: ignore[attr-defined]
- f"'{node.func.id}'"
+ "keyword error in function call "
+ f"'{node.func.id}'" # type: ignore[attr-defined]
)
if key.arg:
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index d41a9c80a10ec..f8250ae475a10 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -626,7 +626,10 @@ def sanitize_array(
elif hasattr(data, "__array__"):
# e.g. dask array GH#38645
- data = np.array(data, copy=copy)
+ if not copy:
+ data = np.asarray(data)
+ else:
+ data = np.array(data, copy=copy)
return sanitize_array(
data,
index=index,
@@ -744,8 +747,11 @@ def _sanitize_str_dtypes(
# GH#19853: If data is a scalar, result has already the result
if not lib.is_scalar(data):
if not np.all(isna(data)):
- data = np.array(data, dtype=dtype, copy=False)
- result = np.array(data, dtype=object, copy=copy)
+ data = np.asarray(data, dtype=dtype)
+ if not copy:
+ result = np.asarray(data, dtype=object)
+ else:
+ result = np.array(data, dtype=object, copy=copy)
return result
@@ -810,6 +816,8 @@ def _try_cast(
# this will raise if we have e.g. floats
subarr = maybe_cast_to_integer_array(arr, dtype)
+ elif not copy:
+ subarr = np.asarray(arr, dtype=dtype)
else:
subarr = np.array(arr, dtype=dtype, copy=copy)
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 7a088bf84c48e..7dd81ec59bc49 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -1332,7 +1332,7 @@ def find_result_type(left_dtype: DtypeObj, right: Any) -> DtypeObj:
right = left_dtype
elif (
not np.issubdtype(left_dtype, np.unsignedinteger)
- and 0 < right <= 2 ** (8 * right_dtype.itemsize - 1) - 1
+ and 0 < right <= np.iinfo(right_dtype).max
):
# If left dtype isn't unsigned, check if it fits in the signed dtype
right = np.dtype(f"i{right_dtype.itemsize}")
@@ -1501,7 +1501,10 @@ def construct_2d_arraylike_from_scalar(
# Attempt to coerce to a numpy array
try:
- arr = np.array(value, dtype=dtype, copy=copy)
+ if not copy:
+ arr = np.asarray(value, dtype=dtype)
+ else:
+ arr = np.array(value, dtype=dtype, copy=copy)
except (ValueError, TypeError) as err:
raise TypeError(
f"DataFrame constructor called with incompatible data and dtype: {err}"
@@ -1651,7 +1654,7 @@ def maybe_cast_to_integer_array(arr: list | np.ndarray, dtype: np.dtype) -> np.n
"out-of-bound Python int",
DeprecationWarning,
)
- casted = np.array(arr, dtype=dtype, copy=False)
+ casted = np.asarray(arr, dtype=dtype)
else:
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=RuntimeWarning)
@@ -1682,6 +1685,7 @@ def maybe_cast_to_integer_array(arr: list | np.ndarray, dtype: np.dtype) -> np.n
arr = np.asarray(arr)
if np.issubdtype(arr.dtype, str):
+ # TODO(numpy-2.0 min): This case will raise an OverflowError above
if (casted.astype(str) == arr).all():
return casted
raise ValueError(f"string values cannot be losslessly cast to {dtype}")
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index 2245359fd8eac..df0251d141984 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -169,6 +169,9 @@ def is_sparse(arr) -> bool:
"""
Check whether an array-like is a 1-D pandas sparse array.
+ .. deprecated:: 2.1.0
+ Use isinstance(dtype, pd.SparseDtype) instead.
+
Check that the one-dimensional array-like is a pandas sparse array.
Returns True if it is a pandas sparse array, not another type of
sparse array.
@@ -295,6 +298,9 @@ def is_datetime64tz_dtype(arr_or_dtype) -> bool:
"""
Check whether an array-like or dtype is of a DatetimeTZDtype dtype.
+ .. deprecated:: 2.1.0
+ Use isinstance(dtype, pd.DatetimeTZDtype) instead.
+
Parameters
----------
arr_or_dtype : array-like or dtype
@@ -381,6 +387,9 @@ def is_period_dtype(arr_or_dtype) -> bool:
"""
Check whether an array-like or dtype is of the Period dtype.
+ .. deprecated:: 2.2.0
+ Use isinstance(dtype, pd.Period) instead.
+
Parameters
----------
arr_or_dtype : array-like or dtype
@@ -424,6 +433,9 @@ def is_interval_dtype(arr_or_dtype) -> bool:
"""
Check whether an array-like or dtype is of the Interval dtype.
+ .. deprecated:: 2.2.0
+ Use isinstance(dtype, pd.IntervalDtype) instead.
+
Parameters
----------
arr_or_dtype : array-like or dtype
@@ -470,6 +482,9 @@ def is_categorical_dtype(arr_or_dtype) -> bool:
"""
Check whether an array-like or dtype is of the Categorical dtype.
+ .. deprecated:: 2.2.0
+ Use isinstance(dtype, pd.CategoricalDtype) instead.
+
Parameters
----------
arr_or_dtype : array-like or dtype
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index ed5256922377a..1c43ef55c11d7 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -919,7 +919,7 @@ def __from_arrow__(self, array: pa.Array | pa.ChunkedArray) -> DatetimeArray:
else:
np_arr = array.to_numpy()
- return DatetimeArray._from_sequence(np_arr, dtype=self, copy=False)
+ return DatetimeArray._simple_new(np_arr, dtype=self)
def __setstate__(self, state) -> None:
# for pickle compat. __get_state__ is defined in the
@@ -2190,7 +2190,9 @@ def numpy_dtype(self) -> np.dtype:
# This can be removed if/when pyarrow addresses it:
# https://github.com/apache/arrow/issues/34462
return np.dtype(f"timedelta64[{self.pyarrow_dtype.unit}]")
- if pa.types.is_string(self.pyarrow_dtype):
+ if pa.types.is_string(self.pyarrow_dtype) or pa.types.is_large_string(
+ self.pyarrow_dtype
+ ):
# pa.string().to_pandas_dtype() = object which we don't want
return np.dtype(str)
try:
diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
index 4dc0d477f89e8..c341ff9dff7e6 100644
--- a/pandas/core/dtypes/missing.py
+++ b/pandas/core/dtypes/missing.py
@@ -632,7 +632,7 @@ def infer_fill_value(val):
"""
if not is_list_like(val):
val = [val]
- val = np.array(val, copy=False)
+ val = np.asarray(val)
if val.dtype.kind in "mM":
return np.array("NaT", dtype=val.dtype)
elif val.dtype == object:
@@ -647,6 +647,20 @@ def infer_fill_value(val):
return np.nan
+def construct_1d_array_from_inferred_fill_value(
+ value: object, length: int
+) -> ArrayLike:
+ # Find our empty_value dtype by constructing an array
+ # from our value and doing a .take on it
+ from pandas.core.algorithms import take_nd
+ from pandas.core.construction import sanitize_array
+ from pandas.core.indexes.base import Index
+
+ arr = sanitize_array(value, Index(range(1)), copy=False)
+ taker = -1 * np.ones(length, dtype=np.intp)
+ return take_nd(arr, taker)
+
+
def maybe_fill(arr: np.ndarray) -> np.ndarray:
"""
Fill numpy.ndarray with NaN, unless we have a integer or boolean dtype.
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 3e2e589440bd9..afcd4d014316e 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -656,26 +656,37 @@ class DataFrame(NDFrame, OpsMixin):
def _constructor(self) -> Callable[..., DataFrame]:
return DataFrame
- def _constructor_from_mgr(self, mgr, axes):
- if self._constructor is DataFrame:
- # we are pandas.DataFrame (or a subclass that doesn't override _constructor)
- return DataFrame._from_mgr(mgr, axes=axes)
- else:
- assert axes is mgr.axes
+ def _constructor_from_mgr(self, mgr, axes) -> DataFrame:
+ df = DataFrame._from_mgr(mgr, axes=axes)
+
+ if type(self) is DataFrame:
+ # This would also work `if self._constructor is DataFrame`, but
+ # this check is slightly faster, benefiting the most-common case.
+ return df
+
+ elif type(self).__name__ == "GeoDataFrame":
+ # Shim until geopandas can override their _constructor_from_mgr
+ # bc they have different behavior for Managers than for DataFrames
return self._constructor(mgr)
+ # We assume that the subclass __init__ knows how to handle a
+ # pd.DataFrame object.
+ return self._constructor(df)
+
_constructor_sliced: Callable[..., Series] = Series
- def _sliced_from_mgr(self, mgr, axes) -> Series:
- return Series._from_mgr(mgr, axes)
+ def _constructor_sliced_from_mgr(self, mgr, axes) -> Series:
+ ser = Series._from_mgr(mgr, axes)
+ ser._name = None # caller is responsible for setting real name
- def _constructor_sliced_from_mgr(self, mgr, axes):
- if self._constructor_sliced is Series:
- ser = self._sliced_from_mgr(mgr, axes)
- ser._name = None # caller is responsible for setting real name
+ if type(self) is DataFrame:
+ # This would also work `if self._constructor_sliced is Series`, but
+ # this check is slightly faster, benefiting the most-common case.
return ser
- assert axes is mgr.axes
- return self._constructor_sliced(mgr)
+
+ # We assume that the subclass __init__ knows how to handle a
+ # pd.Series object.
+ return self._constructor_sliced(ser)
# ----------------------------------------------------------------------
# Constructors
@@ -987,6 +998,33 @@ def __dataframe_consortium_standard__(
)
return convert_to_standard_compliant_dataframe(self, api_version=api_version)
+ def __arrow_c_stream__(self, requested_schema=None):
+ """
+ Export the pandas DataFrame as an Arrow C stream PyCapsule.
+
+ This relies on pyarrow to convert the pandas DataFrame to the Arrow
+ format (and follows the default behaviour of ``pyarrow.Table.from_pandas``
+ in its handling of the index, i.e. store the index as a column except
+ for RangeIndex).
+ This conversion is not necessarily zero-copy.
+
+ Parameters
+ ----------
+ requested_schema : PyCapsule, default None
+ The schema to which the dataframe should be casted, passed as a
+ PyCapsule containing a C ArrowSchema representation of the
+ requested schema.
+
+ Returns
+ -------
+ PyCapsule
+ """
+ pa = import_optional_dependency("pyarrow", min_version="14.0.0")
+ if requested_schema is not None:
+ requested_schema = pa.Schema._import_from_c_capsule(requested_schema)
+ table = pa.Table.from_pandas(self, schema=requested_schema)
+ return table.__arrow_c_stream__()
+
# ----------------------------------------------------------------------
@property
@@ -1376,7 +1414,8 @@ def _get_values_for_csv(
na_rep=na_rep,
quoting=quoting,
)
- return self._constructor_from_mgr(mgr, axes=mgr.axes)
+ # error: Incompatible return value type (got "DataFrame", expected "Self")
+ return self._constructor_from_mgr(mgr, axes=mgr.axes) # type: ignore[return-value]
# ----------------------------------------------------------------------
@@ -1953,7 +1992,7 @@ def to_numpy(
dtype = np.dtype(dtype)
result = self._mgr.as_array(dtype=dtype, copy=copy, na_value=na_value)
if result.dtype is not dtype:
- result = np.array(result, dtype=dtype, copy=False)
+ result = np.asarray(result, dtype=dtype)
return result
@@ -4016,7 +4055,9 @@ def _getitem_nocopy(self, key: list):
copy=False,
only_slice=True,
)
- return self._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+ result = self._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+ result = result.__finalize__(self)
+ return result
def __getitem__(self, key):
check_dict_or_set_indexers(key)
@@ -5048,7 +5089,8 @@ def predicate(arr: ArrayLike) -> bool:
return True
mgr = self._mgr._get_data_subset(predicate).copy(deep=None)
- return self._constructor_from_mgr(mgr, axes=mgr.axes).__finalize__(self)
+ # error: Incompatible return value type (got "DataFrame", expected "Self")
+ return self._constructor_from_mgr(mgr, axes=mgr.axes).__finalize__(self) # type: ignore[return-value]
def insert(
self,
@@ -5830,6 +5872,9 @@ def shift(
)
fill_value = lib.no_default
+ if self.empty:
+ return self.copy()
+
axis = self._get_axis_number(axis)
if is_list_like(periods):
@@ -8930,6 +8975,7 @@ def update(
1 2 500.0
2 3 6.0
"""
+
if not PYPY and using_copy_on_write():
if sys.getrefcount(self) <= REF_COUNT:
warnings.warn(
@@ -8978,7 +9024,17 @@ def update(
if mask.all():
continue
- self.loc[:, col] = self[col].where(mask, that)
+ with warnings.catch_warnings():
+ warnings.filterwarnings(
+ "ignore",
+ message="Downcasting behavior",
+ category=FutureWarning,
+ )
+ # GH#57124 - `that` might get upcasted because of NA values, and then
+ # downcasted in where because of the mask. Ignoring the warning
+ # is a stopgap, will replace with a new implementation of update
+ # in 3.0.
+ self.loc[:, col] = self[col].where(mask, that)
# ----------------------------------------------------------------------
# Data reshaping
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index de25a02c6b37c..796357355fef4 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -336,6 +336,7 @@ def _as_manager(self, typ: str, copy: bool_t = True) -> Self:
# fastpath of passing a manager doesn't check the option/manager class
return self._constructor_from_mgr(new_mgr, axes=new_mgr.axes).__finalize__(self)
+ @final
@classmethod
def _from_mgr(cls, mgr: Manager, axes: list[Index]) -> Self:
"""
@@ -657,7 +658,7 @@ def _get_cleaned_column_resolvers(self) -> dict[Hashable, Series]:
return {
clean_column_name(k): Series(
- v, copy=False, index=self.index, name=k
+ v, copy=False, index=self.index, name=k, dtype=self.dtypes[k]
).__finalize__(self)
for k, v in zip(self.columns, self._iter_column_arrays())
if not isinstance(k, int)
@@ -2145,7 +2146,9 @@ def empty(self) -> bool_t:
# GH#23114 Ensure ndarray.__op__(DataFrame) returns NotImplemented
__array_priority__: int = 1000
- def __array__(self, dtype: npt.DTypeLike | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: npt.DTypeLike | None = None, copy: bool_t | None = None
+ ) -> np.ndarray:
values = self._values
arr = np.asarray(values, dtype=dtype)
if (
@@ -2969,6 +2972,9 @@ def to_sql(
database. Otherwise, the datetimes will be stored as timezone unaware
timestamps local to the original timezone.
+ Not all datastores support ``method="multi"``. Oracle, for example,
+ does not support multi-value insert.
+
References
----------
.. [1] https://docs.sqlalchemy.org
@@ -3275,18 +3281,18 @@ def to_xarray(self):
2 lion mammal 80.5 4
3 monkey mammal NaN 4
- >>> df.to_xarray()
+ >>> df.to_xarray() # doctest: +SKIP
<xarray.Dataset>
Dimensions: (index: 4)
Coordinates:
- * index (index) int64 0 1 2 3
+ * index (index) int64 32B 0 1 2 3
Data variables:
- name (index) object 'falcon' 'parrot' 'lion' 'monkey'
- class (index) object 'bird' 'bird' 'mammal' 'mammal'
- max_speed (index) float64 389.0 24.0 80.5 nan
- num_legs (index) int64 2 2 4 4
+ name (index) object 32B 'falcon' 'parrot' 'lion' 'monkey'
+ class (index) object 32B 'bird' 'bird' 'mammal' 'mammal'
+ max_speed (index) float64 32B 389.0 24.0 80.5 nan
+ num_legs (index) int64 32B 2 2 4 4
- >>> df['max_speed'].to_xarray()
+ >>> df['max_speed'].to_xarray() # doctest: +SKIP
<xarray.DataArray 'max_speed' (index: 4)>
array([389. , 24. , 80.5, nan])
Coordinates:
@@ -3308,7 +3314,7 @@ class (index) object 'bird' 'bird' 'mammal' 'mammal'
2018-01-02 falcon 361
parrot 15
- >>> df_multiindex.to_xarray()
+ >>> df_multiindex.to_xarray() # doctest: +SKIP
<xarray.Dataset>
Dimensions: (date: 2, animal: 2)
Coordinates:
@@ -7187,6 +7193,8 @@ def fillna(
or the string 'infer' which will try to downcast to an appropriate
equal type (e.g. float64 to int64 if possible).
+ .. deprecated:: 2.2.0
+
Returns
-------
{klass} or None
@@ -7522,6 +7530,8 @@ def ffill(
or the string 'infer' which will try to downcast to an appropriate
equal type (e.g. float64 to int64 if possible).
+ .. deprecated:: 2.2.0
+
Returns
-------
{klass} or None
@@ -7713,6 +7723,8 @@ def bfill(
or the string 'infer' which will try to downcast to an appropriate
equal type (e.g. float64 to int64 if possible).
+ .. deprecated:: 2.2.0
+
Returns
-------
{klass} or None
@@ -12120,19 +12132,20 @@ def pct_change(
if limit is lib.no_default:
cols = self.items() if self.ndim == 2 else [(None, self)]
for _, col in cols:
- mask = col.isna().values
- mask = mask[np.argmax(~mask) :]
- if mask.any():
- warnings.warn(
- "The default fill_method='pad' in "
- f"{type(self).__name__}.pct_change is deprecated and will "
- "be removed in a future version. Either fill in any "
- "non-leading NA values prior to calling pct_change or "
- "specify 'fill_method=None' to not fill NA values.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
- break
+ if len(col) > 0:
+ mask = col.isna().values
+ mask = mask[np.argmax(~mask) :]
+ if mask.any():
+ warnings.warn(
+ "The default fill_method='pad' in "
+ f"{type(self).__name__}.pct_change is deprecated and "
+ "will be removed in a future version. Either fill in "
+ "any non-leading NA values prior to calling pct_change "
+ "or specify 'fill_method=None' to not fill NA values.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ break
fill_method = "pad"
if limit is lib.no_default:
limit = None
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 089e15afd465b..db8949788567b 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -1831,7 +1831,7 @@ def f(g):
message=_apply_groupings_depr.format(
type(self).__name__, "apply"
),
- category=FutureWarning,
+ category=DeprecationWarning,
stacklevel=find_stack_level(),
)
except TypeError:
@@ -3335,9 +3335,13 @@ def max(
)
@final
- def first(self, numeric_only: bool = False, min_count: int = -1) -> NDFrameT:
+ def first(
+ self, numeric_only: bool = False, min_count: int = -1, skipna: bool = True
+ ) -> NDFrameT:
"""
- Compute the first non-null entry of each column.
+ Compute the first entry of each column within each group.
+
+ Defaults to skipping NA elements.
Parameters
----------
@@ -3345,12 +3349,17 @@ def first(self, numeric_only: bool = False, min_count: int = -1) -> NDFrameT:
Include only float, int, boolean columns.
min_count : int, default -1
The required number of valid values to perform the operation. If fewer
- than ``min_count`` non-NA values are present the result will be NA.
+ than ``min_count`` valid values are present the result will be NA.
+ skipna : bool, default True
+ Exclude NA/null values. If an entire row/column is NA, the result
+ will be NA.
+
+ .. versionadded:: 2.2.1
Returns
-------
Series or DataFrame
- First non-null of values within each group.
+ First values within each group.
See Also
--------
@@ -3402,12 +3411,17 @@ def first(x: Series):
min_count=min_count,
alias="first",
npfunc=first_compat,
+ skipna=skipna,
)
@final
- def last(self, numeric_only: bool = False, min_count: int = -1) -> NDFrameT:
+ def last(
+ self, numeric_only: bool = False, min_count: int = -1, skipna: bool = True
+ ) -> NDFrameT:
"""
- Compute the last non-null entry of each column.
+ Compute the last entry of each column within each group.
+
+ Defaults to skipping NA elements.
Parameters
----------
@@ -3416,12 +3430,17 @@ def last(self, numeric_only: bool = False, min_count: int = -1) -> NDFrameT:
everything, then use only numeric data.
min_count : int, default -1
The required number of valid values to perform the operation. If fewer
- than ``min_count`` non-NA values are present the result will be NA.
+ than ``min_count`` valid values are present the result will be NA.
+ skipna : bool, default True
+ Exclude NA/null values. If an entire row/column is NA, the result
+ will be NA.
+
+ .. versionadded:: 2.2.1
Returns
-------
Series or DataFrame
- Last non-null of values within each group.
+ Last of values within each group.
See Also
--------
@@ -3461,6 +3480,7 @@ def last(x: Series):
min_count=min_count,
alias="last",
npfunc=last_compat,
+ skipna=skipna,
)
@final
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 5e83eaee02afc..e2ddf9aa5c0c1 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -424,6 +424,7 @@ def _call_cython_op(
mask=mask,
result_mask=result_mask,
is_datetimelike=is_datetimelike,
+ **kwargs,
)
elif self.how in ["sem", "std", "var", "ohlc", "prod", "median"]:
if self.how in ["std", "sem"]:
diff --git a/pandas/core/indexes/accessors.py b/pandas/core/indexes/accessors.py
index 929c7f4a63f8f..7e3ba4089ff60 100644
--- a/pandas/core/indexes/accessors.py
+++ b/pandas/core/indexes/accessors.py
@@ -148,6 +148,20 @@ def _delegate_method(self, name: str, *args, **kwargs):
return result
+@delegate_names(
+ delegate=ArrowExtensionArray,
+ accessors=TimedeltaArray._datetimelike_ops,
+ typ="property",
+ accessor_mapping=lambda x: f"_dt_{x}",
+ raise_on_missing=False,
+)
+@delegate_names(
+ delegate=ArrowExtensionArray,
+ accessors=TimedeltaArray._datetimelike_methods,
+ typ="method",
+ accessor_mapping=lambda x: f"_dt_{x}",
+ raise_on_missing=False,
+)
@delegate_names(
delegate=ArrowExtensionArray,
accessors=DatetimeArray._datetimelike_ops,
@@ -213,6 +227,9 @@ def _delegate_method(self, name: str, *args, **kwargs):
return result
+ def to_pytimedelta(self):
+ return cast(ArrowExtensionArray, self._parent.array)._dt_to_pytimedelta()
+
def to_pydatetime(self):
# GH#20306
warnings.warn(
@@ -241,6 +258,26 @@ def isocalendar(self) -> DataFrame:
)
return iso_calendar_df
+ @property
+ def components(self) -> DataFrame:
+ from pandas import DataFrame
+
+ components_df = DataFrame(
+ {
+ col: getattr(self._parent.array, f"_dt_{col}")
+ for col in [
+ "days",
+ "hours",
+ "minutes",
+ "seconds",
+ "milliseconds",
+ "microseconds",
+ "nanoseconds",
+ ]
+ }
+ )
+ return components_df
+
@delegate_names(
delegate=DatetimeArray,
@@ -592,7 +629,7 @@ def __new__(cls, data: Series): # pyright: ignore[reportInconsistentConstructor
index=orig.index,
)
- if isinstance(data.dtype, ArrowDtype) and data.dtype.kind == "M":
+ if isinstance(data.dtype, ArrowDtype) and data.dtype.kind in "Mm":
return ArrowTemporalProperties(data, orig)
if lib.is_np_dtype(data.dtype, "M"):
return DatetimeProperties(data, orig)
diff --git a/pandas/core/indexes/api.py b/pandas/core/indexes/api.py
index 560285bd57a22..15292953e72d0 100644
--- a/pandas/core/indexes/api.py
+++ b/pandas/core/indexes/api.py
@@ -295,6 +295,7 @@ def _find_common_index_dtype(inds):
raise TypeError("Cannot join tz-naive with tz-aware DatetimeIndex")
if len(dtis) == len(indexes):
+ sort = True
result = indexes[0]
elif len(dtis) > 1:
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 88a08dd55f739..6822c2c99427e 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -912,7 +912,7 @@ def __len__(self) -> int:
"""
return len(self._data)
- def __array__(self, dtype=None) -> np.ndarray:
+ def __array__(self, dtype=None, copy=None) -> np.ndarray:
"""
The array interface, return my values.
"""
@@ -956,7 +956,7 @@ def __array_ufunc__(self, ufunc: np.ufunc, method: str_t, *inputs, **kwargs):
return self.__array_wrap__(result)
@final
- def __array_wrap__(self, result, context=None):
+ def __array_wrap__(self, result, context=None, return_scalar=False):
"""
Gets called after a ufunc and other functions e.g. np.split.
"""
@@ -3663,9 +3663,12 @@ def difference(self, other, sort=None):
def _difference(self, other, sort):
# overridden by RangeIndex
+ this = self
+ if isinstance(self, ABCCategoricalIndex) and self.hasnans and other.hasnans:
+ this = this.dropna()
other = other.unique()
- the_diff = self[other.get_indexer_for(self) == -1]
- the_diff = the_diff if self.is_unique else the_diff.unique()
+ the_diff = this[other.get_indexer_for(this) == -1]
+ the_diff = the_diff if this.is_unique else the_diff.unique()
the_diff = _maybe_try_sort(the_diff, sort)
return the_diff
@@ -4615,38 +4618,12 @@ def join(
if level is not None and (self._is_multi or other._is_multi):
return self._join_level(other, level, how=how)
- lidx: np.ndarray | None
- ridx: np.ndarray | None
-
- if len(other) == 0:
- if how in ("left", "outer"):
- if sort and not self.is_monotonic_increasing:
- lidx = self.argsort()
- join_index = self.take(lidx)
- else:
- lidx = None
- join_index = self._view()
- ridx = np.broadcast_to(np.intp(-1), len(join_index))
- return join_index, lidx, ridx
- elif how in ("right", "inner", "cross"):
- join_index = other._view()
- lidx = np.array([], dtype=np.intp)
- return join_index, lidx, None
-
- if len(self) == 0:
- if how in ("right", "outer"):
- if sort and not other.is_monotonic_increasing:
- ridx = other.argsort()
- join_index = other.take(ridx)
- else:
- ridx = None
- join_index = other._view()
- lidx = np.broadcast_to(np.intp(-1), len(join_index))
- return join_index, lidx, ridx
- elif how in ("left", "inner", "cross"):
- join_index = self._view()
- ridx = np.array([], dtype=np.intp)
- return join_index, None, ridx
+ if len(self) == 0 or len(other) == 0:
+ try:
+ return self._join_empty(other, how, sort)
+ except TypeError:
+ # object dtype; non-comparable objects
+ pass
if self.dtype != other.dtype:
dtype = self._find_common_type_compat(other)
@@ -4681,6 +4658,33 @@ def join(
return self._join_via_get_indexer(other, how, sort)
+ @final
+ def _join_empty(
+ self, other: Index, how: JoinHow, sort: bool
+ ) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+ assert len(self) == 0 or len(other) == 0
+ _validate_join_method(how)
+
+ lidx: np.ndarray | None
+ ridx: np.ndarray | None
+
+ if len(other):
+ how = cast(JoinHow, {"left": "right", "right": "left"}.get(how, how))
+ join_index, ridx, lidx = other._join_empty(self, how, sort)
+ elif how in ["left", "outer"]:
+ if sort and not self.is_monotonic_increasing:
+ lidx = self.argsort()
+ join_index = self.take(lidx)
+ else:
+ lidx = None
+ join_index = self._view()
+ ridx = np.broadcast_to(np.intp(-1), len(join_index))
+ else:
+ join_index = other._view()
+ lidx = np.array([], dtype=np.intp)
+ ridx = None
+ return join_index, lidx, ridx
+
@final
def _join_via_get_indexer(
self, other: Index, how: JoinHow, sort: bool
@@ -5913,17 +5917,14 @@ def sort_values(
(Index([1000, 100, 10, 1], dtype='int64'), array([3, 1, 0, 2]))
"""
if key is None and (
- self.is_monotonic_increasing or self.is_monotonic_decreasing
+ (ascending and self.is_monotonic_increasing)
+ or (not ascending and self.is_monotonic_decreasing)
):
- reverse = ascending != self.is_monotonic_increasing
- sorted_index = self[::-1] if reverse else self.copy()
if return_indexer:
indexer = np.arange(len(self), dtype=np.intp)
- if reverse:
- indexer = indexer[::-1]
- return sorted_index, indexer
+ return self.copy(), indexer
else:
- return sorted_index
+ return self.copy()
# GH 35584. Sort missing values according to na_position kwarg
# ignore na_position for MultiIndex
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 2a4e027e2b806..091ddbcc099be 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -774,7 +774,7 @@ def _values(self) -> np.ndarray:
):
vals = vals.astype(object)
- vals = np.array(vals, copy=False)
+ vals = np.asarray(vals)
vals = algos.take_nd(vals, codes, fill_value=index._na_value)
values.append(vals)
@@ -1309,7 +1309,7 @@ def copy( # type: ignore[override]
new_index._id = self._id
return new_index
- def __array__(self, dtype=None) -> np.ndarray:
+ def __array__(self, dtype=None, copy=None) -> np.ndarray:
"""the array interface, return my values"""
return self.values
@@ -3397,7 +3397,7 @@ def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
locs = (level_codes >= idx.start) & (level_codes < idx.stop)
return locs
- locs = np.array(level_codes == idx, dtype=bool, copy=False)
+ locs = np.asarray(level_codes == idx, dtype=bool)
if not locs.any():
# The label is present in self.levels[level] but unused:
@@ -3488,6 +3488,8 @@ def _to_bool_indexer(indexer) -> npt.NDArray[np.bool_]:
"is not the same length as the index"
)
lvl_indexer = np.asarray(k)
+ if indexer is None:
+ lvl_indexer = lvl_indexer.copy()
elif is_list_like(k):
# a collection of labels to include from this level (these are or'd)
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 4be7e17035128..869e511fc0720 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -57,6 +57,7 @@
ABCSeries,
)
from pandas.core.dtypes.missing import (
+ construct_1d_array_from_inferred_fill_value,
infer_fill_value,
is_valid_na_for_dtype,
isna,
@@ -68,7 +69,6 @@
from pandas.core.construction import (
array as pd_array,
extract_array,
- sanitize_array,
)
from pandas.core.indexers import (
check_array_indexer,
@@ -844,7 +844,6 @@ def _ensure_listlike_indexer(self, key, axis=None, value=None) -> None:
if self.ndim != 2:
return
- orig_key = key
if isinstance(key, tuple) and len(key) > 1:
# key may be a tuple if we are .loc
# if length of key is > 1 set key to column part
@@ -862,7 +861,7 @@ def _ensure_listlike_indexer(self, key, axis=None, value=None) -> None:
keys = self.obj.columns.union(key, sort=False)
diff = Index(key).difference(self.obj.columns, sort=False)
- if len(diff) and com.is_null_slice(orig_key[0]):
+ if len(diff):
# e.g. if we are doing df.loc[:, ["A", "B"]] = 7 and "B"
# is a new column, add the new columns with dtype=np.void
# so that later when we go through setitem_single_column
@@ -1878,12 +1877,9 @@ def _setitem_with_indexer(self, indexer, value, name: str = "iloc"):
self.obj[key] = empty_value
elif not is_list_like(value):
- # Find our empty_value dtype by constructing an array
- # from our value and doing a .take on it
- arr = sanitize_array(value, Index(range(1)), copy=False)
- taker = -1 * np.ones(len(self.obj), dtype=np.intp)
- empty_value = algos.take_nd(arr, taker)
- self.obj[key] = empty_value
+ self.obj[key] = construct_1d_array_from_inferred_fill_value(
+ value, len(self.obj)
+ )
else:
# FIXME: GH#42099#issuecomment-864326014
self.obj[key] = infer_fill_value(value)
@@ -2141,10 +2137,41 @@ def _setitem_single_column(self, loc: int, value, plane_indexer) -> None:
# If we're setting an entire column and we can't do it inplace,
# then we can use value's dtype (or inferred dtype)
# instead of object
+ dtype = self.obj.dtypes.iloc[loc]
+ if dtype not in (np.void, object) and not self.obj.empty:
+ # - Exclude np.void, as that is a special case for expansion.
+ # We want to warn for
+ # df = pd.DataFrame({'a': [1, 2]})
+ # df.loc[:, 'a'] = .3
+ # but not for
+ # df = pd.DataFrame({'a': [1, 2]})
+ # df.loc[:, 'b'] = .3
+ # - Exclude `object`, as then no upcasting happens.
+ # - Exclude empty initial object with enlargement,
+ # as then there's nothing to be inconsistent with.
+ warnings.warn(
+ f"Setting an item of incompatible dtype is deprecated "
+ "and will raise in a future error of pandas. "
+ f"Value '{value}' has dtype incompatible with {dtype}, "
+ "please explicitly cast to a compatible dtype first.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
self.obj.isetitem(loc, value)
else:
# set value into the column (first attempting to operate inplace, then
# falling back to casting if necessary)
+ dtype = self.obj.dtypes.iloc[loc]
+ if dtype == np.void:
+ # This means we're expanding, with multiple columns, e.g.
+ # df = pd.DataFrame({'A': [1,2,3], 'B': [4,5,6]})
+ # df.loc[df.index <= 2, ['F', 'G']] = (1, 'abc')
+ # Columns F and G will initially be set to np.void.
+ # Here, we replace those temporary `np.void` columns with
+ # columns of the appropriate dtype, based on `value`.
+ self.obj.iloc[:, loc] = construct_1d_array_from_inferred_fill_value(
+ value, len(self.obj)
+ )
self.obj._mgr.column_setitem(loc, plane_indexer, value)
self.obj._clear_item_cache()
diff --git a/pandas/core/interchange/buffer.py b/pandas/core/interchange/buffer.py
index a54e4428bd836..5d24325e67f62 100644
--- a/pandas/core/interchange/buffer.py
+++ b/pandas/core/interchange/buffer.py
@@ -12,6 +12,7 @@
if TYPE_CHECKING:
import numpy as np
+ import pyarrow as pa
class PandasBuffer(Buffer):
@@ -23,7 +24,7 @@ def __init__(self, x: np.ndarray, allow_copy: bool = True) -> None:
"""
Handle only regular columns (= numpy arrays) for now.
"""
- if not x.strides == (x.dtype.itemsize,):
+ if x.strides[0] and not x.strides == (x.dtype.itemsize,):
# The protocol does not support strided buffers, so a copy is
# necessary. If that's not allowed, we need to raise an exception.
if allow_copy:
@@ -76,3 +77,60 @@ def __repr__(self) -> str:
)
+ ")"
)
+
+
+class PandasBufferPyarrow(Buffer):
+ """
+ Data in the buffer is guaranteed to be contiguous in memory.
+ """
+
+ def __init__(
+ self,
+ buffer: pa.Buffer,
+ *,
+ length: int,
+ ) -> None:
+ """
+ Handle pyarrow chunked arrays.
+ """
+ self._buffer = buffer
+ self._length = length
+
+ @property
+ def bufsize(self) -> int:
+ """
+ Buffer size in bytes.
+ """
+ return self._buffer.size
+
+ @property
+ def ptr(self) -> int:
+ """
+ Pointer to start of the buffer as an integer.
+ """
+ return self._buffer.address
+
+ def __dlpack__(self) -> Any:
+ """
+ Represent this structure as DLPack interface.
+ """
+ raise NotImplementedError()
+
+ def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]:
+ """
+ Device type and device ID for where the data in the buffer resides.
+ """
+ return (DlpackDeviceType.CPU, None)
+
+ def __repr__(self) -> str:
+ return (
+ "PandasBuffer[pyarrow]("
+ + str(
+ {
+ "bufsize": self.bufsize,
+ "ptr": self.ptr,
+ "device": "CPU",
+ }
+ )
+ + ")"
+ )
diff --git a/pandas/core/interchange/column.py b/pandas/core/interchange/column.py
index acfbc5d9e6c62..d59a3df694bb3 100644
--- a/pandas/core/interchange/column.py
+++ b/pandas/core/interchange/column.py
@@ -1,6 +1,9 @@
from __future__ import annotations
-from typing import Any
+from typing import (
+ TYPE_CHECKING,
+ Any,
+)
import numpy as np
@@ -9,14 +12,18 @@
from pandas.errors import NoBufferPresent
from pandas.util._decorators import cache_readonly
-from pandas.core.dtypes.dtypes import (
+from pandas.core.dtypes.dtypes import BaseMaskedDtype
+
+import pandas as pd
+from pandas import (
ArrowDtype,
DatetimeTZDtype,
)
-
-import pandas as pd
from pandas.api.types import is_string_dtype
-from pandas.core.interchange.buffer import PandasBuffer
+from pandas.core.interchange.buffer import (
+ PandasBuffer,
+ PandasBufferPyarrow,
+)
from pandas.core.interchange.dataframe_protocol import (
Column,
ColumnBuffers,
@@ -29,6 +36,9 @@
dtype_to_arrow_c_fmt,
)
+if TYPE_CHECKING:
+ from pandas.core.interchange.dataframe_protocol import Buffer
+
_NP_KINDS = {
"i": DtypeKind.INT,
"u": DtypeKind.UINT,
@@ -76,6 +86,14 @@ def __init__(self, column: pd.Series, allow_copy: bool = True) -> None:
Note: doesn't deal with extension arrays yet, just assume a regular
Series/ndarray for now.
"""
+ if isinstance(column, pd.DataFrame):
+ raise TypeError(
+ "Expected a Series, got a DataFrame. This likely happened "
+ "because you called __dataframe__ on a DataFrame which, "
+ "after converting column names to string, resulted in duplicated "
+ f"names: {column.columns}. Please rename these columns before "
+ "using the interchange protocol."
+ )
if not isinstance(column, pd.Series):
raise NotImplementedError(f"Columns of type {type(column)} not handled yet")
@@ -116,7 +134,7 @@ def dtype(self) -> tuple[DtypeKind, int, str, str]:
Endianness.NATIVE,
)
elif is_string_dtype(dtype):
- if infer_dtype(self._col) == "string":
+ if infer_dtype(self._col) in ("string", "empty"):
return (
DtypeKind.STRING,
8,
@@ -143,9 +161,21 @@ def _dtype_from_pandasdtype(self, dtype) -> tuple[DtypeKind, int, str, str]:
byteorder = dtype.numpy_dtype.byteorder
elif isinstance(dtype, DatetimeTZDtype):
byteorder = dtype.base.byteorder # type: ignore[union-attr]
+ elif isinstance(dtype, BaseMaskedDtype):
+ byteorder = dtype.numpy_dtype.byteorder
else:
byteorder = dtype.byteorder
+ if dtype == "bool[pyarrow]":
+ # return early to avoid the `* 8` below, as this is a bitmask
+ # rather than a bytemask
+ return (
+ kind,
+ dtype.itemsize, # pyright: ignore[reportGeneralTypeIssues]
+ ArrowCTypes.BOOL,
+ byteorder,
+ )
+
return kind, dtype.itemsize * 8, dtype_to_arrow_c_fmt(dtype), byteorder
@property
@@ -179,6 +209,16 @@ def describe_categorical(self):
@property
def describe_null(self):
+ if isinstance(self._col.dtype, BaseMaskedDtype):
+ column_null_dtype = ColumnNullType.USE_BYTEMASK
+ null_value = 1
+ return column_null_dtype, null_value
+ if isinstance(self._col.dtype, ArrowDtype):
+ # We already rechunk (if necessary / allowed) upon initialization, so this
+ # is already single-chunk by the time we get here.
+ if self._col.array._pa_array.chunks[0].buffers()[0] is None: # type: ignore[attr-defined]
+ return ColumnNullType.NON_NULLABLE, None
+ return ColumnNullType.USE_BITMASK, 0
kind = self.dtype[0]
try:
null, value = _NULL_DESCRIPTION[kind]
@@ -263,10 +303,11 @@ def get_buffers(self) -> ColumnBuffers:
def _get_data_buffer(
self,
- ) -> tuple[PandasBuffer, Any]: # Any is for self.dtype tuple
+ ) -> tuple[Buffer, tuple[DtypeKind, int, str, str]]:
"""
Return the buffer containing the data and the buffer's associated dtype.
"""
+ buffer: Buffer
if self.dtype[0] in (
DtypeKind.INT,
DtypeKind.UINT,
@@ -276,12 +317,25 @@ def _get_data_buffer(
):
# self.dtype[2] is an ArrowCTypes.TIMESTAMP where the tz will make
# it longer than 4 characters
+ dtype = self.dtype
if self.dtype[0] == DtypeKind.DATETIME and len(self.dtype[2]) > 4:
np_arr = self._col.dt.tz_convert(None).to_numpy()
else:
- np_arr = self._col.to_numpy()
+ arr = self._col.array
+ if isinstance(self._col.dtype, BaseMaskedDtype):
+ np_arr = arr._data # type: ignore[attr-defined]
+ elif isinstance(self._col.dtype, ArrowDtype):
+ # We already rechunk (if necessary / allowed) upon initialization,
+ # so this is already single-chunk by the time we get here.
+ arr = arr._pa_array.chunks[0] # type: ignore[attr-defined]
+ buffer = PandasBufferPyarrow(
+ arr.buffers()[1], # type: ignore[attr-defined]
+ length=len(arr),
+ )
+ return buffer, dtype
+ else:
+ np_arr = arr._ndarray # type: ignore[attr-defined]
buffer = PandasBuffer(np_arr, allow_copy=self._allow_copy)
- dtype = self.dtype
elif self.dtype[0] == DtypeKind.CATEGORICAL:
codes = self._col.values._codes
buffer = PandasBuffer(codes, allow_copy=self._allow_copy)
@@ -301,24 +355,40 @@ def _get_data_buffer(
buffer = PandasBuffer(np.frombuffer(b, dtype="uint8"))
# Define the dtype for the returned buffer
- dtype = (
- DtypeKind.STRING,
- 8,
- ArrowCTypes.STRING,
- Endianness.NATIVE,
- ) # note: currently only support native endianness
+ # TODO: this will need correcting
+ # https://github.com/pandas-dev/pandas/issues/54781
+ dtype = self.dtype
else:
raise NotImplementedError(f"Data type {self._col.dtype} not handled yet")
return buffer, dtype
- def _get_validity_buffer(self) -> tuple[PandasBuffer, Any]:
+ def _get_validity_buffer(self) -> tuple[Buffer, Any] | None:
"""
Return the buffer containing the mask values indicating missing data and
the buffer's associated dtype.
Raises NoBufferPresent if null representation is not a bit or byte mask.
"""
null, invalid = self.describe_null
+ buffer: Buffer
+ if isinstance(self._col.dtype, ArrowDtype):
+ # We already rechunk (if necessary / allowed) upon initialization, so this
+ # is already single-chunk by the time we get here.
+ arr = self._col.array._pa_array.chunks[0] # type: ignore[attr-defined]
+ dtype = (DtypeKind.BOOL, 1, ArrowCTypes.BOOL, Endianness.NATIVE)
+ if arr.buffers()[0] is None:
+ return None
+ buffer = PandasBufferPyarrow(
+ arr.buffers()[0],
+ length=len(arr),
+ )
+ return buffer, dtype
+
+ if isinstance(self._col.dtype, BaseMaskedDtype):
+ mask = self._col.array._mask # type: ignore[attr-defined]
+ buffer = PandasBuffer(mask)
+ dtype = (DtypeKind.BOOL, 8, ArrowCTypes.BOOL, Endianness.NATIVE)
+ return buffer, dtype
if self.dtype[0] == DtypeKind.STRING:
# For now, use byte array as the mask.
diff --git a/pandas/core/interchange/dataframe.py b/pandas/core/interchange/dataframe.py
index 4f08b2c2b3a7b..1abacddfc7e3b 100644
--- a/pandas/core/interchange/dataframe.py
+++ b/pandas/core/interchange/dataframe.py
@@ -5,6 +5,7 @@
from pandas.core.interchange.column import PandasColumn
from pandas.core.interchange.dataframe_protocol import DataFrame as DataFrameXchg
+from pandas.core.interchange.utils import maybe_rechunk
if TYPE_CHECKING:
from collections.abc import (
@@ -32,8 +33,12 @@ def __init__(self, df: DataFrame, allow_copy: bool = True) -> None:
Constructor - an instance of this (private) class is returned from
`pd.DataFrame.__dataframe__`.
"""
- self._df = df
+ self._df = df.rename(columns=str, copy=False)
self._allow_copy = allow_copy
+ for i, _col in enumerate(self._df.columns):
+ rechunked = maybe_rechunk(self._df.iloc[:, i], allow_copy=allow_copy)
+ if rechunked is not None:
+ self._df.isetitem(i, rechunked)
def __dataframe__(
self, nan_as_null: bool = False, allow_copy: bool = True
diff --git a/pandas/core/interchange/from_dataframe.py b/pandas/core/interchange/from_dataframe.py
index d45ae37890ba7..4162ebc33f0d6 100644
--- a/pandas/core/interchange/from_dataframe.py
+++ b/pandas/core/interchange/from_dataframe.py
@@ -295,13 +295,14 @@ def string_column_to_ndarray(col: Column) -> tuple[np.ndarray, Any]:
null_pos = None
if null_kind in (ColumnNullType.USE_BITMASK, ColumnNullType.USE_BYTEMASK):
- assert buffers["validity"], "Validity buffers cannot be empty for masks"
- valid_buff, valid_dtype = buffers["validity"]
- null_pos = buffer_to_ndarray(
- valid_buff, valid_dtype, offset=col.offset, length=col.size()
- )
- if sentinel_val == 0:
- null_pos = ~null_pos
+ validity = buffers["validity"]
+ if validity is not None:
+ valid_buff, valid_dtype = validity
+ null_pos = buffer_to_ndarray(
+ valid_buff, valid_dtype, offset=col.offset, length=col.size()
+ )
+ if sentinel_val == 0:
+ null_pos = ~null_pos
# Assemble the strings from the code units
str_list: list[None | float | str] = [None] * col.size()
@@ -486,6 +487,8 @@ def set_nulls(
np.ndarray or pd.Series
Data with the nulls being set.
"""
+ if validity is None:
+ return data
null_kind, sentinel_val = col.describe_null
null_pos = None
diff --git a/pandas/core/interchange/utils.py b/pandas/core/interchange/utils.py
index 4ac063080e62d..fd1c7c9639242 100644
--- a/pandas/core/interchange/utils.py
+++ b/pandas/core/interchange/utils.py
@@ -16,6 +16,8 @@
DatetimeTZDtype,
)
+import pandas as pd
+
if typing.TYPE_CHECKING:
from pandas._typing import DtypeObj
@@ -37,6 +39,7 @@
"float": "f", # float32
"double": "g", # float64
"string": "u",
+ "large_string": "U",
"binary": "z",
"time32[s]": "tts",
"time32[ms]": "ttm",
@@ -141,6 +144,35 @@ def dtype_to_arrow_c_fmt(dtype: DtypeObj) -> str:
elif isinstance(dtype, DatetimeTZDtype):
return ArrowCTypes.TIMESTAMP.format(resolution=dtype.unit[0], tz=dtype.tz)
+ elif isinstance(dtype, pd.BooleanDtype):
+ return ArrowCTypes.BOOL
+
raise NotImplementedError(
f"Conversion of {dtype} to Arrow C format string is not implemented."
)
+
+
+def maybe_rechunk(series: pd.Series, *, allow_copy: bool) -> pd.Series | None:
+ """
+ Rechunk a multi-chunk pyarrow array into a single-chunk array, if necessary.
+
+ - Returns `None` if the input series is not backed by a multi-chunk pyarrow array
+ (and so doesn't need rechunking)
+ - Returns a single-chunk-backed-Series if the input is backed by a multi-chunk
+ pyarrow array and `allow_copy` is `True`.
+ - Raises a `RuntimeError` if `allow_copy` is `False` and input is a
+ based by a multi-chunk pyarrow array.
+ """
+ if not isinstance(series.dtype, pd.ArrowDtype):
+ return None
+ chunked_array = series.array._pa_array # type: ignore[attr-defined]
+ if len(chunked_array.chunks) == 1:
+ return None
+ if not allow_copy:
+ raise RuntimeError(
+ "Found multi-chunk pyarrow array, but `allow_copy` is False. "
+ "Please rechunk the array before calling this function, or set "
+ "`allow_copy=True`."
+ )
+ arr = chunked_array.combine_chunks()
+ return pd.Series(arr, dtype=series.dtype, name=series.name, index=series.index)
diff --git a/pandas/core/internals/api.py b/pandas/core/internals/api.py
index e5ef44d07061e..b0b3937ca47ea 100644
--- a/pandas/core/internals/api.py
+++ b/pandas/core/internals/api.py
@@ -9,12 +9,10 @@
from __future__ import annotations
from typing import TYPE_CHECKING
-import warnings
import numpy as np
from pandas._libs.internals import BlockPlacement
-from pandas.util._exceptions import find_stack_level
from pandas.core.dtypes.common import pandas_dtype
from pandas.core.dtypes.dtypes import (
@@ -52,14 +50,6 @@ def make_block(
- Block.make_block_same_class
- Block.__init__
"""
- warnings.warn(
- # GH#40226
- "make_block is deprecated and will be removed in a future version. "
- "Use public APIs instead.",
- DeprecationWarning,
- stacklevel=find_stack_level(),
- )
-
if dtype is not None:
dtype = pandas_dtype(dtype)
@@ -123,6 +113,7 @@ def maybe_infer_ndim(values, placement: BlockPlacement, ndim: int | None) -> int
def __getattr__(name: str):
# GH#55139
+ import warnings
if name in [
"Block",
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 20eff9315bc80..259e969112dd7 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1,6 +1,7 @@
from __future__ import annotations
from functools import wraps
+import inspect
import re
from typing import (
TYPE_CHECKING,
@@ -498,6 +499,9 @@ def coerce_to_target_dtype(self, other, warn_on_upcast: bool = False) -> Block:
and is_integer_dtype(self.values.dtype)
and isna(other)
and other is not NaT
+ and not (
+ isinstance(other, (np.datetime64, np.timedelta64)) and np.isnat(other)
+ )
):
warn_on_upcast = False
elif (
@@ -512,7 +516,7 @@ def coerce_to_target_dtype(self, other, warn_on_upcast: bool = False) -> Block:
if warn_on_upcast:
warnings.warn(
f"Setting an item of incompatible dtype is deprecated "
- "and will raise in a future error of pandas. "
+ "and will raise an error in a future version of pandas. "
f"Value '{other}' has dtype incompatible with {self.values.dtype}, "
"please explicitly cast to a compatible dtype first.",
FutureWarning,
@@ -1421,7 +1425,14 @@ def setitem(self, indexer, value, using_cow: bool = False) -> Block:
if isinstance(casted, np.ndarray) and casted.ndim == 1 and len(casted) == 1:
# NumPy 1.25 deprecation: https://github.com/numpy/numpy/pull/10615
casted = casted[0, ...]
- values[indexer] = casted
+ try:
+ values[indexer] = casted
+ except (TypeError, ValueError) as err:
+ if is_list_like(casted):
+ raise ValueError(
+ "setting an array element with a sequence."
+ ) from err
+ raise
return self
def putmask(
@@ -2256,11 +2267,21 @@ def pad_or_backfill(
) -> list[Block]:
values = self.values
+ kwargs: dict[str, Any] = {"method": method, "limit": limit}
+ if "limit_area" in inspect.signature(values._pad_or_backfill).parameters:
+ kwargs["limit_area"] = limit_area
+ elif limit_area is not None:
+ raise NotImplementedError(
+ f"{type(values).__name__} does not implement limit_area "
+ "(added in pandas 2.2). 3rd-party ExtnsionArray authors "
+ "need to add this argument to _pad_or_backfill."
+ )
+
if values.ndim == 2 and axis == 1:
# NDArrayBackedExtensionArray.fillna assumes axis=0
- new_values = values.T._pad_or_backfill(method=method, limit=limit).T
+ new_values = values.T._pad_or_backfill(**kwargs).T
else:
- new_values = values._pad_or_backfill(method=method, limit=limit)
+ new_values = values._pad_or_backfill(**kwargs)
return [self.make_block_same_class(new_values)]
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index 3719bf1f77f85..2e0e04717373f 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -12,7 +12,6 @@
cast,
)
import warnings
-import weakref
import numpy as np
@@ -282,8 +281,8 @@ def references_same_values(self, mgr: BaseBlockManager, blkno: int) -> bool:
Checks if two blocks from two different block managers reference the
same underlying values.
"""
- ref = weakref.ref(self.blocks[blkno])
- return ref in mgr.blocks[blkno].refs.referenced_blocks
+ blk = self.blocks[blkno]
+ return any(blk is ref() for ref in mgr.blocks[blkno].refs.referenced_blocks)
def get_dtypes(self) -> npt.NDArray[np.object_]:
dtypes = np.array([blk.dtype for blk in self.blocks], dtype=object)
@@ -1683,6 +1682,8 @@ def as_array(
na_value=na_value,
copy=copy,
).reshape(blk.shape)
+ elif not copy:
+ arr = np.asarray(blk.values, dtype=dtype)
else:
arr = np.array(blk.values, dtype=dtype, copy=copy)
diff --git a/pandas/core/methods/to_dict.py b/pandas/core/methods/to_dict.py
index 7bd4851425c3b..accbd92a91ed6 100644
--- a/pandas/core/methods/to_dict.py
+++ b/pandas/core/methods/to_dict.py
@@ -171,13 +171,9 @@ def to_dict(
return into_c(
(
k,
- list(
- map(
- maybe_box_native, v.to_numpy(na_value=box_na_values[i]).tolist()
- )
- )
+ list(map(maybe_box_native, v.to_numpy(na_value=box_na_values[i])))
if i in object_dtype_indices_as_set
- else v.to_numpy().tolist(),
+ else list(map(maybe_box_native, v.to_numpy())),
)
for i, (k, v) in enumerate(df.items())
)
diff --git a/pandas/core/missing.py b/pandas/core/missing.py
index d275445983b6f..c016aab8ad074 100644
--- a/pandas/core/missing.py
+++ b/pandas/core/missing.py
@@ -3,10 +3,7 @@
"""
from __future__ import annotations
-from functools import (
- partial,
- wraps,
-)
+from functools import wraps
from typing import (
TYPE_CHECKING,
Any,
@@ -34,6 +31,7 @@
from pandas.core.dtypes.cast import infer_dtype_from
from pandas.core.dtypes.common import (
is_array_like,
+ is_bool_dtype,
is_numeric_dtype,
is_numeric_v_string_like,
is_object_dtype,
@@ -103,21 +101,34 @@ def mask_missing(arr: ArrayLike, values_to_mask) -> npt.NDArray[np.bool_]:
# GH 21977
mask = np.zeros(arr.shape, dtype=bool)
- for x in nonna:
- if is_numeric_v_string_like(arr, x):
- # GH#29553 prevent numpy deprecation warnings
- pass
- else:
- if potential_na:
- new_mask = np.zeros(arr.shape, dtype=np.bool_)
- new_mask[arr_mask] = arr[arr_mask] == x
+ if (
+ is_numeric_dtype(arr.dtype)
+ and not is_bool_dtype(arr.dtype)
+ and is_bool_dtype(nonna.dtype)
+ ):
+ pass
+ elif (
+ is_bool_dtype(arr.dtype)
+ and is_numeric_dtype(nonna.dtype)
+ and not is_bool_dtype(nonna.dtype)
+ ):
+ pass
+ else:
+ for x in nonna:
+ if is_numeric_v_string_like(arr, x):
+ # GH#29553 prevent numpy deprecation warnings
+ pass
else:
- new_mask = arr == x
+ if potential_na:
+ new_mask = np.zeros(arr.shape, dtype=np.bool_)
+ new_mask[arr_mask] = arr[arr_mask] == x
+ else:
+ new_mask = arr == x
- if not isinstance(new_mask, np.ndarray):
- # usually BooleanArray
- new_mask = new_mask.to_numpy(dtype=bool, na_value=False)
- mask |= new_mask
+ if not isinstance(new_mask, np.ndarray):
+ # usually BooleanArray
+ new_mask = new_mask.to_numpy(dtype=bool, na_value=False)
+ mask |= new_mask
if na_mask.any():
mask |= isna(arr)
@@ -338,6 +349,7 @@ def interpolate_2d_inplace(
limit_direction: str = "forward",
limit_area: str | None = None,
fill_value: Any | None = None,
+ mask=None,
**kwargs,
) -> None:
"""
@@ -385,6 +397,7 @@ def func(yvalues: np.ndarray) -> None:
limit_area=limit_area_validated,
fill_value=fill_value,
bounds_error=False,
+ mask=mask,
**kwargs,
)
@@ -429,6 +442,7 @@ def _interpolate_1d(
fill_value: Any | None = None,
bounds_error: bool = False,
order: int | None = None,
+ mask=None,
**kwargs,
) -> None:
"""
@@ -442,8 +456,10 @@ def _interpolate_1d(
-----
Fills 'yvalues' in-place.
"""
-
- invalid = isna(yvalues)
+ if mask is not None:
+ invalid = mask
+ else:
+ invalid = isna(yvalues)
valid = ~invalid
if not valid.any():
@@ -520,7 +536,10 @@ def _interpolate_1d(
**kwargs,
)
- if is_datetimelike:
+ if mask is not None:
+ mask[:] = False
+ mask[preserve_nans] = True
+ elif is_datetimelike:
yvalues[preserve_nans] = NaT.value
else:
yvalues[preserve_nans] = np.nan
@@ -823,6 +842,7 @@ def _interpolate_with_limit_area(
values,
method=method,
limit=limit,
+ limit_area=limit_area,
)
if limit_area == "inside":
@@ -863,27 +883,6 @@ def pad_or_backfill_inplace(
-----
Modifies values in-place.
"""
- if limit_area is not None:
- np.apply_along_axis(
- # error: Argument 1 to "apply_along_axis" has incompatible type
- # "partial[None]"; expected
- # "Callable[..., Union[_SupportsArray[dtype[<nothing>]],
- # Sequence[_SupportsArray[dtype[<nothing>]]],
- # Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]],
- # Sequence[Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]]],
- # Sequence[Sequence[Sequence[Sequence[_
- # SupportsArray[dtype[<nothing>]]]]]]]]"
- partial( # type: ignore[arg-type]
- _interpolate_with_limit_area,
- method=method,
- limit=limit,
- limit_area=limit_area,
- ),
- axis,
- values,
- )
- return
-
transf = (lambda x: x) if axis == 0 else (lambda x: x.T)
# reshape a 1 dim if needed
@@ -897,8 +896,7 @@ def pad_or_backfill_inplace(
func = get_fill_func(method, ndim=2)
# _pad_2d and _backfill_2d both modify tvalues inplace
- func(tvalues, limit=limit)
- return
+ func(tvalues, limit=limit, limit_area=limit_area)
def _fillna_prep(
@@ -909,7 +907,6 @@ def _fillna_prep(
if mask is None:
mask = isna(values)
- mask = mask.view(np.uint8)
return mask
@@ -919,16 +916,23 @@ def _datetimelike_compat(func: F) -> F:
"""
@wraps(func)
- def new_func(values, limit: int | None = None, mask=None):
+ def new_func(
+ values,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ mask=None,
+ ):
if needs_i8_conversion(values.dtype):
if mask is None:
# This needs to occur before casting to int64
mask = isna(values)
- result, mask = func(values.view("i8"), limit=limit, mask=mask)
+ result, mask = func(
+ values.view("i8"), limit=limit, limit_area=limit_area, mask=mask
+ )
return result.view(values.dtype), mask
- return func(values, limit=limit, mask=mask)
+ return func(values, limit=limit, limit_area=limit_area, mask=mask)
return cast(F, new_func)
@@ -937,9 +941,12 @@ def new_func(values, limit: int | None = None, mask=None):
def _pad_1d(
values: np.ndarray,
limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
mask: npt.NDArray[np.bool_] | None = None,
) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
mask = _fillna_prep(values, mask)
+ if limit_area is not None and not mask.all():
+ _fill_limit_area_1d(mask, limit_area)
algos.pad_inplace(values, mask, limit=limit)
return values, mask
@@ -948,9 +955,12 @@ def _pad_1d(
def _backfill_1d(
values: np.ndarray,
limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
mask: npt.NDArray[np.bool_] | None = None,
) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
mask = _fillna_prep(values, mask)
+ if limit_area is not None and not mask.all():
+ _fill_limit_area_1d(mask, limit_area)
algos.backfill_inplace(values, mask, limit=limit)
return values, mask
@@ -959,9 +969,12 @@ def _backfill_1d(
def _pad_2d(
values: np.ndarray,
limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
mask: npt.NDArray[np.bool_] | None = None,
):
mask = _fillna_prep(values, mask)
+ if limit_area is not None:
+ _fill_limit_area_2d(mask, limit_area)
if values.size:
algos.pad_2d_inplace(values, mask, limit=limit)
@@ -973,9 +986,14 @@ def _pad_2d(
@_datetimelike_compat
def _backfill_2d(
- values, limit: int | None = None, mask: npt.NDArray[np.bool_] | None = None
+ values,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ mask: npt.NDArray[np.bool_] | None = None,
):
mask = _fillna_prep(values, mask)
+ if limit_area is not None:
+ _fill_limit_area_2d(mask, limit_area)
if values.size:
algos.backfill_2d_inplace(values, mask, limit=limit)
@@ -985,6 +1003,63 @@ def _backfill_2d(
return values, mask
+def _fill_limit_area_1d(
+ mask: npt.NDArray[np.bool_], limit_area: Literal["outside", "inside"]
+) -> None:
+ """Prepare 1d mask for ffill/bfill with limit_area.
+
+ Caller is responsible for checking at least one value of mask is False.
+ When called, mask will no longer faithfully represent when
+ the corresponding are NA or not.
+
+ Parameters
+ ----------
+ mask : np.ndarray[bool, ndim=1]
+ Mask representing NA values when filling.
+ limit_area : { "outside", "inside" }
+ Whether to limit filling to outside or inside the outer most non-NA value.
+ """
+ neg_mask = ~mask
+ first = neg_mask.argmax()
+ last = len(neg_mask) - neg_mask[::-1].argmax() - 1
+ if limit_area == "inside":
+ mask[:first] = False
+ mask[last + 1 :] = False
+ elif limit_area == "outside":
+ mask[first + 1 : last] = False
+
+
+def _fill_limit_area_2d(
+ mask: npt.NDArray[np.bool_], limit_area: Literal["outside", "inside"]
+) -> None:
+ """Prepare 2d mask for ffill/bfill with limit_area.
+
+ When called, mask will no longer faithfully represent when
+ the corresponding are NA or not.
+
+ Parameters
+ ----------
+ mask : np.ndarray[bool, ndim=1]
+ Mask representing NA values when filling.
+ limit_area : { "outside", "inside" }
+ Whether to limit filling to outside or inside the outer most non-NA value.
+ """
+ neg_mask = ~mask.T
+ if limit_area == "outside":
+ # Identify inside
+ la_mask = (
+ np.maximum.accumulate(neg_mask, axis=0)
+ & np.maximum.accumulate(neg_mask[::-1], axis=0)[::-1]
+ )
+ else:
+ # Identify outside
+ la_mask = (
+ ~np.maximum.accumulate(neg_mask, axis=0)
+ | ~np.maximum.accumulate(neg_mask[::-1], axis=0)[::-1]
+ )
+ mask[la_mask.T] = False
+
+
_fill_methods = {"pad": _pad_1d, "backfill": _backfill_1d}
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 48a5f85e1c388..0dd808a0ab296 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -1306,12 +1306,15 @@ def first(
self,
numeric_only: bool = False,
min_count: int = 0,
+ skipna: bool = True,
*args,
**kwargs,
):
maybe_warn_args_and_kwargs(type(self), "first", args, kwargs)
nv.validate_resampler_func("first", args, kwargs)
- return self._downsample("first", numeric_only=numeric_only, min_count=min_count)
+ return self._downsample(
+ "first", numeric_only=numeric_only, min_count=min_count, skipna=skipna
+ )
@final
@doc(GroupBy.last)
@@ -1319,12 +1322,15 @@ def last(
self,
numeric_only: bool = False,
min_count: int = 0,
+ skipna: bool = True,
*args,
**kwargs,
):
maybe_warn_args_and_kwargs(type(self), "last", args, kwargs)
nv.validate_resampler_func("last", args, kwargs)
- return self._downsample("last", numeric_only=numeric_only, min_count=min_count)
+ return self._downsample(
+ "last", numeric_only=numeric_only, min_count=min_count, skipna=skipna
+ )
@final
@doc(GroupBy.median)
@@ -2542,7 +2548,8 @@ def _take_new_index(
if axis == 1:
raise NotImplementedError("axis 1 is not supported")
new_mgr = obj._mgr.reindex_indexer(new_axis=new_index, indexer=indexer, axis=1)
- return obj._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+ # error: Incompatible return value type (got "DataFrame", expected "NDFrameT")
+ return obj._constructor_from_mgr(new_mgr, axes=new_mgr.axes) # type: ignore[return-value]
else:
raise ValueError("'obj' should be either a Series or a DataFrame")
@@ -2906,7 +2913,7 @@ def _apply(
new_message = _apply_groupings_depr.format("DataFrameGroupBy", "resample")
with rewrite_warning(
target_message=target_message,
- target_category=FutureWarning,
+ target_category=DeprecationWarning,
new_message=new_message,
):
result = grouped.apply(how, *args, include_groups=include_groups, **kwargs)
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index aacea92611697..dc18bb65b35bc 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -205,8 +205,10 @@ def concat(
Check whether the new concatenated axis contains duplicates. This can
be very expensive relative to the actual data concatenation.
sort : bool, default False
- Sort non-concatenation axis if it is not already aligned.
-
+ Sort non-concatenation axis if it is not already aligned. One exception to
+ this is when the non-concatentation axis is a DatetimeIndex and join='outer'
+ and the axis is not already aligned. In that case, the non-concatenation
+ axis is always sorted lexicographically.
copy : bool, default True
If False, do not copy data unnecessarily.
diff --git a/pandas/core/reshape/melt.py b/pandas/core/reshape/melt.py
index bb1cd0d738dac..e54f847895f1a 100644
--- a/pandas/core/reshape/melt.py
+++ b/pandas/core/reshape/melt.py
@@ -458,8 +458,7 @@ def wide_to_long(
def get_var_names(df, stub: str, sep: str, suffix: str):
regex = rf"^{re.escape(stub)}{re.escape(sep)}{suffix}$"
- pattern = re.compile(regex)
- return df.columns[df.columns.str.match(pattern)]
+ return df.columns[df.columns.str.match(regex)]
def melt_stub(df, stub: str, i, j, value_vars, sep: str):
newdf = melt(
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 690e3c2700c6c..646f40f6141d8 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -1526,6 +1526,11 @@ def _maybe_coerce_merge_keys(self) -> None:
) or (lk.dtype.kind == "M" and rk.dtype.kind == "M"):
# allows datetime with different resolutions
continue
+ # datetime and timedelta not allowed
+ elif lk.dtype.kind == "M" and rk.dtype.kind == "m":
+ raise ValueError(msg)
+ elif lk.dtype.kind == "m" and rk.dtype.kind == "M":
+ raise ValueError(msg)
elif is_object_dtype(lk.dtype) and is_object_dtype(rk.dtype):
continue
@@ -1925,10 +1930,9 @@ def get_result(self, copy: bool | None = True) -> DataFrame:
if self.fill_method == "ffill":
if left_indexer is None:
- raise TypeError("left_indexer cannot be None")
- left_indexer = cast("npt.NDArray[np.intp]", left_indexer)
- right_indexer = cast("npt.NDArray[np.intp]", right_indexer)
- left_join_indexer = libjoin.ffill_indexer(left_indexer)
+ left_join_indexer = None
+ else:
+ left_join_indexer = libjoin.ffill_indexer(left_indexer)
if right_indexer is None:
right_join_indexer = None
else:
@@ -2483,18 +2487,30 @@ def _factorize_keys(
.combine_chunks()
.dictionary_encode()
)
- length = len(dc.dictionary)
llab, rlab, count = (
- pc.fill_null(dc.indices[slice(len_lk)], length)
+ pc.fill_null(dc.indices[slice(len_lk)], -1)
.to_numpy()
.astype(np.intp, copy=False),
- pc.fill_null(dc.indices[slice(len_lk, None)], length)
+ pc.fill_null(dc.indices[slice(len_lk, None)], -1)
.to_numpy()
.astype(np.intp, copy=False),
len(dc.dictionary),
)
+
+ if sort:
+ uniques = dc.dictionary.to_numpy(zero_copy_only=False)
+ llab, rlab = _sort_labels(uniques, llab, rlab)
+
if dc.null_count > 0:
+ lmask = llab == -1
+ lany = lmask.any()
+ rmask = rlab == -1
+ rany = rmask.any()
+ if lany:
+ np.putmask(llab, lmask, count)
+ if rany:
+ np.putmask(rlab, rmask, count)
count += 1
return llab, rlab, count
diff --git a/pandas/core/series.py b/pandas/core/series.py
index e3b401cd3c88b..6fd019656d207 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -67,6 +67,9 @@
from pandas.core.dtypes.astype import astype_is_view
from pandas.core.dtypes.cast import (
LossySetitemError,
+ construct_1d_arraylike_from_scalar,
+ find_common_type,
+ infer_dtype_from,
maybe_box_native,
maybe_cast_pointwise_result,
)
@@ -83,8 +86,12 @@
from pandas.core.dtypes.dtypes import (
CategoricalDtype,
ExtensionDtype,
+ SparseDtype,
+)
+from pandas.core.dtypes.generic import (
+ ABCDataFrame,
+ ABCSeries,
)
-from pandas.core.dtypes.generic import ABCDataFrame
from pandas.core.dtypes.inference import is_hashable
from pandas.core.dtypes.missing import (
isna,
@@ -113,6 +120,7 @@
from pandas.core.arrays.sparse import SparseAccessor
from pandas.core.arrays.string_ import StringDtype
from pandas.core.construction import (
+ array as pd_array,
extract_array,
sanitize_array,
)
@@ -525,7 +533,7 @@ def __init__(
data = data.reindex(index, copy=copy)
copy = False
data = data._mgr
- elif is_dict_like(data):
+ elif isinstance(data, Mapping):
data, index = self._init_dict(data, index, dtype)
dtype = None
copy = False
@@ -597,7 +605,7 @@ def __init__(
)
def _init_dict(
- self, data, index: Index | None = None, dtype: DtypeObj | None = None
+ self, data: Mapping, index: Index | None = None, dtype: DtypeObj | None = None
):
"""
Derive the "_mgr" and "index" attributes of a new Series from a
@@ -654,14 +662,17 @@ def _constructor(self) -> Callable[..., Series]:
return Series
def _constructor_from_mgr(self, mgr, axes):
- if self._constructor is Series:
- # we are pandas.Series (or a subclass that doesn't override _constructor)
- ser = Series._from_mgr(mgr, axes=axes)
- ser._name = None # caller is responsible for setting real name
+ ser = Series._from_mgr(mgr, axes=axes)
+ ser._name = None # caller is responsible for setting real name
+
+ if type(self) is Series:
+ # This would also work `if self._constructor is Series`, but
+ # this check is slightly faster, benefiting the most-common case.
return ser
- else:
- assert axes is mgr.axes
- return self._constructor(mgr)
+
+ # We assume that the subclass __init__ knows how to handle a
+ # pd.Series object.
+ return self._constructor(ser)
@property
def _constructor_expanddim(self) -> Callable[..., DataFrame]:
@@ -673,18 +684,19 @@ def _constructor_expanddim(self) -> Callable[..., DataFrame]:
return DataFrame
- def _expanddim_from_mgr(self, mgr, axes) -> DataFrame:
+ def _constructor_expanddim_from_mgr(self, mgr, axes):
from pandas.core.frame import DataFrame
- return DataFrame._from_mgr(mgr, axes=mgr.axes)
+ df = DataFrame._from_mgr(mgr, axes=mgr.axes)
- def _constructor_expanddim_from_mgr(self, mgr, axes):
- from pandas.core.frame import DataFrame
+ if type(self) is Series:
+ # This would also work `if self._constructor_expanddim is DataFrame`,
+ # but this check is slightly faster, benefiting the most-common case.
+ return df
- if self._constructor_expanddim is DataFrame:
- return self._expanddim_from_mgr(mgr, axes)
- assert axes is mgr.axes
- return self._constructor_expanddim(mgr)
+ # We assume that the subclass __init__ knows how to handle a
+ # pd.DataFrame object.
+ return self._constructor_expanddim(df)
# types
@property
@@ -963,7 +975,9 @@ def view(self, dtype: Dtype | None = None) -> Series:
# ----------------------------------------------------------------------
# NDArray Compat
- def __array__(self, dtype: npt.DTypeLike | None = None) -> np.ndarray:
+ def __array__(
+ self, dtype: npt.DTypeLike | None = None, copy: bool | None = None
+ ) -> np.ndarray:
"""
Return the values as a NumPy array.
@@ -976,6 +990,9 @@ def __array__(self, dtype: npt.DTypeLike | None = None) -> np.ndarray:
The dtype to use for the resulting NumPy array. By default,
the dtype is inferred from the data.
+ copy : bool or None, optional
+ Unused.
+
Returns
-------
numpy.ndarray
@@ -2788,13 +2805,11 @@ def round(self, decimals: int = 0, *args, **kwargs) -> Series:
dtype: float64
"""
nv.validate_round(args, kwargs)
- result = self._values.round(decimals)
- result = self._constructor(result, index=self.index, copy=False).__finalize__(
+ new_mgr = self._mgr.round(decimals=decimals, using_cow=using_copy_on_write())
+ return self._constructor_from_mgr(new_mgr, axes=new_mgr.axes).__finalize__(
self, method="round"
)
- return result
-
@overload
def quantile(
self, q: float = ..., interpolation: QuantileInterpolation = ...
@@ -3505,6 +3520,13 @@ def combine_first(self, other) -> Series:
"""
from pandas.core.reshape.concat import concat
+ if self.dtype == other.dtype:
+ if self.index.equals(other.index):
+ return self.mask(self.isna(), other)
+ elif self._can_hold_na and not isinstance(self.dtype, SparseDtype):
+ this, other = self.align(other, join="outer")
+ return this.mask(this.isna(), other)
+
new_index = self.index.union(other.index)
this = self
@@ -4061,6 +4083,7 @@ def argsort(
axis: Axis = 0,
kind: SortKind = "quicksort",
order: None = None,
+ stable: None = None,
) -> Series:
"""
Return the integer indices that would sort the Series values.
@@ -4077,6 +4100,8 @@ def argsort(
information. 'mergesort' and 'stable' are the only stable algorithms.
order : None
Has no effect but is accepted for compatibility with numpy.
+ stable : None
+ Has no effect but is accepted for compatibility with numpy.
Returns
-------
@@ -5629,6 +5654,121 @@ def between(
return lmask & rmask
+ def case_when(
+ self,
+ caselist: list[
+ tuple[
+ ArrayLike | Callable[[Series], Series | np.ndarray | Sequence[bool]],
+ ArrayLike | Scalar | Callable[[Series], Series | np.ndarray],
+ ],
+ ],
+ ) -> Series:
+ """
+ Replace values where the conditions are True.
+
+ Parameters
+ ----------
+ caselist : A list of tuples of conditions and expected replacements
+ Takes the form: ``(condition0, replacement0)``,
+ ``(condition1, replacement1)``, ... .
+ ``condition`` should be a 1-D boolean array-like object
+ or a callable. If ``condition`` is a callable,
+ it is computed on the Series
+ and should return a boolean Series or array.
+ The callable must not change the input Series
+ (though pandas doesn`t check it). ``replacement`` should be a
+ 1-D array-like object, a scalar or a callable.
+ If ``replacement`` is a callable, it is computed on the Series
+ and should return a scalar or Series. The callable
+ must not change the input Series
+ (though pandas doesn`t check it).
+
+ .. versionadded:: 2.2.0
+
+ Returns
+ -------
+ Series
+
+ See Also
+ --------
+ Series.mask : Replace values where the condition is True.
+
+ Examples
+ --------
+ >>> c = pd.Series([6, 7, 8, 9], name='c')
+ >>> a = pd.Series([0, 0, 1, 2])
+ >>> b = pd.Series([0, 3, 4, 5])
+
+ >>> c.case_when(caselist=[(a.gt(0), a), # condition, replacement
+ ... (b.gt(0), b)])
+ 0 6
+ 1 3
+ 2 1
+ 3 2
+ Name: c, dtype: int64
+ """
+ if not isinstance(caselist, list):
+ raise TypeError(
+ f"The caselist argument should be a list; instead got {type(caselist)}"
+ )
+
+ if not caselist:
+ raise ValueError(
+ "provide at least one boolean condition, "
+ "with a corresponding replacement."
+ )
+
+ for num, entry in enumerate(caselist):
+ if not isinstance(entry, tuple):
+ raise TypeError(
+ f"Argument {num} must be a tuple; instead got {type(entry)}."
+ )
+ if len(entry) != 2:
+ raise ValueError(
+ f"Argument {num} must have length 2; "
+ "a condition and replacement; "
+ f"instead got length {len(entry)}."
+ )
+ caselist = [
+ (
+ com.apply_if_callable(condition, self),
+ com.apply_if_callable(replacement, self),
+ )
+ for condition, replacement in caselist
+ ]
+ default = self.copy()
+ conditions, replacements = zip(*caselist)
+ common_dtypes = [infer_dtype_from(arg)[0] for arg in [*replacements, default]]
+ if len(set(common_dtypes)) > 1:
+ common_dtype = find_common_type(common_dtypes)
+ updated_replacements = []
+ for condition, replacement in zip(conditions, replacements):
+ if is_scalar(replacement):
+ replacement = construct_1d_arraylike_from_scalar(
+ value=replacement, length=len(condition), dtype=common_dtype
+ )
+ elif isinstance(replacement, ABCSeries):
+ replacement = replacement.astype(common_dtype)
+ else:
+ replacement = pd_array(replacement, dtype=common_dtype)
+ updated_replacements.append(replacement)
+ replacements = updated_replacements
+ default = default.astype(common_dtype)
+
+ counter = reversed(range(len(conditions)))
+ for position, condition, replacement in zip(
+ counter, conditions[::-1], replacements[::-1]
+ ):
+ try:
+ default = default.mask(
+ condition, other=replacement, axis=0, inplace=False, level=None
+ )
+ except Exception as error:
+ raise ValueError(
+ f"Failed to apply condition{position} and replacement{position}."
+ ) from error
+ return default
+
# error: Cannot determine type of 'isna'
@doc(NDFrame.isna, klass=_shared_doc_kwargs["klass"]) # type: ignore[has-type]
def isna(self) -> Series:
diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py
index 1b7d632c0fa80..da10a12d02ae4 100644
--- a/pandas/core/strings/accessor.py
+++ b/pandas/core/strings/accessor.py
@@ -1336,14 +1336,14 @@ def contains(
return self._wrap_result(result, fill_value=na, returns_string=False)
@forbid_nonstring_types(["bytes"])
- def match(self, pat, case: bool = True, flags: int = 0, na=None):
+ def match(self, pat: str, case: bool = True, flags: int = 0, na=None):
"""
Determine if each string starts with a match of a regular expression.
Parameters
----------
pat : str
- Character sequence or regular expression.
+ Character sequence.
case : bool, default True
If True, case sensitive.
flags : int, default 0 (no flags)
diff --git a/pandas/core/util/numba_.py b/pandas/core/util/numba_.py
index b8d489179338b..4825c9fee24b1 100644
--- a/pandas/core/util/numba_.py
+++ b/pandas/core/util/numba_.py
@@ -1,11 +1,14 @@
"""Common utilities for Numba operations"""
from __future__ import annotations
+import types
from typing import (
TYPE_CHECKING,
Callable,
)
+import numpy as np
+
from pandas.compat._optional import import_optional_dependency
from pandas.errors import NumbaUtilError
@@ -83,6 +86,12 @@ def jit_user_function(func: Callable) -> Callable:
if numba.extending.is_jitted(func):
# Don't jit a user passed jitted function
numba_func = func
+ elif getattr(np, func.__name__, False) is func or isinstance(
+ func, types.BuiltinFunctionType
+ ):
+ # Not necessary to jit builtins or np functions
+ # This will mess up register_jitable
+ numba_func = func
else:
numba_func = numba.extending.register_jitable(func)
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index e78bd258c11ff..68cec16ec9eca 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -14,7 +14,6 @@
Any,
Callable,
Literal,
- cast,
)
import numpy as np
@@ -39,6 +38,7 @@
is_numeric_dtype,
needs_i8_conversion,
)
+from pandas.core.dtypes.dtypes import ArrowDtype
from pandas.core.dtypes.generic import (
ABCDataFrame,
ABCSeries,
@@ -104,6 +104,7 @@
NDFrameT,
QuantileInterpolation,
WindowingRankType,
+ npt,
)
from pandas import (
@@ -404,11 +405,12 @@ def _insert_on_column(self, result: DataFrame, obj: DataFrame) -> None:
result[name] = extra_col
@property
- def _index_array(self):
+ def _index_array(self) -> npt.NDArray[np.int64] | None:
# TODO: why do we get here with e.g. MultiIndex?
- if needs_i8_conversion(self._on.dtype):
- idx = cast("PeriodIndex | DatetimeIndex | TimedeltaIndex", self._on)
- return idx.asi8
+ if isinstance(self._on, (PeriodIndex, DatetimeIndex, TimedeltaIndex)):
+ return self._on.asi8
+ elif isinstance(self._on.dtype, ArrowDtype) and self._on.dtype.kind in "mM":
+ return self._on.to_numpy(dtype=np.int64)
return None
def _resolve_output(self, out: DataFrame, obj: DataFrame) -> DataFrame:
@@ -439,7 +441,7 @@ def _apply_series(
self, homogeneous_func: Callable[..., ArrayLike], name: str | None = None
) -> Series:
"""
- Series version of _apply_blockwise
+ Series version of _apply_columnwise
"""
obj = self._create_data(self._selected_obj)
@@ -455,7 +457,7 @@ def _apply_series(
index = self._slice_axis_for_step(obj.index, result)
return obj._constructor(result, index=index, name=obj.name)
- def _apply_blockwise(
+ def _apply_columnwise(
self,
homogeneous_func: Callable[..., ArrayLike],
name: str,
@@ -614,7 +616,7 @@ def calc(x):
return result
if self.method == "single":
- return self._apply_blockwise(homogeneous_func, name, numeric_only)
+ return self._apply_columnwise(homogeneous_func, name, numeric_only)
else:
return self._apply_tablewise(homogeneous_func, name, numeric_only)
@@ -1232,7 +1234,9 @@ def calc(x):
return result
- return self._apply_blockwise(homogeneous_func, name, numeric_only)[:: self.step]
+ return self._apply_columnwise(homogeneous_func, name, numeric_only)[
+ :: self.step
+ ]
@doc(
_shared_docs["aggregate"],
@@ -1868,6 +1872,7 @@ def _validate(self):
if (
self.obj.empty
or isinstance(self._on, (DatetimeIndex, TimedeltaIndex, PeriodIndex))
+ or (isinstance(self._on.dtype, ArrowDtype) and self._on.dtype.kind in "mM")
) and isinstance(self.window, (str, BaseOffset, timedelta)):
self._validate_datetimelike_monotonic()
diff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py
index bce890c6f73b0..786f719337b84 100644
--- a/pandas/io/excel/_base.py
+++ b/pandas/io/excel/_base.py
@@ -160,36 +160,24 @@
If converters are specified, they will be applied INSTEAD
of dtype conversion.
If you use ``None``, it will infer the dtype of each column based on the data.
-engine : str, default None
+engine : {{'openpyxl', 'calamine', 'odf', 'pyxlsb', 'xlrd'}}, default None
If io is not a buffer or path, this must be set to identify io.
- Supported engines: "xlrd", "openpyxl", "odf", "pyxlsb", "calamine".
Engine compatibility :
- - ``xlr`` supports old-style Excel files (.xls).
- ``openpyxl`` supports newer Excel file formats.
- - ``odf`` supports OpenDocument file formats (.odf, .ods, .odt).
- - ``pyxlsb`` supports Binary Excel files.
- ``calamine`` supports Excel (.xls, .xlsx, .xlsm, .xlsb)
and OpenDocument (.ods) file formats.
+ - ``odf`` supports OpenDocument file formats (.odf, .ods, .odt).
+ - ``pyxlsb`` supports Binary Excel files.
+ - ``xlrd`` supports old-style Excel files (.xls).
- .. versionchanged:: 1.2.0
- The engine `xlrd <https://xlrd.readthedocs.io/en/latest/>`_
- now only supports old-style ``.xls`` files.
- When ``engine=None``, the following logic will be
- used to determine the engine:
-
- - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),
- then `odf <https://pypi.org/project/odfpy/>`_ will be used.
- - Otherwise if ``path_or_buffer`` is an xls format,
- ``xlrd`` will be used.
- - Otherwise if ``path_or_buffer`` is in xlsb format,
- ``pyxlsb`` will be used.
-
- .. versionadded:: 1.3.0
- - Otherwise ``openpyxl`` will be used.
-
- .. versionchanged:: 1.3.0
+ When ``engine=None``, the following logic will be used to determine the engine:
+ - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),
+ then `odf <https://pypi.org/project/odfpy/>`_ will be used.
+ - Otherwise if ``path_or_buffer`` is an xls format, ``xlrd`` will be used.
+ - Otherwise if ``path_or_buffer`` is in xlsb format, ``pyxlsb`` will be used.
+ - Otherwise ``openpyxl`` will be used.
converters : dict, default None
Dict of functions for converting values in certain columns. Keys can
either be integers or column labels, values are functions that take one
diff --git a/pandas/io/excel/_calamine.py b/pandas/io/excel/_calamine.py
index 4f65acf1aa40e..5259469f7a569 100644
--- a/pandas/io/excel/_calamine.py
+++ b/pandas/io/excel/_calamine.py
@@ -74,9 +74,7 @@ def load_workbook(
) -> CalamineWorkbook:
from python_calamine import load_workbook
- return load_workbook(
- filepath_or_buffer, **engine_kwargs # type: ignore[arg-type]
- )
+ return load_workbook(filepath_or_buffer, **engine_kwargs)
@property
def sheet_names(self) -> list[str]:
diff --git a/pandas/io/html.py b/pandas/io/html.py
index 5d5bf079784be..4eeeb1b655f8a 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -269,7 +269,7 @@ def _attr_getter(self, obj, attr):
# Both lxml and BeautifulSoup have the same implementation:
return obj.get(attr)
- def _href_getter(self, obj):
+ def _href_getter(self, obj) -> str | None:
"""
Return a href if the DOM node contains a child <a> or None.
@@ -392,7 +392,7 @@ def _parse_tables(self, document, match, attrs):
"""
raise AbstractMethodError(self)
- def _equals_tag(self, obj, tag):
+ def _equals_tag(self, obj, tag) -> bool:
"""
Return whether an individual DOM node matches a tag
@@ -591,14 +591,8 @@ class _BeautifulSoupHtml5LibFrameParser(_HtmlFrameParser):
:class:`pandas.io.html._HtmlFrameParser`.
"""
- def __init__(self, *args, **kwargs) -> None:
- super().__init__(*args, **kwargs)
- from bs4 import SoupStrainer
-
- self._strainer = SoupStrainer("table")
-
def _parse_tables(self, document, match, attrs):
- element_name = self._strainer.name
+ element_name = "table"
tables = document.find_all(element_name, attrs=attrs)
if not tables:
raise ValueError("No tables found")
@@ -629,7 +623,7 @@ def _href_getter(self, obj) -> str | None:
def _text_getter(self, obj):
return obj.text
- def _equals_tag(self, obj, tag):
+ def _equals_tag(self, obj, tag) -> bool:
return obj.name == tag
def _parse_td(self, row):
@@ -758,7 +752,7 @@ def _parse_tables(self, document, match, kwargs):
raise ValueError(f"No tables found matching regex {repr(pattern)}")
return tables
- def _equals_tag(self, obj, tag):
+ def _equals_tag(self, obj, tag) -> bool:
return obj.tag == tag
def _build_doc(self):
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index ed66e46b300f7..9414f45215029 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -255,7 +255,7 @@ def __init__(
self.is_copy = None
self._format_axes()
- def _format_axes(self):
+ def _format_axes(self) -> None:
raise AbstractMethodError(self)
def write(self) -> str:
@@ -287,7 +287,7 @@ def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
else:
return self.obj
- def _format_axes(self):
+ def _format_axes(self) -> None:
if not self.obj.index.is_unique and self.orient == "index":
raise ValueError(f"Series index must be unique for orient='{self.orient}'")
@@ -304,7 +304,7 @@ def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
obj_to_write = self.obj
return obj_to_write
- def _format_axes(self):
+ def _format_axes(self) -> None:
"""
Try to format axes if they are datelike.
"""
@@ -1193,7 +1193,7 @@ def parse(self):
self._try_convert_types()
return self.obj
- def _parse(self):
+ def _parse(self) -> None:
raise AbstractMethodError(self)
@final
@@ -1217,7 +1217,7 @@ def _convert_axes(self) -> None:
new_axis = Index(new_ser, dtype=new_ser.dtype, copy=False)
setattr(self.obj, axis_name, new_axis)
- def _try_convert_types(self):
+ def _try_convert_types(self) -> None:
raise AbstractMethodError(self)
@final
@@ -1266,6 +1266,7 @@ def _try_convert_data(
if result:
return new_data, True
+ converted = False
if self.dtype_backend is not lib.no_default and not is_axis:
# Fall through for conversion later on
return data, True
@@ -1273,16 +1274,17 @@ def _try_convert_data(
# try float
try:
data = data.astype("float64")
+ converted = True
except (TypeError, ValueError):
pass
- if data.dtype.kind == "f":
- if data.dtype != "float64":
- # coerce floats to 64
- try:
- data = data.astype("float64")
- except (TypeError, ValueError):
- pass
+ if data.dtype.kind == "f" and data.dtype != "float64":
+ # coerce floats to 64
+ try:
+ data = data.astype("float64")
+ converted = True
+ except (TypeError, ValueError):
+ pass
# don't coerce 0-len data
if len(data) and data.dtype in ("float", "object"):
@@ -1291,14 +1293,15 @@ def _try_convert_data(
new_data = data.astype("int64")
if (new_data == data).all():
data = new_data
+ converted = True
except (TypeError, ValueError, OverflowError):
pass
- # coerce ints to 64
- if data.dtype == "int":
- # coerce floats to 64
+ if data.dtype == "int" and data.dtype != "int64":
+ # coerce ints to 64
try:
data = data.astype("int64")
+ converted = True
except (TypeError, ValueError):
pass
@@ -1307,7 +1310,7 @@ def _try_convert_data(
if self.orient == "split":
return data, False
- return data, True
+ return data, converted
@final
def _try_convert_to_date(self, data: Series) -> tuple[Series, bool]:
diff --git a/pandas/io/parsers/arrow_parser_wrapper.py b/pandas/io/parsers/arrow_parser_wrapper.py
index 66a7ccacf675b..890b22154648e 100644
--- a/pandas/io/parsers/arrow_parser_wrapper.py
+++ b/pandas/io/parsers/arrow_parser_wrapper.py
@@ -41,7 +41,7 @@ def __init__(self, src: ReadBuffer[bytes], **kwds) -> None:
self._parse_kwds()
- def _parse_kwds(self):
+ def _parse_kwds(self) -> None:
"""
Validates keywords before passing to pyarrow.
"""
@@ -104,7 +104,7 @@ def _get_pyarrow_options(self) -> None:
] = None # PyArrow raises an exception by default
elif on_bad_lines == ParserBase.BadLineHandleMethod.WARN:
- def handle_warning(invalid_row):
+ def handle_warning(invalid_row) -> str:
warnings.warn(
f"Expected {invalid_row.expected_columns} columns, but found "
f"{invalid_row.actual_columns}: {invalid_row.text}",
@@ -219,7 +219,7 @@ def _finalize_pandas_output(self, frame: DataFrame) -> DataFrame:
raise ValueError(e)
return frame
- def _validate_usecols(self, usecols):
+ def _validate_usecols(self, usecols) -> None:
if lib.is_list_like(usecols) and not all(isinstance(x, str) for x in usecols):
raise ValueError(
"The pyarrow engine does not allow 'usecols' to be integer "
diff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py
index a9b41b45aba2f..e04f27b560610 100644
--- a/pandas/io/parsers/readers.py
+++ b/pandas/io/parsers/readers.py
@@ -240,6 +240,8 @@
performance of reading a large file.
verbose : bool, default False
Indicate number of ``NA`` values placed in non-numeric columns.
+
+ .. deprecated:: 2.2.0
skip_blank_lines : bool, default True
If ``True``, skip over blank lines rather than interpreting as ``NaN`` values.
parse_dates : bool, list of Hashable, list of lists or dict of {{Hashable : list}}, \
@@ -396,7 +398,7 @@
- Callable, function with signature
as described in `pyarrow documentation
<https://arrow.apache.org/docs/python/generated/pyarrow.csv.ParseOptions.html
- #pyarrow.csv.ParseOptions.invalid_row_handler>_` when ``engine='pyarrow'``
+ #pyarrow.csv.ParseOptions.invalid_row_handler>`_ when ``engine='pyarrow'``
delim_whitespace : bool, default False
Specifies whether or not whitespace (e.g. ``' '`` or ``'\\t'``) will be
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 50611197ad7dd..13c2f10785124 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -1707,7 +1707,7 @@ def info(self) -> str:
# ------------------------------------------------------------------------
# private methods
- def _check_if_open(self):
+ def _check_if_open(self) -> None:
if not self.is_open:
raise ClosedFileError(f"{self._path} file is not open!")
@@ -4065,7 +4065,7 @@ def _create_axes(
if isinstance(data_converted.dtype, CategoricalDtype):
ordered = data_converted.ordered
meta = "category"
- metadata = np.array(data_converted.categories, copy=False).ravel()
+ metadata = np.asarray(data_converted.categories).ravel()
data, dtype_name = _get_data_and_dtype_name(data_converted)
diff --git a/pandas/io/sas/sas_xport.py b/pandas/io/sas/sas_xport.py
index e68f4789f0a06..11b2ed0ee7316 100644
--- a/pandas/io/sas/sas_xport.py
+++ b/pandas/io/sas/sas_xport.py
@@ -288,7 +288,7 @@ def close(self) -> None:
def _get_row(self):
return self.filepath_or_buffer.read(80).decode()
- def _read_header(self):
+ def _read_header(self) -> None:
self.filepath_or_buffer.seek(0)
# read file header
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index b0fa6bc6e90c4..3e17175167f25 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -1012,22 +1012,19 @@ def _execute_insert(self, conn, keys: list[str], data_iter) -> int:
def _execute_insert_multi(self, conn, keys: list[str], data_iter) -> int:
"""
- Alternative to _execute_insert for DBs support multivalue INSERT.
+ Alternative to _execute_insert for DBs support multi-value INSERT.
Note: multi-value insert is usually faster for analytics DBs
and tables containing a few columns
but performance degrades quickly with increase of columns.
+
"""
from sqlalchemy import insert
data = [dict(zip(keys, row)) for row in data_iter]
- stmt = insert(self.table)
- # conn.execute is used here to ensure compatibility with Oracle.
- # Using stmt.values(data) would produce a multi row insert that
- # isn't supported by Oracle.
- # see: https://docs.sqlalchemy.org/en/20/core/dml.html#sqlalchemy.sql.expression.Insert.values
- result = conn.execute(stmt, data)
+ stmt = insert(self.table).values(data)
+ result = conn.execute(stmt)
return result.rowcount
def insert_data(self) -> tuple[list[str], list[np.ndarray]]:
@@ -1514,7 +1511,7 @@ def _create_sql_schema(
keys: list[str] | None = None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
pass
@@ -2073,7 +2070,7 @@ def _create_sql_schema(
keys: list[str] | None = None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
table = SQLTable(
table_name,
self,
@@ -2403,7 +2400,9 @@ def to_sql(
raise ValueError("datatypes not supported") from exc
with self.con.cursor() as cur:
- total_inserted = cur.adbc_ingest(table_name, tbl, mode=mode)
+ total_inserted = cur.adbc_ingest(
+ table_name=name, data=tbl, mode=mode, db_schema_name=schema
+ )
self.con.commit()
return total_inserted
@@ -2433,7 +2432,7 @@ def _create_sql_schema(
keys: list[str] | None = None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
raise NotImplementedError("not implemented for adbc")
@@ -2879,7 +2878,7 @@ def _create_sql_schema(
keys=None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
table = SQLiteTable(
table_name,
self,
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index 0f097c6059c7c..4abf9af185a01 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -47,9 +47,11 @@
)
from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.base import ExtensionDtype
from pandas.core.dtypes.common import (
ensure_object,
is_numeric_dtype,
+ is_string_dtype,
)
from pandas.core.dtypes.dtypes import CategoricalDtype
@@ -62,8 +64,6 @@
to_datetime,
to_timedelta,
)
-from pandas.core.arrays.boolean import BooleanDtype
-from pandas.core.arrays.integer import IntegerDtype
from pandas.core.frame import DataFrame
from pandas.core.indexes.base import Index
from pandas.core.indexes.range import RangeIndex
@@ -591,17 +591,22 @@ def _cast_to_stata_types(data: DataFrame) -> DataFrame:
for col in data:
# Cast from unsupported types to supported types
- is_nullable_int = isinstance(data[col].dtype, (IntegerDtype, BooleanDtype))
+ is_nullable_int = (
+ isinstance(data[col].dtype, ExtensionDtype)
+ and data[col].dtype.kind in "iub"
+ )
# We need to find orig_missing before altering data below
orig_missing = data[col].isna()
if is_nullable_int:
- missing_loc = data[col].isna()
- if missing_loc.any():
- # Replace with always safe value
- fv = 0 if isinstance(data[col].dtype, IntegerDtype) else False
- data.loc[missing_loc, col] = fv
+ fv = 0 if data[col].dtype.kind in "iu" else False
# Replace with NumPy-compatible column
- data[col] = data[col].astype(data[col].dtype.numpy_dtype)
+ data[col] = data[col].fillna(fv).astype(data[col].dtype.numpy_dtype)
+ elif isinstance(data[col].dtype, ExtensionDtype):
+ if getattr(data[col].dtype, "numpy_dtype", None) is not None:
+ data[col] = data[col].astype(data[col].dtype.numpy_dtype)
+ elif is_string_dtype(data[col].dtype):
+ data[col] = data[col].astype("object")
+
dtype = data[col].dtype
empty_df = data.shape[0] == 0
for c_data in conversion_data:
@@ -687,7 +692,7 @@ def __init__(
self._prepare_value_labels()
- def _prepare_value_labels(self):
+ def _prepare_value_labels(self) -> None:
"""Encode value labels."""
self.text_len = 0
diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py
index 479a5e19dc1c5..2979903edf360 100644
--- a/pandas/plotting/_matplotlib/core.py
+++ b/pandas/plotting/_matplotlib/core.py
@@ -662,7 +662,7 @@ def _ensure_frame(self, data) -> DataFrame:
return data
@final
- def _compute_plot_data(self):
+ def _compute_plot_data(self) -> None:
data = self.data
# GH15079 reconstruct data if by is defined
@@ -699,7 +699,7 @@ def _compute_plot_data(self):
self.data = numeric_data.apply(type(self)._convert_to_ndarray)
- def _make_plot(self, fig: Figure):
+ def _make_plot(self, fig: Figure) -> None:
raise AbstractMethodError(self)
@final
@@ -745,7 +745,7 @@ def _post_plot_logic(self, ax: Axes, data) -> None:
"""Post process for each axes. Overridden in child classes"""
@final
- def _adorn_subplots(self, fig: Figure):
+ def _adorn_subplots(self, fig: Figure) -> None:
"""Common post process unrelated to data"""
if len(self.axes) > 0:
all_axes = self._get_subplots(fig)
@@ -1323,7 +1323,7 @@ def __init__(
c = self.data.columns[c]
self.c = c
- def _make_plot(self, fig: Figure):
+ def _make_plot(self, fig: Figure) -> None:
x, y, c, data = self.x, self.y, self.c, self.data
ax = self.axes[0]
diff --git a/pandas/plotting/_matplotlib/timeseries.py b/pandas/plotting/_matplotlib/timeseries.py
index bf1c0f6346f02..c7ddfa55d0417 100644
--- a/pandas/plotting/_matplotlib/timeseries.py
+++ b/pandas/plotting/_matplotlib/timeseries.py
@@ -205,7 +205,10 @@ def _get_ax_freq(ax: Axes):
def _get_period_alias(freq: timedelta | BaseOffset | str) -> str | None:
- freqstr = to_offset(freq, is_period=True).rule_code
+ if isinstance(freq, BaseOffset):
+ freqstr = freq.name
+ else:
+ freqstr = to_offset(freq, is_period=True).rule_code
return get_period_alias(freqstr)
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index dbff88dc6f4f6..a468449efd507 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -1586,6 +1586,38 @@ def test_dti_add_sub_nonzero_mth_offset(
expected = tm.box_expected(expected, box_with_array, False)
tm.assert_equal(result, expected)
+ def test_dt64arr_series_add_DateOffset_with_milli(self):
+ # GH 57529
+ dti = DatetimeIndex(
+ [
+ "2000-01-01 00:00:00.012345678",
+ "2000-01-31 00:00:00.012345678",
+ "2000-02-29 00:00:00.012345678",
+ ],
+ dtype="datetime64[ns]",
+ )
+ result = dti + DateOffset(milliseconds=4)
+ expected = DatetimeIndex(
+ [
+ "2000-01-01 00:00:00.016345678",
+ "2000-01-31 00:00:00.016345678",
+ "2000-02-29 00:00:00.016345678",
+ ],
+ dtype="datetime64[ns]",
+ )
+ tm.assert_index_equal(result, expected)
+
+ result = dti + DateOffset(days=1, milliseconds=4)
+ expected = DatetimeIndex(
+ [
+ "2000-01-02 00:00:00.016345678",
+ "2000-02-01 00:00:00.016345678",
+ "2000-03-01 00:00:00.016345678",
+ ],
+ dtype="datetime64[ns]",
+ )
+ tm.assert_index_equal(result, expected)
+
class TestDatetime64OverflowHandling:
# TODO: box + de-duplicate
diff --git a/pandas/tests/arrays/boolean/test_construction.py b/pandas/tests/arrays/boolean/test_construction.py
index a5a2dd33940b8..645e763fbf00c 100644
--- a/pandas/tests/arrays/boolean/test_construction.py
+++ b/pandas/tests/arrays/boolean/test_construction.py
@@ -308,8 +308,6 @@ def test_to_numpy(box):
# converting to int or float without specifying na_value raises
with pytest.raises(ValueError, match="cannot convert to 'int64'-dtype"):
arr.to_numpy(dtype="int64")
- with pytest.raises(ValueError, match="cannot convert to 'float64'-dtype"):
- arr.to_numpy(dtype="float64")
def test_to_numpy_copy():
diff --git a/pandas/tests/arrays/categorical/conftest.py b/pandas/tests/arrays/categorical/conftest.py
deleted file mode 100644
index 37249210f28f4..0000000000000
--- a/pandas/tests/arrays/categorical/conftest.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import pytest
-
-from pandas import Categorical
-
-
-@pytest.fixture
-def factor():
- """Fixture returning a Categorical object"""
- return Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
diff --git a/pandas/tests/arrays/categorical/test_api.py b/pandas/tests/arrays/categorical/test_api.py
index b4215b4a6fe21..a939ee5f6f53f 100644
--- a/pandas/tests/arrays/categorical/test_api.py
+++ b/pandas/tests/arrays/categorical/test_api.py
@@ -385,7 +385,8 @@ def test_remove_unused_categories(self):
class TestCategoricalAPIWithFactor:
- def test_describe(self, factor):
+ def test_describe(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
# string type
desc = factor.describe()
assert factor.ordered
diff --git a/pandas/tests/arrays/categorical/test_indexing.py b/pandas/tests/arrays/categorical/test_indexing.py
index 3377c411a7084..5e1c5c64fa660 100644
--- a/pandas/tests/arrays/categorical/test_indexing.py
+++ b/pandas/tests/arrays/categorical/test_indexing.py
@@ -21,7 +21,8 @@
class TestCategoricalIndexingWithFactor:
- def test_getitem(self, factor):
+ def test_getitem(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
assert factor[0] == "a"
assert factor[-1] == "c"
@@ -31,7 +32,8 @@ def test_getitem(self, factor):
subf = factor[np.asarray(factor) == "c"]
tm.assert_numpy_array_equal(subf._codes, np.array([2, 2, 2], dtype=np.int8))
- def test_setitem(self, factor):
+ def test_setitem(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
# int/positional
c = factor.copy()
c[0] = "b"
diff --git a/pandas/tests/arrays/categorical/test_operators.py b/pandas/tests/arrays/categorical/test_operators.py
index 16b941eab4830..4174d2adc810b 100644
--- a/pandas/tests/arrays/categorical/test_operators.py
+++ b/pandas/tests/arrays/categorical/test_operators.py
@@ -17,7 +17,8 @@ def test_categories_none_comparisons(self):
factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
tm.assert_categorical_equal(factor, factor)
- def test_comparisons(self, factor):
+ def test_comparisons(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
result = factor[factor == "a"]
expected = factor[np.asarray(factor) == "a"]
tm.assert_categorical_equal(result, expected)
diff --git a/pandas/tests/arrays/categorical/test_repr.py b/pandas/tests/arrays/categorical/test_repr.py
index d6f93fbbd912f..ef0315130215c 100644
--- a/pandas/tests/arrays/categorical/test_repr.py
+++ b/pandas/tests/arrays/categorical/test_repr.py
@@ -17,7 +17,8 @@
class TestCategoricalReprWithFactor:
- def test_print(self, factor, using_infer_string):
+ def test_print(self, using_infer_string):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
if using_infer_string:
expected = [
"['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c']",
diff --git a/pandas/tests/arrays/datetimes/test_constructors.py b/pandas/tests/arrays/datetimes/test_constructors.py
index daf4aa3b47f56..3652b5fec46bb 100644
--- a/pandas/tests/arrays/datetimes/test_constructors.py
+++ b/pandas/tests/arrays/datetimes/test_constructors.py
@@ -223,7 +223,7 @@ def test_2d(self, order):
("s", "ns", "US/Central", "Asia/Kolkata", COARSE_TO_FINE_SAFE),
],
)
-def test_from_arrowtest_from_arrow_with_different_units_and_timezones_with_(
+def test_from_arrow_with_different_units_and_timezones_with(
pa_unit, pd_unit, pa_tz, pd_tz, data
):
pa = pytest.importorskip("pyarrow")
@@ -233,9 +233,8 @@ def test_from_arrowtest_from_arrow_with_different_units_and_timezones_with_(
dtype = DatetimeTZDtype(unit=pd_unit, tz=pd_tz)
result = dtype.__from_arrow__(arr)
- expected = DatetimeArray._from_sequence(
- np.array(data, dtype=f"datetime64[{pa_unit}]").astype(f"datetime64[{pd_unit}]"),
- dtype=dtype,
+ expected = DatetimeArray._from_sequence(data, dtype=f"M8[{pa_unit}, UTC]").astype(
+ dtype, copy=False
)
tm.assert_extension_array_equal(result, expected)
diff --git a/pandas/tests/arrays/floating/test_to_numpy.py b/pandas/tests/arrays/floating/test_to_numpy.py
index a25ac40cb3e7c..e954cecba417a 100644
--- a/pandas/tests/arrays/floating/test_to_numpy.py
+++ b/pandas/tests/arrays/floating/test_to_numpy.py
@@ -33,10 +33,10 @@ def test_to_numpy_float(box):
tm.assert_numpy_array_equal(result, expected)
arr = con([0.1, 0.2, None], dtype="Float64")
- with pytest.raises(ValueError, match="cannot convert to 'float64'-dtype"):
- result = arr.to_numpy(dtype="float64")
+ result = arr.to_numpy(dtype="float64")
+ expected = np.array([0.1, 0.2, np.nan], dtype="float64")
+ tm.assert_numpy_array_equal(result, expected)
- # need to explicitly specify na_value
result = arr.to_numpy(dtype="float64", na_value=np.nan)
expected = np.array([0.1, 0.2, np.nan], dtype="float64")
tm.assert_numpy_array_equal(result, expected)
@@ -100,7 +100,7 @@ def test_to_numpy_dtype(box, dtype):
tm.assert_numpy_array_equal(result, expected)
-@pytest.mark.parametrize("dtype", ["float64", "float32", "int32", "int64", "bool"])
+@pytest.mark.parametrize("dtype", ["int32", "int64", "bool"])
@pytest.mark.parametrize("box", [True, False], ids=["series", "array"])
def test_to_numpy_na_raises(box, dtype):
con = pd.Series if box else pd.array
diff --git a/pandas/tests/arrays/integer/test_arithmetic.py b/pandas/tests/arrays/integer/test_arithmetic.py
index d979dd445a61a..8acd298f37a07 100644
--- a/pandas/tests/arrays/integer/test_arithmetic.py
+++ b/pandas/tests/arrays/integer/test_arithmetic.py
@@ -197,6 +197,7 @@ def test_error_invalid_values(data, all_arithmetic_operators, using_infer_string
"Addition/subtraction of integers and integer-arrays with Timestamp",
"has no kernel",
"not implemented",
+ "The 'out' kwarg is necessary. Use numpy.strings.multiply without it.",
]
)
with pytest.raises(errs, match=msg):
diff --git a/pandas/tests/arrays/integer/test_dtypes.py b/pandas/tests/arrays/integer/test_dtypes.py
index e3848cdfe3aa9..8620763988e06 100644
--- a/pandas/tests/arrays/integer/test_dtypes.py
+++ b/pandas/tests/arrays/integer/test_dtypes.py
@@ -271,7 +271,7 @@ def test_to_numpy_dtype(dtype, in_series):
tm.assert_numpy_array_equal(result, expected)
-@pytest.mark.parametrize("dtype", ["float64", "int64", "bool"])
+@pytest.mark.parametrize("dtype", ["int64", "bool"])
def test_to_numpy_na_raises(dtype):
a = pd.array([0, 1, None], dtype="Int64")
with pytest.raises(ValueError, match=dtype):
diff --git a/pandas/tests/arrays/masked/test_function.py b/pandas/tests/arrays/masked/test_function.py
index 4c7bd6e293ef4..b259018cd6121 100644
--- a/pandas/tests/arrays/masked/test_function.py
+++ b/pandas/tests/arrays/masked/test_function.py
@@ -5,6 +5,7 @@
import pandas as pd
import pandas._testing as tm
+from pandas.core.arrays import BaseMaskedArray
arrays = [pd.array([1, 2, 3, None], dtype=dtype) for dtype in tm.ALL_INT_EA_DTYPES]
arrays += [
@@ -55,3 +56,19 @@ def test_tolist(data):
result = data.tolist()
expected = list(data)
tm.assert_equal(result, expected)
+
+
+def test_to_numpy():
+ # GH#56991
+
+ class MyStringArray(BaseMaskedArray):
+ dtype = pd.StringDtype()
+ _dtype_cls = pd.StringDtype
+ _internal_fill_value = pd.NA
+
+ arr = MyStringArray(
+ values=np.array(["a", "b", "c"]), mask=np.array([False, True, False])
+ )
+ result = arr.to_numpy()
+ expected = np.array(["a", pd.NA, "c"])
+ tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 82524ea115019..7f85c891afeed 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -12,6 +12,7 @@
Timestamp,
)
from pandas._libs.tslibs.dtypes import freq_to_period_freqstr
+from pandas.compat.numpy import np_version_gt2
import pandas as pd
from pandas import (
@@ -638,13 +639,14 @@ def test_round(self, arr1d):
def test_array_interface(self, datetime_index):
arr = datetime_index._data
+ copy_false = None if np_version_gt2 else False
# default asarray gives the same underlying data (for tz naive)
result = np.asarray(arr)
expected = arr._ndarray
assert result is expected
tm.assert_numpy_array_equal(result, expected)
- result = np.array(arr, copy=False)
+ result = np.array(arr, copy=copy_false)
assert result is expected
tm.assert_numpy_array_equal(result, expected)
@@ -653,7 +655,7 @@ def test_array_interface(self, datetime_index):
expected = arr._ndarray
assert result is expected
tm.assert_numpy_array_equal(result, expected)
- result = np.array(arr, dtype="datetime64[ns]", copy=False)
+ result = np.array(arr, dtype="datetime64[ns]", copy=copy_false)
assert result is expected
tm.assert_numpy_array_equal(result, expected)
result = np.array(arr, dtype="datetime64[ns]")
@@ -696,6 +698,7 @@ def test_array_tz(self, arr1d):
# GH#23524
arr = arr1d
dti = self.index_cls(arr1d)
+ copy_false = None if np_version_gt2 else False
expected = dti.asi8.view("M8[ns]")
result = np.array(arr, dtype="M8[ns]")
@@ -704,17 +707,18 @@ def test_array_tz(self, arr1d):
result = np.array(arr, dtype="datetime64[ns]")
tm.assert_numpy_array_equal(result, expected)
- # check that we are not making copies when setting copy=False
- result = np.array(arr, dtype="M8[ns]", copy=False)
+ # check that we are not making copies when setting copy=copy_false
+ result = np.array(arr, dtype="M8[ns]", copy=copy_false)
assert result.base is expected.base
assert result.base is not None
- result = np.array(arr, dtype="datetime64[ns]", copy=False)
+ result = np.array(arr, dtype="datetime64[ns]", copy=copy_false)
assert result.base is expected.base
assert result.base is not None
def test_array_i8_dtype(self, arr1d):
arr = arr1d
dti = self.index_cls(arr1d)
+ copy_false = None if np_version_gt2 else False
expected = dti.asi8
result = np.array(arr, dtype="i8")
@@ -723,8 +727,8 @@ def test_array_i8_dtype(self, arr1d):
result = np.array(arr, dtype=np.int64)
tm.assert_numpy_array_equal(result, expected)
- # check that we are still making copies when setting copy=False
- result = np.array(arr, dtype="i8", copy=False)
+ # check that we are still making copies when setting copy=copy_false
+ result = np.array(arr, dtype="i8", copy=copy_false)
assert result.base is not expected.base
assert result.base is None
@@ -950,13 +954,14 @@ def test_int_properties(self, timedelta_index, propname):
def test_array_interface(self, timedelta_index):
arr = timedelta_index._data
+ copy_false = None if np_version_gt2 else False
# default asarray gives the same underlying data
result = np.asarray(arr)
expected = arr._ndarray
assert result is expected
tm.assert_numpy_array_equal(result, expected)
- result = np.array(arr, copy=False)
+ result = np.array(arr, copy=copy_false)
assert result is expected
tm.assert_numpy_array_equal(result, expected)
@@ -965,7 +970,7 @@ def test_array_interface(self, timedelta_index):
expected = arr._ndarray
assert result is expected
tm.assert_numpy_array_equal(result, expected)
- result = np.array(arr, dtype="timedelta64[ns]", copy=False)
+ result = np.array(arr, dtype="timedelta64[ns]", copy=copy_false)
assert result is expected
tm.assert_numpy_array_equal(result, expected)
result = np.array(arr, dtype="timedelta64[ns]")
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 9a576be10d5ca..8f0576cc65a27 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -766,12 +766,18 @@ def test_iter_zoneinfo_fold(self, tz):
"freq, freq_depr",
[
("2ME", "2M"),
+ ("2SME", "2SM"),
+ ("2SME", "2sm"),
("2QE", "2Q"),
("2QE-SEP", "2Q-SEP"),
("1YE", "1Y"),
("2YE-MAR", "2Y-MAR"),
("1YE", "1A"),
("2YE-MAR", "2A-MAR"),
+ ("2ME", "2m"),
+ ("2QE-SEP", "2q-sep"),
+ ("2YE-MAR", "2a-mar"),
+ ("2YE", "2y"),
],
)
def test_date_range_frequency_M_Q_Y_A_deprecated(self, freq, freq_depr):
@@ -784,6 +790,42 @@ def test_date_range_frequency_M_Q_Y_A_deprecated(self, freq, freq_depr):
result = pd.date_range("1/1/2000", periods=4, freq=freq_depr)
tm.assert_index_equal(result, expected)
+ @pytest.mark.parametrize("freq_depr", ["2H", "2CBH", "2MIN", "2S", "2mS", "2Us"])
+ def test_date_range_uppercase_frequency_deprecated(self, freq_depr):
+ # GH#9586, GH#54939
+ depr_msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+ f"future version. Please use '{freq_depr.lower()[1:]}' instead."
+
+ expected = pd.date_range("1/1/2000", periods=4, freq=freq_depr.lower())
+ with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+ result = pd.date_range("1/1/2000", periods=4, freq=freq_depr)
+ tm.assert_index_equal(result, expected)
+
+ @pytest.mark.parametrize(
+ "freq_depr",
+ [
+ "2ye-mar",
+ "2ys",
+ "2qe",
+ "2qs-feb",
+ "2bqs",
+ "2sms",
+ "2bms",
+ "2cbme",
+ "2me",
+ "2w",
+ ],
+ )
+ def test_date_range_lowercase_frequency_deprecated(self, freq_depr):
+ # GH#9586, GH#54939
+ depr_msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+ f"future version, please use '{freq_depr.upper()[1:]}' instead."
+
+ expected = pd.date_range("1/1/2000", periods=4, freq=freq_depr.upper())
+ with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+ result = pd.date_range("1/1/2000", periods=4, freq=freq_depr)
+ tm.assert_index_equal(result, expected)
+
def test_factorize_sort_without_freq():
dta = DatetimeArray._from_sequence([0, 2, 1], dtype="M8[ns]")
diff --git a/pandas/tests/copy_view/test_chained_assignment_deprecation.py b/pandas/tests/copy_view/test_chained_assignment_deprecation.py
index 80e38380ed27c..0a37f6b813e55 100644
--- a/pandas/tests/copy_view/test_chained_assignment_deprecation.py
+++ b/pandas/tests/copy_view/test_chained_assignment_deprecation.py
@@ -1,6 +1,7 @@
import numpy as np
import pytest
+from pandas.compat import PY311
from pandas.errors import (
ChainedAssignmentError,
SettingWithCopyWarning,
@@ -42,7 +43,9 @@ def test_methods_iloc_warn(using_copy_on_write):
("ffill", ()),
],
)
-def test_methods_iloc_getitem_item_cache(func, args, using_copy_on_write):
+def test_methods_iloc_getitem_item_cache(
+ func, args, using_copy_on_write, warn_copy_on_write
+):
# ensure we don't incorrectly raise chained assignment warning because
# of the item cache / iloc not setting the item cache
df_orig = DataFrame({"a": [1, 2, 3], "b": 1})
@@ -66,14 +69,74 @@ def test_methods_iloc_getitem_item_cache(func, args, using_copy_on_write):
ser = df["a"]
getattr(ser, func)(*args, inplace=True)
+ df = df_orig.copy()
+ df["a"] # populate the item_cache
+ # TODO(CoW-warn) because of the usage of *args, this doesn't warn on Py3.11+
+ if using_copy_on_write:
+ with tm.raises_chained_assignment_error(not PY311):
+ getattr(df["a"], func)(*args, inplace=True)
+ else:
+ with tm.assert_cow_warning(not PY311, match="A value"):
+ getattr(df["a"], func)(*args, inplace=True)
+
+ df = df_orig.copy()
+ ser = df["a"] # populate the item_cache and keep ref
+ if using_copy_on_write:
+ with tm.raises_chained_assignment_error(not PY311):
+ getattr(df["a"], func)(*args, inplace=True)
+ else:
+ # ideally also warns on the default mode, but the ser' _cacher
+ # messes up the refcount + even in warning mode this doesn't trigger
+ # the warning of Py3.1+ (see above)
+ with tm.assert_cow_warning(warn_copy_on_write and not PY311, match="A value"):
+ getattr(df["a"], func)(*args, inplace=True)
+
+
+def test_methods_iloc_getitem_item_cache_fillna(
+ using_copy_on_write, warn_copy_on_write
+):
+ # ensure we don't incorrectly raise chained assignment warning because
+ # of the item cache / iloc not setting the item cache
+ df_orig = DataFrame({"a": [1, 2, 3], "b": 1})
+
+ df = df_orig.copy()
+ ser = df.iloc[:, 0]
+ ser.fillna(1, inplace=True)
+
+ # parent that holds item_cache is dead, so don't increase ref count
+ df = df_orig.copy()
+ ser = df.copy()["a"]
+ ser.fillna(1, inplace=True)
+
+ df = df_orig.copy()
+ df["a"] # populate the item_cache
+ ser = df.iloc[:, 0] # iloc creates a new object
+ ser.fillna(1, inplace=True)
+
+ df = df_orig.copy()
+ df["a"] # populate the item_cache
+ ser = df["a"]
+ ser.fillna(1, inplace=True)
+
df = df_orig.copy()
df["a"] # populate the item_cache
if using_copy_on_write:
with tm.raises_chained_assignment_error():
- df["a"].fillna(0, inplace=True)
+ df["a"].fillna(1, inplace=True)
else:
with tm.assert_cow_warning(match="A value"):
- df["a"].fillna(0, inplace=True)
+ df["a"].fillna(1, inplace=True)
+
+ df = df_orig.copy()
+ ser = df["a"] # populate the item_cache and keep ref
+ if using_copy_on_write:
+ with tm.raises_chained_assignment_error():
+ df["a"].fillna(1, inplace=True)
+ else:
+ # TODO(CoW-warn) ideally also warns on the default mode, but the ser' _cacher
+ # messes up the refcount
+ with tm.assert_cow_warning(warn_copy_on_write, match="A value"):
+ df["a"].fillna(1, inplace=True)
# TODO(CoW-warn) expand the cases
diff --git a/pandas/tests/copy_view/test_indexing.py b/pandas/tests/copy_view/test_indexing.py
index 6f3850ab64daa..479fa148f994a 100644
--- a/pandas/tests/copy_view/test_indexing.py
+++ b/pandas/tests/copy_view/test_indexing.py
@@ -1144,11 +1144,16 @@ def test_set_value_copy_only_necessary_column(
df_orig = df.copy()
view = df[:]
- if val == "a" and indexer[0] != slice(None):
+ if val == "a" and not warn_copy_on_write:
with tm.assert_produces_warning(
FutureWarning, match="Setting an item of incompatible dtype is deprecated"
):
indexer_func(df)[indexer] = val
+ if val == "a" and warn_copy_on_write:
+ with tm.assert_produces_warning(
+ FutureWarning, match="incompatible dtype|Setting a value on a view"
+ ):
+ indexer_func(df)[indexer] = val
else:
with tm.assert_cow_warning(warn_copy_on_write and val == 100):
indexer_func(df)[indexer] = val
@@ -1224,6 +1229,27 @@ def test_series_midx_tuples_slice(using_copy_on_write, warn_copy_on_write):
tm.assert_series_equal(ser, expected)
+def test_midx_read_only_bool_indexer():
+ # GH#56635
+ def mklbl(prefix, n):
+ return [f"{prefix}{i}" for i in range(n)]
+
+ idx = pd.MultiIndex.from_product(
+ [mklbl("A", 4), mklbl("B", 2), mklbl("C", 4), mklbl("D", 2)]
+ )
+ cols = pd.MultiIndex.from_tuples(
+ [("a", "foo"), ("a", "bar"), ("b", "foo"), ("b", "bah")], names=["lvl0", "lvl1"]
+ )
+ df = DataFrame(1, index=idx, columns=cols).sort_index().sort_index(axis=1)
+
+ mask = df[("a", "foo")] == 1
+ expected_mask = mask.copy()
+ result = df.loc[pd.IndexSlice[mask, :, ["C1", "C3"]], :]
+ expected = df.loc[pd.IndexSlice[:, :, ["C1", "C3"]], :]
+ tm.assert_frame_equal(result, expected)
+ tm.assert_series_equal(mask, expected_mask)
+
+
def test_loc_enlarging_with_dataframe(using_copy_on_write):
df = DataFrame({"a": [1, 2, 3]})
rhs = DataFrame({"b": [1, 2, 3], "c": [4, 5, 6]})
diff --git a/pandas/tests/copy_view/test_methods.py b/pandas/tests/copy_view/test_methods.py
index 862aebdc70a9d..5d1eefccbb1e7 100644
--- a/pandas/tests/copy_view/test_methods.py
+++ b/pandas/tests/copy_view/test_methods.py
@@ -280,6 +280,17 @@ def test_reset_index_series_drop(using_copy_on_write, index):
tm.assert_series_equal(ser, ser_orig)
+def test_groupby_column_index_in_references():
+ df = DataFrame(
+ {"A": ["a", "b", "c", "d"], "B": [1, 2, 3, 4], "C": ["a", "a", "b", "b"]}
+ )
+ df = df.set_index("A")
+ key = df["C"]
+ result = df.groupby(key, observed=True).sum()
+ expected = df.groupby("C", observed=True).sum()
+ tm.assert_frame_equal(result, expected)
+
+
def test_rename_columns(using_copy_on_write):
# Case: renaming columns returns a new dataframe
# + afterwards modifying the result
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index 0dad0b05303ad..de1ddce724a5b 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -445,12 +445,12 @@ def test_construction(self):
def test_cannot_use_custom_businessday(self):
# GH#52534
- msg = "CustomBusinessDay is not supported as period frequency"
+ msg = "C is not supported as period frequency"
+ msg1 = "<CustomBusinessDay> is not supported as period frequency"
msg2 = r"PeriodDtype\[B\] is deprecated"
- with pytest.raises(TypeError, match=msg):
- with tm.assert_produces_warning(FutureWarning, match=msg2):
- PeriodDtype("C")
- with pytest.raises(TypeError, match=msg):
+ with pytest.raises(ValueError, match=msg):
+ PeriodDtype("C")
+ with pytest.raises(ValueError, match=msg1):
with tm.assert_produces_warning(FutureWarning, match=msg2):
PeriodDtype(pd.offsets.CustomBusinessDay())
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 49eb06c299886..0567be737c681 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -112,8 +112,8 @@ def it_outer():
def __len__(self) -> int:
return len(self._values)
- def __array__(self, t=None):
- return np.asarray(self._values, dtype=t)
+ def __array__(self, dtype=None, copy=None):
+ return np.asarray(self._values, dtype=dtype)
@property
def ndim(self):
diff --git a/pandas/tests/extension/array_with_attr/array.py b/pandas/tests/extension/array_with_attr/array.py
index d0249d9af8098..2789d51ec2ce3 100644
--- a/pandas/tests/extension/array_with_attr/array.py
+++ b/pandas/tests/extension/array_with_attr/array.py
@@ -49,7 +49,10 @@ def __init__(self, values, attr=None) -> None:
@classmethod
def _from_sequence(cls, scalars, *, dtype=None, copy=False):
- data = np.array(scalars, dtype="float64", copy=copy)
+ if not copy:
+ data = np.asarray(scalars, dtype="float64")
+ else:
+ data = np.array(scalars, dtype="float64", copy=copy)
return cls(data)
def __getitem__(self, item):
diff --git a/pandas/tests/extension/base/groupby.py b/pandas/tests/extension/base/groupby.py
index 75628ea177fc2..414683b02dcba 100644
--- a/pandas/tests/extension/base/groupby.py
+++ b/pandas/tests/extension/base/groupby.py
@@ -114,13 +114,13 @@ def test_groupby_extension_transform(self, data_for_grouping):
def test_groupby_extension_apply(self, data_for_grouping, groupby_apply_op):
df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- df.groupby("B", group_keys=False).apply(groupby_apply_op)
- df.groupby("B", group_keys=False).A.apply(groupby_apply_op)
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
+ df.groupby("B", group_keys=False, observed=False).apply(groupby_apply_op)
+ df.groupby("B", group_keys=False, observed=False).A.apply(groupby_apply_op)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- df.groupby("A", group_keys=False).apply(groupby_apply_op)
- df.groupby("A", group_keys=False).B.apply(groupby_apply_op)
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
+ df.groupby("A", group_keys=False, observed=False).apply(groupby_apply_op)
+ df.groupby("A", group_keys=False, observed=False).B.apply(groupby_apply_op)
def test_groupby_apply_identity(self, data_for_grouping):
df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
diff --git a/pandas/tests/extension/base/missing.py b/pandas/tests/extension/base/missing.py
index ffb7a24b4b390..dbd6682c12123 100644
--- a/pandas/tests/extension/base/missing.py
+++ b/pandas/tests/extension/base/missing.py
@@ -77,6 +77,28 @@ def test_fillna_limit_pad(self, data_missing):
expected = pd.Series(data_missing.take([1, 1, 1, 0, 1]))
tm.assert_series_equal(result, expected)
+ @pytest.mark.parametrize(
+ "limit_area, input_ilocs, expected_ilocs",
+ [
+ ("outside", [1, 0, 0, 0, 1], [1, 0, 0, 0, 1]),
+ ("outside", [1, 0, 1, 0, 1], [1, 0, 1, 0, 1]),
+ ("outside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 1]),
+ ("outside", [0, 1, 0, 1, 0], [0, 1, 0, 1, 1]),
+ ("inside", [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [1, 0, 1, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 0]),
+ ("inside", [0, 1, 0, 1, 0], [0, 1, 1, 1, 0]),
+ ],
+ )
+ def test_ffill_limit_area(
+ self, data_missing, limit_area, input_ilocs, expected_ilocs
+ ):
+ # GH#56616
+ arr = data_missing.take(input_ilocs)
+ result = pd.Series(arr).ffill(limit_area=limit_area)
+ expected = pd.Series(data_missing.take(expected_ilocs))
+ tm.assert_series_equal(result, expected)
+
@pytest.mark.filterwarnings(
"ignore:Series.fillna with 'method' is deprecated:FutureWarning"
)
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index b3c57ee49a724..9907e345ada63 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -156,6 +156,36 @@ def test_fillna_limit_pad(self, data_missing):
):
super().test_fillna_limit_pad(data_missing)
+ @pytest.mark.parametrize(
+ "limit_area, input_ilocs, expected_ilocs",
+ [
+ ("outside", [1, 0, 0, 0, 1], [1, 0, 0, 0, 1]),
+ ("outside", [1, 0, 1, 0, 1], [1, 0, 1, 0, 1]),
+ ("outside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 1]),
+ ("outside", [0, 1, 0, 1, 0], [0, 1, 0, 1, 1]),
+ ("inside", [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [1, 0, 1, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 0]),
+ ("inside", [0, 1, 0, 1, 0], [0, 1, 1, 1, 0]),
+ ],
+ )
+ def test_ffill_limit_area(
+ self, data_missing, limit_area, input_ilocs, expected_ilocs
+ ):
+ # GH#56616
+ msg = "ExtensionArray.fillna 'method' keyword is deprecated"
+ with tm.assert_produces_warning(
+ DeprecationWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
+ ):
+ msg = "DecimalArray does not implement limit_area"
+ with pytest.raises(NotImplementedError, match=msg):
+ super().test_ffill_limit_area(
+ data_missing, limit_area, input_ilocs, expected_ilocs
+ )
+
def test_fillna_limit_backfill(self, data_missing):
msg = "Series.fillna with 'method' is deprecated"
with tm.assert_produces_warning(
diff --git a/pandas/tests/extension/json/array.py b/pandas/tests/extension/json/array.py
index d3d9dcc4a4712..e43b50322bb92 100644
--- a/pandas/tests/extension/json/array.py
+++ b/pandas/tests/extension/json/array.py
@@ -146,7 +146,7 @@ def __eq__(self, other):
def __ne__(self, other):
return NotImplemented
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None, copy=None):
if dtype is None:
dtype = object
if dtype == object:
@@ -210,8 +210,10 @@ def astype(self, dtype, copy=True):
value = self.astype(str) # numpy doesn't like nested dicts
arr_cls = dtype.construct_array_type()
return arr_cls._from_sequence(value, dtype=dtype, copy=False)
-
- return np.array([dict(x) for x in self], dtype=dtype, copy=copy)
+ elif not copy:
+ return np.asarray([dict(x) for x in self], dtype=dtype)
+ else:
+ return np.array([dict(x) for x in self], dtype=dtype, copy=copy)
def unique(self):
# Parent method doesn't work since np.array will try to infer
@@ -235,6 +237,10 @@ def _values_for_argsort(self):
frozen = [tuple(x.items()) for x in self]
return construct_1d_object_array_from_listlike(frozen)
+ def _pad_or_backfill(self, *, method, limit=None, copy=True):
+ # GH#56616 - test EA method without limit_area argument
+ return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
+
def make_data():
# TODO: Use a regular dict. See _NDFrameIndexer._setitem_with_indexer
diff --git a/pandas/tests/extension/json/test_json.py b/pandas/tests/extension/json/test_json.py
index 7686bc5abb44c..a18edac9aef93 100644
--- a/pandas/tests/extension/json/test_json.py
+++ b/pandas/tests/extension/json/test_json.py
@@ -149,6 +149,29 @@ def test_fillna_frame(self):
"""We treat dictionaries as a mapping in fillna, not a scalar."""
super().test_fillna_frame()
+ @pytest.mark.parametrize(
+ "limit_area, input_ilocs, expected_ilocs",
+ [
+ ("outside", [1, 0, 0, 0, 1], [1, 0, 0, 0, 1]),
+ ("outside", [1, 0, 1, 0, 1], [1, 0, 1, 0, 1]),
+ ("outside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 1]),
+ ("outside", [0, 1, 0, 1, 0], [0, 1, 0, 1, 1]),
+ ("inside", [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [1, 0, 1, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 0]),
+ ("inside", [0, 1, 0, 1, 0], [0, 1, 1, 1, 0]),
+ ],
+ )
+ def test_ffill_limit_area(
+ self, data_missing, limit_area, input_ilocs, expected_ilocs
+ ):
+ # GH#56616
+ msg = "JSONArray does not implement limit_area"
+ with pytest.raises(NotImplementedError, match=msg):
+ super().test_ffill_limit_area(
+ data_missing, limit_area, input_ilocs, expected_ilocs
+ )
+
@unhashable
def test_value_counts(self, all_data, dropna):
super().test_value_counts(all_data, dropna)
diff --git a/pandas/tests/extension/list/array.py b/pandas/tests/extension/list/array.py
index f07585c0aec10..b3bb35c9396f4 100644
--- a/pandas/tests/extension/list/array.py
+++ b/pandas/tests/extension/list/array.py
@@ -115,7 +115,10 @@ def astype(self, dtype, copy=True):
elif is_string_dtype(dtype) and not is_object_dtype(dtype):
# numpy has problems with astype(str) for nested elements
return np.array([str(x) for x in self.data], dtype=dtype)
- return np.array(self.data, dtype=dtype, copy=copy)
+ elif not copy:
+ return np.asarray(self.data, dtype=dtype)
+ else:
+ return np.array(self.data, dtype=dtype, copy=copy)
@classmethod
def _concat_same_type(cls, to_concat):
diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
index 3b03272f18203..d9a3033b8380e 100644
--- a/pandas/tests/extension/test_arrow.py
+++ b/pandas/tests/extension/test_arrow.py
@@ -1903,16 +1903,21 @@ def test_str_match(pat, case, na, exp):
@pytest.mark.parametrize(
"pat, case, na, exp",
[
- ["abc", False, None, [True, None]],
- ["Abc", True, None, [False, None]],
- ["bc", True, None, [False, None]],
- ["ab", False, True, [True, True]],
- ["a[a-z]{2}", False, None, [True, None]],
- ["A[a-z]{1}", True, None, [False, None]],
+ ["abc", False, None, [True, True, False, None]],
+ ["Abc", True, None, [False, False, False, None]],
+ ["bc", True, None, [False, False, False, None]],
+ ["ab", False, None, [True, True, False, None]],
+ ["a[a-z]{2}", False, None, [True, True, False, None]],
+ ["A[a-z]{1}", True, None, [False, False, False, None]],
+ # GH Issue: #56652
+ ["abc$", False, None, [True, False, False, None]],
+ ["abc\\$", False, None, [False, True, False, None]],
+ ["Abc$", True, None, [False, False, False, None]],
+ ["Abc\\$", True, None, [False, False, False, None]],
],
)
def test_str_fullmatch(pat, case, na, exp):
- ser = pd.Series(["abc", None], dtype=ArrowDtype(pa.string()))
+ ser = pd.Series(["abc", "abc$", "$abc", None], dtype=ArrowDtype(pa.string()))
result = ser.str.match(pat, case=case, na=na)
expected = pd.Series(exp, dtype=ArrowDtype(pa.bool_()))
tm.assert_series_equal(result, expected)
@@ -2723,6 +2728,111 @@ def test_dt_tz_convert(unit):
tm.assert_series_equal(result, expected)
+@pytest.mark.parametrize("dtype", ["timestamp[ms][pyarrow]", "duration[ms][pyarrow]"])
+def test_as_unit(dtype):
+ # GH 52284
+ ser = pd.Series([1000, None], dtype=dtype)
+ result = ser.dt.as_unit("ns")
+ expected = ser.astype(dtype.replace("ms", "ns"))
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "prop, expected",
+ [
+ ["days", 1],
+ ["seconds", 2],
+ ["microseconds", 3],
+ ["nanoseconds", 4],
+ ],
+)
+def test_dt_timedelta_properties(prop, expected):
+ # GH 52284
+ ser = pd.Series(
+ [
+ pd.Timedelta(
+ days=1,
+ seconds=2,
+ microseconds=3,
+ nanoseconds=4,
+ ),
+ None,
+ ],
+ dtype=ArrowDtype(pa.duration("ns")),
+ )
+ result = getattr(ser.dt, prop)
+ expected = pd.Series(
+ ArrowExtensionArray(pa.array([expected, None], type=pa.int32()))
+ )
+ tm.assert_series_equal(result, expected)
+
+
+def test_dt_timedelta_total_seconds():
+ # GH 52284
+ ser = pd.Series(
+ [
+ pd.Timedelta(
+ days=1,
+ seconds=2,
+ microseconds=3,
+ nanoseconds=4,
+ ),
+ None,
+ ],
+ dtype=ArrowDtype(pa.duration("ns")),
+ )
+ result = ser.dt.total_seconds()
+ expected = pd.Series(
+ ArrowExtensionArray(pa.array([86402.000003, None], type=pa.float64()))
+ )
+ tm.assert_series_equal(result, expected)
+
+
+def test_dt_to_pytimedelta():
+ # GH 52284
+ data = [timedelta(1, 2, 3), timedelta(1, 2, 4)]
+ ser = pd.Series(data, dtype=ArrowDtype(pa.duration("ns")))
+
+ result = ser.dt.to_pytimedelta()
+ expected = np.array(data, dtype=object)
+ tm.assert_numpy_array_equal(result, expected)
+ assert all(type(res) is timedelta for res in result)
+
+ expected = ser.astype("timedelta64[ns]").dt.to_pytimedelta()
+ tm.assert_numpy_array_equal(result, expected)
+
+
+def test_dt_components():
+ # GH 52284
+ ser = pd.Series(
+ [
+ pd.Timedelta(
+ days=1,
+ seconds=2,
+ microseconds=3,
+ nanoseconds=4,
+ ),
+ None,
+ ],
+ dtype=ArrowDtype(pa.duration("ns")),
+ )
+ result = ser.dt.components
+ expected = pd.DataFrame(
+ [[1, 0, 0, 2, 0, 3, 4], [None, None, None, None, None, None, None]],
+ columns=[
+ "days",
+ "hours",
+ "minutes",
+ "seconds",
+ "milliseconds",
+ "microseconds",
+ "nanoseconds",
+ ],
+ dtype="int32[pyarrow]",
+ )
+ tm.assert_frame_equal(result, expected)
+
+
@pytest.mark.parametrize("skipna", [True, False])
def test_boolean_reduce_series_all_null(all_boolean_reductions, skipna):
# GH51624
@@ -3124,6 +3234,22 @@ def test_factorize_chunked_dictionary():
tm.assert_index_equal(res_uniques, exp_uniques)
+def test_dictionary_astype_categorical():
+ # GH#56672
+ arrs = [
+ pa.array(np.array(["a", "x", "c", "a"])).dictionary_encode(),
+ pa.array(np.array(["a", "d", "c"])).dictionary_encode(),
+ ]
+ ser = pd.Series(ArrowExtensionArray(pa.chunked_array(arrs)))
+ result = ser.astype("category")
+ categories = pd.Index(["a", "x", "c", "d"], dtype=ArrowDtype(pa.string()))
+ expected = pd.Series(
+ ["a", "x", "c", "a", "a", "d", "c"],
+ dtype=pd.CategoricalDtype(categories=categories),
+ )
+ tm.assert_series_equal(result, expected)
+
+
def test_arrow_floordiv():
# GH 55561
a = pd.Series([-7], dtype="int64[pyarrow]")
@@ -3133,6 +3259,92 @@ def test_arrow_floordiv():
tm.assert_series_equal(result, expected)
+def test_arrow_floordiv_large_values():
+ # GH 56645
+ a = pd.Series([1425801600000000000], dtype="int64[pyarrow]")
+ expected = pd.Series([1425801600000], dtype="int64[pyarrow]")
+ result = a // 1_000_000
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["int64[pyarrow]", "uint64[pyarrow]"])
+def test_arrow_floordiv_large_integral_result(dtype):
+ # GH 56676
+ a = pd.Series([18014398509481983], dtype=dtype)
+ result = a // 1
+ tm.assert_series_equal(result, a)
+
+
+@pytest.mark.parametrize("pa_type", tm.SIGNED_INT_PYARROW_DTYPES)
+def test_arrow_floordiv_larger_divisor(pa_type):
+ # GH 56676
+ dtype = ArrowDtype(pa_type)
+ a = pd.Series([-23], dtype=dtype)
+ result = a // 24
+ expected = pd.Series([-1], dtype=dtype)
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("pa_type", tm.SIGNED_INT_PYARROW_DTYPES)
+def test_arrow_floordiv_integral_invalid(pa_type):
+ # GH 56676
+ min_value = np.iinfo(pa_type.to_pandas_dtype()).min
+ a = pd.Series([min_value], dtype=ArrowDtype(pa_type))
+ with pytest.raises(pa.lib.ArrowInvalid, match="overflow|not in range"):
+ a // -1
+ with pytest.raises(pa.lib.ArrowInvalid, match="divide by zero"):
+ a // 0
+
+
+@pytest.mark.parametrize("dtype", tm.FLOAT_PYARROW_DTYPES_STR_REPR)
+def test_arrow_floordiv_floating_0_divisor(dtype):
+ # GH 56676
+ a = pd.Series([2], dtype=dtype)
+ result = a // 0
+ expected = pd.Series([float("inf")], dtype=dtype)
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["float64", "datetime64[ns]", "timedelta64[ns]"])
+def test_astype_int_with_null_to_numpy_dtype(dtype):
+ # GH 57093
+ ser = pd.Series([1, None], dtype="int64[pyarrow]")
+ result = ser.astype(dtype)
+ expected = pd.Series([1, None], dtype=dtype)
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("pa_type", tm.ALL_INT_PYARROW_DTYPES)
+def test_arrow_integral_floordiv_large_values(pa_type):
+ # GH 56676
+ max_value = np.iinfo(pa_type.to_pandas_dtype()).max
+ dtype = ArrowDtype(pa_type)
+ a = pd.Series([max_value], dtype=dtype)
+ b = pd.Series([1], dtype=dtype)
+ result = a // b
+ tm.assert_series_equal(result, a)
+
+
+@pytest.mark.parametrize("dtype", ["int64[pyarrow]", "uint64[pyarrow]"])
+def test_arrow_true_division_large_divisor(dtype):
+ # GH 56706
+ a = pd.Series([0], dtype=dtype)
+ b = pd.Series([18014398509481983], dtype=dtype)
+ expected = pd.Series([0], dtype="float64[pyarrow]")
+ result = a / b
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["int64[pyarrow]", "uint64[pyarrow]"])
+def test_arrow_floor_division_large_divisor(dtype):
+ # GH 56706
+ a = pd.Series([0], dtype=dtype)
+ b = pd.Series([18014398509481983], dtype=dtype)
+ expected = pd.Series([0], dtype=dtype)
+ result = a // b
+ tm.assert_series_equal(result, expected)
+
+
def test_string_to_datetime_parsing_cast():
# GH 56266
string_dates = ["2020-01-01 04:30:00", "2020-01-02 00:00:00", "2020-01-03 00:00:00"]
@@ -3153,9 +3365,24 @@ def test_string_to_time_parsing_cast():
tm.assert_series_equal(result, expected)
+def test_to_numpy_float():
+ # GH#56267
+ ser = pd.Series([32, 40, None], dtype="float[pyarrow]")
+ result = ser.astype("float64")
+ expected = pd.Series([32, 40, np.nan], dtype="float64")
+ tm.assert_series_equal(result, expected)
+
+
def test_to_numpy_timestamp_to_int():
# GH 55997
ser = pd.Series(["2020-01-01 04:30:00"], dtype="timestamp[ns][pyarrow]")
result = ser.to_numpy(dtype=np.int64)
expected = np.array([1577853000000000000])
tm.assert_numpy_array_equal(result, expected)
+
+
+def test_map_numeric_na_action():
+ ser = pd.Series([32, 40, None], dtype="int64[pyarrow]")
+ result = ser.map(lambda x: 42, na_action="ignore")
+ expected = pd.Series([42.0, 42.0, np.nan], dtype="float64")
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/extension/test_common.py b/pandas/tests/extension/test_common.py
index 3d8523f344d46..5eda0f00f54ca 100644
--- a/pandas/tests/extension/test_common.py
+++ b/pandas/tests/extension/test_common.py
@@ -17,7 +17,7 @@ class DummyArray(ExtensionArray):
def __init__(self, data) -> None:
self.data = data
- def __array__(self, dtype):
+ def __array__(self, dtype=None, copy=None):
return self.data
@property
@@ -30,8 +30,10 @@ def astype(self, dtype, copy=True):
if copy:
return type(self)(self.data)
return self
-
- return np.array(self, dtype=dtype, copy=copy)
+ elif not copy:
+ return np.asarray(self, dtype=dtype)
+ else:
+ return np.array(self, dtype=dtype, copy=copy)
class TestExtensionArrayDtype:
diff --git a/pandas/tests/extension/test_masked.py b/pandas/tests/extension/test_masked.py
index 3efc561d6a125..651f783b44d1f 100644
--- a/pandas/tests/extension/test_masked.py
+++ b/pandas/tests/extension/test_masked.py
@@ -179,6 +179,15 @@ def test_map(self, data_missing, na_action):
expected = data_missing.to_numpy()
tm.assert_numpy_array_equal(result, expected)
+ def test_map_na_action_ignore(self, data_missing_for_sorting):
+ zero = data_missing_for_sorting[2]
+ result = data_missing_for_sorting.map(lambda x: zero, na_action="ignore")
+ if data_missing_for_sorting.dtype.kind == "b":
+ expected = np.array([False, pd.NA, False], dtype=object)
+ else:
+ expected = np.array([zero, np.nan, zero])
+ tm.assert_numpy_array_equal(result, expected)
+
def _get_expected_exception(self, op_name, obj, other):
try:
dtype = tm.get_dtype(obj)
diff --git a/pandas/tests/extension/test_numpy.py b/pandas/tests/extension/test_numpy.py
index aaf49f53ba02b..e38144f4c615b 100644
--- a/pandas/tests/extension/test_numpy.py
+++ b/pandas/tests/extension/test_numpy.py
@@ -421,16 +421,6 @@ def test_index_from_listlike_with_dtype(self, data):
def test_EA_types(self, engine, data, request):
super().test_EA_types(engine, data, request)
- @pytest.mark.xfail(reason="Expect NumpyEA, get np.ndarray")
- def test_compare_array(self, data, comparison_op):
- super().test_compare_array(data, comparison_op)
-
- def test_compare_scalar(self, data, comparison_op, request):
- if data.dtype.kind == "f" or comparison_op.__name__ in ["eq", "ne"]:
- mark = pytest.mark.xfail(reason="Expect NumpyEA, get np.ndarray")
- request.applymarker(mark)
- super().test_compare_scalar(data, comparison_op)
-
class Test2DCompat(base.NDArrayBacked2DTests):
pass
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index 97e7ae15c6c63..22d9c7f26a57c 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -949,7 +949,8 @@ def test_setitem_frame_upcast(self):
# needs upcasting
df = DataFrame([[1, 2, "foo"], [3, 4, "bar"]], columns=["A", "B", "C"])
df2 = df.copy()
- df2.loc[:, ["A", "B"]] = df.loc[:, ["A", "B"]] + 0.5
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ df2.loc[:, ["A", "B"]] = df.loc[:, ["A", "B"]] + 0.5
expected = df.reindex(columns=["A", "B"])
expected += 0.5
expected["C"] = df["C"]
@@ -1387,20 +1388,20 @@ def test_loc_expand_empty_frame_keep_midx_names(self):
tm.assert_frame_equal(df, expected)
@pytest.mark.parametrize(
- "val, idxr, warn",
+ "val, idxr",
[
- ("x", "a", None), # TODO: this should warn as well
- ("x", ["a"], None), # TODO: this should warn as well
- (1, "a", None), # TODO: this should warn as well
- (1, ["a"], FutureWarning),
+ ("x", "a"),
+ ("x", ["a"]),
+ (1, "a"),
+ (1, ["a"]),
],
)
- def test_loc_setitem_rhs_frame(self, idxr, val, warn):
+ def test_loc_setitem_rhs_frame(self, idxr, val):
# GH#47578
df = DataFrame({"a": [1, 2]})
with tm.assert_produces_warning(
- warn, match="Setting an item of incompatible dtype"
+ FutureWarning, match="Setting an item of incompatible dtype"
):
df.loc[:, idxr] = DataFrame({"a": [val, 11]}, index=[1, 2])
expected = DataFrame({"a": [np.nan, val]})
@@ -1996,7 +1997,7 @@ def _check_setitem_invalid(self, df, invalid, indexer, warn):
np.datetime64("NaT"),
np.timedelta64("NaT"),
]
- _indexers = [0, [0], slice(0, 1), [True, False, False]]
+ _indexers = [0, [0], slice(0, 1), [True, False, False], slice(None, None, None)]
@pytest.mark.parametrize(
"invalid", _invalid_scalars + [1, 1.0, np.int64(1), np.float64(1)]
@@ -2010,7 +2011,7 @@ def test_setitem_validation_scalar_bool(self, invalid, indexer):
@pytest.mark.parametrize("indexer", _indexers)
def test_setitem_validation_scalar_int(self, invalid, any_int_numpy_dtype, indexer):
df = DataFrame({"a": [1, 2, 3]}, dtype=any_int_numpy_dtype)
- if isna(invalid) and invalid is not pd.NaT:
+ if isna(invalid) and invalid is not pd.NaT and not np.isnat(invalid):
warn = None
else:
warn = FutureWarning
diff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py
index e802a56ecbc81..a58dd701f0f22 100644
--- a/pandas/tests/frame/indexing/test_setitem.py
+++ b/pandas/tests/frame/indexing/test_setitem.py
@@ -1381,3 +1381,39 @@ def test_frame_setitem_empty_dataframe(self):
index=dti[:0],
)
tm.assert_frame_equal(df, expected)
+
+
+def test_full_setter_loc_incompatible_dtype():
+ # https://github.com/pandas-dev/pandas/issues/55791
+ df = DataFrame({"a": [1, 2]})
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ df.loc[:, "a"] = True
+ expected = DataFrame({"a": [True, True]})
+ tm.assert_frame_equal(df, expected)
+
+ df = DataFrame({"a": [1, 2]})
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ df.loc[:, "a"] = {0: 3.5, 1: 4.5}
+ expected = DataFrame({"a": [3.5, 4.5]})
+ tm.assert_frame_equal(df, expected)
+
+ df = DataFrame({"a": [1, 2]})
+ df.loc[:, "a"] = {0: 3, 1: 4}
+ expected = DataFrame({"a": [3, 4]})
+ tm.assert_frame_equal(df, expected)
+
+
+def test_setitem_partial_row_multiple_columns():
+ # https://github.com/pandas-dev/pandas/issues/56503
+ df = DataFrame({"A": [1, 2, 3], "B": [4.0, 5, 6]})
+ # should not warn
+ df.loc[df.index <= 1, ["F", "G"]] = (1, "abc")
+ expected = DataFrame(
+ {
+ "A": [1, 2, 3],
+ "B": [4.0, 5, 6],
+ "F": [1.0, 1, float("nan")],
+ "G": ["abc", "abc", float("nan")],
+ }
+ )
+ tm.assert_frame_equal(df, expected)
diff --git a/pandas/tests/frame/methods/test_fillna.py b/pandas/tests/frame/methods/test_fillna.py
index 6757669351c5c..89c50a8c21e1c 100644
--- a/pandas/tests/frame/methods/test_fillna.py
+++ b/pandas/tests/frame/methods/test_fillna.py
@@ -862,41 +862,29 @@ def test_pad_backfill_deprecated(func):
@pytest.mark.parametrize(
"data, expected_data, method, kwargs",
(
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, 3.0, 3.0, 3.0, 7.0, np.nan, np.nan],
"ffill",
{"limit_area": "inside"},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, 3.0, np.nan, np.nan, 7.0, np.nan, np.nan],
"ffill",
{"limit_area": "inside", "limit": 1},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, 7.0],
"ffill",
{"limit_area": "outside"},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, np.nan],
"ffill",
{"limit_area": "outside", "limit": 1},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
(
[np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
@@ -910,41 +898,29 @@ def test_pad_backfill_deprecated(func):
"ffill",
{"limit_area": "outside", "limit": 1},
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, 7.0, 7.0, 7.0, 7.0, np.nan, np.nan],
"bfill",
{"limit_area": "inside"},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, np.nan, np.nan, 7.0, 7.0, np.nan, np.nan],
"bfill",
{"limit_area": "inside", "limit": 1},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[3.0, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan],
"bfill",
{"limit_area": "outside"},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan],
"bfill",
{"limit_area": "outside", "limit": 1},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
),
)
diff --git a/pandas/tests/frame/methods/test_interpolate.py b/pandas/tests/frame/methods/test_interpolate.py
index e0641fcb65bd3..252b950004bea 100644
--- a/pandas/tests/frame/methods/test_interpolate.py
+++ b/pandas/tests/frame/methods/test_interpolate.py
@@ -508,8 +508,41 @@ def test_interpolate_empty_df(self):
assert result is None
tm.assert_frame_equal(df, expected)
- def test_interpolate_ea_raise(self):
+ def test_interpolate_ea(self, any_int_ea_dtype):
# GH#55347
- df = DataFrame({"a": [1, None, 2]}, dtype="Int64")
- with pytest.raises(NotImplementedError, match="does not implement"):
- df.interpolate()
+ df = DataFrame({"a": [1, None, None, None, 3]}, dtype=any_int_ea_dtype)
+ orig = df.copy()
+ result = df.interpolate(limit=2)
+ expected = DataFrame({"a": [1, 1.5, 2.0, None, 3]}, dtype="Float64")
+ tm.assert_frame_equal(result, expected)
+ tm.assert_frame_equal(df, orig)
+
+ @pytest.mark.parametrize(
+ "dtype",
+ [
+ "Float64",
+ "Float32",
+ pytest.param("float32[pyarrow]", marks=td.skip_if_no("pyarrow")),
+ pytest.param("float64[pyarrow]", marks=td.skip_if_no("pyarrow")),
+ ],
+ )
+ def test_interpolate_ea_float(self, dtype):
+ # GH#55347
+ df = DataFrame({"a": [1, None, None, None, 3]}, dtype=dtype)
+ orig = df.copy()
+ result = df.interpolate(limit=2)
+ expected = DataFrame({"a": [1, 1.5, 2.0, None, 3]}, dtype=dtype)
+ tm.assert_frame_equal(result, expected)
+ tm.assert_frame_equal(df, orig)
+
+ @pytest.mark.parametrize(
+ "dtype",
+ ["int64", "uint64", "int32", "int16", "int8", "uint32", "uint16", "uint8"],
+ )
+ def test_interpolate_arrow(self, dtype):
+ # GH#55347
+ pytest.importorskip("pyarrow")
+ df = DataFrame({"a": [1, None, None, None, 3]}, dtype=dtype + "[pyarrow]")
+ result = df.interpolate(limit=2)
+ expected = DataFrame({"a": [1, 1.5, 2.0, None, 3]}, dtype="float64[pyarrow]")
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_select_dtypes.py b/pandas/tests/frame/methods/test_select_dtypes.py
index 47c479faed1ef..d1bee6a3de613 100644
--- a/pandas/tests/frame/methods/test_select_dtypes.py
+++ b/pandas/tests/frame/methods/test_select_dtypes.py
@@ -32,7 +32,7 @@ def __init__(self, data, dtype) -> None:
self.data = data
self._dtype = dtype
- def __array__(self, dtype):
+ def __array__(self, dtype=None, copy=None):
return self.data
@property
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
index b21aa2d687682..abb30595fdcb8 100644
--- a/pandas/tests/frame/methods/test_shift.py
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -756,3 +756,9 @@ def test_shift_with_iterable_check_other_arguments(self):
msg = "Cannot specify `suffix` if `periods` is an int."
with pytest.raises(ValueError, match=msg):
df.shift(1, suffix="fails")
+
+ def test_shift_axis_one_empty(self):
+ # GH#57301
+ df = DataFrame()
+ result = df.shift(1, axis=1)
+ tm.assert_frame_equal(result, df)
diff --git a/pandas/tests/frame/methods/test_sort_index.py b/pandas/tests/frame/methods/test_sort_index.py
index 49e292057e4dc..830561a1349ee 100644
--- a/pandas/tests/frame/methods/test_sort_index.py
+++ b/pandas/tests/frame/methods/test_sort_index.py
@@ -1002,3 +1002,27 @@ def test_axis_columns_ignore_index():
result = df.sort_index(axis="columns", ignore_index=True)
expected = DataFrame([[2, 1]])
tm.assert_frame_equal(result, expected)
+
+
+def test_sort_index_stable_sort():
+ # GH 57151
+ df = DataFrame(
+ data=[
+ (Timestamp("2024-01-30 13:00:00"), 13.0),
+ (Timestamp("2024-01-30 13:00:00"), 13.1),
+ (Timestamp("2024-01-30 12:00:00"), 12.0),
+ (Timestamp("2024-01-30 12:00:00"), 12.1),
+ ],
+ columns=["dt", "value"],
+ ).set_index(["dt"])
+ result = df.sort_index(level="dt", kind="stable")
+ expected = DataFrame(
+ data=[
+ (Timestamp("2024-01-30 12:00:00"), 12.0),
+ (Timestamp("2024-01-30 12:00:00"), 12.1),
+ (Timestamp("2024-01-30 13:00:00"), 13.0),
+ (Timestamp("2024-01-30 13:00:00"), 13.1),
+ ],
+ columns=["dt", "value"],
+ ).set_index(["dt"])
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_to_dict.py b/pandas/tests/frame/methods/test_to_dict.py
index 61f0ad30b4519..570f85a4a31ee 100644
--- a/pandas/tests/frame/methods/test_to_dict.py
+++ b/pandas/tests/frame/methods/test_to_dict.py
@@ -12,8 +12,11 @@
NA,
DataFrame,
Index,
+ Interval,
MultiIndex,
+ Period,
Series,
+ Timedelta,
Timestamp,
)
import pandas._testing as tm
@@ -519,3 +522,14 @@ def test_to_dict_pos_args_deprecation(self):
)
with tm.assert_produces_warning(FutureWarning, match=msg):
df.to_dict("records", {})
+
+
+@pytest.mark.parametrize(
+ "val", [Timestamp(2020, 1, 1), Timedelta(1), Period("2020"), Interval(1, 2)]
+)
+def test_to_dict_list_pd_scalars(val):
+ # GH 54824
+ df = DataFrame({"a": [val]})
+ result = df.to_dict(orient="list")
+ expected = {"a": [val]}
+ assert result == expected
diff --git a/pandas/tests/frame/methods/test_transpose.py b/pandas/tests/frame/methods/test_transpose.py
index d0caa071fae1c..3e74094f266d1 100644
--- a/pandas/tests/frame/methods/test_transpose.py
+++ b/pandas/tests/frame/methods/test_transpose.py
@@ -3,6 +3,7 @@
import pandas.util._test_decorators as td
+import pandas as pd
from pandas import (
DataFrame,
DatetimeIndex,
@@ -190,3 +191,19 @@ def test_transpose_not_inferring_dt_mixed_blocks(self):
dtype=object,
)
tm.assert_frame_equal(result, expected)
+
+ @pytest.mark.parametrize("dtype1", ["Int64", "Float64"])
+ @pytest.mark.parametrize("dtype2", ["Int64", "Float64"])
+ def test_transpose(self, dtype1, dtype2):
+ # GH#57315 - transpose should have F contiguous blocks
+ df = DataFrame(
+ {
+ "a": pd.array([1, 1, 2], dtype=dtype1),
+ "b": pd.array([3, 4, 5], dtype=dtype2),
+ }
+ )
+ result = df.T
+ for blk in result._mgr.blocks:
+ # When dtypes are unequal, we get NumPy object array
+ data = blk.values._data if dtype1 == dtype2 else blk.values
+ assert data.flags["F_CONTIGUOUS"]
diff --git a/pandas/tests/frame/methods/test_update.py b/pandas/tests/frame/methods/test_update.py
index 7c7a0d23ff75f..8af1798aa8e00 100644
--- a/pandas/tests/frame/methods/test_update.py
+++ b/pandas/tests/frame/methods/test_update.py
@@ -48,16 +48,18 @@ def test_update(self):
def test_update_dtypes(self):
# gh 3016
df = DataFrame(
- [[1.0, 2.0, False, True], [4.0, 5.0, True, False]],
- columns=["A", "B", "bool1", "bool2"],
+ [[1.0, 2.0, 1, False, True], [4.0, 5.0, 2, True, False]],
+ columns=["A", "B", "int", "bool1", "bool2"],
)
- other = DataFrame([[45, 45]], index=[0], columns=["A", "B"])
+ other = DataFrame(
+ [[45, 45, 3, True]], index=[0], columns=["A", "B", "int", "bool1"]
+ )
df.update(other)
expected = DataFrame(
- [[45.0, 45.0, False, True], [4.0, 5.0, True, False]],
- columns=["A", "B", "bool1", "bool2"],
+ [[45.0, 45.0, 3, True, True], [4.0, 5.0, 2, True, False]],
+ columns=["A", "B", "int", "bool1", "bool2"],
)
tm.assert_frame_equal(df, expected)
@@ -160,11 +162,8 @@ def test_update_with_different_dtype(self, using_copy_on_write):
# GH#3217
df = DataFrame({"a": [1, 3], "b": [np.nan, 2]})
df["c"] = np.nan
- if using_copy_on_write:
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
df.update({"c": Series(["foo"], index=[0])})
- else:
- with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
- df["c"].update(Series(["foo"], index=[0]))
expected = DataFrame(
{
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 42ce658701355..0593de7556406 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -59,7 +59,7 @@ def __init__(self, value, dtype) -> None:
self.value = value
self.dtype = np.dtype(dtype)
- def __array__(self):
+ def __array__(self, dtype=None, copy=None):
return np.array(self.value, dtype=self.dtype)
def __str__(self) -> str:
diff --git a/pandas/tests/frame/test_arrow_interface.py b/pandas/tests/frame/test_arrow_interface.py
new file mode 100644
index 0000000000000..098d1829b973c
--- /dev/null
+++ b/pandas/tests/frame/test_arrow_interface.py
@@ -0,0 +1,45 @@
+import ctypes
+
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+
+pa = pytest.importorskip("pyarrow")
+
+
+@td.skip_if_no("pyarrow", min_version="14.0")
+def test_dataframe_arrow_interface():
+ df = pd.DataFrame({"a": [1, 2, 3], "b": ["a", "b", "c"]})
+
+ capsule = df.__arrow_c_stream__()
+ assert (
+ ctypes.pythonapi.PyCapsule_IsValid(
+ ctypes.py_object(capsule), b"arrow_array_stream"
+ )
+ == 1
+ )
+
+ table = pa.table(df)
+ expected = pa.table({"a": [1, 2, 3], "b": ["a", "b", "c"]})
+ assert table.equals(expected)
+
+ schema = pa.schema([("a", pa.int8()), ("b", pa.string())])
+ table = pa.table(df, schema=schema)
+ expected = expected.cast(schema)
+ assert table.equals(expected)
+
+
+@td.skip_if_no("pyarrow", min_version="15.0")
+def test_dataframe_to_arrow():
+ df = pd.DataFrame({"a": [1, 2, 3], "b": ["a", "b", "c"]})
+
+ table = pa.RecordBatchReader.from_stream(df).read_all()
+ expected = pa.table({"a": [1, 2, 3], "b": ["a", "b", "c"]})
+ assert table.equals(expected)
+
+ schema = pa.schema([("a", pa.int8()), ("b", pa.string())])
+ table = pa.RecordBatchReader.from_stream(df, schema=schema).read_all()
+ expected = expected.cast(schema)
+ assert table.equals(expected)
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 6e818d79d5ba8..acd0675fd43ec 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -2857,7 +2857,7 @@ def test_dict_data_arrow_column_expansion(self, key_val, col_vals, col_type):
)
result = DataFrame({key_val: [1, 2]}, columns=cols)
expected = DataFrame([[1, np.nan], [2, np.nan]], columns=cols)
- expected.iloc[:, 1] = expected.iloc[:, 1].astype(object)
+ expected.isetitem(1, expected.iloc[:, 1].astype(object))
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py
index a498296e09c52..2c807c72582c5 100644
--- a/pandas/tests/frame/test_query_eval.py
+++ b/pandas/tests/frame/test_query_eval.py
@@ -1415,3 +1415,11 @@ def test_query_ea_equality_comparison(self, dtype, engine):
}
)
tm.assert_frame_equal(result, expected)
+
+ def test_all_nat_in_object(self):
+ # GH#57068
+ now = pd.Timestamp.now("UTC") # noqa: F841
+ df = DataFrame({"a": pd.to_datetime([None, None], utc=True)}, dtype=object)
+ result = df.query("a > @now")
+ expected = DataFrame({"a": []}, dtype=object)
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_stack_unstack.py b/pandas/tests/frame/test_stack_unstack.py
index 6e1e743eb60de..d8b92091260a3 100644
--- a/pandas/tests/frame/test_stack_unstack.py
+++ b/pandas/tests/frame/test_stack_unstack.py
@@ -1825,7 +1825,7 @@ def test_unstack_bug(self, future_stack):
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby(["state", "exp", "barcode", "v"]).apply(len)
unstacked = result.unstack()
diff --git a/pandas/tests/frame/test_subclass.py b/pandas/tests/frame/test_subclass.py
index ef78ae62cb4d6..855b58229cbdb 100644
--- a/pandas/tests/frame/test_subclass.py
+++ b/pandas/tests/frame/test_subclass.py
@@ -26,6 +26,17 @@ def _constructor(self):
class TestDataFrameSubclassing:
+ def test_no_warning_on_mgr(self):
+ # GH#57032
+ df = tm.SubclassedDataFrame(
+ {"X": [1, 2, 3], "Y": [1, 2, 3]}, index=["a", "b", "c"]
+ )
+ with tm.assert_produces_warning(None):
+ # df.isna() goes through _constructor_from_mgr, which we want to
+ # *not* pass a Manager do __init__
+ df.isna()
+ df["X"].isna()
+
def test_frame_subclassing_and_slicing(self):
# Subclass frame and ensure it returns the right class on slicing it
# In reference to PR 9632
diff --git a/pandas/tests/generic/test_to_xarray.py b/pandas/tests/generic/test_to_xarray.py
index e0d79c3f15282..d8401a8b2ae3f 100644
--- a/pandas/tests/generic/test_to_xarray.py
+++ b/pandas/tests/generic/test_to_xarray.py
@@ -41,7 +41,7 @@ def test_to_xarray_index_types(self, index_flat, df, using_infer_string):
df.index.name = "foo"
df.columns.name = "bar"
result = df.to_xarray()
- assert result.dims["foo"] == 4
+ assert result.sizes["foo"] == 4
assert len(result.coords) == 1
assert len(result.data_vars) == 8
tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
@@ -62,7 +62,7 @@ def test_to_xarray_empty(self, df):
df.index.name = "foo"
result = df[0:0].to_xarray()
- assert result.dims["foo"] == 0
+ assert result.sizes["foo"] == 0
assert isinstance(result, Dataset)
def test_to_xarray_with_multiindex(self, df, using_infer_string):
@@ -71,8 +71,8 @@ def test_to_xarray_with_multiindex(self, df, using_infer_string):
# MultiIndex
df.index = MultiIndex.from_product([["a"], range(4)], names=["one", "two"])
result = df.to_xarray()
- assert result.dims["one"] == 1
- assert result.dims["two"] == 4
+ assert result.sizes["one"] == 1
+ assert result.sizes["two"] == 4
assert len(result.coords) == 2
assert len(result.data_vars) == 8
tm.assert_almost_equal(list(result.coords.keys()), ["one", "two"])
diff --git a/pandas/tests/groupby/aggregate/test_other.py b/pandas/tests/groupby/aggregate/test_other.py
index 0596193c137e1..00136e572288e 100644
--- a/pandas/tests/groupby/aggregate/test_other.py
+++ b/pandas/tests/groupby/aggregate/test_other.py
@@ -502,7 +502,7 @@ def test_agg_timezone_round_trip():
# GH#27110 applying iloc should return a DataFrame
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
assert ts == grouped.apply(lambda x: x.iloc[0]).iloc[0, 1]
ts = df["B"].iloc[2]
@@ -510,7 +510,7 @@ def test_agg_timezone_round_trip():
# GH#27110 applying iloc should return a DataFrame
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
assert ts == grouped.apply(lambda x: x.iloc[-1]).iloc[0, 1]
diff --git a/pandas/tests/groupby/methods/test_value_counts.py b/pandas/tests/groupby/methods/test_value_counts.py
index 2fa79c815d282..8e25177368d8b 100644
--- a/pandas/tests/groupby/methods/test_value_counts.py
+++ b/pandas/tests/groupby/methods/test_value_counts.py
@@ -330,7 +330,7 @@ def test_against_frame_and_seriesgroupby(
)
if frame:
# compare against apply with DataFrame value_counts
- warn = FutureWarning if groupby == "column" else None
+ warn = DeprecationWarning if groupby == "column" else None
msg = "DataFrameGroupBy.apply operated on the grouping columns"
with tm.assert_produces_warning(warn, match=msg):
expected = gp.apply(
diff --git a/pandas/tests/groupby/test_apply.py b/pandas/tests/groupby/test_apply.py
index 34b6e7c4cde5f..0ddacfab8c102 100644
--- a/pandas/tests/groupby/test_apply.py
+++ b/pandas/tests/groupby/test_apply.py
@@ -28,7 +28,7 @@ def store(group):
groups.append(group)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
df.groupby("index").apply(store)
expected_value = DataFrame(
{"index": [0] * 10, 0: [1] * 10}, index=pd.RangeIndex(0, 100, 10)
@@ -115,7 +115,7 @@ def test_apply_index_date_object(using_infer_string):
)
expected = Series(["00:00", "02:00", "02:00"], index=exp_idx)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("date", group_keys=False).apply(
lambda x: x["time"][x["value"].idxmax()]
)
@@ -227,7 +227,7 @@ def f_constant_df(group):
del names[:]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
df.groupby("a", group_keys=False).apply(func)
assert names == group_names
@@ -247,7 +247,7 @@ def test_group_apply_once_per_group2(capsys):
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
df.groupby("group_by_column", group_keys=False).apply(
lambda df: print("function_called")
)
@@ -271,9 +271,9 @@ def fast(group):
return group.copy()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
fast_df = df.groupby("A", group_keys=False).apply(fast)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
slow_df = df.groupby("A", group_keys=False).apply(slow)
tm.assert_frame_equal(fast_df, slow_df)
@@ -297,7 +297,7 @@ def test_groupby_apply_identity_maybecopy_index_identical(func):
df = DataFrame({"g": [1, 2, 2, 2], "a": [1, 2, 3, 4], "b": [5, 6, 7, 8]})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("g", group_keys=False).apply(func)
tm.assert_frame_equal(result, df)
@@ -342,9 +342,9 @@ def test_groupby_as_index_apply():
tm.assert_index_equal(res_not_as, exp)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
res_as_apply = g_as.apply(lambda x: x.head(2)).index
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
res_not_as_apply = g_not_as.apply(lambda x: x.head(2)).index
# apply doesn't maintain the original ordering
@@ -359,7 +359,7 @@ def test_groupby_as_index_apply():
ind = Index(list("abcde"))
df = DataFrame([[1, 2], [2, 3], [1, 4], [1, 5], [2, 6]], index=ind)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
res = df.groupby(0, as_index=False, group_keys=False).apply(lambda x: x).index
tm.assert_index_equal(res, ind)
@@ -390,17 +390,17 @@ def desc3(group):
return result
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = grouped.apply(desc)
assert result.index.names == ("A", "B", "stat")
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result2 = grouped.apply(desc2)
assert result2.index.names == ("A", "B", "stat")
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result3 = grouped.apply(desc3)
assert result3.index.names == ("A", "B", None)
@@ -432,7 +432,7 @@ def test_apply_series_yield_constant(df):
def test_apply_frame_yield_constant(df):
# GH13568
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby(["A", "B"]).apply(len)
assert isinstance(result, Series)
assert result.name is None
@@ -445,7 +445,7 @@ def test_apply_frame_yield_constant(df):
def test_apply_frame_to_series(df):
grouped = df.groupby(["A", "B"])
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = grouped.apply(len)
expected = grouped.count()["C"]
tm.assert_index_equal(result.index, expected.index)
@@ -456,7 +456,7 @@ def test_apply_frame_not_as_index_column_name(df):
# GH 35964 - path within _wrap_applied_output not hit by a test
grouped = df.groupby(["A", "B"], as_index=False)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = grouped.apply(len)
expected = grouped.count().rename(columns={"C": np.nan}).drop(columns="D")
# TODO(GH#34306): Use assert_frame_equal when column name is not np.nan
@@ -481,7 +481,7 @@ def trans2(group):
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").apply(trans)
exp = df.groupby("A")["C"].apply(trans2)
tm.assert_series_equal(result, exp, check_names=False)
@@ -512,7 +512,7 @@ def test_apply_chunk_view(group_keys):
df = DataFrame({"key": [1, 1, 1, 2, 2, 2, 3, 3, 3], "value": range(9)})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("key", group_keys=group_keys).apply(lambda x: x.iloc[:2])
expected = df.take([0, 1, 3, 4, 6, 7])
if group_keys:
@@ -535,7 +535,7 @@ def test_apply_no_name_column_conflict():
# it works! #2605
grouped = df.groupby(["name", "name2"])
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
grouped.apply(lambda x: x.sort_values("value", inplace=True))
@@ -554,7 +554,7 @@ def f(group):
return group
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("d", group_keys=False).apply(f)
expected = df.copy()
@@ -580,7 +580,7 @@ def f(group):
return group
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("d", group_keys=False).apply(f)
expected = df.copy()
@@ -620,9 +620,9 @@ def filt2(x):
return x[x.category == "c"]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = data.groupby("id_field").apply(filt1)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = data.groupby("id_field").apply(filt2)
tm.assert_frame_equal(result, expected)
@@ -643,7 +643,7 @@ def test_apply_with_duplicated_non_sorted_axis(test_series):
tm.assert_series_equal(result, expected)
else:
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("Y", group_keys=False).apply(lambda x: x)
# not expecting the order to remain the same for duplicated axis
@@ -690,7 +690,7 @@ def f(g):
return g
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = grouped.apply(f)
assert "value3" in result
@@ -706,11 +706,11 @@ def test_apply_numeric_coercion_when_datetime():
{"Number": [1, 2], "Date": ["2017-03-02"] * 2, "Str": ["foo", "inf"]}
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = df.groupby(["Number"]).apply(lambda x: x.iloc[0])
df.Date = pd.to_datetime(df.Date)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby(["Number"]).apply(lambda x: x.iloc[0])
tm.assert_series_equal(result["Str"], expected["Str"])
@@ -723,7 +723,7 @@ def get_B(g):
return g.iloc[0][["B"]]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").apply(get_B)["B"]
expected = df.B
expected.index = df.A
@@ -750,9 +750,9 @@ def predictions(tool):
df2 = df1.copy()
df2.oTime = pd.to_datetime(df2.oTime)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = df1.groupby("Key").apply(predictions).p1
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df2.groupby("Key").apply(predictions).p1
tm.assert_series_equal(expected, result)
@@ -769,7 +769,7 @@ def test_apply_aggregating_timedelta_and_datetime():
)
df["time_delta_zero"] = df.datetime - df.datetime
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("clientid").apply(
lambda ddf: Series(
{"clientid_age": ddf.time_delta_zero.min(), "date": ddf.datetime.min()}
@@ -818,13 +818,13 @@ def func_with_date(batch):
return Series({"b": datetime(2015, 1, 1), "c": 2})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
dfg_no_conversion = df.groupby(by=["a"]).apply(func_with_no_date)
dfg_no_conversion_expected = DataFrame({"c": 2}, index=[1])
dfg_no_conversion_expected.index.name = "a"
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
dfg_conversion = df.groupby(by=["a"]).apply(func_with_date)
dfg_conversion_expected = DataFrame(
{"b": pd.Timestamp(2015, 1, 1).as_unit("ns"), "c": 2}, index=[1]
@@ -870,7 +870,7 @@ def test_func(x):
pass
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = test_df.groupby("groups").apply(test_func)
expected = DataFrame()
tm.assert_frame_equal(result, expected)
@@ -887,9 +887,9 @@ def test_func(x):
return x.iloc[[0, -1]]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result1 = test_df1.groupby("groups").apply(test_func)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result2 = test_df2.groupby("groups").apply(test_func)
index1 = MultiIndex.from_arrays([[1, 1], [0, 2]], names=["groups", None])
index2 = MultiIndex.from_arrays([[2, 2], [1, 3]], names=["groups", None])
@@ -904,7 +904,7 @@ def test_groupby_apply_return_empty_chunk():
df = DataFrame({"value": [0, 1], "group": ["filled", "empty"]})
groups = df.groupby("group")
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = groups.apply(lambda group: group[group.value != 1]["value"])
expected = Series(
[0],
@@ -933,7 +933,7 @@ def test_func_returns_object():
# GH 28652
df = DataFrame({"a": [1, 2]}, index=Index([1, 2]))
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("a").apply(lambda g: g.index)
expected = Series([Index([1]), Index([2])], index=Index([1, 2], name="a"))
@@ -952,7 +952,7 @@ def test_apply_datetime_issue(group_column_dtlike, using_infer_string):
df = DataFrame({"a": ["foo"], "b": [group_column_dtlike]})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("a").apply(lambda x: Series(["spam"], index=[42]))
dtype = "string" if using_infer_string else "object"
@@ -992,7 +992,7 @@ def most_common_values(df):
return Series({c: s.value_counts().index[0] for c, s in df.items()})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = tdf.groupby("day").apply(most_common_values)["userId"]
expected = Series(
["17661101"], index=pd.DatetimeIndex(["2015-02-24"], name="day"), name="userId"
@@ -1035,7 +1035,7 @@ def test_groupby_apply_datetime_result_dtypes(using_infer_string):
columns=["observation", "color", "mood", "intensity", "score"],
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = data.groupby("color").apply(lambda g: g.iloc[0]).dtypes
dtype = "string" if using_infer_string else object
expected = Series(
@@ -1058,7 +1058,7 @@ def test_apply_index_has_complex_internals(index):
# GH 31248
df = DataFrame({"group": [1, 1, 2], "value": [0, 1, 0]}, index=index)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("group", group_keys=False).apply(lambda x: x)
tm.assert_frame_equal(result, df)
@@ -1083,7 +1083,7 @@ def test_apply_function_returns_non_pandas_non_scalar(function, expected_values)
# GH 31441
df = DataFrame(["A", "A", "B", "B"], columns=["groups"])
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("groups").apply(function)
expected = Series(expected_values, index=Index(["A", "B"], name="groups"))
tm.assert_series_equal(result, expected)
@@ -1097,7 +1097,7 @@ def fct(group):
df = DataFrame({"A": ["a", "a", "b", "none"], "B": [1, 2, 3, np.nan]})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").apply(fct)
expected = Series(
[[1.0, 2.0], [3.0], [np.nan]], index=Index(["a", "b", "none"], name="A")
@@ -1110,7 +1110,7 @@ def test_apply_function_index_return(function):
# GH: 22541
df = DataFrame([1, 2, 2, 2, 1, 2, 3, 1, 3, 1], columns=["id"])
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("id").apply(function)
expected = Series(
[Index([0, 4, 7, 9]), Index([1, 2, 3, 5]), Index([6, 8])],
@@ -1148,7 +1148,7 @@ def test_apply_result_type(group_keys, udf):
# regardless of whether the UDF happens to be a transform.
df = DataFrame({"A": ["a", "b"], "B": [1, 2]})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
df_result = df.groupby("A", group_keys=group_keys).apply(udf)
series_result = df.B.groupby(df.A, group_keys=group_keys).apply(udf)
@@ -1165,9 +1165,9 @@ def test_result_order_group_keys_false():
# apply result order should not depend on whether index is the same or just equal
df = DataFrame({"A": [2, 1, 2], "B": [1, 2, 3]})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A", group_keys=False).apply(lambda x: x)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = df.groupby("A", group_keys=False).apply(lambda x: x.copy())
tm.assert_frame_equal(result, expected)
@@ -1181,11 +1181,11 @@ def test_apply_with_timezones_aware():
df2 = DataFrame({"x": list(range(2)) * 3, "y": range(6), "t": index_tz})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result1 = df1.groupby("x", group_keys=False).apply(
lambda df: df[["x", "y"]].copy()
)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result2 = df2.groupby("x", group_keys=False).apply(
lambda df: df[["x", "y"]].copy()
)
@@ -1205,7 +1205,7 @@ def test_apply_is_unchanged_when_other_methods_are_called_first(reduction_func):
)
expected = DataFrame(
- {"a": [264, 297], "b": [15, 6], "c": [150, 60]},
+ {"b": [15, 6], "c": [150, 60]},
index=Index([88, 99], name="a"),
)
@@ -1213,7 +1213,7 @@ def test_apply_is_unchanged_when_other_methods_are_called_first(reduction_func):
grp = df.groupby(by="a")
msg = "The behavior of DataFrame.sum with axis=None is deprecated"
with tm.assert_produces_warning(FutureWarning, match=msg, check_stacklevel=False):
- result = grp.apply(sum)
+ result = grp.apply(sum, include_groups=False)
tm.assert_frame_equal(result, expected)
# Check output when another method is called before .apply()
@@ -1221,7 +1221,7 @@ def test_apply_is_unchanged_when_other_methods_are_called_first(reduction_func):
args = get_groupby_method_args(reduction_func, df)
_ = getattr(grp, reduction_func)(*args)
with tm.assert_produces_warning(FutureWarning, match=msg, check_stacklevel=False):
- result = grp.apply(sum)
+ result = grp.apply(sum, include_groups=False)
tm.assert_frame_equal(result, expected)
@@ -1244,7 +1244,7 @@ def test_apply_with_date_in_multiindex_does_not_convert_to_timestamp():
grp = df.groupby(["A", "B"])
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = grp.apply(lambda x: x.head(1))
expected = df.iloc[[0, 2, 3]]
@@ -1294,7 +1294,7 @@ def test_apply_dropna_with_indexed_same(dropna):
index=list("xxyxz"),
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("group", dropna=dropna, group_keys=False).apply(lambda x: x)
expected = df.dropna() if dropna else df.iloc[[0, 3, 1, 2, 4]]
tm.assert_frame_equal(result, expected)
@@ -1321,7 +1321,7 @@ def test_apply_as_index_constant_lambda(as_index, expected):
# GH 13217
df = DataFrame({"a": [1, 1, 2, 2], "b": [1, 1, 2, 2], "c": [1, 1, 1, 1]})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby(["a", "b"], as_index=as_index).apply(lambda x: 1)
tm.assert_equal(result, expected)
@@ -1333,7 +1333,7 @@ def test_sort_index_groups():
index=range(5),
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("C").apply(lambda x: x.A.sort_index())
expected = Series(
range(1, 6),
@@ -1355,7 +1355,7 @@ def test_positional_slice_groups_datetimelike():
}
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = expected.groupby(
[expected.let, expected.date.dt.date], group_keys=False
).apply(lambda x: x.iloc[0:])
@@ -1402,9 +1402,9 @@ def test_apply_na(dropna):
)
dfgrp = df.groupby("grp", dropna=dropna)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = dfgrp.apply(lambda grp_df: grp_df.nlargest(1, "z"))
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = dfgrp.apply(lambda x: x.sort_values("z", ascending=False).head(1))
tm.assert_frame_equal(result, expected)
@@ -1412,7 +1412,7 @@ def test_apply_na(dropna):
def test_apply_empty_string_nan_coerce_bug():
# GH#24903
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = (
DataFrame(
{
@@ -1449,7 +1449,7 @@ def test_apply_index_key_error_bug(index_values):
index=Index(["a2", "a3", "aa"], name="a"),
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = result.groupby("a").apply(
lambda df: Series([df["b"].mean()], index=["b_mean"])
)
@@ -1501,7 +1501,7 @@ def test_apply_nonmonotonic_float_index(arg, idx):
# GH 34455
expected = DataFrame({"col": arg}, index=idx)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = expected.groupby("col", group_keys=False).apply(lambda x: x)
tm.assert_frame_equal(result, expected)
@@ -1554,7 +1554,7 @@ def test_include_groups(include_groups):
# GH#7155
df = DataFrame({"a": [1, 1, 2], "b": [3, 4, 5]})
gb = df.groupby("a")
- warn = FutureWarning if include_groups else None
+ warn = DeprecationWarning if include_groups else None
msg = "DataFrameGroupBy.apply operated on the grouping columns"
with tm.assert_produces_warning(warn, match=msg):
result = gb.apply(lambda x: x.sum(), include_groups=include_groups)
@@ -1590,11 +1590,11 @@ def test_builtins_apply(keys, f):
npfunc = lambda x: getattr(np, fname)(x, axis=0) # numpy's equivalent function
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = gb.apply(npfunc)
tm.assert_frame_equal(result, expected)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected2 = gb.apply(lambda x: npfunc(x))
tm.assert_frame_equal(result, expected2)
diff --git a/pandas/tests/groupby/test_apply_mutate.py b/pandas/tests/groupby/test_apply_mutate.py
index 09d5e06bf6ddd..cfd1a4bca9d91 100644
--- a/pandas/tests/groupby/test_apply_mutate.py
+++ b/pandas/tests/groupby/test_apply_mutate.py
@@ -14,12 +14,12 @@ def test_group_by_copy():
).set_index("name")
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
grp_by_same_value = df.groupby(["age"], group_keys=False).apply(
lambda group: group
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
grp_by_copy = df.groupby(["age"], group_keys=False).apply(
lambda group: group.copy()
)
@@ -54,9 +54,9 @@ def f_no_copy(x):
return x.groupby("cat2")["rank"].min()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
grpby_copy = df.groupby("cat1").apply(f_copy)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
grpby_no_copy = df.groupby("cat1").apply(f_no_copy)
tm.assert_series_equal(grpby_copy, grpby_no_copy)
@@ -68,14 +68,14 @@ def test_no_mutate_but_looks_like():
df = pd.DataFrame({"key": [1, 1, 1, 2, 2, 2, 3, 3, 3], "value": range(9)})
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result1 = df.groupby("key", group_keys=True).apply(lambda x: x[:].key)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result2 = df.groupby("key", group_keys=True).apply(lambda x: x.key)
tm.assert_series_equal(result1, result2)
-def test_apply_function_with_indexing():
+def test_apply_function_with_indexing(warn_copy_on_write):
# GH: 33058
df = pd.DataFrame(
{"col1": ["A", "A", "A", "B", "B", "B"], "col2": [1, 2, 3, 4, 5, 6]}
@@ -86,7 +86,9 @@ def fn(x):
return x.col2
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(
+ DeprecationWarning, match=msg, raise_on_extra_warnings=not warn_copy_on_write
+ ):
result = df.groupby(["col1"], as_index=False).apply(fn)
expected = pd.Series(
[1, 2, 0, 4, 5, 0],
diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py
index 7a91601bf688f..f60ff65536f20 100644
--- a/pandas/tests/groupby/test_categorical.py
+++ b/pandas/tests/groupby/test_categorical.py
@@ -125,7 +125,7 @@ def f(x):
return x.drop_duplicates("person_name").iloc[0]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = g.apply(f)
expected = x.iloc[[0, 1]].copy()
expected.index = Index([1, 2], name="person_id")
@@ -333,7 +333,7 @@ def test_apply(ordered):
idx = MultiIndex.from_arrays([missing, dense], names=["missing", "dense"])
expected = Series(1, index=idx)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = grouped.apply(lambda x: 1)
tm.assert_series_equal(result, expected)
@@ -2050,7 +2050,7 @@ def test_category_order_apply(as_index, sort, observed, method, index_kind, orde
df["a2"] = df["a"]
df = df.set_index(keys)
gb = df.groupby(keys, as_index=as_index, sort=sort, observed=observed)
- warn = FutureWarning if method == "apply" and index_kind == "range" else None
+ warn = DeprecationWarning if method == "apply" and index_kind == "range" else None
msg = "DataFrameGroupBy.apply operated on the grouping columns"
with tm.assert_produces_warning(warn, match=msg):
op_result = getattr(gb, method)(lambda x: x.sum(numeric_only=True))
diff --git a/pandas/tests/groupby/test_counting.py b/pandas/tests/groupby/test_counting.py
index 16d7fe61b90ad..2622895f9f8d2 100644
--- a/pandas/tests/groupby/test_counting.py
+++ b/pandas/tests/groupby/test_counting.py
@@ -290,7 +290,7 @@ def test_count():
for key in ["1st", "2nd", ["1st", "2nd"]]:
left = df.groupby(key).count()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
right = df.groupby(key).apply(DataFrame.count).drop(key, axis=1)
tm.assert_frame_equal(left, right)
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 4c903e691add1..ed9acdd0c9dde 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -163,7 +163,7 @@ def max_value(group):
return group.loc[group["value"].idxmax()]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
applied = df.groupby("A").apply(max_value)
result = applied.dtypes
expected = df.dtypes
@@ -186,7 +186,7 @@ def f_0(grp):
expected = df.groupby("A").first()[["B"]]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").apply(f_0)[["B"]]
tm.assert_frame_equal(result, expected)
@@ -196,7 +196,7 @@ def f_1(grp):
return grp.iloc[0]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").apply(f_1)[["B"]]
e = expected.copy()
e.loc["Tiger"] = np.nan
@@ -208,7 +208,7 @@ def f_2(grp):
return grp.iloc[0]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").apply(f_2)[["B"]]
e = expected.copy()
e.loc["Pony"] = np.nan
@@ -221,7 +221,7 @@ def f_3(grp):
return grp.iloc[0]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").apply(f_3)[["C"]]
e = df.groupby("A").first()[["C"]]
e.loc["Pony"] = pd.NaT
@@ -234,7 +234,7 @@ def f_4(grp):
return grp.iloc[0].loc["C"]
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").apply(f_4)
e = df.groupby("A").first()["C"].copy()
e.loc["Pony"] = np.nan
@@ -421,9 +421,9 @@ def f3(x):
# correct result
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result1 = df.groupby("a").apply(f1)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result2 = df2.groupby("a").apply(f1)
tm.assert_frame_equal(result1, result2)
@@ -1377,13 +1377,13 @@ def summarize_random_name(df):
return Series({"count": 1, "mean": 2, "omissions": 3}, name=df.iloc[0]["A"])
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
metrics = df.groupby("A").apply(summarize)
assert metrics.columns.name is None
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
metrics = df.groupby("A").apply(summarize, "metrics")
assert metrics.columns.name == "metrics"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
metrics = df.groupby("A").apply(summarize_random_name)
assert metrics.columns.name is None
@@ -1678,7 +1678,7 @@ def test_dont_clobber_name_column():
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("key", group_keys=False).apply(lambda x: x)
tm.assert_frame_equal(result, df)
@@ -1762,7 +1762,7 @@ def freducex(x):
# make sure all these work
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
grouped.apply(f)
grouped.aggregate(freduce)
grouped.aggregate({"C": freduce, "D": freduce})
@@ -1785,7 +1785,7 @@ def f(group):
return group.copy()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
df.groupby("a", sort=False, group_keys=False).apply(f)
expected_names = [0, 1, 2]
@@ -1993,7 +1993,7 @@ def test_sort(x):
tm.assert_frame_equal(x, x.sort_values(by=sort_column))
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
g.apply(test_sort)
@@ -2180,7 +2180,7 @@ def test_empty_groupby_apply_nonunique_columns():
df.columns = [0, 1, 2, 0]
gb = df.groupby(df[1], group_keys=False)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
res = gb.apply(lambda x: x)
assert (res.dtypes == df.dtypes).all()
diff --git a/pandas/tests/groupby/test_groupby_dropna.py b/pandas/tests/groupby/test_groupby_dropna.py
index 73638eba0a3b3..9155f2cccf117 100644
--- a/pandas/tests/groupby/test_groupby_dropna.py
+++ b/pandas/tests/groupby/test_groupby_dropna.py
@@ -325,7 +325,7 @@ def test_groupby_apply_with_dropna_for_multi_index(dropna, data, selected_data,
df = pd.DataFrame(data)
gb = df.groupby("groups", dropna=dropna)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = gb.apply(lambda grp: pd.DataFrame({"values": range(len(grp))}))
mi_tuples = tuple(zip(data["groups"], selected_data["values"]))
diff --git a/pandas/tests/groupby/test_groupby_subclass.py b/pandas/tests/groupby/test_groupby_subclass.py
index bf809bd5db437..0832b67b38098 100644
--- a/pandas/tests/groupby/test_groupby_subclass.py
+++ b/pandas/tests/groupby/test_groupby_subclass.py
@@ -69,16 +69,27 @@ def test_groupby_preserves_metadata():
def func(group):
assert isinstance(group, tm.SubclassedDataFrame)
assert hasattr(group, "testattr")
+ assert group.testattr == "hello"
return group.testattr
msg = "DataFrameGroupBy.apply operated on the grouping columns"
with tm.assert_produces_warning(
- FutureWarning, match=msg, raise_on_extra_warnings=False
+ DeprecationWarning,
+ match=msg,
+ raise_on_extra_warnings=False,
+ check_stacklevel=False,
):
result = custom_df.groupby("c").apply(func)
expected = tm.SubclassedSeries(["hello"] * 3, index=Index([7, 8, 9], name="c"))
tm.assert_series_equal(result, expected)
+ result = custom_df.groupby("c").apply(func, include_groups=False)
+ tm.assert_series_equal(result, expected)
+
+ # https://github.com/pandas-dev/pandas/pull/56761
+ result = custom_df.groupby("c")[["a", "b"]].apply(func)
+ tm.assert_series_equal(result, expected)
+
def func2(group):
assert isinstance(group, tm.SubclassedSeries)
assert hasattr(group, "testattr")
@@ -115,7 +126,10 @@ def test_groupby_resample_preserves_subclass(obj):
# Confirm groupby.resample() preserves dataframe type
msg = "DataFrameGroupBy.resample operated on the grouping columns"
with tm.assert_produces_warning(
- FutureWarning, match=msg, raise_on_extra_warnings=False
+ DeprecationWarning,
+ match=msg,
+ raise_on_extra_warnings=False,
+ check_stacklevel=False,
):
result = df.groupby("Buyer").resample("5D").sum()
assert isinstance(result, obj)
diff --git a/pandas/tests/groupby/test_grouping.py b/pandas/tests/groupby/test_grouping.py
index 363ff883385db..d763b67059375 100644
--- a/pandas/tests/groupby/test_grouping.py
+++ b/pandas/tests/groupby/test_grouping.py
@@ -238,7 +238,7 @@ def test_grouper_creation_bug(self):
tm.assert_frame_equal(result, expected)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = g.apply(lambda x: x.sum())
expected["A"] = [0, 2, 4]
expected = expected.loc[:, ["A", "B"]]
diff --git a/pandas/tests/groupby/test_reductions.py b/pandas/tests/groupby/test_reductions.py
index 425079f943aba..25b0f80639cff 100644
--- a/pandas/tests/groupby/test_reductions.py
+++ b/pandas/tests/groupby/test_reductions.py
@@ -7,6 +7,9 @@
from pandas._libs.tslibs import iNaT
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.missing import na_value_for_dtype
+
import pandas as pd
from pandas import (
DataFrame,
@@ -195,6 +198,68 @@ def test_empty(frame_or_series, bool_agg_func):
tm.assert_equal(result, expected)
+@pytest.mark.parametrize("how", ["idxmin", "idxmax"])
+def test_idxmin_idxmax_extremes(how, any_real_numpy_dtype):
+ # GH#57040
+ if any_real_numpy_dtype is int or any_real_numpy_dtype is float:
+ # No need to test
+ return
+ info = np.iinfo if "int" in any_real_numpy_dtype else np.finfo
+ min_value = info(any_real_numpy_dtype).min
+ max_value = info(any_real_numpy_dtype).max
+ df = DataFrame(
+ {"a": [2, 1, 1, 2], "b": [min_value, max_value, max_value, min_value]},
+ dtype=any_real_numpy_dtype,
+ )
+ gb = df.groupby("a")
+ result = getattr(gb, how)()
+ expected = DataFrame(
+ {"b": [1, 0]}, index=pd.Index([1, 2], name="a", dtype=any_real_numpy_dtype)
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("how", ["idxmin", "idxmax"])
+def test_idxmin_idxmax_extremes_skipna(skipna, how, float_numpy_dtype):
+ # GH#57040
+ min_value = np.finfo(float_numpy_dtype).min
+ max_value = np.finfo(float_numpy_dtype).max
+ df = DataFrame(
+ {
+ "a": Series(np.repeat(range(1, 6), repeats=2), dtype="intp"),
+ "b": Series(
+ [
+ np.nan,
+ min_value,
+ np.nan,
+ max_value,
+ min_value,
+ np.nan,
+ max_value,
+ np.nan,
+ np.nan,
+ np.nan,
+ ],
+ dtype=float_numpy_dtype,
+ ),
+ },
+ )
+ gb = df.groupby("a")
+
+ warn = None if skipna else FutureWarning
+ msg = f"The behavior of DataFrameGroupBy.{how} with all-NA values"
+ with tm.assert_produces_warning(warn, match=msg):
+ result = getattr(gb, how)(skipna=skipna)
+ if skipna:
+ values = [1, 3, 4, 6, np.nan]
+ else:
+ values = np.nan
+ expected = DataFrame(
+ {"b": values}, index=pd.Index(range(1, 6), name="a", dtype="intp")
+ )
+ tm.assert_frame_equal(result, expected)
+
+
@pytest.mark.parametrize(
"func, values",
[
@@ -265,6 +330,34 @@ def test_groupby_non_arithmetic_agg_int_like_precision(method, data):
tm.assert_frame_equal(result, expected)
+@pytest.mark.parametrize("how", ["first", "last"])
+def test_first_last_skipna(any_real_nullable_dtype, sort, skipna, how):
+ # GH#57019
+ na_value = na_value_for_dtype(pandas_dtype(any_real_nullable_dtype))
+ df = DataFrame(
+ {
+ "a": [2, 1, 1, 2, 3, 3],
+ "b": [na_value, 3.0, na_value, 4.0, np.nan, np.nan],
+ "c": [na_value, 3.0, na_value, 4.0, np.nan, np.nan],
+ },
+ dtype=any_real_nullable_dtype,
+ )
+ gb = df.groupby("a", sort=sort)
+ method = getattr(gb, how)
+ result = method(skipna=skipna)
+
+ ilocs = {
+ ("first", True): [3, 1, 4],
+ ("first", False): [0, 1, 4],
+ ("last", True): [3, 1, 5],
+ ("last", False): [3, 2, 5],
+ }[how, skipna]
+ expected = df.iloc[ilocs].set_index("a")
+ if sort:
+ expected = expected.sort_index()
+ tm.assert_frame_equal(result, expected)
+
+
def test_idxmin_idxmax_axis1():
df = DataFrame(
np.random.default_rng(2).standard_normal((10, 4)), columns=["A", "B", "C", "D"]
diff --git a/pandas/tests/groupby/test_timegrouper.py b/pandas/tests/groupby/test_timegrouper.py
index d357a65e79796..8ef7c2b8ce859 100644
--- a/pandas/tests/groupby/test_timegrouper.py
+++ b/pandas/tests/groupby/test_timegrouper.py
@@ -478,10 +478,10 @@ def sumfunc_series(x):
return Series([x["value"].sum()], ("sum",))
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = df.groupby(Grouper(key="date")).apply(sumfunc_series)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df_dt.groupby(Grouper(freq="ME", key="date")).apply(sumfunc_series)
tm.assert_frame_equal(
result.reset_index(drop=True), expected.reset_index(drop=True)
@@ -499,9 +499,9 @@ def sumfunc_value(x):
return x.value.sum()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = df.groupby(Grouper(key="date")).apply(sumfunc_value)
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df_dt.groupby(Grouper(freq="ME", key="date")).apply(sumfunc_value)
tm.assert_series_equal(
result.reset_index(drop=True), expected.reset_index(drop=True)
@@ -929,7 +929,7 @@ def test_groupby_apply_timegrouper_with_nat_apply_squeeze(
# function that returns a Series
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
res = gb.apply(lambda x: x["Quantity"] * 2)
dti = Index([Timestamp("2013-12-31")], dtype=df["Date"].dtype, name="Date")
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index a2ecd6c65db60..fd9bd5cc55538 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -668,7 +668,7 @@ def f(group):
grouped = df.groupby("c")
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = grouped.apply(f)
assert result["d"].dtype == np.float64
@@ -826,7 +826,7 @@ def test_cython_transform_frame(request, op, args, targop, df_fix, gb_target):
if op != "shift" or not isinstance(gb_target.get("by"), (str, list)):
warn = None
else:
- warn = FutureWarning
+ warn = DeprecationWarning
msg = "DataFrameGroupBy.apply operated on the grouping columns"
with tm.assert_produces_warning(warn, match=msg):
expected = gb.apply(targop)
diff --git a/pandas/tests/indexes/base_class/test_constructors.py b/pandas/tests/indexes/base_class/test_constructors.py
index fd5176a28565e..338509dd239e6 100644
--- a/pandas/tests/indexes/base_class/test_constructors.py
+++ b/pandas/tests/indexes/base_class/test_constructors.py
@@ -71,3 +71,10 @@ def test_inference_on_pandas_objects(self):
with tm.assert_produces_warning(FutureWarning, match="Dtype inference"):
result = Index(ser)
assert result.dtype != np.object_
+
+ def test_constructor_not_read_only(self):
+ # GH#57130
+ ser = Series([1, 2], dtype=object)
+ with pd.option_context("mode.copy_on_write", True):
+ idx = Index(ser)
+ assert idx._values.flags.writeable
diff --git a/pandas/tests/indexes/categorical/test_setops.py b/pandas/tests/indexes/categorical/test_setops.py
new file mode 100644
index 0000000000000..2e87b90efd54c
--- /dev/null
+++ b/pandas/tests/indexes/categorical/test_setops.py
@@ -0,0 +1,18 @@
+import numpy as np
+import pytest
+
+from pandas import (
+ CategoricalIndex,
+ Index,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("na_value", [None, np.nan])
+def test_difference_with_na(na_value):
+ # GH 57318
+ ci = CategoricalIndex(["a", "b", "c", None])
+ other = Index(["c", na_value])
+ result = ci.difference(other)
+ expected = CategoricalIndex(["a", "b"], categories=["a", "b", "c"])
+ tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/datetimes/methods/test_to_period.py b/pandas/tests/indexes/datetimes/methods/test_to_period.py
index 42a3f3b0f7b42..de8d32f64cde2 100644
--- a/pandas/tests/indexes/datetimes/methods/test_to_period.py
+++ b/pandas/tests/indexes/datetimes/methods/test_to_period.py
@@ -111,23 +111,6 @@ def test_to_period_frequency_M_Q_Y_A_deprecated(self, freq, freq_depr):
with tm.assert_produces_warning(FutureWarning, match=msg):
assert prng.freq == freq_depr
- @pytest.mark.parametrize(
- "freq, freq_depr",
- [
- ("2BQE-SEP", "2BQ-SEP"),
- ("2BYE-MAR", "2BY-MAR"),
- ],
- )
- def test_to_period_frequency_BQ_BY_deprecated(self, freq, freq_depr):
- # GH#9586
- msg = f"'{freq_depr[1:]}' is deprecated and will be removed "
- f"in a future version, please use '{freq[1:]}' instead."
-
- rng = date_range("01-Jan-2012", periods=8, freq=freq)
- prng = rng.to_period()
- with tm.assert_produces_warning(FutureWarning, match=msg):
- prng.freq == freq_depr
-
def test_to_period_infer(self):
# https://github.com/pandas-dev/pandas/issues/33358
rng = date_range(
@@ -238,5 +221,5 @@ def test_to_period_offsets_not_supported(self, freq):
# GH#56243
msg = f"{freq[1:]} is not supported as period frequency"
ts = date_range("1/1/2012", periods=4, freq=freq)
- with pytest.raises(TypeError, match=msg):
+ with pytest.raises(ValueError, match=msg):
ts.to_period()
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 44dd64e162413..d26bee80003e9 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -822,6 +822,17 @@ def test_frequencies_A_deprecated_Y_renamed(self, freq, freq_depr):
result = date_range("1/1/2000", periods=2, freq=freq_depr)
tm.assert_index_equal(result, expected)
+ def test_to_offset_with_lowercase_deprecated_freq(self) -> None:
+ # https://github.com/pandas-dev/pandas/issues/56847
+ msg = (
+ "'m' is deprecated and will be removed in a future version, please use "
+ "'ME' instead."
+ )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ result = date_range("2010-01-01", periods=2, freq="m")
+ expected = DatetimeIndex(["2010-01-31", "2010-02-28"], freq="ME")
+ tm.assert_index_equal(result, expected)
+
def test_date_range_bday(self):
sdate = datetime(1999, 12, 25)
idx = date_range(start=sdate, freq="1B", periods=20)
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index 5db0aa5cf510f..bac9548b932c1 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -10,8 +10,6 @@
)
import pandas._testing as tm
-START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
-
class TestDatetimeIndexOps:
def test_infer_freq(self, freq_sample):
@@ -26,6 +24,7 @@ def test_infer_freq(self, freq_sample):
class TestBusinessDatetimeIndex:
@pytest.fixture
def rng(self, freq):
+ START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
return bdate_range(START, END, freq=freq)
def test_comparison(self, rng):
diff --git a/pandas/tests/indexes/datetimes/test_partial_slicing.py b/pandas/tests/indexes/datetimes/test_partial_slicing.py
index 0ebb88afb6c86..8b493fc61cb58 100644
--- a/pandas/tests/indexes/datetimes/test_partial_slicing.py
+++ b/pandas/tests/indexes/datetimes/test_partial_slicing.py
@@ -236,7 +236,7 @@ def test_partial_slice_second_precision(self):
rng = date_range(
start=datetime(2005, 1, 1, 0, 0, 59, microsecond=999990),
periods=20,
- freq="US",
+ freq="us",
)
s = Series(np.arange(20), rng)
diff --git a/pandas/tests/indexes/interval/test_constructors.py b/pandas/tests/indexes/interval/test_constructors.py
index 778c07b46e57c..e47a014f18045 100644
--- a/pandas/tests/indexes/interval/test_constructors.py
+++ b/pandas/tests/indexes/interval/test_constructors.py
@@ -3,6 +3,8 @@
import numpy as np
import pytest
+import pandas.util._test_decorators as td
+
from pandas.core.dtypes.common import is_unsigned_integer_dtype
from pandas.core.dtypes.dtypes import IntervalDtype
@@ -517,3 +519,17 @@ def test_dtype_closed_mismatch():
with pytest.raises(ValueError, match=msg):
IntervalArray([], dtype=dtype, closed="neither")
+
+
+@pytest.mark.parametrize(
+ "dtype",
+ ["Float64", pytest.param("float64[pyarrow]", marks=td.skip_if_no("pyarrow"))],
+)
+def test_ea_dtype(dtype):
+ # GH#56765
+ bins = [(0.0, 0.4), (0.4, 0.6)]
+ interval_dtype = IntervalDtype(subtype=dtype, closed="left")
+ result = IntervalIndex.from_tuples(bins, closed="left", dtype=interval_dtype)
+ assert result.dtype == interval_dtype
+ expected = IntervalIndex.from_tuples(bins, closed="left").astype(interval_dtype)
+ tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/interval/test_interval_range.py b/pandas/tests/indexes/interval/test_interval_range.py
index d4d4a09c44d13..e8de59f84bcc6 100644
--- a/pandas/tests/indexes/interval/test_interval_range.py
+++ b/pandas/tests/indexes/interval/test_interval_range.py
@@ -84,9 +84,7 @@ def test_constructor_timestamp(self, closed, name, freq, periods, tz):
tm.assert_index_equal(result, expected)
# GH 20976: linspace behavior defined from start/end/periods
- if not breaks.freq.is_anchored() and tz is None:
- # matches expected only for non-anchored offsets and tz naive
- # (anchored/DST transitions cause unequal spacing in expected)
+ if not breaks.freq.n == 1 and tz is None:
result = interval_range(
start=start, end=end, periods=periods, name=name, closed=closed
)
diff --git a/pandas/tests/indexes/object/test_indexing.py b/pandas/tests/indexes/object/test_indexing.py
index ebf9dac715f8d..443cacf94d239 100644
--- a/pandas/tests/indexes/object/test_indexing.py
+++ b/pandas/tests/indexes/object/test_indexing.py
@@ -7,6 +7,7 @@
NA,
is_matching_na,
)
+from pandas.compat import pa_version_under16p0
import pandas.util._test_decorators as td
import pandas as pd
@@ -200,7 +201,16 @@ class TestSliceLocs:
(pd.IndexSlice["m":"m":-1], ""), # type: ignore[misc]
],
)
- def test_slice_locs_negative_step(self, in_slice, expected, dtype):
+ def test_slice_locs_negative_step(self, in_slice, expected, dtype, request):
+ if (
+ not pa_version_under16p0
+ and dtype == "string[pyarrow_numpy]"
+ and in_slice == slice("a", "a", -1)
+ ):
+ request.applymarker(
+ pytest.mark.xfail(reason="https://github.com/apache/arrow/issues/40642")
+ )
+
index = Index(list("bcdxy"), dtype=dtype)
s_start, s_stop = index.slice_locs(in_slice.start, in_slice.stop, in_slice.step)
diff --git a/pandas/tests/indexes/period/methods/test_asfreq.py b/pandas/tests/indexes/period/methods/test_asfreq.py
index ed078a3e8fb8b..865bae69d91c7 100644
--- a/pandas/tests/indexes/period/methods/test_asfreq.py
+++ b/pandas/tests/indexes/period/methods/test_asfreq.py
@@ -1,3 +1,5 @@
+import re
+
import pytest
from pandas import (
@@ -7,6 +9,8 @@
)
import pandas._testing as tm
+from pandas.tseries import offsets
+
class TestPeriodIndex:
def test_asfreq(self):
@@ -136,3 +140,50 @@ def test_asfreq_with_different_n(self):
excepted = Series([1, 2], index=PeriodIndex(["2020-02", "2020-04"], freq="M"))
tm.assert_series_equal(result, excepted)
+
+ @pytest.mark.parametrize(
+ "freq",
+ [
+ "2BMS",
+ "2YS-MAR",
+ "2bh",
+ ],
+ )
+ def test_pi_asfreq_not_supported_frequency(self, freq):
+ # GH#55785
+ msg = f"{freq[1:]} is not supported as period frequency"
+
+ pi = PeriodIndex(["2020-01-01", "2021-01-01"], freq="M")
+ with pytest.raises(ValueError, match=msg):
+ pi.asfreq(freq=freq)
+
+ @pytest.mark.parametrize(
+ "freq",
+ [
+ "2BME",
+ "2YE-MAR",
+ "2QE",
+ ],
+ )
+ def test_pi_asfreq_invalid_frequency(self, freq):
+ # GH#55785
+ msg = f"Invalid frequency: {freq}"
+
+ pi = PeriodIndex(["2020-01-01", "2021-01-01"], freq="M")
+ with pytest.raises(ValueError, match=msg):
+ pi.asfreq(freq=freq)
+
+ @pytest.mark.parametrize(
+ "freq",
+ [
+ offsets.MonthBegin(2),
+ offsets.BusinessMonthEnd(2),
+ ],
+ )
+ def test_pi_asfreq_invalid_baseoffset(self, freq):
+ # GH#56945
+ msg = re.escape(f"{freq} is not supported as period frequency")
+
+ pi = PeriodIndex(["2020-01-01", "2021-01-01"], freq="M")
+ with pytest.raises(ValueError, match=msg):
+ pi.asfreq(freq=freq)
diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index 387dc47c48d20..892eb7b4a00d1 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -26,9 +26,12 @@ class TestPeriodIndexDisallowedFreqs:
("2M", "2ME"),
("2Q-MAR", "2QE-MAR"),
("2Y-FEB", "2YE-FEB"),
+ ("2M", "2me"),
+ ("2Q-MAR", "2qe-MAR"),
+ ("2Y-FEB", "2yE-feb"),
],
)
- def test_period_index_frequency_ME_error_message(self, freq, freq_depr):
+ def test_period_index_offsets_frequency_error_message(self, freq, freq_depr):
# GH#52064
msg = f"for Period, please use '{freq[1:]}' instead of '{freq_depr[1:]}'"
@@ -38,7 +41,7 @@ def test_period_index_frequency_ME_error_message(self, freq, freq_depr):
with pytest.raises(ValueError, match=msg):
period_range(start="2020-01-01", end="2020-01-02", freq=freq_depr)
- @pytest.mark.parametrize("freq_depr", ["2SME", "2CBME", "2BYE"])
+ @pytest.mark.parametrize("freq_depr", ["2SME", "2sme", "2CBME", "2BYE", "2Bye"])
def test_period_index_frequency_invalid_freq(self, freq_depr):
# GH#9586
msg = f"Invalid frequency: {freq_depr[1:]}"
@@ -48,6 +51,15 @@ def test_period_index_frequency_invalid_freq(self, freq_depr):
with pytest.raises(ValueError, match=msg):
PeriodIndex(["2020-01", "2020-05"], freq=freq_depr)
+ @pytest.mark.parametrize("freq", ["2BQE-SEP", "2BYE-MAR", "2BME"])
+ def test_period_index_from_datetime_index_invalid_freq(self, freq):
+ # GH#56899
+ msg = f"Invalid frequency: {freq[1:]}"
+
+ rng = date_range("01-Jan-2012", periods=8, freq=freq)
+ with pytest.raises(ValueError, match=msg):
+ rng.to_period()
+
class TestPeriodIndex:
def test_from_ordinals(self):
@@ -538,7 +550,9 @@ def test_period_range_length(self):
assert i1.freq == end_intv.freq
assert i1[-1] == end_intv
- end_intv = Period("2006-12-31", "1w")
+ msg = "'w' is deprecated and will be removed in a future version."
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ end_intv = Period("2006-12-31", "1w")
i2 = period_range(end=end_intv, periods=10)
assert len(i1) == len(i2)
assert (i1 == i2).all()
@@ -567,7 +581,9 @@ def test_mixed_freq_raises(self):
with tm.assert_produces_warning(FutureWarning, match=msg):
end_intv = Period("2005-05-01", "B")
- vals = [end_intv, Period("2006-12-31", "w")]
+ msg = "'w' is deprecated and will be removed in a future version."
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ vals = [end_intv, Period("2006-12-31", "w")]
msg = r"Input has different freq=W-SUN from PeriodIndex\(freq=B\)"
depr_msg = r"PeriodDtype\[B\] is deprecated"
with pytest.raises(IncompatibleFrequency, match=msg):
diff --git a/pandas/tests/indexes/period/test_period_range.py b/pandas/tests/indexes/period/test_period_range.py
index 2543b49089948..6f8e6d07da8bf 100644
--- a/pandas/tests/indexes/period/test_period_range.py
+++ b/pandas/tests/indexes/period/test_period_range.py
@@ -181,7 +181,9 @@ def test_construction_from_period(self):
def test_mismatched_start_end_freq_raises(self):
depr_msg = "Period with BDay freq is deprecated"
- end_w = Period("2006-12-31", "1w")
+ msg = "'w' is deprecated and will be removed in a future version."
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ end_w = Period("2006-12-31", "1w")
with tm.assert_produces_warning(FutureWarning, match=depr_msg):
start_b = Period("02-Apr-2005", "B")
@@ -203,19 +205,37 @@ def test_constructor_U(self):
with pytest.raises(ValueError, match="Invalid frequency: X"):
period_range("2007-1-1", periods=500, freq="X")
- def test_H_deprecated_from_time_series(self):
+ @pytest.mark.parametrize(
+ "freq,freq_depr",
+ [
+ ("2Y", "2A"),
+ ("2Y", "2a"),
+ ("2Y-AUG", "2A-AUG"),
+ ("2Y-AUG", "2A-aug"),
+ ],
+ )
+ def test_a_deprecated_from_time_series(self, freq, freq_depr):
# GH#52536
- msg = "'H' is deprecated and will be removed in a future version."
+ msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+ f"future version. Please use '{freq[1:]}' instead."
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ period_range(freq=freq_depr, start="1/1/2001", end="12/1/2009")
+
+ @pytest.mark.parametrize("freq_depr", ["2H", "2MIN", "2S", "2US", "2NS"])
+ def test_uppercase_freq_deprecated_from_time_series(self, freq_depr):
+ # GH#52536, GH#54939
+ msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+ f"future version. Please use '{freq_depr.lower()[1:]}' instead."
+
with tm.assert_produces_warning(FutureWarning, match=msg):
- period_range(freq="2H", start="1/1/2001", end="12/1/2009")
+ period_range("2020-01-01 00:00:00 00:00", periods=2, freq=freq_depr)
+
+ @pytest.mark.parametrize("freq_depr", ["2m", "2q-sep", "2y", "2w"])
+ def test_lowercase_freq_deprecated_from_time_series(self, freq_depr):
+ # GH#52536, GH#54939
+ msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+ f"future version. Please use '{freq_depr.upper()[1:]}' instead."
- @pytest.mark.parametrize("freq_depr", ["2A", "A-DEC", "200A-AUG"])
- def test_a_deprecated_from_time_series(self, freq_depr):
- # GH#52536
- freq_msg = freq_depr[freq_depr.index("A") :]
- msg = (
- f"'{freq_msg}' is deprecated and will be removed in a future version, "
- f"please use 'Y{freq_msg[1:]}' instead."
- )
with tm.assert_produces_warning(FutureWarning, match=msg):
period_range(freq=freq_depr, start="1/1/2001", end="12/1/2009")
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 666d92064c86c..b7204d7af1cbb 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -358,7 +358,10 @@ def test_view_with_args_object_array_raises(self, index):
with pytest.raises(NotImplementedError, match="i8"):
index.view("i8")
else:
- msg = "Cannot change data-type for object array"
+ msg = (
+ "Cannot change data-type for array of references|"
+ "Cannot change data-type for object array|"
+ )
with pytest.raises(TypeError, match=msg):
index.view("i8")
@@ -1722,3 +1725,13 @@ def test_nan_comparison_same_object(op):
result = op(idx, idx.copy())
tm.assert_numpy_array_equal(result, expected)
+
+
+@td.skip_if_no("pyarrow")
+def test_is_monotonic_pyarrow_list_type():
+ # GH 57333
+ import pyarrow as pa
+
+ idx = Index([[1], [2, 3]], dtype=pd.ArrowDtype(pa.list_(pa.int64())))
+ assert not idx.is_monotonic_increasing
+ assert not idx.is_monotonic_decreasing
diff --git a/pandas/tests/indexes/test_common.py b/pandas/tests/indexes/test_common.py
index 412a59d15307d..80c39322b9b81 100644
--- a/pandas/tests/indexes/test_common.py
+++ b/pandas/tests/indexes/test_common.py
@@ -500,3 +500,12 @@ def test_ndarray_compat_properties(index):
# test for validity
idx.nbytes
idx.values.nbytes
+
+
+def test_compare_read_only_array():
+ # GH#57130
+ arr = np.array([], dtype=object)
+ arr.flags.writeable = False
+ idx = pd.Index(arr)
+ result = idx > 69
+ assert result.dtype == bool
diff --git a/pandas/tests/indexes/test_index_new.py b/pandas/tests/indexes/test_index_new.py
index 72641077c90fe..6042e5b9cc679 100644
--- a/pandas/tests/indexes/test_index_new.py
+++ b/pandas/tests/indexes/test_index_new.py
@@ -413,7 +413,7 @@ class ArrayLike:
def __init__(self, array) -> None:
self.array = array
- def __array__(self, dtype=None) -> np.ndarray:
+ def __array__(self, dtype=None, copy=None) -> np.ndarray:
return self.array
expected = Index(array)
diff --git a/pandas/tests/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index 409eca42f404b..43dd3812e8b7d 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -535,7 +535,8 @@ def test_iloc_setitem_frame_duplicate_columns_multiple_blocks(
# if the assigned values cannot be held by existing integer arrays,
# we cast
- df.iloc[:, 0] = df.iloc[:, 0] + 0.5
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ df.iloc[:, 0] = df.iloc[:, 0] + 0.5
if not using_array_manager:
assert len(df._mgr.blocks) == 2
@@ -1471,6 +1472,7 @@ def test_iloc_setitem_pure_position_based(self):
def test_iloc_nullable_int64_size_1_nan(self):
# GH 31861
result = DataFrame({"a": ["test"], "b": [np.nan]})
- result.loc[:, "b"] = result.loc[:, "b"].astype("Int64")
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ result.loc[:, "b"] = result.loc[:, "b"].astype("Int64")
expected = DataFrame({"a": ["test"], "b": array([NA], dtype="Int64")})
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index fb0adc56c401b..0cd1390d41461 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -584,7 +584,8 @@ def test_loc_setitem_consistency(self, frame_for_consistency, val):
}
)
df = frame_for_consistency.copy()
- df.loc[:, "date"] = val
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ df.loc[:, "date"] = val
tm.assert_frame_equal(df, expected)
def test_loc_setitem_consistency_dt64_to_str(self, frame_for_consistency):
@@ -598,7 +599,8 @@ def test_loc_setitem_consistency_dt64_to_str(self, frame_for_consistency):
}
)
df = frame_for_consistency.copy()
- df.loc[:, "date"] = "foo"
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ df.loc[:, "date"] = "foo"
tm.assert_frame_equal(df, expected)
def test_loc_setitem_consistency_dt64_to_float(self, frame_for_consistency):
@@ -611,14 +613,16 @@ def test_loc_setitem_consistency_dt64_to_float(self, frame_for_consistency):
}
)
df = frame_for_consistency.copy()
- df.loc[:, "date"] = 1.0
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ df.loc[:, "date"] = 1.0
tm.assert_frame_equal(df, expected)
def test_loc_setitem_consistency_single_row(self):
# GH 15494
# setting on frame with single row
df = DataFrame({"date": Series([Timestamp("20180101")])})
- df.loc[:, "date"] = "string"
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ df.loc[:, "date"] = "string"
expected = DataFrame({"date": Series(["string"])})
tm.assert_frame_equal(df, expected)
@@ -678,9 +682,10 @@ def test_loc_setitem_consistency_slice_column_len(self):
# timedelta64[m] -> float, so this cannot be done inplace, so
# no warning
- df.loc[:, ("Respondent", "Duration")] = df.loc[
- :, ("Respondent", "Duration")
- ] / Timedelta(60_000_000_000)
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+ df.loc[:, ("Respondent", "Duration")] = df.loc[
+ :, ("Respondent", "Duration")
+ ] / Timedelta(60_000_000_000)
expected = Series(
[23.0, 12.0, 14.0, 36.0], index=df.index, name=("Respondent", "Duration")
@@ -1230,13 +1235,7 @@ def test_loc_setitem_empty_append_raises(self):
with pytest.raises(KeyError, match=msg):
df.loc[[0, 1], "x"] = data
- msg = "|".join(
- [
- "cannot copy sequence with size 2 to array axis with dimension 0",
- r"could not broadcast input array from shape \(2,\) into shape \(0,\)",
- "Must have equal len keys and value when setting with an iterable",
- ]
- )
+ msg = "setting an array element with a sequence."
with pytest.raises(ValueError, match=msg):
df.loc[0:2, "x"] = data
@@ -1487,7 +1486,11 @@ def test_loc_setitem_datetimeindex_tz(self, idxer, tz_naive_fixture):
# if result started off with object dtype, then the .loc.__setitem__
# below would retain object dtype
result = DataFrame(index=idx, columns=["var"], dtype=np.float64)
- result.loc[:, idxer] = expected
+ with tm.assert_produces_warning(
+ FutureWarning if idxer == "var" else None, match="incompatible dtype"
+ ):
+ # See https://github.com/pandas-dev/pandas/issues/56223
+ result.loc[:, idxer] = expected
tm.assert_frame_equal(result, expected)
def test_loc_setitem_time_key(self, using_array_manager):
@@ -1566,16 +1569,10 @@ def test_loc_setitem_2d_to_1d_raises(self):
# float64 dtype to avoid upcast when trying to set float data
ser = Series(range(2), dtype="float64")
- msg = "|".join(
- [
- r"shape mismatch: value array of shape \(2,2\)",
- r"cannot reshape array of size 4 into shape \(2,\)",
- ]
- )
+ msg = "setting an array element with a sequence."
with pytest.raises(ValueError, match=msg):
ser.loc[range(2)] = data
- msg = r"could not broadcast input array from shape \(2,2\) into shape \(2,?\)"
with pytest.raises(ValueError, match=msg):
ser.loc[:] = data
@@ -3355,3 +3352,15 @@ def test_getitem_loc_str_periodindex(self):
index = pd.period_range(start="2000", periods=20, freq="B")
series = Series(range(20), index=index)
assert series.loc["2000-01-14"] == 9
+
+ def test_loc_nonunique_masked_index(self):
+ # GH 57027
+ ids = list(range(11))
+ index = Index(ids * 1000, dtype="Int64")
+ df = DataFrame({"val": np.arange(len(index), dtype=np.intp)}, index=index)
+ result = df.loc[ids]
+ expected = DataFrame(
+ {"val": index.argsort(kind="stable").astype(np.intp)},
+ index=Index(np.array(ids).repeat(1000), dtype="Int64"),
+ )
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/interchange/test_impl.py b/pandas/tests/interchange/test_impl.py
index 15c2b8d000b37..25418b8bb2b37 100644
--- a/pandas/tests/interchange/test_impl.py
+++ b/pandas/tests/interchange/test_impl.py
@@ -1,4 +1,7 @@
-from datetime import datetime
+from datetime import (
+ datetime,
+ timezone,
+)
import numpy as np
import pytest
@@ -179,8 +182,6 @@ def test_missing_from_masked():
}
)
- df2 = df.__dataframe__()
-
rng = np.random.default_rng(2)
dict_null = {col: rng.integers(low=0, high=len(df)) for col in df.columns}
for col, num_nulls in dict_null.items():
@@ -303,6 +304,51 @@ def test_multi_chunk_pyarrow() -> None:
pd.api.interchange.from_dataframe(table, allow_copy=False)
+def test_multi_chunk_column() -> None:
+ pytest.importorskip("pyarrow", "11.0.0")
+ ser = pd.Series([1, 2, None], dtype="Int64[pyarrow]")
+ df = pd.concat([ser, ser], ignore_index=True).to_frame("a")
+ df_orig = df.copy()
+ with pytest.raises(
+ RuntimeError, match="Found multi-chunk pyarrow array, but `allow_copy` is False"
+ ):
+ pd.api.interchange.from_dataframe(df.__dataframe__(allow_copy=False))
+ result = pd.api.interchange.from_dataframe(df.__dataframe__(allow_copy=True))
+ # Interchange protocol defaults to creating numpy-backed columns, so currently this
+ # is 'float64'.
+ expected = pd.DataFrame({"a": [1.0, 2.0, None, 1.0, 2.0, None]}, dtype="float64")
+ tm.assert_frame_equal(result, expected)
+
+ # Check that the rechunking we did didn't modify the original DataFrame.
+ tm.assert_frame_equal(df, df_orig)
+ assert len(df["a"].array._pa_array.chunks) == 2
+ assert len(df_orig["a"].array._pa_array.chunks) == 2
+
+
+def test_timestamp_ns_pyarrow():
+ # GH 56712
+ pytest.importorskip("pyarrow", "11.0.0")
+ timestamp_args = {
+ "year": 2000,
+ "month": 1,
+ "day": 1,
+ "hour": 1,
+ "minute": 1,
+ "second": 1,
+ }
+ df = pd.Series(
+ [datetime(**timestamp_args)],
+ dtype="timestamp[ns][pyarrow]",
+ name="col0",
+ ).to_frame()
+
+ dfi = df.__dataframe__()
+ result = pd.api.interchange.from_dataframe(dfi)["col0"].item()
+
+ expected = pd.Timestamp(**timestamp_args)
+ assert result == expected
+
+
@pytest.mark.parametrize("tz", ["UTC", "US/Pacific"])
@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_datetimetzdtype(tz, unit):
@@ -362,3 +408,197 @@ def test_interchange_from_corrected_buffer_dtypes(monkeypatch) -> None:
interchange.get_column_by_name = lambda _: column
monkeypatch.setattr(df, "__dataframe__", lambda allow_copy: interchange)
pd.api.interchange.from_dataframe(df)
+
+
+def test_empty_string_column():
+ # https://github.com/pandas-dev/pandas/issues/56703
+ df = pd.DataFrame({"a": []}, dtype=str)
+ df2 = df.__dataframe__()
+ result = pd.api.interchange.from_dataframe(df2)
+ tm.assert_frame_equal(df, result)
+
+
+def test_large_string():
+ # GH#56702
+ pytest.importorskip("pyarrow")
+ df = pd.DataFrame({"a": ["x"]}, dtype="large_string[pyarrow]")
+ result = pd.api.interchange.from_dataframe(df.__dataframe__())
+ expected = pd.DataFrame({"a": ["x"]}, dtype="object")
+ tm.assert_frame_equal(result, expected)
+
+
+def test_non_str_names():
+ # https://github.com/pandas-dev/pandas/issues/56701
+ df = pd.Series([1, 2, 3], name=0).to_frame()
+ names = df.__dataframe__().column_names()
+ assert names == ["0"]
+
+
+def test_non_str_names_w_duplicates():
+ # https://github.com/pandas-dev/pandas/issues/56701
+ df = pd.DataFrame({"0": [1, 2, 3], 0: [4, 5, 6]})
+ dfi = df.__dataframe__()
+ with pytest.raises(
+ TypeError,
+ match=(
+ "Expected a Series, got a DataFrame. This likely happened because you "
+ "called __dataframe__ on a DataFrame which, after converting column "
+ r"names to string, resulted in duplicated names: Index\(\['0', '0'\], "
+ r"dtype='object'\). Please rename these columns before using the "
+ "interchange protocol."
+ ),
+ ):
+ pd.api.interchange.from_dataframe(dfi, allow_copy=False)
+
+
+@pytest.mark.parametrize(
+ ("data", "dtype", "expected_dtype"),
+ [
+ ([1, 2, None], "Int64", "int64"),
+ ([1, 2, None], "Int64[pyarrow]", "int64"),
+ ([1, 2, None], "Int8", "int8"),
+ ([1, 2, None], "Int8[pyarrow]", "int8"),
+ (
+ [1, 2, None],
+ "UInt64",
+ "uint64",
+ ),
+ (
+ [1, 2, None],
+ "UInt64[pyarrow]",
+ "uint64",
+ ),
+ ([1.0, 2.25, None], "Float32", "float32"),
+ ([1.0, 2.25, None], "Float32[pyarrow]", "float32"),
+ ([True, False, None], "boolean", "bool"),
+ ([True, False, None], "boolean[pyarrow]", "bool"),
+ (["much ado", "about", None], "string[pyarrow_numpy]", "large_string"),
+ (["much ado", "about", None], "string[pyarrow]", "large_string"),
+ (
+ [datetime(2020, 1, 1), datetime(2020, 1, 2), None],
+ "timestamp[ns][pyarrow]",
+ "timestamp[ns]",
+ ),
+ (
+ [datetime(2020, 1, 1), datetime(2020, 1, 2), None],
+ "timestamp[us][pyarrow]",
+ "timestamp[us]",
+ ),
+ (
+ [
+ datetime(2020, 1, 1, tzinfo=timezone.utc),
+ datetime(2020, 1, 2, tzinfo=timezone.utc),
+ None,
+ ],
+ "timestamp[us, Asia/Kathmandu][pyarrow]",
+ "timestamp[us, tz=Asia/Kathmandu]",
+ ),
+ ],
+)
+def test_pandas_nullable_with_missing_values(
+ data: list, dtype: str, expected_dtype: str
+) -> None:
+ # https://github.com/pandas-dev/pandas/issues/57643
+ # https://github.com/pandas-dev/pandas/issues/57664
+ pa = pytest.importorskip("pyarrow", "11.0.0")
+ import pyarrow.interchange as pai
+
+ if expected_dtype == "timestamp[us, tz=Asia/Kathmandu]":
+ expected_dtype = pa.timestamp("us", "Asia/Kathmandu")
+
+ df = pd.DataFrame({"a": data}, dtype=dtype)
+ result = pai.from_dataframe(df.__dataframe__())["a"]
+ assert result.type == expected_dtype
+ assert result[0].as_py() == data[0]
+ assert result[1].as_py() == data[1]
+ assert result[2].as_py() is None
+
+
+@pytest.mark.parametrize(
+ ("data", "dtype", "expected_dtype"),
+ [
+ ([1, 2, 3], "Int64", "int64"),
+ ([1, 2, 3], "Int64[pyarrow]", "int64"),
+ ([1, 2, 3], "Int8", "int8"),
+ ([1, 2, 3], "Int8[pyarrow]", "int8"),
+ (
+ [1, 2, 3],
+ "UInt64",
+ "uint64",
+ ),
+ (
+ [1, 2, 3],
+ "UInt64[pyarrow]",
+ "uint64",
+ ),
+ ([1.0, 2.25, 5.0], "Float32", "float32"),
+ ([1.0, 2.25, 5.0], "Float32[pyarrow]", "float32"),
+ ([True, False, False], "boolean", "bool"),
+ ([True, False, False], "boolean[pyarrow]", "bool"),
+ (["much ado", "about", "nothing"], "string[pyarrow_numpy]", "large_string"),
+ (["much ado", "about", "nothing"], "string[pyarrow]", "large_string"),
+ (
+ [datetime(2020, 1, 1), datetime(2020, 1, 2), datetime(2020, 1, 3)],
+ "timestamp[ns][pyarrow]",
+ "timestamp[ns]",
+ ),
+ (
+ [datetime(2020, 1, 1), datetime(2020, 1, 2), datetime(2020, 1, 3)],
+ "timestamp[us][pyarrow]",
+ "timestamp[us]",
+ ),
+ (
+ [
+ datetime(2020, 1, 1, tzinfo=timezone.utc),
+ datetime(2020, 1, 2, tzinfo=timezone.utc),
+ datetime(2020, 1, 3, tzinfo=timezone.utc),
+ ],
+ "timestamp[us, Asia/Kathmandu][pyarrow]",
+ "timestamp[us, tz=Asia/Kathmandu]",
+ ),
+ ],
+)
+def test_pandas_nullable_without_missing_values(
+ data: list, dtype: str, expected_dtype: str
+) -> None:
+ # https://github.com/pandas-dev/pandas/issues/57643
+ pa = pytest.importorskip("pyarrow", "11.0.0")
+ import pyarrow.interchange as pai
+
+ if expected_dtype == "timestamp[us, tz=Asia/Kathmandu]":
+ expected_dtype = pa.timestamp("us", "Asia/Kathmandu")
+
+ df = pd.DataFrame({"a": data}, dtype=dtype)
+ result = pai.from_dataframe(df.__dataframe__())["a"]
+ assert result.type == expected_dtype
+ assert result[0].as_py() == data[0]
+ assert result[1].as_py() == data[1]
+ assert result[2].as_py() == data[2]
+
+
+def test_string_validity_buffer() -> None:
+ # https://github.com/pandas-dev/pandas/issues/57761
+ pytest.importorskip("pyarrow", "11.0.0")
+ df = pd.DataFrame({"a": ["x"]}, dtype="large_string[pyarrow]")
+ result = df.__dataframe__().get_column_by_name("a").get_buffers()["validity"]
+ assert result is None
+
+
+def test_string_validity_buffer_no_missing() -> None:
+ # https://github.com/pandas-dev/pandas/issues/57762
+ pytest.importorskip("pyarrow", "11.0.0")
+ df = pd.DataFrame({"a": ["x", None]}, dtype="large_string[pyarrow]")
+ validity = df.__dataframe__().get_column_by_name("a").get_buffers()["validity"]
+ assert validity is not None
+ result = validity[1]
+ expected = (DtypeKind.BOOL, 1, ArrowCTypes.BOOL, "=")
+ assert result == expected
+
+
+def test_empty_dataframe():
+ # https://github.com/pandas-dev/pandas/issues/56700
+ df = pd.DataFrame({"a": []}, dtype="int8")
+ dfi = df.__dataframe__()
+ result = pd.api.interchange.from_dataframe(dfi, allow_copy=False)
+ expected = pd.DataFrame({"a": []}, dtype="int8")
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/internals/test_api.py b/pandas/tests/internals/test_api.py
index f816cef38b9ab..1251a6ae97a1c 100644
--- a/pandas/tests/internals/test_api.py
+++ b/pandas/tests/internals/test_api.py
@@ -68,9 +68,7 @@ def test_deprecations(name):
def test_make_block_2d_with_dti():
# GH#41168
dti = pd.date_range("2012", periods=3, tz="UTC")
- msg = "make_block is deprecated"
- with tm.assert_produces_warning(DeprecationWarning, match=msg):
- blk = api.make_block(dti, placement=[0])
+ blk = api.make_block(dti, placement=[0])
assert blk.shape == (1, 3)
assert blk.values.shape == (1, 3)
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 2265522bc7ecb..ce88bae6e02f2 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -1383,11 +1383,9 @@ def test_validate_ndim():
values = np.array([1.0, 2.0])
placement = BlockPlacement(slice(2))
msg = r"Wrong number of dimensions. values.ndim != ndim \[1 != 2\]"
- depr_msg = "make_block is deprecated"
with pytest.raises(ValueError, match=msg):
- with tm.assert_produces_warning(DeprecationWarning, match=depr_msg):
- make_block(values, placement, ndim=2)
+ make_block(values, placement, ndim=2)
def test_block_shape():
@@ -1402,12 +1400,8 @@ def test_make_block_no_pandas_array(block_maker):
# https://github.com/pandas-dev/pandas/pull/24866
arr = pd.arrays.NumpyExtensionArray(np.array([1, 2]))
- warn = None if block_maker is not make_block else DeprecationWarning
- msg = "make_block is deprecated and will be removed in a future version"
-
# NumpyExtensionArray, no dtype
- with tm.assert_produces_warning(warn, match=msg):
- result = block_maker(arr, BlockPlacement(slice(len(arr))), ndim=arr.ndim)
+ result = block_maker(arr, BlockPlacement(slice(len(arr))), ndim=arr.ndim)
assert result.dtype.kind in ["i", "u"]
if block_maker is make_block:
@@ -1415,16 +1409,14 @@ def test_make_block_no_pandas_array(block_maker):
assert result.is_extension is False
# NumpyExtensionArray, NumpyEADtype
- with tm.assert_produces_warning(warn, match=msg):
- result = block_maker(arr, slice(len(arr)), dtype=arr.dtype, ndim=arr.ndim)
+ result = block_maker(arr, slice(len(arr)), dtype=arr.dtype, ndim=arr.ndim)
assert result.dtype.kind in ["i", "u"]
assert result.is_extension is False
# new_block no longer taked dtype keyword
# ndarray, NumpyEADtype
- with tm.assert_produces_warning(warn, match=msg):
- result = block_maker(
- arr.to_numpy(), slice(len(arr)), dtype=arr.dtype, ndim=arr.ndim
- )
+ result = block_maker(
+ arr.to_numpy(), slice(len(arr)), dtype=arr.dtype, ndim=arr.ndim
+ )
assert result.dtype.kind in ["i", "u"]
assert result.is_extension is False
diff --git a/pandas/tests/io/excel/test_odf.py b/pandas/tests/io/excel/test_odf.py
index f01827fa4ca2f..b5bb9b27258d8 100644
--- a/pandas/tests/io/excel/test_odf.py
+++ b/pandas/tests/io/excel/test_odf.py
@@ -3,11 +3,16 @@
import numpy as np
import pytest
+from pandas.compat import is_platform_windows
+
import pandas as pd
import pandas._testing as tm
pytest.importorskip("odf")
+if is_platform_windows():
+ pytestmark = pytest.mark.single_cpu
+
@pytest.fixture(autouse=True)
def cd_and_set_engine(monkeypatch, datapath):
diff --git a/pandas/tests/io/excel/test_odswriter.py b/pandas/tests/io/excel/test_odswriter.py
index 271353a173d2a..1c728ad801bc1 100644
--- a/pandas/tests/io/excel/test_odswriter.py
+++ b/pandas/tests/io/excel/test_odswriter.py
@@ -6,6 +6,8 @@
import pytest
+from pandas.compat import is_platform_windows
+
import pandas as pd
import pandas._testing as tm
@@ -13,6 +15,9 @@
odf = pytest.importorskip("odf")
+if is_platform_windows():
+ pytestmark = pytest.mark.single_cpu
+
@pytest.fixture
def ext():
diff --git a/pandas/tests/io/excel/test_openpyxl.py b/pandas/tests/io/excel/test_openpyxl.py
index 2df9ec9e53516..e53b5830ec6a4 100644
--- a/pandas/tests/io/excel/test_openpyxl.py
+++ b/pandas/tests/io/excel/test_openpyxl.py
@@ -5,6 +5,8 @@
import numpy as np
import pytest
+from pandas.compat import is_platform_windows
+
import pandas as pd
from pandas import DataFrame
import pandas._testing as tm
@@ -17,6 +19,9 @@
openpyxl = pytest.importorskip("openpyxl")
+if is_platform_windows():
+ pytestmark = pytest.mark.single_cpu
+
@pytest.fixture
def ext():
diff --git a/pandas/tests/io/excel/test_readers.py b/pandas/tests/io/excel/test_readers.py
index 15712f36da4ca..8da8535952dcf 100644
--- a/pandas/tests/io/excel/test_readers.py
+++ b/pandas/tests/io/excel/test_readers.py
@@ -18,6 +18,7 @@
from pandas._config import using_pyarrow_string_dtype
+from pandas.compat import is_platform_windows
import pandas.util._test_decorators as td
import pandas as pd
@@ -34,6 +35,9 @@
StringArray,
)
+if is_platform_windows():
+ pytestmark = pytest.mark.single_cpu
+
read_ext_params = [".xls", ".xlsx", ".xlsm", ".xlsb", ".ods"]
engine_params = [
# Add any engines to test here
diff --git a/pandas/tests/io/excel/test_style.py b/pandas/tests/io/excel/test_style.py
index 3ca8637885639..89615172688d7 100644
--- a/pandas/tests/io/excel/test_style.py
+++ b/pandas/tests/io/excel/test_style.py
@@ -4,6 +4,7 @@
import numpy as np
import pytest
+from pandas.compat import is_platform_windows
import pandas.util._test_decorators as td
from pandas import (
@@ -20,6 +21,9 @@
# could compute styles and render to excel without jinja2, since there is no
# 'template' file, but this needs the import error to delayed until render time.
+if is_platform_windows():
+ pytestmark = pytest.mark.single_cpu
+
def assert_equal_cell_styles(cell1, cell2):
# TODO: should find a better way to check equality
diff --git a/pandas/tests/io/excel/test_writers.py b/pandas/tests/io/excel/test_writers.py
index 8c003723c1c71..292eab2d88152 100644
--- a/pandas/tests/io/excel/test_writers.py
+++ b/pandas/tests/io/excel/test_writers.py
@@ -11,6 +11,7 @@
import numpy as np
import pytest
+from pandas.compat import is_platform_windows
from pandas.compat._constants import PY310
from pandas.compat._optional import import_optional_dependency
import pandas.util._test_decorators as td
@@ -34,6 +35,9 @@
)
from pandas.io.excel._util import _writers
+if is_platform_windows():
+ pytestmark = pytest.mark.single_cpu
+
def get_exp_unit(path: str) -> str:
return "ns"
diff --git a/pandas/tests/io/excel/test_xlrd.py b/pandas/tests/io/excel/test_xlrd.py
index 6d5008ca9ee68..066393d91eead 100644
--- a/pandas/tests/io/excel/test_xlrd.py
+++ b/pandas/tests/io/excel/test_xlrd.py
@@ -3,6 +3,8 @@
import numpy as np
import pytest
+from pandas.compat import is_platform_windows
+
import pandas as pd
import pandas._testing as tm
@@ -11,6 +13,9 @@
xlrd = pytest.importorskip("xlrd")
+if is_platform_windows():
+ pytestmark = pytest.mark.single_cpu
+
@pytest.fixture(params=[".xls"])
def read_ext_xlrd(request):
diff --git a/pandas/tests/io/excel/test_xlsxwriter.py b/pandas/tests/io/excel/test_xlsxwriter.py
index 94f6bdfaf069c..529367761fc02 100644
--- a/pandas/tests/io/excel/test_xlsxwriter.py
+++ b/pandas/tests/io/excel/test_xlsxwriter.py
@@ -2,6 +2,8 @@
import pytest
+from pandas.compat import is_platform_windows
+
from pandas import DataFrame
import pandas._testing as tm
@@ -9,6 +11,9 @@
xlsxwriter = pytest.importorskip("xlsxwriter")
+if is_platform_windows():
+ pytestmark = pytest.mark.single_cpu
+
@pytest.fixture
def ext():
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 0eefb0b52c483..5279f3f1cdfbe 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -24,6 +24,7 @@
DataFrame,
DatetimeIndex,
Index,
+ RangeIndex,
Series,
Timestamp,
date_range,
@@ -179,7 +180,7 @@ def test_frame_non_unique_columns(self, orient, data):
# in milliseconds; these are internally stored in nanosecond,
# so divide to get where we need
# TODO: a to_epoch method would also solve; see GH 14772
- expected.iloc[:, 0] = expected.iloc[:, 0].astype(np.int64) // 1000000
+ expected.isetitem(0, expected.iloc[:, 0].astype(np.int64) // 1000000)
elif orient == "split":
expected = df
expected.columns = ["x", "x.1"]
@@ -493,12 +494,12 @@ def test_frame_mixedtype_orient(self): # GH10289
left = read_json(inp, orient=orient, convert_axes=False)
tm.assert_frame_equal(left, right)
- right.index = pd.RangeIndex(len(df))
+ right.index = RangeIndex(len(df))
inp = StringIO(df.to_json(orient="records"))
left = read_json(inp, orient="records", convert_axes=False)
tm.assert_frame_equal(left, right)
- right.columns = pd.RangeIndex(df.shape[1])
+ right.columns = RangeIndex(df.shape[1])
inp = StringIO(df.to_json(orient="values"))
left = read_json(inp, orient="values", convert_axes=False)
tm.assert_frame_equal(left, right)
@@ -2172,3 +2173,30 @@ def test_json_pos_args_deprecation():
with tm.assert_produces_warning(FutureWarning, match=msg):
buf = BytesIO()
df.to_json(buf, "split")
+
+
+@td.skip_if_no("pyarrow")
+def test_to_json_ea_null():
+ # GH#57224
+ df = DataFrame(
+ {
+ "a": Series([1, NA], dtype="int64[pyarrow]"),
+ "b": Series([2, NA], dtype="Int64"),
+ }
+ )
+ result = df.to_json(orient="records", lines=True)
+ expected = """{"a":1,"b":2}
+{"a":null,"b":null}
+"""
+ assert result == expected
+
+
+def test_read_json_lines_rangeindex():
+ # GH 57429
+ data = """
+{"a": 1, "b": 2}
+{"a": 3, "b": 4}
+"""
+ result = read_json(StringIO(data), lines=True).index
+ expected = RangeIndex(2)
+ tm.assert_index_equal(result, expected, exact=True)
diff --git a/pandas/tests/io/parser/common/test_chunksize.py b/pandas/tests/io/parser/common/test_chunksize.py
index 5e47bcc1c5b0e..9f42cf674b0a7 100644
--- a/pandas/tests/io/parser/common/test_chunksize.py
+++ b/pandas/tests/io/parser/common/test_chunksize.py
@@ -220,20 +220,14 @@ def test_chunks_have_consistent_numerical_type(all_parsers, monkeypatch):
data = "a\n" + "\n".join(integers + ["1.0", "2.0"] + integers)
# Coercions should work without warnings.
- warn = None
- if parser.engine == "pyarrow":
- warn = DeprecationWarning
- depr_msg = "Passing a BlockManager to DataFrame"
- with tm.assert_produces_warning(warn, match=depr_msg, check_stacklevel=False):
- with monkeypatch.context() as m:
- m.setattr(libparsers, "DEFAULT_BUFFER_HEURISTIC", heuristic)
- result = parser.read_csv(StringIO(data))
+ with monkeypatch.context() as m:
+ m.setattr(libparsers, "DEFAULT_BUFFER_HEURISTIC", heuristic)
+ result = parser.read_csv(StringIO(data))
assert type(result.a[0]) is np.float64
assert result.a.dtype == float
-@pytest.mark.filterwarnings("ignore:make_block is deprecated:FutureWarning")
def test_warn_if_chunks_have_mismatched_type(all_parsers):
warning_type = None
parser = all_parsers
@@ -252,11 +246,8 @@ def test_warn_if_chunks_have_mismatched_type(all_parsers):
buf = StringIO(data)
if parser.engine == "pyarrow":
- df = parser.read_csv_check_warnings(
- DeprecationWarning,
- "Passing a BlockManager to DataFrame is deprecated",
+ df = parser.read_csv(
buf,
- check_stacklevel=False,
)
else:
df = parser.read_csv_check_warnings(
diff --git a/pandas/tests/io/parser/common/test_read_errors.py b/pandas/tests/io/parser/common/test_read_errors.py
index 4a4ae2b259289..f5a724bad4fa2 100644
--- a/pandas/tests/io/parser/common/test_read_errors.py
+++ b/pandas/tests/io/parser/common/test_read_errors.py
@@ -130,14 +130,9 @@ def test_catch_too_many_names(all_parsers):
else "Number of passed names did not match "
"number of header fields in the file"
)
- depr_msg = "Passing a BlockManager to DataFrame is deprecated"
- warn = None
- if parser.engine == "pyarrow":
- warn = DeprecationWarning
- with tm.assert_produces_warning(warn, match=depr_msg, check_stacklevel=False):
- with pytest.raises(ValueError, match=msg):
- parser.read_csv(StringIO(data), header=0, names=["a", "b", "c", "d"])
+ with pytest.raises(ValueError, match=msg):
+ parser.read_csv(StringIO(data), header=0, names=["a", "b", "c", "d"])
@skip_pyarrow # CSV parse error: Empty CSV file or block
@@ -168,13 +163,7 @@ def test_suppress_error_output(all_parsers):
data = "a\n1\n1,2,3\n4\n5,6,7"
expected = DataFrame({"a": [1, 4]})
- warn = None
- if parser.engine == "pyarrow":
- warn = DeprecationWarning
- msg = "Passing a BlockManager to DataFrame"
-
- with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
- result = parser.read_csv(StringIO(data), on_bad_lines="skip")
+ result = parser.read_csv(StringIO(data), on_bad_lines="skip")
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/test_parse_dates.py b/pandas/tests/io/parser/test_parse_dates.py
index d8f362039ba13..623657b412682 100644
--- a/pandas/tests/io/parser/test_parse_dates.py
+++ b/pandas/tests/io/parser/test_parse_dates.py
@@ -33,12 +33,9 @@
from pandas.io.parsers import read_csv
-pytestmark = [
- pytest.mark.filterwarnings(
- "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
- ),
- pytest.mark.filterwarnings("ignore:make_block is deprecated:DeprecationWarning"),
-]
+pytestmark = pytest.mark.filterwarnings(
+ "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")
skip_pyarrow = pytest.mark.usefixtures("pyarrow_skip")
diff --git a/pandas/tests/io/pytables/test_timezones.py b/pandas/tests/io/pytables/test_timezones.py
index 8c61830ebe038..c5613daf62207 100644
--- a/pandas/tests/io/pytables/test_timezones.py
+++ b/pandas/tests/io/pytables/test_timezones.py
@@ -104,7 +104,7 @@ def test_append_with_timezones(setup_path, gettz):
msg = (
r"invalid info for \[values_block_1\] for \[tz\], "
- r"existing_value \[(dateutil/.*)?US/Eastern\] "
+ r"existing_value \[(dateutil/.*)?(US/Eastern|America/New_York)\] "
r"conflicts with new value \[(dateutil/.*)?EET\]"
)
with pytest.raises(ValueError, match=msg):
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index ad7cdad363e78..e4b94177eedb2 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1000,9 +1000,7 @@ def test_filter_row_groups(self, pa):
df = pd.DataFrame({"a": list(range(3))})
with tm.ensure_clean() as path:
df.to_parquet(path, engine=pa)
- result = read_parquet(
- path, pa, filters=[("a", "==", 0)], use_legacy_dataset=False
- )
+ result = read_parquet(path, pa, filters=[("a", "==", 0)])
assert len(result) == 1
def test_read_parquet_manager(self, pa, using_array_manager):
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 6645aefd4f0a7..4f1f965f26aa9 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -1373,6 +1373,30 @@ def insert_on_conflict(table, conn, keys, data_iter):
pandasSQL.drop_table("test_insert_conflict")
+@pytest.mark.parametrize("conn", all_connectable)
+def test_to_sql_on_public_schema(conn, request):
+ if "sqlite" in conn or "mysql" in conn:
+ request.applymarker(
+ pytest.mark.xfail(
+ reason="test for public schema only specific to postgresql"
+ )
+ )
+
+ conn = request.getfixturevalue(conn)
+
+ test_data = DataFrame([[1, 2.1, "a"], [2, 3.1, "b"]], columns=list("abc"))
+ test_data.to_sql(
+ name="test_public_schema",
+ con=conn,
+ if_exists="append",
+ index=False,
+ schema="public",
+ )
+
+ df_out = sql.read_sql_table("test_public_schema", conn, schema="public")
+ tm.assert_frame_equal(test_data, df_out)
+
+
@pytest.mark.parametrize("conn", mysql_connectable)
def test_insertion_method_on_conflict_update(conn, request):
# GH 14553: Example in to_sql docstring
@@ -2229,12 +2253,14 @@ def test_api_chunksize_read(conn, request):
@pytest.mark.parametrize("conn", all_connectable)
def test_api_categorical(conn, request):
if conn == "postgresql_adbc_conn":
- request.node.add_marker(
- pytest.mark.xfail(
- reason="categorical dtype not implemented for ADBC postgres driver",
- strict=True,
+ adbc = import_optional_dependency("adbc_driver_postgresql", errors="ignore")
+ if adbc is not None and Version(adbc.__version__) < Version("0.9.0"):
+ request.node.add_marker(
+ pytest.mark.xfail(
+ reason="categorical dtype not implemented for ADBC postgres driver",
+ strict=True,
+ )
)
- )
# GH8624
# test that categorical gets written correctly as dense column
conn = request.getfixturevalue(conn)
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index 3e4e1a107da9d..6bd74faa8a3db 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -11,6 +11,8 @@
import numpy as np
import pytest
+import pandas.util._test_decorators as td
+
import pandas as pd
from pandas import CategoricalDtype
import pandas._testing as tm
@@ -1921,6 +1923,41 @@ def test_writer_118_exceptions(self):
with pytest.raises(ValueError, match="You must use version 119"):
StataWriterUTF8(path, df, version=118)
+ @pytest.mark.parametrize(
+ "dtype_backend",
+ ["numpy_nullable", pytest.param("pyarrow", marks=td.skip_if_no("pyarrow"))],
+ )
+ def test_read_write_ea_dtypes(self, dtype_backend):
+ df = DataFrame(
+ {
+ "a": [1, 2, None],
+ "b": ["a", "b", "c"],
+ "c": [True, False, None],
+ "d": [1.5, 2.5, 3.5],
+ "e": pd.date_range("2020-12-31", periods=3, freq="D"),
+ },
+ index=pd.Index([0, 1, 2], name="index"),
+ )
+ df = df.convert_dtypes(dtype_backend=dtype_backend)
+ df.to_stata("test_stata.dta", version=118)
+
+ with tm.ensure_clean() as path:
+ df.to_stata(path)
+ written_and_read_again = self.read_dta(path)
+
+ expected = DataFrame(
+ {
+ "a": [1, 2, np.nan],
+ "b": ["a", "b", "c"],
+ "c": [1.0, 0, np.nan],
+ "d": [1.5, 2.5, 3.5],
+ "e": pd.date_range("2020-12-31", periods=3, freq="D"),
+ },
+ index=pd.Index([0, 1, 2], name="index", dtype=np.int32),
+ )
+
+ tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
+
@pytest.mark.parametrize("version", [105, 108, 111, 113, 114])
def test_backward_compat(version, datapath):
diff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py
index 50644e33e45e1..dcf6c6099abab 100644
--- a/pandas/tests/resample/test_base.py
+++ b/pandas/tests/resample/test_base.py
@@ -3,6 +3,9 @@
import numpy as np
import pytest
+from pandas.core.dtypes.common import is_extension_array_dtype
+
+import pandas as pd
from pandas import (
DataFrame,
DatetimeIndex,
@@ -429,3 +432,29 @@ def test_resample_quantile(series):
result = ser.resample(freq).quantile(q)
expected = ser.resample(freq).agg(lambda x: x.quantile(q)).rename(ser.name)
tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("how", ["first", "last"])
+def test_first_last_skipna(any_real_nullable_dtype, skipna, how):
+ # GH#57019
+ if is_extension_array_dtype(any_real_nullable_dtype):
+ na_value = Series(dtype=any_real_nullable_dtype).dtype.na_value
+ else:
+ na_value = np.nan
+ df = DataFrame(
+ {
+ "a": [2, 1, 1, 2],
+ "b": [na_value, 3.0, na_value, 4.0],
+ "c": [na_value, 3.0, na_value, 4.0],
+ },
+ index=date_range("2020-01-01", periods=4, freq="D"),
+ dtype=any_real_nullable_dtype,
+ )
+ rs = df.resample("ME")
+ method = getattr(rs, how)
+ result = method(skipna=skipna)
+
+ gb = df.groupby(df.shape[0] * [pd.to_datetime("2020-01-31")])
+ expected = getattr(gb, how)(skipna=skipna)
+ expected.index.freq = "ME"
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 80583f5d3c5f2..ddd81ab1d347d 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -1080,10 +1080,10 @@ def test_resample_segfault(unit):
).set_index("timestamp")
df.index = df.index.as_unit(unit)
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("ID").resample("5min").sum()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = df.groupby("ID").apply(lambda x: x.resample("5min").sum())
tm.assert_frame_equal(result, expected)
@@ -1104,7 +1104,7 @@ def test_resample_dtype_preservation(unit):
assert result.val.dtype == np.int32
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("group").resample("1D").ffill()
assert result.val.dtype == np.int32
@@ -1881,10 +1881,10 @@ def f(data, add_arg):
df = DataFrame({"A": 1, "B": 2}, index=date_range("2017", periods=10))
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").resample("D").agg(f, multiplier).astype(float)
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = df.groupby("A").resample("D").mean().multiply(multiplier)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index eb80f56dd7d4b..6b7cce7d15a5b 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -1006,6 +1006,32 @@ def test_resample_t_l_deprecated(self):
result = ser.resample("T").mean()
tm.assert_series_equal(result, expected)
+ @pytest.mark.parametrize(
+ "freq, freq_depr, freq_res, freq_depr_res, data",
+ [
+ ("2Q", "2q", "2Y", "2y", [0.5]),
+ ("2M", "2m", "2Q", "2q", [1.0, 3.0]),
+ ],
+ )
+ def test_resample_lowercase_frequency_deprecated(
+ self, freq, freq_depr, freq_res, freq_depr_res, data
+ ):
+ depr_msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+ f"future version. Please use '{freq[1:]}' instead."
+ depr_msg_res = f"'{freq_depr_res[1:]}' is deprecated and will be removed in a "
+ f"future version. Please use '{freq_res[1:]}' instead."
+
+ with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+ rng_l = period_range("2020-01-01", "2020-08-01", freq=freq_depr)
+ ser = Series(np.arange(len(rng_l)), index=rng_l)
+
+ rng = period_range("2020-01-01", "2020-08-01", freq=freq_res)
+ expected = Series(data=data, index=rng)
+
+ with tm.assert_produces_warning(FutureWarning, match=depr_msg_res):
+ result = ser.resample(freq_depr_res).mean()
+ tm.assert_series_equal(result, expected)
+
@pytest.mark.parametrize(
"offset",
[
@@ -1014,8 +1040,8 @@ def test_resample_t_l_deprecated(self):
offsets.BusinessHour(2),
],
)
- def test_asfreq_invalid_period_freq(self, offset, series_and_frame):
- # GH#9586
+ def test_asfreq_invalid_period_offset(self, offset, series_and_frame):
+ # GH#55785
msg = f"Invalid offset: '{offset.base}' for converting time series "
df = series_and_frame
@@ -1031,6 +1057,9 @@ def test_asfreq_invalid_period_freq(self, offset, series_and_frame):
("2Q-FEB", "2QE-FEB"),
("2Y", "2YE"),
("2Y-MAR", "2YE-MAR"),
+ ("2M", "2me"),
+ ("2Q", "2qe"),
+ ("2Y-MAR", "2ye-mar"),
],
)
def test_resample_frequency_ME_QE_YE_error_message(series_and_frame, freq, freq_depr):
diff --git a/pandas/tests/resample/test_resample_api.py b/pandas/tests/resample/test_resample_api.py
index 7e8779ab48b7e..12abd1c98784b 100644
--- a/pandas/tests/resample/test_resample_api.py
+++ b/pandas/tests/resample/test_resample_api.py
@@ -78,7 +78,7 @@ def test_groupby_resample_api():
index = pd.MultiIndex.from_arrays([[1] * 8 + [2] * 8, i], names=["group", "date"])
expected = DataFrame({"val": [5] * 7 + [6] + [7] * 7 + [8]}, index=index)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("group").apply(lambda x: x.resample("1D").ffill())[["val"]]
tm.assert_frame_equal(result, expected)
@@ -1040,11 +1040,11 @@ def test_args_kwargs_depr(method, raises):
if raises:
with tm.assert_produces_warning(FutureWarning, match=warn_msg):
with pytest.raises(UnsupportedFunctionCall, match=error_msg):
- func(*args, 1, 2, 3)
+ func(*args, 1, 2, 3, 4)
else:
with tm.assert_produces_warning(FutureWarning, match=warn_msg):
with pytest.raises(TypeError, match=error_msg_type):
- func(*args, 1, 2, 3)
+ func(*args, 1, 2, 3, 4)
def test_df_axis_param_depr():
diff --git a/pandas/tests/resample/test_resampler_grouper.py b/pandas/tests/resample/test_resampler_grouper.py
index 337c5ff53bd14..550523a432a89 100644
--- a/pandas/tests/resample/test_resampler_grouper.py
+++ b/pandas/tests/resample/test_resampler_grouper.py
@@ -70,10 +70,10 @@ def f_0(x):
return x.set_index("date").resample("D").asfreq()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = df.groupby("id").apply(f_0)
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.set_index("date").groupby("id").resample("D").asfreq()
tm.assert_frame_equal(result, expected)
@@ -89,10 +89,10 @@ def f_1(x):
return x.resample("1D").ffill()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = df.groupby("group").apply(f_1)
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("group").resample("1D").ffill()
tm.assert_frame_equal(result, expected)
@@ -109,7 +109,7 @@ def test_getitem(test_frame):
tm.assert_series_equal(result, expected)
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = g.resample("2s").mean().B
tm.assert_series_equal(result, expected)
@@ -235,10 +235,10 @@ def test_methods(f, test_frame):
r = g.resample("2s")
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = getattr(r, f)()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
tm.assert_equal(result, expected)
@@ -257,10 +257,10 @@ def test_methods_std_var(f, test_frame):
g = test_frame.groupby("A")
r = g.resample("2s")
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = getattr(r, f)(ddof=1)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(lambda x: getattr(x.resample("2s"), f)(ddof=1))
tm.assert_frame_equal(result, expected)
@@ -271,14 +271,14 @@ def test_apply(test_frame):
# reduction
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.resample("2s").sum()
def f_0(x):
return x.resample("2s").sum()
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = r.apply(f_0)
tm.assert_frame_equal(result, expected)
@@ -286,7 +286,7 @@ def f_1(x):
return x.resample("2s").apply(lambda y: y.sum())
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = g.apply(f_1)
# y.sum() results in int64 instead of int32 on 32-bit architectures
expected = expected.astype("int64")
@@ -356,7 +356,7 @@ def test_resample_groupby_with_label(unit):
index = date_range("2000-01-01", freq="2D", periods=5, unit=unit)
df = DataFrame(index=index, data={"col0": [0, 0, 1, 1, 2], "col1": [1, 1, 1, 1, 1]})
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("col0").resample("1W", label="left").sum()
mi = [
@@ -379,7 +379,7 @@ def test_consistency_with_window(test_frame):
df = test_frame
expected = Index([1, 2, 3], name="A")
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").resample("2s").mean()
assert result.index.nlevels == 2
tm.assert_index_equal(result.index.levels[0], expected)
@@ -479,7 +479,7 @@ def test_empty(keys):
# GH 26411
df = DataFrame([], columns=["a", "b"], index=TimedeltaIndex([]))
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby(keys).resample(rule=pd.to_timedelta("00:00:01")).mean()
expected = (
DataFrame(columns=["a", "b"])
@@ -503,7 +503,8 @@ def test_resample_groupby_agg_object_dtype_all_nan(consolidate):
if consolidate:
df = df._consolidate()
- with tm.assert_produces_warning(FutureWarning):
+ msg = "DataFrameGroupBy.resample operated on the grouping columns"
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby(["key"]).resample("W", on="date").min()
idx = pd.MultiIndex.from_arrays(
[
@@ -555,7 +556,7 @@ def test_resample_no_index(keys):
df["date"] = pd.to_datetime(df["date"])
df = df.set_index("date")
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby(keys).resample(rule=pd.to_timedelta("00:00:01")).mean()
expected = DataFrame(columns=["a", "b", "date"]).set_index(keys, drop=False)
expected["date"] = pd.to_datetime(expected["date"])
@@ -604,7 +605,7 @@ def test_groupby_resample_size_all_index_same():
index=date_range("31/12/2000 18:00", freq="h", periods=12),
)
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = df.groupby("A").resample("D").size()
mi_exp = pd.MultiIndex.from_arrays(
diff --git a/pandas/tests/resample/test_time_grouper.py b/pandas/tests/resample/test_time_grouper.py
index 3d9098917a12d..3f9340b800eae 100644
--- a/pandas/tests/resample/test_time_grouper.py
+++ b/pandas/tests/resample/test_time_grouper.py
@@ -346,7 +346,7 @@ def test_groupby_resample_interpolate():
df["week_starting"] = date_range("01/01/2018", periods=3, freq="W")
msg = "DataFrameGroupBy.resample operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = (
df.set_index("week_starting")
.groupby("volume")
diff --git a/pandas/tests/reshape/concat/test_datetimes.py b/pandas/tests/reshape/concat/test_datetimes.py
index 71ddff7438254..4c94dc0d51f7e 100644
--- a/pandas/tests/reshape/concat/test_datetimes.py
+++ b/pandas/tests/reshape/concat/test_datetimes.py
@@ -73,23 +73,23 @@ def test_concat_datetime_timezone(self):
exp_idx = DatetimeIndex(
[
- "2010-12-31 23:00:00+00:00",
- "2011-01-01 00:00:00+00:00",
- "2011-01-01 01:00:00+00:00",
"2010-12-31 15:00:00+00:00",
"2010-12-31 16:00:00+00:00",
"2010-12-31 17:00:00+00:00",
+ "2010-12-31 23:00:00+00:00",
+ "2011-01-01 00:00:00+00:00",
+ "2011-01-01 01:00:00+00:00",
]
).as_unit("ns")
expected = DataFrame(
[
- [1, np.nan],
- [2, np.nan],
- [3, np.nan],
[np.nan, 1],
[np.nan, 2],
[np.nan, 3],
+ [1, np.nan],
+ [2, np.nan],
+ [3, np.nan],
],
index=exp_idx,
columns=["a", "b"],
diff --git a/pandas/tests/reshape/merge/test_join.py b/pandas/tests/reshape/merge/test_join.py
index 5a1f47e341222..db5a0437a14f0 100644
--- a/pandas/tests/reshape/merge/test_join.py
+++ b/pandas/tests/reshape/merge/test_join.py
@@ -16,6 +16,7 @@
bdate_range,
concat,
merge,
+ option_context,
)
import pandas._testing as tm
@@ -563,24 +564,30 @@ def test_join_many_non_unique_index(self):
tm.assert_frame_equal(inner, left)
tm.assert_frame_equal(inner, right)
- def test_join_sort(self):
- left = DataFrame({"key": ["foo", "bar", "baz", "foo"], "value": [1, 2, 3, 4]})
- right = DataFrame({"value2": ["a", "b", "c"]}, index=["bar", "baz", "foo"])
-
- joined = left.join(right, on="key", sort=True)
- expected = DataFrame(
- {
- "key": ["bar", "baz", "foo", "foo"],
- "value": [2, 3, 1, 4],
- "value2": ["a", "b", "c", "c"],
- },
- index=[1, 2, 0, 3],
- )
- tm.assert_frame_equal(joined, expected)
-
- # smoke test
- joined = left.join(right, on="key", sort=False)
- tm.assert_index_equal(joined.index, Index(range(4)), exact=True)
+ @pytest.mark.parametrize(
+ "infer_string", [False, pytest.param(True, marks=td.skip_if_no("pyarrow"))]
+ )
+ def test_join_sort(self, infer_string):
+ with option_context("future.infer_string", infer_string):
+ left = DataFrame(
+ {"key": ["foo", "bar", "baz", "foo"], "value": [1, 2, 3, 4]}
+ )
+ right = DataFrame({"value2": ["a", "b", "c"]}, index=["bar", "baz", "foo"])
+
+ joined = left.join(right, on="key", sort=True)
+ expected = DataFrame(
+ {
+ "key": ["bar", "baz", "foo", "foo"],
+ "value": [2, 3, 1, 4],
+ "value2": ["a", "b", "c", "c"],
+ },
+ index=[1, 2, 0, 3],
+ )
+ tm.assert_frame_equal(joined, expected)
+
+ # smoke test
+ joined = left.join(right, on="key", sort=False)
+ tm.assert_index_equal(joined.index, Index(range(4)), exact=True)
def test_join_mixed_non_unique_index(self):
# GH 12814, unorderable types in py3 with a non-unique index
@@ -624,7 +631,7 @@ def test_mixed_type_join_with_suffix(self):
df.insert(5, "dt", "foo")
grouped = df.groupby("id")
- msg = re.escape("agg function failed [how->mean,dtype->object]")
+ msg = re.escape("agg function failed [how->mean,dtype->")
with pytest.raises(TypeError, match=msg):
grouped.mean()
mn = grouped.mean(numeric_only=True)
@@ -769,7 +776,7 @@ def test_join_on_tz_aware_datetimeindex(self):
)
result = df1.join(df2.set_index("date"), on="date")
expected = df1.copy()
- expected["vals_2"] = Series([np.nan] * 2 + list("tuv"), dtype=object)
+ expected["vals_2"] = Series([np.nan] * 2 + list("tuv"))
tm.assert_frame_equal(result, expected)
def test_join_datetime_string(self):
@@ -1035,6 +1042,25 @@ def test_join_empty(left_empty, how, exp):
tm.assert_frame_equal(result, expected)
+def test_join_empty_uncomparable_columns():
+ # GH 57048
+ df1 = DataFrame()
+ df2 = DataFrame(columns=["test"])
+ df3 = DataFrame(columns=["foo", ("bar", "baz")])
+
+ result = df1 + df2
+ expected = DataFrame(columns=["test"])
+ tm.assert_frame_equal(result, expected)
+
+ result = df2 + df3
+ expected = DataFrame(columns=[("bar", "baz"), "foo", "test"])
+ tm.assert_frame_equal(result, expected)
+
+ result = df1 + df3
+ expected = DataFrame(columns=[("bar", "baz"), "foo"])
+ tm.assert_frame_equal(result, expected)
+
+
@pytest.mark.parametrize(
"how, values",
[
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index d7a343ae9f152..ed49f3b758cc5 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -8,7 +8,10 @@
import numpy as np
import pytest
-from pandas.core.dtypes.common import is_object_dtype
+from pandas.core.dtypes.common import (
+ is_object_dtype,
+ is_string_dtype,
+)
from pandas.core.dtypes.dtypes import CategoricalDtype
import pandas as pd
@@ -316,14 +319,15 @@ def test_merge_copy(self):
merged["d"] = "peekaboo"
assert (right["d"] == "bar").all()
- def test_merge_nocopy(self, using_array_manager):
+ def test_merge_nocopy(self, using_array_manager, using_infer_string):
left = DataFrame({"a": 0, "b": 1}, index=range(10))
right = DataFrame({"c": "foo", "d": "bar"}, index=range(10))
merged = merge(left, right, left_index=True, right_index=True, copy=False)
assert np.shares_memory(merged["a"]._values, left["a"]._values)
- assert np.shares_memory(merged["d"]._values, right["d"]._values)
+ if not using_infer_string:
+ assert np.shares_memory(merged["d"]._values, right["d"]._values)
def test_intelligently_handle_join_key(self):
# #733, be a bit more 1337 about not returning unconsolidated DataFrame
@@ -667,11 +671,13 @@ def test_merge_nan_right(self):
"i1_": {0: 0, 1: np.nan},
"i3": {0: 0.0, 1: np.nan},
None: {0: 0, 1: 0},
- }
+ },
+ columns=Index(["i1", "i2", "i1_", "i3", None], dtype=object),
)
.set_index(None)
.reset_index()[["i1", "i2", "i1_", "i3"]]
)
+ result.columns = result.columns.astype("object")
tm.assert_frame_equal(result, expected, check_dtype=False)
def test_merge_nan_right2(self):
@@ -820,7 +826,7 @@ def test_overlapping_columns_error_message(self):
# #2649, #10639
df2.columns = ["key1", "foo", "foo"]
- msg = r"Data columns not unique: Index\(\['foo'\], dtype='object'\)"
+ msg = r"Data columns not unique: Index\(\['foo'\], dtype='object|string'\)"
with pytest.raises(MergeError, match=msg):
merge(df, df2)
@@ -1498,7 +1504,7 @@ def test_different(self, right_vals):
# We allow merging on object and categorical cols and cast
# categorical cols to object
result = merge(left, right, on="A")
- assert is_object_dtype(result.A.dtype)
+ assert is_object_dtype(result.A.dtype) or is_string_dtype(result.A.dtype)
@pytest.mark.parametrize(
"d1", [np.int64, np.int32, np.intc, np.int16, np.int8, np.uint8]
@@ -1637,7 +1643,7 @@ def test_merge_incompat_dtypes_are_ok(self, df1_vals, df2_vals):
result = merge(df1, df2, on=["A"])
assert is_object_dtype(result.A.dtype)
result = merge(df2, df1, on=["A"])
- assert is_object_dtype(result.A.dtype)
+ assert is_object_dtype(result.A.dtype) or is_string_dtype(result.A.dtype)
@pytest.mark.parametrize(
"df1_vals, df2_vals",
@@ -1867,25 +1873,27 @@ def right():
class TestMergeCategorical:
- def test_identical(self, left):
+ def test_identical(self, left, using_infer_string):
# merging on the same, should preserve dtypes
merged = merge(left, left, on="X")
result = merged.dtypes.sort_index()
+ dtype = np.dtype("O") if not using_infer_string else "string"
expected = Series(
- [CategoricalDtype(categories=["foo", "bar"]), np.dtype("O"), np.dtype("O")],
+ [CategoricalDtype(categories=["foo", "bar"]), dtype, dtype],
index=["X", "Y_x", "Y_y"],
)
tm.assert_series_equal(result, expected)
- def test_basic(self, left, right):
+ def test_basic(self, left, right, using_infer_string):
# we have matching Categorical dtypes in X
# so should preserve the merged column
merged = merge(left, right, on="X")
result = merged.dtypes.sort_index()
+ dtype = np.dtype("O") if not using_infer_string else "string"
expected = Series(
[
CategoricalDtype(categories=["foo", "bar"]),
- np.dtype("O"),
+ dtype,
np.dtype("int64"),
],
index=["X", "Y", "Z"],
@@ -1989,16 +1997,17 @@ def test_multiindex_merge_with_unordered_categoricalindex(self, ordered):
).set_index(["id", "p"])
tm.assert_frame_equal(result, expected)
- def test_other_columns(self, left, right):
+ def test_other_columns(self, left, right, using_infer_string):
# non-merge columns should preserve if possible
right = right.assign(Z=right.Z.astype("category"))
merged = merge(left, right, on="X")
result = merged.dtypes.sort_index()
+ dtype = np.dtype("O") if not using_infer_string else "string"
expected = Series(
[
CategoricalDtype(categories=["foo", "bar"]),
- np.dtype("O"),
+ dtype,
CategoricalDtype(categories=[1, 2]),
],
index=["X", "Y", "Z"],
@@ -2017,7 +2026,9 @@ def test_other_columns(self, left, right):
lambda x: x.astype(CategoricalDtype(ordered=True)),
],
)
- def test_dtype_on_merged_different(self, change, join_type, left, right):
+ def test_dtype_on_merged_different(
+ self, change, join_type, left, right, using_infer_string
+ ):
# our merging columns, X now has 2 different dtypes
# so we must be object as a result
@@ -2029,9 +2040,8 @@ def test_dtype_on_merged_different(self, change, join_type, left, right):
merged = merge(left, right, on="X", how=join_type)
result = merged.dtypes.sort_index()
- expected = Series(
- [np.dtype("O"), np.dtype("O"), np.dtype("int64")], index=["X", "Y", "Z"]
- )
+ dtype = np.dtype("O") if not using_infer_string else "string"
+ expected = Series([dtype, dtype, np.dtype("int64")], index=["X", "Y", "Z"])
tm.assert_series_equal(result, expected)
def test_self_join_multiple_categories(self):
@@ -2499,7 +2509,7 @@ def test_merge_multiindex_columns():
expected_index = MultiIndex.from_tuples(tuples, names=["outer", "inner"])
expected = DataFrame(columns=expected_index)
- tm.assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected, check_dtype=False)
def test_merge_datetime_upcast_dtype():
@@ -2984,7 +2994,27 @@ def test_merge_empty_frames_column_order(left_empty, right_empty):
if left_empty and right_empty:
expected = expected.iloc[:0]
elif left_empty:
- expected.loc[:, "B"] = np.nan
+ expected["B"] = np.nan
elif right_empty:
- expected.loc[:, ["C", "D"]] = np.nan
+ expected[["C", "D"]] = np.nan
tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("how", ["left", "right", "inner", "outer"])
+def test_merge_datetime_and_timedelta(how):
+ left = DataFrame({"key": Series([1, None], dtype="datetime64[ns]")})
+ right = DataFrame({"key": Series([1], dtype="timedelta64[ns]")})
+
+ msg = (
+ f"You are trying to merge on {left['key'].dtype} and {right['key'].dtype} "
+ "columns for key 'key'. If you wish to proceed you should use pd.concat"
+ )
+ with pytest.raises(ValueError, match=re.escape(msg)):
+ left.merge(right, on="key", how=how)
+
+ msg = (
+ f"You are trying to merge on {right['key'].dtype} and {left['key'].dtype} "
+ "columns for key 'key'. If you wish to proceed you should use pd.concat"
+ )
+ with pytest.raises(ValueError, match=re.escape(msg)):
+ right.merge(left, on="key", how=how)
diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py
index b656191cc739d..a2e22ea73fd86 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -3081,8 +3081,11 @@ def test_on_float_by_int(self):
tm.assert_frame_equal(result, expected)
- def test_merge_datatype_error_raises(self):
- msg = r"Incompatible merge dtype, .*, both sides must have numeric dtype"
+ def test_merge_datatype_error_raises(self, using_infer_string):
+ if using_infer_string:
+ msg = "incompatible merge keys"
+ else:
+ msg = r"Incompatible merge dtype, .*, both sides must have numeric dtype"
left = pd.DataFrame({"left_val": [1, 5, 10], "a": ["a", "b", "c"]})
right = pd.DataFrame({"right_val": [1, 2, 3, 6, 7], "a": [1, 2, 3, 6, 7]})
@@ -3134,7 +3137,7 @@ def test_merge_on_nans(self, func, side):
else:
merge_asof(df, df_null, on="a")
- def test_by_nullable(self, any_numeric_ea_dtype):
+ def test_by_nullable(self, any_numeric_ea_dtype, using_infer_string):
# Note: this test passes if instead of using pd.array we use
# np.array([np.nan, 1]). Other than that, I (@jbrockmendel)
# have NO IDEA what the expected behavior is.
@@ -3176,6 +3179,8 @@ def test_by_nullable(self, any_numeric_ea_dtype):
}
)
expected["value_y"] = np.array([np.nan, np.nan, np.nan], dtype=object)
+ if using_infer_string:
+ expected["value_y"] = expected["value_y"].astype("string[pyarrow_numpy]")
tm.assert_frame_equal(result, expected)
def test_merge_by_col_tz_aware(self):
@@ -3201,7 +3206,7 @@ def test_merge_by_col_tz_aware(self):
)
tm.assert_frame_equal(result, expected)
- def test_by_mixed_tz_aware(self):
+ def test_by_mixed_tz_aware(self, using_infer_string):
# GH 26649
left = pd.DataFrame(
{
@@ -3225,6 +3230,8 @@ def test_by_mixed_tz_aware(self):
columns=["by_col1", "by_col2", "on_col", "value_x"],
)
expected["value_y"] = np.array([np.nan], dtype=object)
+ if using_infer_string:
+ expected["value_y"] = expected["value_y"].astype("string[pyarrow_numpy]")
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("dtype", ["float64", "int16", "m8[ns]", "M8[us]"])
diff --git a/pandas/tests/reshape/merge/test_merge_ordered.py b/pandas/tests/reshape/merge/test_merge_ordered.py
index abd61026b4e37..0bd3ca3cf2c1b 100644
--- a/pandas/tests/reshape/merge/test_merge_ordered.py
+++ b/pandas/tests/reshape/merge/test_merge_ordered.py
@@ -219,3 +219,26 @@ def test_ffill_validate_fill_method(self, left, right, invalid_method):
ValueError, match=re.escape("fill_method must be 'ffill' or None")
):
merge_ordered(left, right, on="key", fill_method=invalid_method)
+
+ def test_ffill_left_merge(self):
+ # GH 57010
+ df1 = DataFrame(
+ {
+ "key": ["a", "c", "e", "a", "c", "e"],
+ "lvalue": [1, 2, 3, 1, 2, 3],
+ "group": ["a", "a", "a", "b", "b", "b"],
+ }
+ )
+ df2 = DataFrame({"key": ["b", "c", "d"], "rvalue": [1, 2, 3]})
+ result = merge_ordered(
+ df1, df2, fill_method="ffill", left_by="group", how="left"
+ )
+ expected = DataFrame(
+ {
+ "key": ["a", "c", "e", "a", "c", "e"],
+ "lvalue": [1, 2, 3, 1, 2, 3],
+ "group": ["a", "a", "a", "b", "b", "b"],
+ "rvalue": [np.nan, 2.0, 2.0, np.nan, 2.0, 2.0],
+ }
+ )
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/merge/test_multi.py b/pandas/tests/reshape/merge/test_multi.py
index 269d3a2b7078e..402ff049884ba 100644
--- a/pandas/tests/reshape/merge/test_multi.py
+++ b/pandas/tests/reshape/merge/test_multi.py
@@ -1,6 +1,8 @@
import numpy as np
import pytest
+import pandas.util._test_decorators as td
+
import pandas as pd
from pandas import (
DataFrame,
@@ -9,6 +11,7 @@
RangeIndex,
Series,
Timestamp,
+ option_context,
)
import pandas._testing as tm
from pandas.core.reshape.concat import concat
@@ -88,67 +91,71 @@ def test_merge_on_multikey(self, left, right, join_type):
tm.assert_frame_equal(result, expected)
- @pytest.mark.parametrize("sort", [False, True])
- def test_left_join_multi_index(self, sort):
- icols = ["1st", "2nd", "3rd"]
+ @pytest.mark.parametrize(
+ "infer_string", [False, pytest.param(True, marks=td.skip_if_no("pyarrow"))]
+ )
+ @pytest.mark.parametrize("sort", [True, False])
+ def test_left_join_multi_index(self, sort, infer_string):
+ with option_context("future.infer_string", infer_string):
+ icols = ["1st", "2nd", "3rd"]
- def bind_cols(df):
- iord = lambda a: 0 if a != a else ord(a)
- f = lambda ts: ts.map(iord) - ord("a")
- return f(df["1st"]) + f(df["3rd"]) * 1e2 + df["2nd"].fillna(0) * 10
+ def bind_cols(df):
+ iord = lambda a: 0 if a != a else ord(a)
+ f = lambda ts: ts.map(iord) - ord("a")
+ return f(df["1st"]) + f(df["3rd"]) * 1e2 + df["2nd"].fillna(0) * 10
- def run_asserts(left, right, sort):
- res = left.join(right, on=icols, how="left", sort=sort)
+ def run_asserts(left, right, sort):
+ res = left.join(right, on=icols, how="left", sort=sort)
- assert len(left) < len(res) + 1
- assert not res["4th"].isna().any()
- assert not res["5th"].isna().any()
+ assert len(left) < len(res) + 1
+ assert not res["4th"].isna().any()
+ assert not res["5th"].isna().any()
- tm.assert_series_equal(res["4th"], -res["5th"], check_names=False)
- result = bind_cols(res.iloc[:, :-2])
- tm.assert_series_equal(res["4th"], result, check_names=False)
- assert result.name is None
+ tm.assert_series_equal(res["4th"], -res["5th"], check_names=False)
+ result = bind_cols(res.iloc[:, :-2])
+ tm.assert_series_equal(res["4th"], result, check_names=False)
+ assert result.name is None
- if sort:
- tm.assert_frame_equal(res, res.sort_values(icols, kind="mergesort"))
+ if sort:
+ tm.assert_frame_equal(res, res.sort_values(icols, kind="mergesort"))
- out = merge(left, right.reset_index(), on=icols, sort=sort, how="left")
+ out = merge(left, right.reset_index(), on=icols, sort=sort, how="left")
- res.index = RangeIndex(len(res))
- tm.assert_frame_equal(out, res)
+ res.index = RangeIndex(len(res))
+ tm.assert_frame_equal(out, res)
- lc = list(map(chr, np.arange(ord("a"), ord("z") + 1)))
- left = DataFrame(
- np.random.default_rng(2).choice(lc, (50, 2)), columns=["1st", "3rd"]
- )
- # Explicit cast to float to avoid implicit cast when setting nan
- left.insert(
- 1,
- "2nd",
- np.random.default_rng(2).integers(0, 10, len(left)).astype("float"),
- )
+ lc = list(map(chr, np.arange(ord("a"), ord("z") + 1)))
+ left = DataFrame(
+ np.random.default_rng(2).choice(lc, (50, 2)), columns=["1st", "3rd"]
+ )
+ # Explicit cast to float to avoid implicit cast when setting nan
+ left.insert(
+ 1,
+ "2nd",
+ np.random.default_rng(2).integers(0, 10, len(left)).astype("float"),
+ )
- i = np.random.default_rng(2).permutation(len(left))
- right = left.iloc[i].copy()
+ i = np.random.default_rng(2).permutation(len(left))
+ right = left.iloc[i].copy()
- left["4th"] = bind_cols(left)
- right["5th"] = -bind_cols(right)
- right.set_index(icols, inplace=True)
+ left["4th"] = bind_cols(left)
+ right["5th"] = -bind_cols(right)
+ right.set_index(icols, inplace=True)
- run_asserts(left, right, sort)
+ run_asserts(left, right, sort)
- # inject some nulls
- left.loc[1::4, "1st"] = np.nan
- left.loc[2::5, "2nd"] = np.nan
- left.loc[3::6, "3rd"] = np.nan
- left["4th"] = bind_cols(left)
+ # inject some nulls
+ left.loc[1::4, "1st"] = np.nan
+ left.loc[2::5, "2nd"] = np.nan
+ left.loc[3::6, "3rd"] = np.nan
+ left["4th"] = bind_cols(left)
- i = np.random.default_rng(2).permutation(len(left))
- right = left.iloc[i, :-1]
- right["5th"] = -bind_cols(right)
- right.set_index(icols, inplace=True)
+ i = np.random.default_rng(2).permutation(len(left))
+ right = left.iloc[i, :-1]
+ right["5th"] = -bind_cols(right)
+ right.set_index(icols, inplace=True)
- run_asserts(left, right, sort)
+ run_asserts(left, right, sort)
@pytest.mark.parametrize("sort", [False, True])
def test_merge_right_vs_left(self, left, right, sort):
@@ -632,7 +639,7 @@ def test_join_multi_levels_outer(self, portfolio, household, expected):
axis=0,
sort=True,
).reindex(columns=expected.columns)
- tm.assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected, check_index_type=False)
def test_join_multi_levels_invalid(self, portfolio, household):
portfolio = portfolio.copy()
diff --git a/pandas/tests/reshape/test_melt.py b/pandas/tests/reshape/test_melt.py
index ff9f927597956..272c5b3403293 100644
--- a/pandas/tests/reshape/test_melt.py
+++ b/pandas/tests/reshape/test_melt.py
@@ -1220,3 +1220,33 @@ def test_missing_stubname(self, dtype):
new_level = expected.index.levels[0].astype(dtype)
expected.index = expected.index.set_levels(new_level, level=0)
tm.assert_frame_equal(result, expected)
+
+
+def test_wide_to_long_pyarrow_string_columns():
+ # GH 57066
+ pytest.importorskip("pyarrow")
+ df = DataFrame(
+ {
+ "ID": {0: 1},
+ "R_test1": {0: 1},
+ "R_test2": {0: 1},
+ "R_test3": {0: 2},
+ "D": {0: 1},
+ }
+ )
+ df.columns = df.columns.astype("string[pyarrow_numpy]")
+ result = wide_to_long(
+ df, stubnames="R", i="ID", j="UNPIVOTED", sep="_", suffix=".*"
+ )
+ expected = DataFrame(
+ [[1, 1], [1, 1], [1, 2]],
+ columns=Index(["D", "R"], dtype=object),
+ index=pd.MultiIndex.from_arrays(
+ [
+ [1, 1, 1],
+ Index(["test1", "test2", "test3"], dtype="string[pyarrow_numpy]"),
+ ],
+ names=["ID", "UNPIVOTED"],
+ ),
+ )
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/scalar/period/test_asfreq.py b/pandas/tests/scalar/period/test_asfreq.py
index 4489c307172d7..73c4d8061c257 100644
--- a/pandas/tests/scalar/period/test_asfreq.py
+++ b/pandas/tests/scalar/period/test_asfreq.py
@@ -820,10 +820,9 @@ def test_asfreq_MS(self):
assert initial.asfreq(freq="M", how="S") == Period("2013-01", "M")
- msg = INVALID_FREQ_ERR_MSG
+ msg = "MS is not supported as period frequency"
with pytest.raises(ValueError, match=msg):
initial.asfreq(freq="MS", how="S")
- msg = "MonthBegin is not supported as period frequency"
- with pytest.raises(TypeError, match=msg):
+ with pytest.raises(ValueError, match=msg):
Period("2013-01", "MS")
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index aa4a8b152b19f..2c3a0816737fc 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -3,6 +3,7 @@
datetime,
timedelta,
)
+import re
import numpy as np
import pytest
@@ -40,21 +41,22 @@ class TestPeriodDisallowedFreqs:
)
def test_offsets_not_supported(self, freq, freq_msg):
# GH#55785
- msg = f"{freq_msg} is not supported as period frequency"
- with pytest.raises(TypeError, match=msg):
+ msg = re.escape(f"{freq} is not supported as period frequency")
+ with pytest.raises(ValueError, match=msg):
Period(year=2014, freq=freq)
def test_custom_business_day_freq_raises(self):
# GH#52534
- msg = "CustomBusinessDay is not supported as period frequency"
- with pytest.raises(TypeError, match=msg):
+ msg = "C is not supported as period frequency"
+ with pytest.raises(ValueError, match=msg):
Period("2023-04-10", freq="C")
- with pytest.raises(TypeError, match=msg):
+ msg = f"{offsets.CustomBusinessDay().base} is not supported as period frequency"
+ with pytest.raises(ValueError, match=msg):
Period("2023-04-10", freq=offsets.CustomBusinessDay())
def test_invalid_frequency_error_message(self):
- msg = "WeekOfMonth is not supported as period frequency"
- with pytest.raises(TypeError, match=msg):
+ msg = "WOM-1MON is not supported as period frequency"
+ with pytest.raises(ValueError, match=msg):
Period("2012-01-02", freq="WOM-1MON")
def test_invalid_frequency_period_error_message(self):
@@ -106,7 +108,9 @@ def test_construction(self):
assert i1 == i3
i1 = Period("1982", freq="min")
- i2 = Period("1982", freq="MIN")
+ msg = "'MIN' is deprecated and will be removed in a future version."
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ i2 = Period("1982", freq="MIN")
assert i1 == i2
i1 = Period(year=2005, month=3, day=1, freq="D")
diff --git a/pandas/tests/scalar/timestamp/test_formats.py b/pandas/tests/scalar/timestamp/test_formats.py
index d7160597ea6d6..e7ebcccef1c86 100644
--- a/pandas/tests/scalar/timestamp/test_formats.py
+++ b/pandas/tests/scalar/timestamp/test_formats.py
@@ -88,7 +88,7 @@ def test_isoformat(ts, timespec, expected_iso):
class TestTimestampRendering:
- timezones = ["UTC", "Asia/Tokyo", "US/Eastern", "dateutil/US/Pacific"]
+ timezones = ["UTC", "Asia/Tokyo", "US/Eastern", "dateutil/America/Los_Angeles"]
@pytest.mark.parametrize("tz", timezones)
@pytest.mark.parametrize("freq", ["D", "M", "S", "N"])
diff --git a/pandas/tests/series/accessors/test_struct_accessor.py b/pandas/tests/series/accessors/test_struct_accessor.py
index 1ec5b3b726d17..80aea75fda406 100644
--- a/pandas/tests/series/accessors/test_struct_accessor.py
+++ b/pandas/tests/series/accessors/test_struct_accessor.py
@@ -2,6 +2,11 @@
import pytest
+from pandas.compat.pyarrow import (
+ pa_version_under11p0,
+ pa_version_under13p0,
+)
+
from pandas import (
ArrowDtype,
DataFrame,
@@ -11,6 +16,7 @@
import pandas._testing as tm
pa = pytest.importorskip("pyarrow")
+pc = pytest.importorskip("pyarrow.compute")
def test_struct_accessor_dtypes():
@@ -53,6 +59,7 @@ def test_struct_accessor_dtypes():
tm.assert_series_equal(actual, expected)
+@pytest.mark.skipif(pa_version_under13p0, reason="pyarrow>=13.0.0 required")
def test_struct_accessor_field():
index = Index([-100, 42, 123])
ser = Series(
@@ -94,10 +101,11 @@ def test_struct_accessor_field():
def test_struct_accessor_field_with_invalid_name_or_index():
ser = Series([], dtype=ArrowDtype(pa.struct([("field", pa.int64())])))
- with pytest.raises(ValueError, match="name_or_index must be an int or str"):
+ with pytest.raises(ValueError, match="name_or_index must be an int, str,"):
ser.struct.field(1.1)
+@pytest.mark.skipif(pa_version_under11p0, reason="pyarrow>=11.0.0 required")
def test_struct_accessor_explode():
index = Index([-100, 42, 123])
ser = Series(
@@ -148,3 +156,41 @@ def test_struct_accessor_api_for_invalid(invalid):
),
):
invalid.struct
+
+
+@pytest.mark.parametrize(
+ ["indices", "name"],
+ [
+ (0, "int_col"),
+ ([1, 2], "str_col"),
+ (pc.field("int_col"), "int_col"),
+ ("int_col", "int_col"),
+ (b"string_col", b"string_col"),
+ ([b"string_col"], "string_col"),
+ ],
+)
+@pytest.mark.skipif(pa_version_under13p0, reason="pyarrow>=13.0.0 required")
+def test_struct_accessor_field_expanded(indices, name):
+ arrow_type = pa.struct(
+ [
+ ("int_col", pa.int64()),
+ (
+ "struct_col",
+ pa.struct(
+ [
+ ("int_col", pa.int64()),
+ ("float_col", pa.float64()),
+ ("str_col", pa.string()),
+ ]
+ ),
+ ),
+ (b"string_col", pa.string()),
+ ]
+ )
+
+ data = pa.array([], type=arrow_type)
+ ser = Series(data, dtype=ArrowDtype(arrow_type))
+ expected = pc.struct_field(data, indices)
+ result = ser.struct.field(indices)
+ tm.assert_equal(result.array._pa_array.combine_chunks(), expected)
+ assert result.name == name
diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py
index c52e47a812183..f4992b758af74 100644
--- a/pandas/tests/series/indexing/test_indexing.py
+++ b/pandas/tests/series/indexing/test_indexing.py
@@ -491,7 +491,7 @@ def _check_setitem_invalid(self, ser, invalid, indexer, warn):
np.datetime64("NaT"),
np.timedelta64("NaT"),
]
- _indexers = [0, [0], slice(0, 1), [True, False, False]]
+ _indexers = [0, [0], slice(0, 1), [True, False, False], slice(None, None, None)]
@pytest.mark.parametrize(
"invalid", _invalid_scalars + [1, 1.0, np.int64(1), np.float64(1)]
@@ -505,7 +505,7 @@ def test_setitem_validation_scalar_bool(self, invalid, indexer):
@pytest.mark.parametrize("indexer", _indexers)
def test_setitem_validation_scalar_int(self, invalid, any_int_numpy_dtype, indexer):
ser = Series([1, 2, 3], dtype=any_int_numpy_dtype)
- if isna(invalid) and invalid is not NaT:
+ if isna(invalid) and invalid is not NaT and not np.isnat(invalid):
warn = None
else:
warn = FutureWarning
diff --git a/pandas/tests/series/methods/test_astype.py b/pandas/tests/series/methods/test_astype.py
index 46f55fff91e41..4c8028e74ee55 100644
--- a/pandas/tests/series/methods/test_astype.py
+++ b/pandas/tests/series/methods/test_astype.py
@@ -673,3 +673,11 @@ def test_astype_timedelta64_with_np_nan(self):
result = Series([Timedelta(1), np.nan], dtype="timedelta64[ns]")
expected = Series([Timedelta(1), NaT], dtype="timedelta64[ns]")
tm.assert_series_equal(result, expected)
+
+ @td.skip_if_no("pyarrow")
+ def test_astype_int_na_string(self):
+ # GH#57418
+ ser = Series([12, NA], dtype="Int64[pyarrow]")
+ result = ser.astype("string[pyarrow]")
+ expected = Series(["12", NA], dtype="string[pyarrow]")
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_case_when.py b/pandas/tests/series/methods/test_case_when.py
new file mode 100644
index 0000000000000..7cb60a11644a3
--- /dev/null
+++ b/pandas/tests/series/methods/test_case_when.py
@@ -0,0 +1,148 @@
+import numpy as np
+import pytest
+
+from pandas import (
+ DataFrame,
+ Series,
+ array as pd_array,
+ date_range,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def df():
+ """
+ base dataframe for testing
+ """
+ return DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+
+
+def test_case_when_caselist_is_not_a_list(df):
+ """
+ Raise ValueError if caselist is not a list.
+ """
+ msg = "The caselist argument should be a list; "
+ msg += "instead got.+"
+ with pytest.raises(TypeError, match=msg): # GH39154
+ df["a"].case_when(caselist=())
+
+
+def test_case_when_no_caselist(df):
+ """
+ Raise ValueError if no caselist is provided.
+ """
+ msg = "provide at least one boolean condition, "
+ msg += "with a corresponding replacement."
+ with pytest.raises(ValueError, match=msg): # GH39154
+ df["a"].case_when([])
+
+
+def test_case_when_odd_caselist(df):
+ """
+ Raise ValueError if no of caselist is odd.
+ """
+ msg = "Argument 0 must have length 2; "
+ msg += "a condition and replacement; instead got length 3."
+
+ with pytest.raises(ValueError, match=msg):
+ df["a"].case_when([(df["a"].eq(1), 1, df.a.gt(1))])
+
+
+def test_case_when_raise_error_from_mask(df):
+ """
+ Raise Error from within Series.mask
+ """
+ msg = "Failed to apply condition0 and replacement0."
+ with pytest.raises(ValueError, match=msg):
+ df["a"].case_when([(df["a"].eq(1), [1, 2])])
+
+
+def test_case_when_single_condition(df):
+ """
+ Test output on a single condition.
+ """
+ result = Series([np.nan, np.nan, np.nan]).case_when([(df.a.eq(1), 1)])
+ expected = Series([1, np.nan, np.nan])
+ tm.assert_series_equal(result, expected)
+
+
+def test_case_when_multiple_conditions(df):
+ """
+ Test output when booleans are derived from a computation
+ """
+ result = Series([np.nan, np.nan, np.nan]).case_when(
+ [(df.a.eq(1), 1), (Series([False, True, False]), 2)]
+ )
+ expected = Series([1, 2, np.nan])
+ tm.assert_series_equal(result, expected)
+
+
+def test_case_when_multiple_conditions_replacement_list(df):
+ """
+ Test output when replacement is a list
+ """
+ result = Series([np.nan, np.nan, np.nan]).case_when(
+ [([True, False, False], 1), (df["a"].gt(1) & df["b"].eq(5), [1, 2, 3])]
+ )
+ expected = Series([1, 2, np.nan])
+ tm.assert_series_equal(result, expected)
+
+
+def test_case_when_multiple_conditions_replacement_extension_dtype(df):
+ """
+ Test output when replacement has an extension dtype
+ """
+ result = Series([np.nan, np.nan, np.nan]).case_when(
+ [
+ ([True, False, False], 1),
+ (df["a"].gt(1) & df["b"].eq(5), pd_array([1, 2, 3], dtype="Int64")),
+ ],
+ )
+ expected = Series([1, 2, np.nan], dtype="Float64")
+ tm.assert_series_equal(result, expected)
+
+
+def test_case_when_multiple_conditions_replacement_series(df):
+ """
+ Test output when replacement is a Series
+ """
+ result = Series([np.nan, np.nan, np.nan]).case_when(
+ [
+ (np.array([True, False, False]), 1),
+ (df["a"].gt(1) & df["b"].eq(5), Series([1, 2, 3])),
+ ],
+ )
+ expected = Series([1, 2, np.nan])
+ tm.assert_series_equal(result, expected)
+
+
+def test_case_when_non_range_index():
+ """
+ Test output if index is not RangeIndex
+ """
+ rng = np.random.default_rng(seed=123)
+ dates = date_range("1/1/2000", periods=8)
+ df = DataFrame(
+ rng.standard_normal(size=(8, 4)), index=dates, columns=["A", "B", "C", "D"]
+ )
+ result = Series(5, index=df.index, name="A").case_when([(df.A.gt(0), df.B)])
+ expected = df.A.mask(df.A.gt(0), df.B).where(df.A.gt(0), 5)
+ tm.assert_series_equal(result, expected)
+
+
+def test_case_when_callable():
+ """
+ Test output on a callable
+ """
+ # https://numpy.org/doc/stable/reference/generated/numpy.piecewise.html
+ x = np.linspace(-2.5, 2.5, 6)
+ ser = Series(x)
+ result = ser.case_when(
+ caselist=[
+ (lambda df: df < 0, lambda df: -df),
+ (lambda df: df >= 0, lambda df: df),
+ ]
+ )
+ expected = np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])
+ tm.assert_series_equal(result, Series(expected))
diff --git a/pandas/tests/series/methods/test_pct_change.py b/pandas/tests/series/methods/test_pct_change.py
index 9727ef3d5c27c..6c80e711c3684 100644
--- a/pandas/tests/series/methods/test_pct_change.py
+++ b/pandas/tests/series/methods/test_pct_change.py
@@ -118,3 +118,11 @@ def test_pct_change_no_warning_na_beginning():
result = ser.pct_change()
expected = Series([np.nan, np.nan, np.nan, 1, 0.5])
tm.assert_series_equal(result, expected)
+
+
+def test_pct_change_empty():
+ # GH 57056
+ ser = Series([], dtype="float64")
+ expected = ser.copy()
+ result = ser.pct_change(periods=0)
+ tm.assert_series_equal(expected, result)
diff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py
index 4330153c186ca..b0f4e233ba5eb 100644
--- a/pandas/tests/series/methods/test_replace.py
+++ b/pandas/tests/series/methods/test_replace.py
@@ -799,3 +799,15 @@ def test_replace_numeric_column_with_na(self, val):
ser.replace(to_replace=1, value=pd.NA, inplace=True)
tm.assert_series_equal(ser, expected)
+
+ def test_replace_ea_float_with_bool(self):
+ # GH#55398
+ ser = pd.Series([0.0], dtype="Float64")
+ expected = ser.copy()
+ result = ser.replace(False, 1.0)
+ tm.assert_series_equal(result, expected)
+
+ ser = pd.Series([False], dtype="boolean")
+ expected = ser.copy()
+ result = ser.replace(0.0, True)
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_round.py b/pandas/tests/series/methods/test_round.py
index 7f60c94f10e4f..c330b7a7dfbbb 100644
--- a/pandas/tests/series/methods/test_round.py
+++ b/pandas/tests/series/methods/test_round.py
@@ -63,3 +63,12 @@ def test_round_nat(self, method, freq, unit):
round_method = getattr(ser.dt, method)
result = round_method(freq)
tm.assert_series_equal(result, expected)
+
+ def test_round_ea_boolean(self):
+ # GH#55936
+ ser = Series([True, False], dtype="boolean")
+ expected = ser.copy()
+ result = ser.round(2)
+ tm.assert_series_equal(result, expected)
+ result.iloc[0] = False
+ tm.assert_series_equal(ser, expected)
diff --git a/pandas/tests/series/methods/test_to_numpy.py b/pandas/tests/series/methods/test_to_numpy.py
index 5fe3e19b0a20b..4bc7631090761 100644
--- a/pandas/tests/series/methods/test_to_numpy.py
+++ b/pandas/tests/series/methods/test_to_numpy.py
@@ -1,9 +1,12 @@
import numpy as np
import pytest
+import pandas.util._test_decorators as td
+
from pandas import (
NA,
Series,
+ Timedelta,
)
import pandas._testing as tm
@@ -23,3 +26,24 @@ def test_to_numpy_cast_before_setting_na():
result = ser.to_numpy(dtype=np.float64, na_value=np.nan)
expected = np.array([1.0])
tm.assert_numpy_array_equal(result, expected)
+
+
+@td.skip_if_no("pyarrow")
+def test_to_numpy_arrow_dtype_given():
+ # GH#57121
+ ser = Series([1, NA], dtype="int64[pyarrow]")
+ result = ser.to_numpy(dtype="float64")
+ expected = np.array([1.0, np.nan])
+ tm.assert_numpy_array_equal(result, expected)
+
+
+def test_astype_ea_int_to_td_ts():
+ # GH#57093
+ ser = Series([1, None], dtype="Int64")
+ result = ser.astype("m8[ns]")
+ expected = Series([1, Timedelta("nat")], dtype="m8[ns]")
+ tm.assert_series_equal(result, expected)
+
+ result = ser.astype("M8[ns]")
+ expected = Series([1, Timedelta("nat")], dtype="M8[ns]")
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index da069afe5e709..4d3839553a0af 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -1958,9 +1958,15 @@ def test_constructor_int64_dtype(self, any_int_dtype):
def test_constructor_raise_on_lossy_conversion_of_strings(self):
# GH#44923
- with pytest.raises(
- ValueError, match="string values cannot be losslessly cast to int8"
- ):
+ if not np_version_gt2:
+ raises = pytest.raises(
+ ValueError, match="string values cannot be losslessly cast to int8"
+ )
+ else:
+ raises = pytest.raises(
+ OverflowError, match="The elements provided in the data"
+ )
+ with raises:
Series(["128"], dtype="int8")
def test_constructor_dtype_timedelta_alternative_construct(self):
diff --git a/pandas/tests/strings/test_find_replace.py b/pandas/tests/strings/test_find_replace.py
index 3f58c6d703f8f..cd4707ac405de 100644
--- a/pandas/tests/strings/test_find_replace.py
+++ b/pandas/tests/strings/test_find_replace.py
@@ -730,6 +730,15 @@ def test_fullmatch(any_string_dtype):
tm.assert_series_equal(result, expected)
+def test_fullmatch_dollar_literal(any_string_dtype):
+ # GH 56652
+ ser = Series(["foo", "foo$foo", np.nan, "foo$"], dtype=any_string_dtype)
+ result = ser.str.fullmatch("foo\\$")
+ expected_dtype = "object" if any_string_dtype in object_pyarrow_numpy else "boolean"
+ expected = Series([False, False, np.nan, True], dtype=expected_dtype)
+ tm.assert_series_equal(result, expected)
+
+
def test_fullmatch_na_kwarg(any_string_dtype):
ser = Series(
["fooBAD__barBAD", "BAD_BADleroybrown", np.nan, "foo"], dtype=any_string_dtype
diff --git a/pandas/tests/test_optional_dependency.py b/pandas/tests/test_optional_dependency.py
index c1d1948d6c31a..52b5f636b1254 100644
--- a/pandas/tests/test_optional_dependency.py
+++ b/pandas/tests/test_optional_dependency.py
@@ -50,6 +50,20 @@ def test_bad_version(monkeypatch):
result = import_optional_dependency("fakemodule")
assert result is module
+ with pytest.raises(ImportError, match="Pandas requires version '1.1.0'"):
+ import_optional_dependency("fakemodule", min_version="1.1.0")
+
+ with tm.assert_produces_warning(UserWarning):
+ result = import_optional_dependency(
+ "fakemodule", errors="warn", min_version="1.1.0"
+ )
+ assert result is None
+
+ result = import_optional_dependency(
+ "fakemodule", errors="ignore", min_version="1.1.0"
+ )
+ assert result is None
+
def test_submodule(monkeypatch):
# Create a fake module with a submodule
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 6791ac0340640..a1ed996dade8e 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -1912,6 +1912,14 @@ def test_unit(self, cache):
with pytest.raises(ValueError, match=msg):
to_datetime([1], unit="D", format="%Y%m%d", cache=cache)
+ def test_unit_str(self, cache):
+ # GH 57051
+ # Test that strs aren't dropping precision to 32-bit accidentally.
+ with tm.assert_produces_warning(FutureWarning):
+ res = to_datetime(["1704660000"], unit="s", origin="unix")
+ expected = to_datetime([1704660000], unit="s", origin="unix")
+ tm.assert_index_equal(res, expected)
+
def test_unit_array_mixed_nans(self, cache):
values = [11111111111111111, 1, 1.0, iNaT, NaT, np.nan, "NaT", ""]
result = to_datetime(values, unit="D", errors="ignore", cache=cache)
diff --git a/pandas/tests/tseries/offsets/conftest.py b/pandas/tests/tseries/offsets/conftest.py
deleted file mode 100644
index 2fc846353dcb5..0000000000000
--- a/pandas/tests/tseries/offsets/conftest.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import datetime
-
-import pytest
-
-from pandas._libs.tslibs import Timestamp
-
-
-@pytest.fixture
-def dt():
- """
- Fixture for common Timestamp.
- """
- return Timestamp(datetime.datetime(2008, 1, 2))
diff --git a/pandas/tests/tseries/offsets/test_business_quarter.py b/pandas/tests/tseries/offsets/test_business_quarter.py
index 44a7f16ab039d..6d7a115054b7f 100644
--- a/pandas/tests/tseries/offsets/test_business_quarter.py
+++ b/pandas/tests/tseries/offsets/test_business_quarter.py
@@ -9,6 +9,7 @@
import pytest
+import pandas._testing as tm
from pandas.tests.tseries.offsets.common import (
assert_is_on_offset,
assert_offset_equal,
@@ -54,9 +55,12 @@ def test_repr(self):
assert repr(BQuarterBegin(startingMonth=1)) == expected
def test_is_anchored(self):
- assert BQuarterBegin(startingMonth=1).is_anchored()
- assert BQuarterBegin().is_anchored()
- assert not BQuarterBegin(2, startingMonth=1).is_anchored()
+ msg = "BQuarterBegin.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert BQuarterBegin(startingMonth=1).is_anchored()
+ assert BQuarterBegin().is_anchored()
+ assert not BQuarterBegin(2, startingMonth=1).is_anchored()
def test_offset_corner_case(self):
# corner
@@ -177,9 +181,12 @@ def test_repr(self):
assert repr(BQuarterEnd(startingMonth=1)) == expected
def test_is_anchored(self):
- assert BQuarterEnd(startingMonth=1).is_anchored()
- assert BQuarterEnd().is_anchored()
- assert not BQuarterEnd(2, startingMonth=1).is_anchored()
+ msg = "BQuarterEnd.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert BQuarterEnd(startingMonth=1).is_anchored()
+ assert BQuarterEnd().is_anchored()
+ assert not BQuarterEnd(2, startingMonth=1).is_anchored()
def test_offset_corner_case(self):
# corner
diff --git a/pandas/tests/tseries/offsets/test_common.py b/pandas/tests/tseries/offsets/test_common.py
index 5b80b8b1c4ab4..aa4e22f71ad66 100644
--- a/pandas/tests/tseries/offsets/test_common.py
+++ b/pandas/tests/tseries/offsets/test_common.py
@@ -250,7 +250,8 @@ def test_sub(date, offset_box, offset2):
[BusinessHour, BusinessHour()],
],
)
-def test_Mult1(offset_box, offset1, dt):
+def test_Mult1(offset_box, offset1):
+ dt = Timestamp(2008, 1, 2)
assert dt + 10 * offset1 == dt + offset_box(10)
assert dt + 5 * offset1 == dt + offset_box(5)
diff --git a/pandas/tests/tseries/offsets/test_fiscal.py b/pandas/tests/tseries/offsets/test_fiscal.py
index 7f8c34bc6832e..824e66a1ddef1 100644
--- a/pandas/tests/tseries/offsets/test_fiscal.py
+++ b/pandas/tests/tseries/offsets/test_fiscal.py
@@ -7,6 +7,7 @@
import pytest
from pandas import Timestamp
+import pandas._testing as tm
from pandas.tests.tseries.offsets.common import (
WeekDay,
assert_is_on_offset,
@@ -295,15 +296,18 @@ def test_apply(self):
class TestFY5253LastOfMonthQuarter:
def test_is_anchored(self):
- assert makeFY5253LastOfMonthQuarter(
- startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
- ).is_anchored()
- assert makeFY5253LastOfMonthQuarter(
- weekday=WeekDay.SAT, startingMonth=3, qtr_with_extra_week=4
- ).is_anchored()
- assert not makeFY5253LastOfMonthQuarter(
- 2, startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
- ).is_anchored()
+ msg = "FY5253Quarter.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert makeFY5253LastOfMonthQuarter(
+ startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+ ).is_anchored()
+ assert makeFY5253LastOfMonthQuarter(
+ weekday=WeekDay.SAT, startingMonth=3, qtr_with_extra_week=4
+ ).is_anchored()
+ assert not makeFY5253LastOfMonthQuarter(
+ 2, startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+ ).is_anchored()
def test_equality(self):
assert makeFY5253LastOfMonthQuarter(
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index ddf56e68b1611..62afb8b83d576 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -625,8 +625,11 @@ def test_default_constructor(self, dt):
assert (dt + DateOffset(2)) == datetime(2008, 1, 4)
def test_is_anchored(self):
- assert not DateOffset(2).is_anchored()
- assert DateOffset(1).is_anchored()
+ msg = "DateOffset.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert not DateOffset(2).is_anchored()
+ assert DateOffset(1).is_anchored()
def test_copy(self):
assert DateOffset(months=2).copy() == DateOffset(months=2)
diff --git a/pandas/tests/tseries/offsets/test_quarter.py b/pandas/tests/tseries/offsets/test_quarter.py
index d183645da507d..5fd3ba0a5fb87 100644
--- a/pandas/tests/tseries/offsets/test_quarter.py
+++ b/pandas/tests/tseries/offsets/test_quarter.py
@@ -9,6 +9,7 @@
import pytest
+import pandas._testing as tm
from pandas.tests.tseries.offsets.common import (
assert_is_on_offset,
assert_offset_equal,
@@ -53,9 +54,12 @@ def test_repr(self):
assert repr(QuarterBegin(startingMonth=1)) == expected
def test_is_anchored(self):
- assert QuarterBegin(startingMonth=1).is_anchored()
- assert QuarterBegin().is_anchored()
- assert not QuarterBegin(2, startingMonth=1).is_anchored()
+ msg = "QuarterBegin.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert QuarterBegin(startingMonth=1).is_anchored()
+ assert QuarterBegin().is_anchored()
+ assert not QuarterBegin(2, startingMonth=1).is_anchored()
def test_offset_corner_case(self):
# corner
@@ -161,9 +165,12 @@ def test_repr(self):
assert repr(QuarterEnd(startingMonth=1)) == expected
def test_is_anchored(self):
- assert QuarterEnd(startingMonth=1).is_anchored()
- assert QuarterEnd().is_anchored()
- assert not QuarterEnd(2, startingMonth=1).is_anchored()
+ msg = "QuarterEnd.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert QuarterEnd(startingMonth=1).is_anchored()
+ assert QuarterEnd().is_anchored()
+ assert not QuarterEnd(2, startingMonth=1).is_anchored()
def test_offset_corner_case(self):
# corner
diff --git a/pandas/tests/tseries/offsets/test_ticks.py b/pandas/tests/tseries/offsets/test_ticks.py
index b68b91826bc6f..399b7038d3426 100644
--- a/pandas/tests/tseries/offsets/test_ticks.py
+++ b/pandas/tests/tseries/offsets/test_ticks.py
@@ -339,7 +339,10 @@ def test_tick_equalities(cls):
@pytest.mark.parametrize("cls", tick_classes)
def test_tick_offset(cls):
- assert not cls().is_anchored()
+ msg = f"{cls.__name__}.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert not cls().is_anchored()
@pytest.mark.parametrize("cls", tick_classes)
diff --git a/pandas/tests/tseries/offsets/test_week.py b/pandas/tests/tseries/offsets/test_week.py
index f42ff091af277..0cd6f769769ae 100644
--- a/pandas/tests/tseries/offsets/test_week.py
+++ b/pandas/tests/tseries/offsets/test_week.py
@@ -21,6 +21,7 @@
WeekOfMonth,
)
+import pandas._testing as tm
from pandas.tests.tseries.offsets.common import (
WeekDay,
assert_is_on_offset,
@@ -42,10 +43,13 @@ def test_corner(self):
Week(weekday=-1)
def test_is_anchored(self):
- assert Week(weekday=0).is_anchored()
- assert not Week().is_anchored()
- assert not Week(2, weekday=2).is_anchored()
- assert not Week(2).is_anchored()
+ msg = "Week.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert Week(weekday=0).is_anchored()
+ assert not Week().is_anchored()
+ assert not Week(2, weekday=2).is_anchored()
+ assert not Week(2).is_anchored()
offset_cases = []
# not business week
diff --git a/pandas/tests/tslibs/test_array_to_datetime.py b/pandas/tests/tslibs/test_array_to_datetime.py
index 632d3b4cc3c84..82175c67764f8 100644
--- a/pandas/tests/tslibs/test_array_to_datetime.py
+++ b/pandas/tests/tslibs/test_array_to_datetime.py
@@ -296,6 +296,23 @@ def test_to_datetime_barely_out_of_bounds():
tslib.array_to_datetime(arr)
+@pytest.mark.parametrize(
+ "timestamp",
+ [
+ # Close enough to bounds that scaling micros to nanos overflows
+ # but adding nanos would result in an in-bounds datetime.
+ "1677-09-21T00:12:43.145224193",
+ "1677-09-21T00:12:43.145224999",
+ # this always worked
+ "1677-09-21T00:12:43.145225000",
+ ],
+)
+def test_to_datetime_barely_inside_bounds(timestamp):
+ # see gh-57150
+ result, _ = tslib.array_to_datetime(np.array([timestamp], dtype=object))
+ tm.assert_numpy_array_equal(result, np.array([timestamp], dtype="M8[ns]"))
+
+
class SubDatetime(datetime):
pass
diff --git a/pandas/tests/tslibs/test_to_offset.py b/pandas/tests/tslibs/test_to_offset.py
index ef68408305232..8ca55648f3780 100644
--- a/pandas/tests/tslibs/test_to_offset.py
+++ b/pandas/tests/tslibs/test_to_offset.py
@@ -45,6 +45,7 @@ def test_to_offset_negative(freqstr, expected):
assert result.n == expected
+@pytest.mark.filterwarnings("ignore:.*'m' is deprecated.*:FutureWarning")
@pytest.mark.parametrize(
"freqstr",
[
@@ -172,3 +173,47 @@ def test_to_offset_pd_timedelta(kwargs, expected):
def test_anchored_shortcuts(shortcut, expected):
result = to_offset(shortcut)
assert result == expected
+
+
+@pytest.mark.parametrize(
+ "freq_depr",
+ [
+ "2ye-mar",
+ "2ys",
+ "2qe",
+ "2qs-feb",
+ "2bqs",
+ "2sms",
+ "2bms",
+ "2cbme",
+ "2me",
+ "2w",
+ ],
+)
+def test_to_offset_lowercase_frequency_deprecated(freq_depr):
+ # GH#54939
+ depr_msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+ f"future version, please use '{freq_depr.upper()[1:]}' instead."
+
+ with pytest.raises(FutureWarning, match=depr_msg):
+ to_offset(freq_depr)
+
+
+@pytest.mark.parametrize(
+ "freq_depr",
+ [
+ "2H",
+ "2BH",
+ "2MIN",
+ "2S",
+ "2Us",
+ "2NS",
+ ],
+)
+def test_to_offset_uppercase_frequency_deprecated(freq_depr):
+ # GH#54939
+ depr_msg = f"'{freq_depr[1:]}' is deprecated and will be removed in a "
+ f"future version, please use '{freq_depr.lower()[1:]}' instead."
+
+ with pytest.raises(FutureWarning, match=depr_msg):
+ to_offset(freq_depr)
diff --git a/pandas/tests/util/test_assert_frame_equal.py b/pandas/tests/util/test_assert_frame_equal.py
index a074898f6046d..79132591b15b3 100644
--- a/pandas/tests/util/test_assert_frame_equal.py
+++ b/pandas/tests/util/test_assert_frame_equal.py
@@ -211,10 +211,7 @@ def test_assert_frame_equal_extension_dtype_mismatch():
"\\[right\\]: int[32|64]"
)
- # TODO: this shouldn't raise (or should raise a better error message)
- # https://github.com/pandas-dev/pandas/issues/56131
- with pytest.raises(AssertionError, match="classes are different"):
- tm.assert_frame_equal(left, right, check_dtype=False)
+ tm.assert_frame_equal(left, right, check_dtype=False)
with pytest.raises(AssertionError, match=msg):
tm.assert_frame_equal(left, right, check_dtype=True)
@@ -246,7 +243,6 @@ def test_assert_frame_equal_ignore_extension_dtype_mismatch():
tm.assert_frame_equal(left, right, check_dtype=False)
-@pytest.mark.xfail(reason="https://github.com/pandas-dev/pandas/issues/56131")
def test_assert_frame_equal_ignore_extension_dtype_mismatch_cross_class():
# https://github.com/pandas-dev/pandas/issues/35715
left = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
@@ -300,9 +296,7 @@ def test_frame_equal_mixed_dtypes(frame_or_series, any_numeric_ea_dtype, indexer
dtypes = (any_numeric_ea_dtype, "int64")
obj1 = frame_or_series([1, 2], dtype=dtypes[indexer[0]])
obj2 = frame_or_series([1, 2], dtype=dtypes[indexer[1]])
- msg = r'(Series|DataFrame.iloc\[:, 0\] \(column name="0"\) classes) are different'
- with pytest.raises(AssertionError, match=msg):
- tm.assert_equal(obj1, obj2, check_exact=True, check_dtype=False)
+ tm.assert_equal(obj1, obj2, check_exact=True, check_dtype=False)
def test_assert_frame_equal_check_like_different_indexes():
diff --git a/pandas/tests/util/test_assert_series_equal.py b/pandas/tests/util/test_assert_series_equal.py
index f722f619bc456..1878e7d838064 100644
--- a/pandas/tests/util/test_assert_series_equal.py
+++ b/pandas/tests/util/test_assert_series_equal.py
@@ -290,10 +290,7 @@ def test_assert_series_equal_extension_dtype_mismatch():
\\[left\\]: Int64
\\[right\\]: int[32|64]"""
- # TODO: this shouldn't raise (or should raise a better error message)
- # https://github.com/pandas-dev/pandas/issues/56131
- with pytest.raises(AssertionError, match="Series classes are different"):
- tm.assert_series_equal(left, right, check_dtype=False)
+ tm.assert_series_equal(left, right, check_dtype=False)
with pytest.raises(AssertionError, match=msg):
tm.assert_series_equal(left, right, check_dtype=True)
@@ -372,7 +369,6 @@ def test_assert_series_equal_ignore_extension_dtype_mismatch():
tm.assert_series_equal(left, right, check_dtype=False)
-@pytest.mark.xfail(reason="https://github.com/pandas-dev/pandas/issues/56131")
def test_assert_series_equal_ignore_extension_dtype_mismatch_cross_class():
# https://github.com/pandas-dev/pandas/issues/35715
left = Series([1, 2, 3], dtype="Int64")
@@ -456,3 +452,33 @@ def test_large_unequal_ints(dtype):
right = Series([1577840521123543], dtype=dtype)
with pytest.raises(AssertionError, match="Series are different"):
tm.assert_series_equal(left, right)
+
+
+@pytest.mark.parametrize("dtype", [None, object])
+@pytest.mark.parametrize("check_exact", [True, False])
+@pytest.mark.parametrize("val", [3, 3.5])
+def test_ea_and_numpy_no_dtype_check(val, check_exact, dtype):
+ # GH#56651
+ left = Series([1, 2, val], dtype=dtype)
+ right = Series(pd.array([1, 2, val]))
+ tm.assert_series_equal(left, right, check_dtype=False, check_exact=check_exact)
+
+
+def test_assert_series_equal_int_tol():
+ # GH#56646
+ left = Series([81, 18, 121, 38, 74, 72, 81, 81, 146, 81, 81, 170, 74, 74])
+ right = Series([72, 9, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72])
+ tm.assert_series_equal(left, right, rtol=1.5)
+
+ tm.assert_frame_equal(left.to_frame(), right.to_frame(), rtol=1.5)
+ tm.assert_extension_array_equal(
+ left.astype("Int64").values, right.astype("Int64").values, rtol=1.5
+ )
+
+
+def test_assert_series_equal_index_exact_default():
+ # GH#57067
+ ser1 = Series(np.zeros(6, dtype=int), [0, 0.2, 0.4, 0.6, 0.8, 1])
+ ser2 = Series(np.zeros(6, dtype=int), np.linspace(0, 1, 6))
+ tm.assert_series_equal(ser1, ser2)
+ tm.assert_frame_equal(ser1.to_frame(), ser2.to_frame())
diff --git a/pandas/tests/window/test_groupby.py b/pandas/tests/window/test_groupby.py
index 400bf10817ab8..45e7e07affd75 100644
--- a/pandas/tests/window/test_groupby.py
+++ b/pandas/tests/window/test_groupby.py
@@ -101,7 +101,7 @@ def test_rolling(self, f, roll_frame):
result = getattr(r, f)()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(lambda x: getattr(x.rolling(4), f)())
# groupby.apply doesn't drop the grouped-by column
expected = expected.drop("A", axis=1)
@@ -117,7 +117,7 @@ def test_rolling_ddof(self, f, roll_frame):
result = getattr(r, f)(ddof=1)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(lambda x: getattr(x.rolling(4), f)(ddof=1))
# groupby.apply doesn't drop the grouped-by column
expected = expected.drop("A", axis=1)
@@ -135,7 +135,7 @@ def test_rolling_quantile(self, interpolation, roll_frame):
result = r.quantile(0.4, interpolation=interpolation)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(
lambda x: x.rolling(4).quantile(0.4, interpolation=interpolation)
)
@@ -182,7 +182,7 @@ def func(x):
return getattr(x.rolling(4), f)(roll_frame)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(func)
# GH 39591: The grouped column should be all np.nan
# (groupby.apply inserts 0s for cov)
@@ -200,7 +200,7 @@ def func(x):
return getattr(x.B.rolling(4), f)(pairwise=True)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(func)
tm.assert_series_equal(result, expected)
@@ -247,7 +247,7 @@ def test_rolling_apply(self, raw, roll_frame):
# reduction
result = r.apply(lambda x: x.sum(), raw=raw)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(lambda x: x.rolling(4).apply(lambda y: y.sum(), raw=raw))
# groupby.apply doesn't drop the grouped-by column
expected = expected.drop("A", axis=1)
@@ -793,11 +793,11 @@ def test_groupby_rolling_object_doesnt_affect_groupby_apply(self, roll_frame):
# GH 39732
g = roll_frame.groupby("A", group_keys=False)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(lambda x: x.rolling(4).sum()).index
_ = g.rolling(window=4)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
result = g.apply(lambda x: x.rolling(4).sum()).index
tm.assert_index_equal(result, expected)
@@ -975,7 +975,7 @@ def test_groupby_monotonic(self):
df = df.sort_values("date")
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = (
df.set_index("date")
.groupby("name")
@@ -1000,7 +1000,7 @@ def test_datelike_on_monotonic_within_each_group(self):
)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = (
df.set_index("B")
.groupby("A")
@@ -1036,7 +1036,7 @@ def test_expanding(self, f, frame):
result = getattr(r, f)()
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(lambda x: getattr(x.expanding(), f)())
# groupby.apply doesn't drop the grouped-by column
expected = expected.drop("A", axis=1)
@@ -1052,7 +1052,7 @@ def test_expanding_ddof(self, f, frame):
result = getattr(r, f)(ddof=0)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(lambda x: getattr(x.expanding(), f)(ddof=0))
# groupby.apply doesn't drop the grouped-by column
expected = expected.drop("A", axis=1)
@@ -1070,7 +1070,7 @@ def test_expanding_quantile(self, interpolation, frame):
result = r.quantile(0.4, interpolation=interpolation)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(
lambda x: x.expanding().quantile(0.4, interpolation=interpolation)
)
@@ -1092,7 +1092,7 @@ def func_0(x):
return getattr(x.expanding(), f)(frame)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(func_0)
# GH 39591: groupby.apply returns 1 instead of nan for windows
# with all nan values
@@ -1109,7 +1109,7 @@ def func_1(x):
return getattr(x.B.expanding(), f)(pairwise=True)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(func_1)
tm.assert_series_equal(result, expected)
@@ -1120,7 +1120,7 @@ def test_expanding_apply(self, raw, frame):
# reduction
result = r.apply(lambda x: x.sum(), raw=raw)
msg = "DataFrameGroupBy.apply operated on the grouping columns"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(DeprecationWarning, match=msg):
expected = g.apply(
lambda x: x.expanding().apply(lambda y: y.sum(), raw=raw)
)
diff --git a/pandas/tests/window/test_numba.py b/pandas/tests/window/test_numba.py
index b1cc7ec186f19..139e1ff7f65fd 100644
--- a/pandas/tests/window/test_numba.py
+++ b/pandas/tests/window/test_numba.py
@@ -446,3 +446,10 @@ def test_table_method_ewm(self, data, method, axis, nogil, parallel, nopython):
engine_kwargs=engine_kwargs, engine="numba"
)
tm.assert_frame_equal(result, expected)
+
+
+@td.skip_if_no("numba")
+def test_npfunc_no_warnings():
+ df = DataFrame({"col1": [1, 2, 3, 4, 5]})
+ with tm.assert_produces_warning(False):
+ df.col1.rolling(2).apply(np.prod, raw=True, engine="numba")
diff --git a/pandas/tests/window/test_timeseries_window.py b/pandas/tests/window/test_timeseries_window.py
index c99fc8a8eb60f..bd0fadeb3e475 100644
--- a/pandas/tests/window/test_timeseries_window.py
+++ b/pandas/tests/window/test_timeseries_window.py
@@ -1,9 +1,12 @@
import numpy as np
import pytest
+import pandas.util._test_decorators as td
+
from pandas import (
DataFrame,
DatetimeIndex,
+ Index,
MultiIndex,
NaT,
Series,
@@ -697,3 +700,16 @@ def test_nat_axis_error(msg, axis):
with pytest.raises(ValueError, match=f"{msg} values must not have NaT"):
with tm.assert_produces_warning(FutureWarning, match=warn_msg):
df.rolling("D", axis=axis).mean()
+
+
+@td.skip_if_no("pyarrow")
+def test_arrow_datetime_axis():
+ # GH 55849
+ expected = Series(
+ np.arange(5, dtype=np.float64),
+ index=Index(
+ date_range("2020-01-01", periods=5), dtype="timestamp[ns][pyarrow]"
+ ),
+ )
+ result = expected.rolling("1D").sum()
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/util/_exceptions.py b/pandas/util/_exceptions.py
index 573f76a63459b..5f50838d37315 100644
--- a/pandas/util/_exceptions.py
+++ b/pandas/util/_exceptions.py
@@ -9,6 +9,7 @@
if TYPE_CHECKING:
from collections.abc import Generator
+ from types import FrameType
@contextlib.contextmanager
@@ -42,15 +43,20 @@ def find_stack_level() -> int:
test_dir = os.path.join(pkg_dir, "tests")
# https://stackoverflow.com/questions/17407119/python-inspect-stack-is-slow
- frame = inspect.currentframe()
- n = 0
- while frame:
- fname = inspect.getfile(frame)
- if fname.startswith(pkg_dir) and not fname.startswith(test_dir):
- frame = frame.f_back
- n += 1
- else:
- break
+ frame: FrameType | None = inspect.currentframe()
+ try:
+ n = 0
+ while frame:
+ filename = inspect.getfile(frame)
+ if filename.startswith(pkg_dir) and not filename.startswith(test_dir):
+ frame = frame.f_back
+ n += 1
+ else:
+ break
+ finally:
+ # See note in
+ # https://docs.python.org/3/library/inspect.html#inspect.Traceback
+ del frame
return n
diff --git a/pandas/util/_validators.py b/pandas/util/_validators.py
index a47f622216ef7..cb0b4d549f49e 100644
--- a/pandas/util/_validators.py
+++ b/pandas/util/_validators.py
@@ -26,7 +26,7 @@
BoolishNoneT = TypeVar("BoolishNoneT", bool, int, None)
-def _check_arg_length(fname, args, max_fname_arg_count, compat_args):
+def _check_arg_length(fname, args, max_fname_arg_count, compat_args) -> None:
"""
Checks whether 'args' has length of at most 'compat_args'. Raises
a TypeError if that is not the case, similar to in Python when a
@@ -46,7 +46,7 @@ def _check_arg_length(fname, args, max_fname_arg_count, compat_args):
)
-def _check_for_default_values(fname, arg_val_dict, compat_args):
+def _check_for_default_values(fname, arg_val_dict, compat_args) -> None:
"""
Check that the keys in `arg_val_dict` are mapped to their
default values as specified in `compat_args`.
@@ -125,7 +125,7 @@ def validate_args(fname, args, max_fname_arg_count, compat_args) -> None:
_check_for_default_values(fname, kwargs, compat_args)
-def _check_for_invalid_keys(fname, kwargs, compat_args):
+def _check_for_invalid_keys(fname, kwargs, compat_args) -> None:
"""
Checks whether 'kwargs' contains any keys that are not
in 'compat_args' and raises a TypeError if there is one.
diff --git a/pyproject.toml b/pyproject.toml
index 5e65edf81f9c7..778146bbcd909 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,12 +6,9 @@ requires = [
"meson==1.2.1",
"wheel",
"Cython==3.0.5", # Note: sync with setup.py, environment.yml and asv.conf.json
- # Any NumPy version should be fine for compiling. Users are unlikely
- # to get a NumPy<1.25 so the result will be compatible with all relevant
- # NumPy versions (if not it is presumably compatible with their version).
- # Pin <2.0 for releases until tested against an RC. But explicitly allow
- # testing the `.dev0` nightlies (which require the extra index).
- "numpy>1.22.4,<=2.0.0.dev0",
+ # Force numpy higher than 2.0rc1, so that built wheels are compatible
+ # with both numpy 1 and 2
+ "numpy>=2.0.0rc1",
"versioneer[toml]"
]
@@ -64,6 +61,7 @@ matplotlib = "pandas:plotting._matplotlib"
[project.optional-dependencies]
test = ['hypothesis>=6.46.1', 'pytest>=7.3.2', 'pytest-xdist>=2.2.0']
+pyarrow = ['pyarrow>=10.0.1']
performance = ['bottleneck>=1.3.6', 'numba>=0.56.4', 'numexpr>=2.8.4']
computation = ['scipy>=1.10.0', 'xarray>=2022.12.0']
fss = ['fsspec>=2022.11.0']
@@ -162,10 +160,6 @@ test-command = """
pd.test(extra_args=["-m not clipboard and single_cpu and not slow and not network and not db", "--no-strict-data-files"]);' \
"""
-[tool.cibuildwheel.macos]
-archs = "x86_64 arm64"
-test-skip = "*_arm64"
-
[tool.cibuildwheel.windows]
before-build = "pip install delvewheel"
repair-wheel-command = "delvewheel repair -w {dest_dir} {wheel}"
@@ -259,6 +253,8 @@ select = [
"FLY",
# flake8-logging-format
"G",
+ # flake8-future-annotations
+ "FA",
]
ignore = [
diff --git a/requirements-dev.txt b/requirements-dev.txt
index cbfb6336b2e16..5a63e59e1db88 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -53,7 +53,7 @@ moto
flask
asv>=0.6.1
flake8==6.1.0
-mypy==1.7.1
+mypy==1.8.0
tokenize-rt
pre-commit>=3.6.0
gitpython
diff --git a/scripts/validate_unwanted_patterns.py b/scripts/validate_unwanted_patterns.py
index 89b67ddd9f5b6..0d724779abfda 100755
--- a/scripts/validate_unwanted_patterns.py
+++ b/scripts/validate_unwanted_patterns.py
@@ -58,6 +58,7 @@
"_iLocIndexer",
# TODO(3.0): GH#55043 - remove upon removal of ArrayManager
"_get_option",
+ "_fill_limit_area_1d",
}
diff --git a/web/pandas/versions.json b/web/pandas/versions.json
index e355005c7c937..2d2599ae8585b 100644
--- a/web/pandas/versions.json
+++ b/web/pandas/versions.json
@@ -5,11 +5,16 @@
"url": "https://pandas.pydata.org/docs/dev/"
},
{
- "name": "2.1 (stable)",
- "version": "2.1",
+ "name": "2.2 (stable)",
+ "version": "2.2",
"url": "https://pandas.pydata.org/docs/",
"preferred": true
},
+ {
+ "name": "2.1",
+ "version": "2.1",
+ "url": "https://pandas.pydata.org/pandas-docs/version/2.1/"
+ },
{
"name": "2.0",
"version": "2.0",
| Backport PR #58181: CI: correct error msg in test_view_index
| https://api.github.com/repos/pandas-dev/pandas/pulls/58186 | 2024-04-08T20:08:20Z | 2024-04-08T20:11:19Z | null | 2024-04-08T20:11:19Z |
CLN: union_indexes | diff --git a/pandas/_libs/lib.pyi b/pandas/_libs/lib.pyi
index b39d32d069619..daaaacee3487d 100644
--- a/pandas/_libs/lib.pyi
+++ b/pandas/_libs/lib.pyi
@@ -67,7 +67,6 @@ def fast_multiget(
default=...,
) -> ArrayLike: ...
def fast_unique_multiple_list_gen(gen: Generator, sort: bool = ...) -> list: ...
-def fast_unique_multiple_list(lists: list, sort: bool | None = ...) -> list: ...
@overload
def map_infer(
arr: np.ndarray,
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index a2205454a5a46..7aa1cb715521e 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -312,34 +312,6 @@ def item_from_zerodim(val: object) -> object:
return val
-@cython.wraparound(False)
-@cython.boundscheck(False)
-def fast_unique_multiple_list(lists: list, sort: bool | None = True) -> list:
- cdef:
- list buf
- Py_ssize_t k = len(lists)
- Py_ssize_t i, j, n
- list uniques = []
- dict table = {}
- object val, stub = 0
-
- for i in range(k):
- buf = lists[i]
- n = len(buf)
- for j in range(n):
- val = buf[j]
- if val not in table:
- table[val] = stub
- uniques.append(val)
- if sort:
- try:
- uniques.sort()
- except TypeError:
- pass
-
- return uniques
-
-
@cython.wraparound(False)
@cython.boundscheck(False)
def fast_unique_multiple_list_gen(object gen, bint sort=True) -> list:
@@ -361,15 +333,15 @@ def fast_unique_multiple_list_gen(object gen, bint sort=True) -> list:
list buf
Py_ssize_t j, n
list uniques = []
- dict table = {}
- object val, stub = 0
+ set table = set()
+ object val
for buf in gen:
n = len(buf)
for j in range(n):
val = buf[j]
if val not in table:
- table[val] = stub
+ table.add(val)
uniques.append(val)
if sort:
try:
diff --git a/pandas/core/indexes/api.py b/pandas/core/indexes/api.py
index 9b05eb42c6d6e..c5e3f3a50e10d 100644
--- a/pandas/core/indexes/api.py
+++ b/pandas/core/indexes/api.py
@@ -209,60 +209,6 @@ def union_indexes(indexes, sort: bool | None = True) -> Index:
indexes, kind = _sanitize_and_check(indexes)
- def _unique_indices(inds, dtype) -> Index:
- """
- Concatenate indices and remove duplicates.
-
- Parameters
- ----------
- inds : list of Index or list objects
- dtype : dtype to set for the resulting Index
-
- Returns
- -------
- Index
- """
- if all(isinstance(ind, Index) for ind in inds):
- inds = [ind.astype(dtype, copy=False) for ind in inds]
- result = inds[0].unique()
- other = inds[1].append(inds[2:])
- diff = other[result.get_indexer_for(other) == -1]
- if len(diff):
- result = result.append(diff.unique())
- if sort:
- result = result.sort_values()
- return result
-
- def conv(i):
- if isinstance(i, Index):
- i = i.tolist()
- return i
-
- return Index(
- lib.fast_unique_multiple_list([conv(i) for i in inds], sort=sort),
- dtype=dtype,
- )
-
- def _find_common_index_dtype(inds):
- """
- Finds a common type for the indexes to pass through to resulting index.
-
- Parameters
- ----------
- inds: list of Index or list objects
-
- Returns
- -------
- The common type or None if no indexes were given
- """
- dtypes = [idx.dtype for idx in indexes if isinstance(idx, Index)]
- if dtypes:
- dtype = find_common_type(dtypes)
- else:
- dtype = None
-
- return dtype
-
if kind == "special":
result = indexes[0]
@@ -294,18 +240,36 @@ def _find_common_index_dtype(inds):
return result
elif kind == "array":
- dtype = _find_common_index_dtype(indexes)
- index = indexes[0]
- if not all(index.equals(other) for other in indexes[1:]):
- index = _unique_indices(indexes, dtype)
+ if not all_indexes_same(indexes):
+ dtype = find_common_type([idx.dtype for idx in indexes])
+ inds = [ind.astype(dtype, copy=False) for ind in indexes]
+ index = inds[0].unique()
+ other = inds[1].append(inds[2:])
+ diff = other[index.get_indexer_for(other) == -1]
+ if len(diff):
+ index = index.append(diff.unique())
+ if sort:
+ index = index.sort_values()
+ else:
+ index = indexes[0]
name = get_unanimous_names(*indexes)[0]
if name != index.name:
index = index.rename(name)
return index
- else: # kind='list'
- dtype = _find_common_index_dtype(indexes)
- return _unique_indices(indexes, dtype)
+ elif kind == "list":
+ dtypes = [idx.dtype for idx in indexes if isinstance(idx, Index)]
+ if dtypes:
+ dtype = find_common_type(dtypes)
+ else:
+ dtype = None
+ all_lists = (idx.tolist() if isinstance(idx, Index) else idx for idx in indexes)
+ return Index(
+ lib.fast_unique_multiple_list_gen(all_lists, sort=bool(sort)),
+ dtype=dtype,
+ )
+ else:
+ raise ValueError(f"{kind=} must be 'special', 'array' or 'list'.")
def _sanitize_and_check(indexes):
@@ -329,14 +293,14 @@ def _sanitize_and_check(indexes):
sanitized_indexes : list of Index or list objects
type : {'list', 'array', 'special'}
"""
- kinds = list({type(index) for index in indexes})
+ kinds = {type(index) for index in indexes}
if list in kinds:
if len(kinds) > 1:
indexes = [
Index(list(x)) if not isinstance(x, Index) else x for x in indexes
]
- kinds.remove(list)
+ kinds -= {list}
else:
return indexes, "list"
| - Just used sets where appropriate
- Added some typing
- Split some helper functions to branches where they are used | https://api.github.com/repos/pandas-dev/pandas/pulls/58183 | 2024-04-08T18:57:52Z | 2024-04-11T15:39:27Z | 2024-04-11T15:39:27Z | 2024-04-11T15:39:30Z |
CI: correct error msg in `test_view_index` | diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index 088fcfcd7d75f..676d33d2b0f81 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -312,7 +312,10 @@ def test_cant_or_shouldnt_cast(self, dtype):
def test_view_index(self, simple_index):
index = simple_index
- msg = "Cannot change data-type for object array"
+ msg = (
+ "Cannot change data-type for array of references.|"
+ "Cannot change data-type for object array.|"
+ )
with pytest.raises(TypeError, match=msg):
index.view(Index)
diff --git a/pandas/tests/indexes/ranges/test_range.py b/pandas/tests/indexes/ranges/test_range.py
index 8d41efa586411..727edb7ae30ad 100644
--- a/pandas/tests/indexes/ranges/test_range.py
+++ b/pandas/tests/indexes/ranges/test_range.py
@@ -375,7 +375,10 @@ def test_cant_or_shouldnt_cast(self, start, stop, step):
def test_view_index(self, simple_index):
index = simple_index
- msg = "Cannot change data-type for object array"
+ msg = (
+ "Cannot change data-type for array of references.|"
+ "Cannot change data-type for object array.|"
+ )
with pytest.raises(TypeError, match=msg):
index.view(Index)
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 997276ef544f7..484f647c7a8f9 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -358,7 +358,10 @@ def test_view_with_args_object_array_raises(self, index):
with pytest.raises(NotImplementedError, match="i8"):
index.view("i8")
else:
- msg = "Cannot change data-type for object array"
+ msg = (
+ "Cannot change data-type for array of references.|"
+ "Cannot change data-type for object array.|"
+ )
with pytest.raises(TypeError, match=msg):
index.view("i8")
diff --git a/pandas/tests/indexes/test_datetimelike.py b/pandas/tests/indexes/test_datetimelike.py
index 0ad5888a44392..e45d11e6286e2 100644
--- a/pandas/tests/indexes/test_datetimelike.py
+++ b/pandas/tests/indexes/test_datetimelike.py
@@ -88,7 +88,10 @@ def test_view(self, simple_index):
result = type(simple_index)(idx)
tm.assert_index_equal(result, idx)
- msg = "Cannot change data-type for object array"
+ msg = (
+ "Cannot change data-type for array of references.|"
+ "Cannot change data-type for object array.|"
+ )
with pytest.raises(TypeError, match=msg):
idx.view(type(simple_index))
diff --git a/pandas/tests/indexes/test_old_base.py b/pandas/tests/indexes/test_old_base.py
index 871e7cdda4102..9b4470021cc1d 100644
--- a/pandas/tests/indexes/test_old_base.py
+++ b/pandas/tests/indexes/test_old_base.py
@@ -880,7 +880,10 @@ def test_view(self, simple_index):
idx_view = idx.view(dtype)
tm.assert_index_equal(idx, index_cls(idx_view, name="Foo"), exact=True)
- msg = "Cannot change data-type for object array"
+ msg = (
+ "Cannot change data-type for array of references.|"
+ "Cannot change data-type for object array.|"
+ )
with pytest.raises(TypeError, match=msg):
# GH#55709
idx.view(index_cls)
| CI failed, the reason: `AssertionError: Regex pattern did not match.`
Replaced error msg `'Cannot change data-type for object array'` with `'Cannot change data-type for array of references.'` | https://api.github.com/repos/pandas-dev/pandas/pulls/58181 | 2024-04-08T16:02:43Z | 2024-04-08T18:23:00Z | 2024-04-08T18:23:00Z | 2024-04-08T21:34:31Z |
Cleanup json_normalize documentation | diff --git a/pandas/io/json/_normalize.py b/pandas/io/json/_normalize.py
index ef717dd9b7ef8..7d3eefae39679 100644
--- a/pandas/io/json/_normalize.py
+++ b/pandas/io/json/_normalize.py
@@ -289,10 +289,10 @@ def json_normalize(
meta : list of paths (str or list of str), default None
Fields to use as metadata for each record in resulting table.
meta_prefix : str, default None
- If True, prefix records with dotted (?) path, e.g. foo.bar.field if
+ If True, prefix records with dotted path, e.g. foo.bar.field if
meta is ['foo', 'bar'].
record_prefix : str, default None
- If True, prefix records with dotted (?) path, e.g. foo.bar.field if
+ If True, prefix records with dotted path, e.g. foo.bar.field if
path to records is ['foo', 'bar'].
errors : {'raise', 'ignore'}, default 'raise'
Configures error handling.
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/58180 | 2024-04-08T14:09:37Z | 2024-04-08T16:43:15Z | 2024-04-08T16:43:15Z | 2024-04-08T17:28:37Z |
TST: Remove deprecation check from test_pyarrow_engine | diff --git a/pandas/tests/io/parser/test_unsupported.py b/pandas/tests/io/parser/test_unsupported.py
index 8d4c28bd61fa1..44a55cf3be240 100644
--- a/pandas/tests/io/parser/test_unsupported.py
+++ b/pandas/tests/io/parser/test_unsupported.py
@@ -155,12 +155,8 @@ def test_pyarrow_engine(self):
kwargs[default] = "warn"
warn = None
- depr_msg = None
+ depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
if "delim_whitespace" in kwargs:
- depr_msg = "The 'delim_whitespace' keyword in pd.read_csv is deprecated"
- warn = FutureWarning
- if "verbose" in kwargs:
- depr_msg = "The 'verbose' keyword in pd.read_csv is deprecated"
warn = FutureWarning
with pytest.raises(ValueError, match=msg):
| - [x] ref https://github.com/pandas-dev/pandas/issues/57966#issuecomment-2041619807_
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58175 | 2024-04-07T21:56:08Z | 2024-04-09T16:46:13Z | 2024-04-09T16:46:13Z | 2024-04-09T16:46:20Z |
ENH: add numeric_only to Dataframe.cum* methods | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 19b448a1871c2..d189c4f4bf248 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -35,7 +35,7 @@ Other enhancements
- Support passing a :class:`Series` input to :func:`json_normalize` that retains the :class:`Series` :class:`Index` (:issue:`51452`)
- Users can globally disable any ``PerformanceWarning`` by setting the option ``mode.performance_warnings`` to ``False`` (:issue:`56920`)
- :meth:`Styler.format_index_names` can now be used to format the index and column names (:issue:`48936` and :issue:`47489`)
--
+- :meth:`DataFrame.cummin`, :meth:`DataFrame.cummax`, :meth:`DataFrame.cumprod` and :meth:`DataFrame.cumsum` methods now have a ``numeric_only`` parameter (:issue:`53072`)
.. ---------------------------------------------------------------------------
.. _whatsnew_300.notable_bug_fixes:
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 66a68755a2a09..d6f4e5ea25fc9 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -12029,20 +12029,52 @@ def kurt(
product = prod
@doc(make_doc("cummin", ndim=2))
- def cummin(self, axis: Axis = 0, skipna: bool = True, *args, **kwargs) -> Self:
- return NDFrame.cummin(self, axis, skipna, *args, **kwargs)
+ def cummin(
+ self,
+ axis: Axis = 0,
+ skipna: bool = True,
+ numeric_only: bool = False,
+ *args,
+ **kwargs,
+ ) -> Self:
+ data = self._get_numeric_data() if numeric_only else self
+ return NDFrame.cummin(data, axis, skipna, *args, **kwargs)
@doc(make_doc("cummax", ndim=2))
- def cummax(self, axis: Axis = 0, skipna: bool = True, *args, **kwargs) -> Self:
- return NDFrame.cummax(self, axis, skipna, *args, **kwargs)
+ def cummax(
+ self,
+ axis: Axis = 0,
+ skipna: bool = True,
+ numeric_only: bool = False,
+ *args,
+ **kwargs,
+ ) -> Self:
+ data = self._get_numeric_data() if numeric_only else self
+ return NDFrame.cummax(data, axis, skipna, *args, **kwargs)
@doc(make_doc("cumsum", ndim=2))
- def cumsum(self, axis: Axis = 0, skipna: bool = True, *args, **kwargs) -> Self:
- return NDFrame.cumsum(self, axis, skipna, *args, **kwargs)
+ def cumsum(
+ self,
+ axis: Axis = 0,
+ skipna: bool = True,
+ numeric_only: bool = False,
+ *args,
+ **kwargs,
+ ) -> Self:
+ data = self._get_numeric_data() if numeric_only else self
+ return NDFrame.cumsum(data, axis, skipna, *args, **kwargs)
@doc(make_doc("cumprod", 2))
- def cumprod(self, axis: Axis = 0, skipna: bool = True, *args, **kwargs) -> Self:
- return NDFrame.cumprod(self, axis, skipna, *args, **kwargs)
+ def cumprod(
+ self,
+ axis: Axis = 0,
+ skipna: bool = True,
+ numeric_only: bool = False,
+ *args,
+ **kwargs,
+ ) -> Self:
+ data = self._get_numeric_data() if numeric_only else self
+ return NDFrame.cumprod(data, axis, skipna, *args, **kwargs)
def nunique(self, axis: Axis = 0, dropna: bool = True) -> Series:
"""
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 8af9503a3691d..e1c1b21249362 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -11925,7 +11925,45 @@ def last_valid_index(self) -> Hashable:
DataFrame.any : Return True if one (or more) elements are True.
"""
-_cnum_doc = """
+_cnum_pd_doc = """
+Return cumulative {desc} over a DataFrame or Series axis.
+
+Returns a DataFrame or Series of the same size containing the cumulative
+{desc}.
+
+Parameters
+----------
+axis : {{0 or 'index', 1 or 'columns'}}, default 0
+ The index or the name of the axis. 0 is equivalent to None or 'index'.
+ For `Series` this parameter is unused and defaults to 0.
+skipna : bool, default True
+ Exclude NA/null values. If an entire row/column is NA, the result
+ will be NA.
+numeric_only : bool, default False
+ Include only float, int, boolean columns.
+*args, **kwargs
+ Additional keywords have no effect but might be accepted for
+ compatibility with NumPy.
+
+Returns
+-------
+{name1} or {name2}
+ Return cumulative {desc} of {name1} or {name2}.
+
+See Also
+--------
+core.window.expanding.Expanding.{accum_func_name} : Similar functionality
+ but ignores ``NaN`` values.
+{name2}.{accum_func_name} : Return the {desc} over
+ {name2} axis.
+{name2}.cummax : Return cumulative maximum over {name2} axis.
+{name2}.cummin : Return cumulative minimum over {name2} axis.
+{name2}.cumsum : Return cumulative sum over {name2} axis.
+{name2}.cumprod : Return cumulative product over {name2} axis.
+
+{examples}"""
+
+_cnum_series_doc = """
Return cumulative {desc} over a DataFrame or Series axis.
Returns a DataFrame or Series of the same size containing the cumulative
@@ -12716,28 +12754,44 @@ def make_doc(name: str, ndim: int) -> str:
kwargs = {"min_count": ""}
elif name == "cumsum":
- base_doc = _cnum_doc
+ if ndim == 1:
+ base_doc = _cnum_series_doc
+ else:
+ base_doc = _cnum_pd_doc
+
desc = "sum"
see_also = ""
examples = _cumsum_examples
kwargs = {"accum_func_name": "sum"}
elif name == "cumprod":
- base_doc = _cnum_doc
+ if ndim == 1:
+ base_doc = _cnum_series_doc
+ else:
+ base_doc = _cnum_pd_doc
+
desc = "product"
see_also = ""
examples = _cumprod_examples
kwargs = {"accum_func_name": "prod"}
elif name == "cummin":
- base_doc = _cnum_doc
+ if ndim == 1:
+ base_doc = _cnum_series_doc
+ else:
+ base_doc = _cnum_pd_doc
+
desc = "minimum"
see_also = ""
examples = _cummin_examples
kwargs = {"accum_func_name": "min"}
elif name == "cummax":
- base_doc = _cnum_doc
+ if ndim == 1:
+ base_doc = _cnum_series_doc
+ else:
+ base_doc = _cnum_pd_doc
+
desc = "maximum"
see_also = ""
examples = _cummax_examples
diff --git a/pandas/tests/frame/test_cumulative.py b/pandas/tests/frame/test_cumulative.py
index d7aad680d389e..ab217e1b1332a 100644
--- a/pandas/tests/frame/test_cumulative.py
+++ b/pandas/tests/frame/test_cumulative.py
@@ -7,10 +7,12 @@
"""
import numpy as np
+import pytest
from pandas import (
DataFrame,
Series,
+ Timestamp,
)
import pandas._testing as tm
@@ -81,3 +83,25 @@ def test_cumsum_preserve_dtypes(self):
}
)
tm.assert_frame_equal(result, expected)
+
+ @pytest.mark.parametrize("method", ["cumsum", "cumprod", "cummin", "cummax"])
+ @pytest.mark.parametrize("axis", [0, 1])
+ def test_numeric_only_flag(self, method, axis):
+ df = DataFrame(
+ {
+ "int": [1, 2, 3],
+ "bool": [True, False, False],
+ "string": ["a", "b", "c"],
+ "float": [1.0, 3.5, 4.0],
+ "datetime": [
+ Timestamp(2018, 1, 1),
+ Timestamp(2019, 1, 1),
+ Timestamp(2020, 1, 1),
+ ],
+ }
+ )
+ df_numeric_only = df.drop(["string", "datetime"], axis=1)
+
+ result = getattr(df, method)(axis=axis, numeric_only=True)
+ expected = getattr(df_numeric_only, method)(axis)
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_api.py b/pandas/tests/groupby/test_api.py
index b5fdf058d1ab0..d2cfa530e7c65 100644
--- a/pandas/tests/groupby/test_api.py
+++ b/pandas/tests/groupby/test_api.py
@@ -183,10 +183,9 @@ def test_frame_consistency(groupby_func):
elif groupby_func in ("bfill", "ffill"):
exclude_expected = {"inplace", "axis", "limit_area"}
elif groupby_func in ("cummax", "cummin"):
- exclude_expected = {"skipna", "args"}
- exclude_result = {"numeric_only"}
+ exclude_expected = {"axis", "skipna", "args"}
elif groupby_func in ("cumprod", "cumsum"):
- exclude_expected = {"skipna"}
+ exclude_expected = {"axis", "skipna", "numeric_only"}
elif groupby_func in ("pct_change",):
exclude_expected = {"kwargs"}
elif groupby_func in ("rank",):
| - [x] closes #53072
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58172 | 2024-04-06T15:46:25Z | 2024-04-11T15:20:49Z | 2024-04-11T15:20:49Z | 2024-04-11T15:24:01Z |
REF: de-duplicate tzinfo-awareness mismatch checks | diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index effd7f586f266..ee8ed762fdb6e 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -74,7 +74,6 @@ from pandas._libs.tslibs.nattype cimport (
c_nat_strings as nat_strings,
)
from pandas._libs.tslibs.timestamps cimport _Timestamp
-from pandas._libs.tslibs.timezones cimport tz_compare
from pandas._libs.tslibs import (
Resolution,
@@ -452,13 +451,9 @@ cpdef array_to_datetime(
ndarray[int64_t] iresult
npy_datetimestruct dts
bint utc_convert = bool(utc)
- bint seen_datetime_offset = False
bint is_raise = errors == "raise"
bint is_coerce = errors == "coerce"
- bint is_same_offsets
_TSObject tsobj
- float tz_offset
- set out_tzoffset_vals = set()
tzinfo tz, tz_out = None
cnp.flatiter it = cnp.PyArray_IterNew(values)
NPY_DATETIMEUNIT item_reso
@@ -568,12 +563,12 @@ cpdef array_to_datetime(
# dateutil timezone objects cannot be hashed, so
# store the UTC offsets in seconds instead
nsecs = tz.utcoffset(None).total_seconds()
- out_tzoffset_vals.add(nsecs)
- seen_datetime_offset = True
+ state.out_tzoffset_vals.add(nsecs)
+ state.found_aware_str = True
else:
# Add a marker for naive string, to track if we are
# parsing mixed naive and aware strings
- out_tzoffset_vals.add("naive")
+ state.out_tzoffset_vals.add("naive")
state.found_naive_str = True
else:
@@ -588,41 +583,7 @@ cpdef array_to_datetime(
raise
return values, None
- if seen_datetime_offset and not utc_convert:
- # GH#17697, GH#57275
- # 1) If all the offsets are equal, return one offset for
- # the parsed dates to (maybe) pass to DatetimeIndex
- # 2) If the offsets are different, then do not force the parsing
- # and raise a ValueError: "cannot parse datetimes with
- # mixed time zones unless `utc=True`" instead
- is_same_offsets = len(out_tzoffset_vals) == 1
- if not is_same_offsets:
- raise ValueError(
- "Mixed timezones detected. Pass utc=True in to_datetime "
- "or tz='UTC' in DatetimeIndex to convert to a common timezone."
- )
- elif state.found_naive or state.found_other:
- # e.g. test_to_datetime_mixed_awareness_mixed_types
- raise ValueError("Cannot mix tz-aware with tz-naive values")
- elif tz_out is not None:
- # GH#55693
- tz_offset = out_tzoffset_vals.pop()
- tz_out2 = timezone(timedelta(seconds=tz_offset))
- if not tz_compare(tz_out, tz_out2):
- # e.g. test_to_datetime_mixed_tzs_mixed_types
- raise ValueError(
- "Mixed timezones detected. Pass utc=True in to_datetime "
- "or tz='UTC' in DatetimeIndex to convert to a common timezone."
- )
- # e.g. test_to_datetime_mixed_types_matching_tzs
- else:
- tz_offset = out_tzoffset_vals.pop()
- tz_out = timezone(timedelta(seconds=tz_offset))
- elif not utc_convert:
- if tz_out and (state.found_other or state.found_naive_str):
- # found_other indicates a tz-naive int, float, dt64, or date
- # e.g. test_to_datetime_mixed_awareness_mixed_types
- raise ValueError("Cannot mix tz-aware with tz-naive values")
+ tz_out = state.check_for_mixed_inputs(tz_out, utc)
if infer_reso:
if state.creso_ever_changed:
diff --git a/pandas/_libs/tslibs/strptime.pxd b/pandas/_libs/tslibs/strptime.pxd
index dd8936f080b31..d2eae910a87b5 100644
--- a/pandas/_libs/tslibs/strptime.pxd
+++ b/pandas/_libs/tslibs/strptime.pxd
@@ -18,9 +18,12 @@ cdef class DatetimeParseState:
bint found_tz
bint found_naive
bint found_naive_str
+ bint found_aware_str
bint found_other
bint creso_ever_changed
NPY_DATETIMEUNIT creso
+ set out_tzoffset_vals
cdef tzinfo process_datetime(self, datetime dt, tzinfo tz, bint utc_convert)
cdef bint update_creso(self, NPY_DATETIMEUNIT item_reso) noexcept
+ cdef tzinfo check_for_mixed_inputs(self, tzinfo tz_out, bint utc)
diff --git a/pandas/_libs/tslibs/strptime.pyx b/pandas/_libs/tslibs/strptime.pyx
index 5c9f1c770ea7f..d6c3285d89c59 100644
--- a/pandas/_libs/tslibs/strptime.pyx
+++ b/pandas/_libs/tslibs/strptime.pyx
@@ -252,8 +252,11 @@ cdef class DatetimeParseState:
# found_naive_str refers to a string that was parsed to a timezone-naive
# datetime.
self.found_naive_str = False
+ self.found_aware_str = False
self.found_other = False
+ self.out_tzoffset_vals = set()
+
self.creso = creso
self.creso_ever_changed = False
@@ -292,6 +295,58 @@ cdef class DatetimeParseState:
"tz-naive values")
return tz
+ cdef tzinfo check_for_mixed_inputs(
+ self,
+ tzinfo tz_out,
+ bint utc,
+ ):
+ cdef:
+ bint is_same_offsets
+ float tz_offset
+
+ if self.found_aware_str and not utc:
+ # GH#17697, GH#57275
+ # 1) If all the offsets are equal, return one offset for
+ # the parsed dates to (maybe) pass to DatetimeIndex
+ # 2) If the offsets are different, then do not force the parsing
+ # and raise a ValueError: "cannot parse datetimes with
+ # mixed time zones unless `utc=True`" instead
+ is_same_offsets = len(self.out_tzoffset_vals) == 1
+ if not is_same_offsets or (self.found_naive or self.found_other):
+ # e.g. test_to_datetime_mixed_awareness_mixed_types (array_to_datetime)
+ raise ValueError(
+ "Mixed timezones detected. Pass utc=True in to_datetime "
+ "or tz='UTC' in DatetimeIndex to convert to a common timezone."
+ )
+ elif tz_out is not None:
+ # GH#55693
+ tz_offset = self.out_tzoffset_vals.pop()
+ tz_out2 = timezone(timedelta(seconds=tz_offset))
+ if not tz_compare(tz_out, tz_out2):
+ # e.g. (array_strptime)
+ # test_to_datetime_mixed_offsets_with_utc_false_removed
+ # e.g. test_to_datetime_mixed_tzs_mixed_types (array_to_datetime)
+ raise ValueError(
+ "Mixed timezones detected. Pass utc=True in to_datetime "
+ "or tz='UTC' in DatetimeIndex to convert to a common timezone."
+ )
+ # e.g. (array_strptime)
+ # test_guess_datetime_format_with_parseable_formats
+ # e.g. test_to_datetime_mixed_types_matching_tzs (array_to_datetime)
+ else:
+ # e.g. test_to_datetime_iso8601_with_timezone_valid (array_strptime)
+ tz_offset = self.out_tzoffset_vals.pop()
+ tz_out = timezone(timedelta(seconds=tz_offset))
+ elif not utc:
+ if tz_out and (self.found_other or self.found_naive_str):
+ # found_other indicates a tz-naive int, float, dt64, or date
+ # e.g. test_to_datetime_mixed_awareness_mixed_types (array_to_datetime)
+ raise ValueError(
+ "Mixed timezones detected. Pass utc=True in to_datetime "
+ "or tz='UTC' in DatetimeIndex to convert to a common timezone."
+ )
+ return tz_out
+
def array_strptime(
ndarray[object] values,
@@ -319,11 +374,8 @@ def array_strptime(
npy_datetimestruct dts
int64_t[::1] iresult
object val
- bint seen_datetime_offset = False
bint is_raise = errors=="raise"
bint is_coerce = errors=="coerce"
- bint is_same_offsets
- set out_tzoffset_vals = set()
tzinfo tz, tz_out = None
bint iso_format = format_is_iso(fmt)
NPY_DATETIMEUNIT out_bestunit, item_reso
@@ -418,15 +470,15 @@ def array_strptime(
) from err
if out_local == 1:
nsecs = out_tzoffset * 60
- out_tzoffset_vals.add(nsecs)
- seen_datetime_offset = True
+ state.out_tzoffset_vals.add(nsecs)
+ state.found_aware_str = True
tz = timezone(timedelta(minutes=out_tzoffset))
value = tz_localize_to_utc_single(
value, tz, ambiguous="raise", nonexistent=None, creso=creso
)
else:
tz = None
- out_tzoffset_vals.add("naive")
+ state.out_tzoffset_vals.add("naive")
state.found_naive_str = True
iresult[i] = value
continue
@@ -475,12 +527,12 @@ def array_strptime(
elif creso == NPY_DATETIMEUNIT.NPY_FR_ms:
nsecs = nsecs // 10**3
- out_tzoffset_vals.add(nsecs)
- seen_datetime_offset = True
+ state.out_tzoffset_vals.add(nsecs)
+ state.found_aware_str = True
else:
state.found_naive_str = True
tz = None
- out_tzoffset_vals.add("naive")
+ state.out_tzoffset_vals.add("naive")
except ValueError as ex:
ex.args = (
@@ -499,35 +551,7 @@ def array_strptime(
raise
return values, None
- if seen_datetime_offset and not utc:
- is_same_offsets = len(out_tzoffset_vals) == 1
- if not is_same_offsets or (state.found_naive or state.found_other):
- raise ValueError(
- "Mixed timezones detected. Pass utc=True in to_datetime "
- "or tz='UTC' in DatetimeIndex to convert to a common timezone."
- )
- elif tz_out is not None:
- # GH#55693
- tz_offset = out_tzoffset_vals.pop()
- tz_out2 = timezone(timedelta(seconds=tz_offset))
- if not tz_compare(tz_out, tz_out2):
- # e.g. test_to_datetime_mixed_offsets_with_utc_false_removed
- raise ValueError(
- "Mixed timezones detected. Pass utc=True in to_datetime "
- "or tz='UTC' in DatetimeIndex to convert to a common timezone."
- )
- # e.g. test_guess_datetime_format_with_parseable_formats
- else:
- # e.g. test_to_datetime_iso8601_with_timezone_valid
- tz_offset = out_tzoffset_vals.pop()
- tz_out = timezone(timedelta(seconds=tz_offset))
- elif not utc:
- if tz_out and (state.found_other or state.found_naive_str):
- # found_other indicates a tz-naive int, float, dt64, or date
- raise ValueError(
- "Mixed timezones detected. Pass utc=True in to_datetime "
- "or tz='UTC' in DatetimeIndex to convert to a common timezone."
- )
+ tz_out = state.check_for_mixed_inputs(tz_out, utc)
if infer_reso:
if state.creso_ever_changed:
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 7992b48a4b0cc..b59dd194cac27 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -3545,19 +3545,27 @@ def test_to_datetime_mixed_awareness_mixed_types(aware_val, naive_val, naive_fir
# issued in _array_to_datetime_object
both_strs = isinstance(aware_val, str) and isinstance(naive_val, str)
has_numeric = isinstance(naive_val, (int, float))
+ both_datetime = isinstance(naive_val, datetime) and isinstance(aware_val, datetime)
+
+ mixed_msg = (
+ "Mixed timezones detected. Pass utc=True in to_datetime or tz='UTC' "
+ "in DatetimeIndex to convert to a common timezone"
+ )
first_non_null = next(x for x in vec if x != "")
# if first_non_null is a not a string, _guess_datetime_format_for_array
# doesn't guess a format so we don't go through array_strptime
if not isinstance(first_non_null, str):
# that case goes through array_strptime which has different behavior
- msg = "Cannot mix tz-aware with tz-naive values"
+ msg = mixed_msg
if naive_first and isinstance(aware_val, Timestamp):
if isinstance(naive_val, Timestamp):
msg = "Tz-aware datetime.datetime cannot be converted to datetime64"
with pytest.raises(ValueError, match=msg):
to_datetime(vec)
else:
+ if not naive_first and both_datetime:
+ msg = "Cannot mix tz-aware with tz-naive values"
with pytest.raises(ValueError, match=msg):
to_datetime(vec)
@@ -3586,7 +3594,7 @@ def test_to_datetime_mixed_awareness_mixed_types(aware_val, naive_val, naive_fir
to_datetime(vec, utc=True)
else:
- msg = "Mixed timezones detected. Pass utc=True in to_datetime"
+ msg = mixed_msg
with pytest.raises(ValueError, match=msg):
to_datetime(vec)
@@ -3594,13 +3602,13 @@ def test_to_datetime_mixed_awareness_mixed_types(aware_val, naive_val, naive_fir
to_datetime(vec, utc=True)
if both_strs:
- msg = "Mixed timezones detected. Pass utc=True in to_datetime"
+ msg = mixed_msg
with pytest.raises(ValueError, match=msg):
to_datetime(vec, format="mixed")
with pytest.raises(ValueError, match=msg):
DatetimeIndex(vec)
else:
- msg = "Cannot mix tz-aware with tz-naive values"
+ msg = mixed_msg
if naive_first and isinstance(aware_val, Timestamp):
if isinstance(naive_val, Timestamp):
msg = "Tz-aware datetime.datetime cannot be converted to datetime64"
@@ -3609,6 +3617,8 @@ def test_to_datetime_mixed_awareness_mixed_types(aware_val, naive_val, naive_fir
with pytest.raises(ValueError, match=msg):
DatetimeIndex(vec)
else:
+ if not naive_first and both_datetime:
+ msg = "Cannot mix tz-aware with tz-naive values"
with pytest.raises(ValueError, match=msg):
to_datetime(vec, format="mixed")
with pytest.raises(ValueError, match=msg):
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58171 | 2024-04-06T15:44:29Z | 2024-04-08T16:44:54Z | 2024-04-08T16:44:54Z | 2024-04-08T17:02:17Z |
No longer produce test.tar/test.zip after running test suite | diff --git a/pandas/tests/frame/methods/test_to_csv.py b/pandas/tests/frame/methods/test_to_csv.py
index f87fa4137d62d..66a35c6f486a4 100644
--- a/pandas/tests/frame/methods/test_to_csv.py
+++ b/pandas/tests/frame/methods/test_to_csv.py
@@ -1406,19 +1406,21 @@ def test_to_csv_categorical_and_interval(self):
expected = tm.convert_rows_list_to_csv_str(expected_rows)
assert result == expected
- def test_to_csv_warn_when_zip_tar_and_append_mode(self):
+ def test_to_csv_warn_when_zip_tar_and_append_mode(self, tmp_path):
# GH57875
df = DataFrame({"a": [1, 2, 3]})
msg = (
"zip and tar do not support mode 'a' properly. This combination will "
"result in multiple files with same name being added to the archive"
)
+ zip_path = tmp_path / "test.zip"
+ tar_path = tmp_path / "test.tar"
with tm.assert_produces_warning(
RuntimeWarning, match=msg, raise_on_extra_warnings=False
):
- df.to_csv("test.zip", mode="a")
+ df.to_csv(zip_path, mode="a")
with tm.assert_produces_warning(
RuntimeWarning, match=msg, raise_on_extra_warnings=False
):
- df.to_csv("test.tar", mode="a")
+ df.to_csv(tar_path, mode="a")
| - [x] closes #58162 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58168 | 2024-04-05T21:45:59Z | 2024-04-05T23:11:11Z | 2024-04-05T23:11:11Z | 2024-04-05T23:11:18Z |
DEPR: enforce Sparse deprecations | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 983768e0f67da..190b515981098 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -208,6 +208,7 @@ Removal of prior version deprecations/changes
- All arguments except ``name`` in :meth:`Index.rename` are now keyword only (:issue:`56493`)
- All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`)
- Disallow calling :meth:`Series.replace` or :meth:`DataFrame.replace` without a ``value`` and with non-dict-like ``to_replace`` (:issue:`33302`)
+- Disallow constructing a :class:`arrays.SparseArray` with scalar data (:issue:`53039`)
- Disallow non-standard (``np.ndarray``, :class:`Index`, :class:`ExtensionArray`, or :class:`Series`) to :func:`isin`, :func:`unique`, :func:`factorize` (:issue:`52986`)
- Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
- Disallow units other than "s", "ms", "us", "ns" for datetime64 and timedelta64 dtypes in :func:`array` (:issue:`53817`)
@@ -216,6 +217,7 @@ Removal of prior version deprecations/changes
- Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
- Removed extension test classes ``BaseNoReduceTests``, ``BaseNumericReduceTests``, ``BaseBooleanReduceTests`` (:issue:`54663`)
- Removed the "closed" and "normalize" keywords in :meth:`DatetimeIndex.__new__` (:issue:`52628`)
+- Require :meth:`SparseDtype.fill_value` to be a valid value for the :meth:`SparseDtype.subtype` (:issue:`53043`)
- Stopped performing dtype inference with in :meth:`Index.insert` with object-dtype index; this often affects the index/columns that result when setting new entries into an empty :class:`Series` or :class:`DataFrame` (:issue:`51363`)
- Removed the "closed" and "unit" keywords in :meth:`TimedeltaIndex.__new__` (:issue:`52628`, :issue:`55499`)
- All arguments in :meth:`Index.sort_values` are now keyword only (:issue:`56493`)
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 2a96423017bb7..134702099371d 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -40,7 +40,6 @@
from pandas.core.dtypes.astype import astype_array
from pandas.core.dtypes.cast import (
- construct_1d_arraylike_from_scalar,
find_common_type,
maybe_box_datetimelike,
)
@@ -399,19 +398,10 @@ def __init__(
dtype = dtype.subtype
if is_scalar(data):
- warnings.warn(
- f"Constructing {type(self).__name__} with scalar data is deprecated "
- "and will raise in a future version. Pass a sequence instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
+ raise TypeError(
+ f"Cannot construct {type(self).__name__} from scalar data. "
+ "Pass a sequence instead."
)
- if sparse_index is None:
- npoints = 1
- else:
- npoints = sparse_index.length
-
- data = construct_1d_arraylike_from_scalar(data, npoints, dtype=None)
- dtype = data.dtype
if dtype is not None:
dtype = pandas_dtype(dtype)
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index f94d32a3b8547..2d8e490f02d52 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -1762,24 +1762,18 @@ def _check_fill_value(self) -> None:
val = self._fill_value
if isna(val):
if not is_valid_na_for_dtype(val, self.subtype):
- warnings.warn(
- "Allowing arbitrary scalar fill_value in SparseDtype is "
- "deprecated. In a future version, the fill_value must be "
- "a valid value for the SparseDtype.subtype.",
- FutureWarning,
- stacklevel=find_stack_level(),
+ raise ValueError(
+ # GH#53043
+ "fill_value must be a valid value for the SparseDtype.subtype"
)
else:
dummy = np.empty(0, dtype=self.subtype)
dummy = ensure_wrapped_if_datetimelike(dummy)
if not can_hold_element(dummy, val):
- warnings.warn(
- "Allowing arbitrary scalar fill_value in SparseDtype is "
- "deprecated. In a future version, the fill_value must be "
- "a valid value for the SparseDtype.subtype.",
- FutureWarning,
- stacklevel=find_stack_level(),
+ raise ValueError(
+ # GH#53043
+ "fill_value must be a valid value for the SparseDtype.subtype"
)
@property
diff --git a/pandas/tests/arrays/sparse/test_array.py b/pandas/tests/arrays/sparse/test_array.py
index 883d6ea3959ff..c35e8204f3437 100644
--- a/pandas/tests/arrays/sparse/test_array.py
+++ b/pandas/tests/arrays/sparse/test_array.py
@@ -52,10 +52,11 @@ def test_set_fill_value(self):
arr.fill_value = 2
assert arr.fill_value == 2
- msg = "Allowing arbitrary scalar fill_value in SparseDtype is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ msg = "fill_value must be a valid value for the SparseDtype.subtype"
+ with pytest.raises(ValueError, match=msg):
+ # GH#53043
arr.fill_value = 3.1
- assert arr.fill_value == 3.1
+ assert arr.fill_value == 2
arr.fill_value = np.nan
assert np.isnan(arr.fill_value)
@@ -64,8 +65,9 @@ def test_set_fill_value(self):
arr.fill_value = True
assert arr.fill_value is True
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with pytest.raises(ValueError, match=msg):
arr.fill_value = 0
+ assert arr.fill_value is True
arr.fill_value = np.nan
assert np.isnan(arr.fill_value)
diff --git a/pandas/tests/arrays/sparse/test_constructors.py b/pandas/tests/arrays/sparse/test_constructors.py
index 2831c8abdaf13..012ff1da0d431 100644
--- a/pandas/tests/arrays/sparse/test_constructors.py
+++ b/pandas/tests/arrays/sparse/test_constructors.py
@@ -144,20 +144,12 @@ def test_constructor_spindex_dtype(self):
@pytest.mark.parametrize("sparse_index", [None, IntIndex(1, [0])])
def test_constructor_spindex_dtype_scalar(self, sparse_index):
# scalar input
- msg = "Constructing SparseArray with scalar data is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- arr = SparseArray(data=1, sparse_index=sparse_index, dtype=None)
- exp = SparseArray([1], dtype=None)
- tm.assert_sp_array_equal(arr, exp)
- assert arr.dtype == SparseDtype(np.int64)
- assert arr.fill_value == 0
+ msg = "Cannot construct SparseArray from scalar data. Pass a sequence instead"
+ with pytest.raises(TypeError, match=msg):
+ SparseArray(data=1, sparse_index=sparse_index, dtype=None)
- with tm.assert_produces_warning(FutureWarning, match=msg):
- arr = SparseArray(data=1, sparse_index=IntIndex(1, [0]), dtype=None)
- exp = SparseArray([1], dtype=None)
- tm.assert_sp_array_equal(arr, exp)
- assert arr.dtype == SparseDtype(np.int64)
- assert arr.fill_value == 0
+ with pytest.raises(TypeError, match=msg):
+ SparseArray(data=1, sparse_index=IntIndex(1, [0]), dtype=None)
def test_constructor_spindex_dtype_scalar_broadcasts(self):
arr = SparseArray(
diff --git a/pandas/tests/arrays/sparse/test_dtype.py b/pandas/tests/arrays/sparse/test_dtype.py
index 6f0d41333f2fd..1819744d9a9ae 100644
--- a/pandas/tests/arrays/sparse/test_dtype.py
+++ b/pandas/tests/arrays/sparse/test_dtype.py
@@ -84,7 +84,6 @@ def test_nans_not_equal():
(SparseDtype("float64"), SparseDtype("float32")),
(SparseDtype("float64"), SparseDtype("float64", 0)),
(SparseDtype("float64"), SparseDtype("datetime64[ns]", np.nan)),
- (SparseDtype(int, pd.NaT), SparseDtype(float, pd.NaT)),
(SparseDtype("float64"), np.dtype("float64")),
]
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58167 | 2024-04-05T20:26:39Z | 2024-04-05T21:40:31Z | 2024-04-05T21:40:30Z | 2024-04-06T00:13:37Z |
TST: Use temp_file fixture over ensure_clean | diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index 0cc8018ea6213..1bd71768d226e 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -63,16 +63,16 @@ def read_csv(self, file):
return read_csv(file, parse_dates=True)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_read_empty_dta(self, version):
+ def test_read_empty_dta(self, version, temp_file):
empty_ds = DataFrame(columns=["unit"])
# GH 7369, make sure can read a 0-obs dta file
- with tm.ensure_clean() as path:
- empty_ds.to_stata(path, write_index=False, version=version)
- empty_ds2 = read_stata(path)
- tm.assert_frame_equal(empty_ds, empty_ds2)
+ path = temp_file
+ empty_ds.to_stata(path, write_index=False, version=version)
+ empty_ds2 = read_stata(path)
+ tm.assert_frame_equal(empty_ds, empty_ds2)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_read_empty_dta_with_dtypes(self, version):
+ def test_read_empty_dta_with_dtypes(self, version, temp_file):
# GH 46240
# Fixing above bug revealed that types are not correctly preserved when
# writing empty DataFrames
@@ -91,9 +91,9 @@ def test_read_empty_dta_with_dtypes(self, version):
}
)
# GH 7369, make sure can read a 0-obs dta file
- with tm.ensure_clean() as path:
- empty_df_typed.to_stata(path, write_index=False, version=version)
- empty_reread = read_stata(path)
+ path = temp_file
+ empty_df_typed.to_stata(path, write_index=False, version=version)
+ empty_reread = read_stata(path)
expected = empty_df_typed
# No uint# support. Downcast since values in range for int#
@@ -108,12 +108,12 @@ def test_read_empty_dta_with_dtypes(self, version):
tm.assert_series_equal(expected.dtypes, empty_reread.dtypes)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_read_index_col_none(self, version):
+ def test_read_index_col_none(self, version, temp_file):
df = DataFrame({"a": range(5), "b": ["b1", "b2", "b3", "b4", "b5"]})
# GH 7369, make sure can read a 0-obs dta file
- with tm.ensure_clean() as path:
- df.to_stata(path, write_index=False, version=version)
- read_df = read_stata(path)
+ path = temp_file
+ df.to_stata(path, write_index=False, version=version)
+ read_df = read_stata(path)
assert isinstance(read_df.index, pd.RangeIndex)
expected = df
@@ -324,39 +324,39 @@ def test_read_dta18(self, datapath):
assert rdr.data_label == "This is a Ünicode data label"
- def test_read_write_dta5(self):
+ def test_read_write_dta5(self, temp_file):
original = DataFrame(
[(np.nan, np.nan, np.nan, np.nan, np.nan)],
columns=["float_miss", "double_miss", "byte_miss", "int_miss", "long_miss"],
)
original.index.name = "index"
- with tm.ensure_clean() as path:
- original.to_stata(path, convert_dates=None)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(path, convert_dates=None)
+ written_and_read_again = self.read_dta(path)
expected = original
expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
- def test_write_dta6(self, datapath):
+ def test_write_dta6(self, datapath, temp_file):
original = self.read_csv(datapath("io", "data", "stata", "stata3.csv"))
original.index.name = "index"
original.index = original.index.astype(np.int32)
original["year"] = original["year"].astype(np.int32)
original["quarter"] = original["quarter"].astype(np.int32)
- with tm.ensure_clean() as path:
- original.to_stata(path, convert_dates=None)
- written_and_read_again = self.read_dta(path)
- tm.assert_frame_equal(
- written_and_read_again.set_index("index"),
- original,
- check_index_type=False,
- )
+ path = temp_file
+ original.to_stata(path, convert_dates=None)
+ written_and_read_again = self.read_dta(path)
+ tm.assert_frame_equal(
+ written_and_read_again.set_index("index"),
+ original,
+ check_index_type=False,
+ )
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_read_write_dta10(self, version):
+ def test_read_write_dta10(self, version, temp_file):
original = DataFrame(
data=[["string", "object", 1, 1.1, np.datetime64("2003-12-25")]],
columns=["string", "object", "integer", "floating", "datetime"],
@@ -366,9 +366,9 @@ def test_read_write_dta10(self, version):
original.index = original.index.astype(np.int32)
original["integer"] = original["integer"].astype(np.int32)
- with tm.ensure_clean() as path:
- original.to_stata(path, convert_dates={"datetime": "tc"}, version=version)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(path, convert_dates={"datetime": "tc"}, version=version)
+ written_and_read_again = self.read_dta(path)
expected = original[:]
# "tc" convert_dates means we store in ms
@@ -379,14 +379,14 @@ def test_read_write_dta10(self, version):
expected,
)
- def test_stata_doc_examples(self):
- with tm.ensure_clean() as path:
- df = DataFrame(
- np.random.default_rng(2).standard_normal((10, 2)), columns=list("AB")
- )
- df.to_stata(path)
+ def test_stata_doc_examples(self, temp_file):
+ path = temp_file
+ df = DataFrame(
+ np.random.default_rng(2).standard_normal((10, 2)), columns=list("AB")
+ )
+ df.to_stata(path)
- def test_write_preserves_original(self):
+ def test_write_preserves_original(self, temp_file):
# 9795
df = DataFrame(
@@ -394,12 +394,12 @@ def test_write_preserves_original(self):
)
df.loc[2, "a":"c"] = np.nan
df_copy = df.copy()
- with tm.ensure_clean() as path:
- df.to_stata(path, write_index=False)
+ path = temp_file
+ df.to_stata(path, write_index=False)
tm.assert_frame_equal(df, df_copy)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_encoding(self, version, datapath):
+ def test_encoding(self, version, datapath, temp_file):
# GH 4626, proper encoding handling
raw = read_stata(datapath("io", "data", "stata", "stata1_encoding.dta"))
encoded = read_stata(datapath("io", "data", "stata", "stata1_encoding.dta"))
@@ -409,12 +409,12 @@ def test_encoding(self, version, datapath):
assert result == expected
assert isinstance(result, str)
- with tm.ensure_clean() as path:
- encoded.to_stata(path, write_index=False, version=version)
- reread_encoded = read_stata(path)
- tm.assert_frame_equal(encoded, reread_encoded)
+ path = temp_file
+ encoded.to_stata(path, write_index=False, version=version)
+ reread_encoded = read_stata(path)
+ tm.assert_frame_equal(encoded, reread_encoded)
- def test_read_write_dta11(self):
+ def test_read_write_dta11(self, temp_file):
original = DataFrame(
[(1, 2, 3, 4)],
columns=[
@@ -431,18 +431,18 @@ def test_read_write_dta11(self):
formatted.index.name = "index"
formatted = formatted.astype(np.int32)
- with tm.ensure_clean() as path:
- with tm.assert_produces_warning(InvalidColumnName):
- original.to_stata(path, convert_dates=None)
+ path = temp_file
+ with tm.assert_produces_warning(InvalidColumnName):
+ original.to_stata(path, convert_dates=None)
- written_and_read_again = self.read_dta(path)
+ written_and_read_again = self.read_dta(path)
expected = formatted
expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_read_write_dta12(self, version):
+ def test_read_write_dta12(self, version, temp_file):
original = DataFrame(
[(1, 2, 3, 4, 5, 6)],
columns=[
@@ -468,18 +468,18 @@ def test_read_write_dta12(self, version):
formatted.index.name = "index"
formatted = formatted.astype(np.int32)
- with tm.ensure_clean() as path:
- with tm.assert_produces_warning(InvalidColumnName):
- original.to_stata(path, convert_dates=None, version=version)
- # should get a warning for that format.
+ path = temp_file
+ with tm.assert_produces_warning(InvalidColumnName):
+ original.to_stata(path, convert_dates=None, version=version)
+ # should get a warning for that format.
- written_and_read_again = self.read_dta(path)
+ written_and_read_again = self.read_dta(path)
expected = formatted
expected.index = expected.index.astype(np.int32)
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
- def test_read_write_dta13(self):
+ def test_read_write_dta13(self, temp_file):
s1 = Series(2**9, dtype=np.int16)
s2 = Series(2**17, dtype=np.int32)
s3 = Series(2**33, dtype=np.int64)
@@ -489,9 +489,9 @@ def test_read_write_dta13(self):
formatted = original
formatted["int64"] = formatted["int64"].astype(np.float64)
- with tm.ensure_clean() as path:
- original.to_stata(path)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(path)
+ written_and_read_again = self.read_dta(path)
expected = formatted
expected.index = expected.index.astype(np.int32)
@@ -501,16 +501,18 @@ def test_read_write_dta13(self):
@pytest.mark.parametrize(
"file", ["stata5_113", "stata5_114", "stata5_115", "stata5_117"]
)
- def test_read_write_reread_dta14(self, file, parsed_114, version, datapath):
+ def test_read_write_reread_dta14(
+ self, file, parsed_114, version, datapath, temp_file
+ ):
file = datapath("io", "data", "stata", f"{file}.dta")
parsed = self.read_dta(file)
parsed.index.name = "index"
tm.assert_frame_equal(parsed_114, parsed)
- with tm.ensure_clean() as path:
- parsed_114.to_stata(path, convert_dates={"date_td": "td"}, version=version)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ parsed_114.to_stata(path, convert_dates={"date_td": "td"}, version=version)
+ written_and_read_again = self.read_dta(path)
expected = parsed_114.copy()
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
@@ -536,38 +538,38 @@ def test_read_write_reread_dta15(self, file, datapath):
tm.assert_frame_equal(expected, parsed)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_timestamp_and_label(self, version):
+ def test_timestamp_and_label(self, version, temp_file):
original = DataFrame([(1,)], columns=["variable"])
time_stamp = datetime(2000, 2, 29, 14, 21)
data_label = "This is a data file."
- with tm.ensure_clean() as path:
- original.to_stata(
- path, time_stamp=time_stamp, data_label=data_label, version=version
- )
+ path = temp_file
+ original.to_stata(
+ path, time_stamp=time_stamp, data_label=data_label, version=version
+ )
- with StataReader(path) as reader:
- assert reader.time_stamp == "29 Feb 2000 14:21"
- assert reader.data_label == data_label
+ with StataReader(path) as reader:
+ assert reader.time_stamp == "29 Feb 2000 14:21"
+ assert reader.data_label == data_label
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_invalid_timestamp(self, version):
+ def test_invalid_timestamp(self, version, temp_file):
original = DataFrame([(1,)], columns=["variable"])
time_stamp = "01 Jan 2000, 00:00:00"
- with tm.ensure_clean() as path:
- msg = "time_stamp should be datetime type"
- with pytest.raises(ValueError, match=msg):
- original.to_stata(path, time_stamp=time_stamp, version=version)
- assert not os.path.isfile(path)
+ path = temp_file
+ msg = "time_stamp should be datetime type"
+ with pytest.raises(ValueError, match=msg):
+ original.to_stata(path, time_stamp=time_stamp, version=version)
+ assert not os.path.isfile(path)
- def test_numeric_column_names(self):
+ def test_numeric_column_names(self, temp_file):
original = DataFrame(np.reshape(np.arange(25.0), (5, 5)))
original.index.name = "index"
- with tm.ensure_clean() as path:
- # should get a warning for that format.
- with tm.assert_produces_warning(InvalidColumnName):
- original.to_stata(path)
+ path = temp_file
+ # should get a warning for that format.
+ with tm.assert_produces_warning(InvalidColumnName):
+ original.to_stata(path)
- written_and_read_again = self.read_dta(path)
+ written_and_read_again = self.read_dta(path)
written_and_read_again = written_and_read_again.set_index("index")
columns = list(written_and_read_again.columns)
@@ -578,7 +580,7 @@ def test_numeric_column_names(self):
tm.assert_frame_equal(expected, written_and_read_again)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_nan_to_missing_value(self, version):
+ def test_nan_to_missing_value(self, version, temp_file):
s1 = Series(np.arange(4.0), dtype=np.float32)
s2 = Series(np.arange(4.0), dtype=np.float64)
s1[::2] = np.nan
@@ -586,48 +588,48 @@ def test_nan_to_missing_value(self, version):
original = DataFrame({"s1": s1, "s2": s2})
original.index.name = "index"
- with tm.ensure_clean() as path:
- original.to_stata(path, version=version)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(path, version=version)
+ written_and_read_again = self.read_dta(path)
written_and_read_again = written_and_read_again.set_index("index")
expected = original
tm.assert_frame_equal(written_and_read_again, expected)
- def test_no_index(self):
+ def test_no_index(self, temp_file):
columns = ["x", "y"]
original = DataFrame(np.reshape(np.arange(10.0), (5, 2)), columns=columns)
original.index.name = "index_not_written"
- with tm.ensure_clean() as path:
- original.to_stata(path, write_index=False)
- written_and_read_again = self.read_dta(path)
- with pytest.raises(KeyError, match=original.index.name):
- written_and_read_again["index_not_written"]
+ path = temp_file
+ original.to_stata(path, write_index=False)
+ written_and_read_again = self.read_dta(path)
+ with pytest.raises(KeyError, match=original.index.name):
+ written_and_read_again["index_not_written"]
- def test_string_no_dates(self):
+ def test_string_no_dates(self, temp_file):
s1 = Series(["a", "A longer string"])
s2 = Series([1.0, 2.0], dtype=np.float64)
original = DataFrame({"s1": s1, "s2": s2})
original.index.name = "index"
- with tm.ensure_clean() as path:
- original.to_stata(path)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(path)
+ written_and_read_again = self.read_dta(path)
expected = original
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
- def test_large_value_conversion(self):
+ def test_large_value_conversion(self, temp_file):
s0 = Series([1, 99], dtype=np.int8)
s1 = Series([1, 127], dtype=np.int8)
s2 = Series([1, 2**15 - 1], dtype=np.int16)
s3 = Series([1, 2**63 - 1], dtype=np.int64)
original = DataFrame({"s0": s0, "s1": s1, "s2": s2, "s3": s3})
original.index.name = "index"
- with tm.ensure_clean() as path:
- with tm.assert_produces_warning(PossiblePrecisionLoss):
- original.to_stata(path)
+ path = temp_file
+ with tm.assert_produces_warning(PossiblePrecisionLoss):
+ original.to_stata(path)
- written_and_read_again = self.read_dta(path)
+ written_and_read_again = self.read_dta(path)
modified = original
modified["s1"] = Series(modified["s1"], dtype=np.int16)
@@ -635,14 +637,14 @@ def test_large_value_conversion(self):
modified["s3"] = Series(modified["s3"], dtype=np.float64)
tm.assert_frame_equal(written_and_read_again.set_index("index"), modified)
- def test_dates_invalid_column(self):
+ def test_dates_invalid_column(self, temp_file):
original = DataFrame([datetime(2006, 11, 19, 23, 13, 20)])
original.index.name = "index"
- with tm.ensure_clean() as path:
- with tm.assert_produces_warning(InvalidColumnName):
- original.to_stata(path, convert_dates={0: "tc"})
+ path = temp_file
+ with tm.assert_produces_warning(InvalidColumnName):
+ original.to_stata(path, convert_dates={0: "tc"})
- written_and_read_again = self.read_dta(path)
+ written_and_read_again = self.read_dta(path)
expected = original.copy()
expected.columns = ["_0"]
@@ -673,7 +675,7 @@ def test_value_labels_old_format(self, datapath):
with StataReader(dpath) as reader:
assert reader.value_labels() == {}
- def test_date_export_formats(self):
+ def test_date_export_formats(self, temp_file):
columns = ["tc", "td", "tw", "tm", "tq", "th", "ty"]
conversions = {c: c for c in columns}
data = [datetime(2006, 11, 20, 23, 13, 20)] * len(columns)
@@ -697,13 +699,13 @@ def test_date_export_formats(self):
)
expected["tc"] = expected["tc"].astype("M8[ms]")
- with tm.ensure_clean() as path:
- original.to_stata(path, convert_dates=conversions)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(path, convert_dates=conversions)
+ written_and_read_again = self.read_dta(path)
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
- def test_write_missing_strings(self):
+ def test_write_missing_strings(self, temp_file):
original = DataFrame([["1"], [None]], columns=["foo"])
expected = DataFrame(
@@ -712,15 +714,15 @@ def test_write_missing_strings(self):
columns=["foo"],
)
- with tm.ensure_clean() as path:
- original.to_stata(path)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(path)
+ written_and_read_again = self.read_dta(path)
tm.assert_frame_equal(written_and_read_again.set_index("index"), expected)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
@pytest.mark.parametrize("byteorder", [">", "<"])
- def test_bool_uint(self, byteorder, version):
+ def test_bool_uint(self, byteorder, version, temp_file):
s0 = Series([0, 1, True], dtype=np.bool_)
s1 = Series([0, 1, 100], dtype=np.uint8)
s2 = Series([0, 1, 255], dtype=np.uint8)
@@ -734,9 +736,9 @@ def test_bool_uint(self, byteorder, version):
)
original.index.name = "index"
- with tm.ensure_clean() as path:
- original.to_stata(path, byteorder=byteorder, version=version)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(path, byteorder=byteorder, version=version)
+ written_and_read_again = self.read_dta(path)
written_and_read_again = written_and_read_again.set_index("index")
@@ -768,7 +770,7 @@ def test_variable_labels(self, datapath):
assert k in keys
assert v in labels
- def test_minimal_size_col(self):
+ def test_minimal_size_col(self, temp_file):
str_lens = (1, 100, 244)
s = {}
for str_len in str_lens:
@@ -776,16 +778,16 @@ def test_minimal_size_col(self):
["a" * str_len, "b" * str_len, "c" * str_len]
)
original = DataFrame(s)
- with tm.ensure_clean() as path:
- original.to_stata(path, write_index=False)
+ path = temp_file
+ original.to_stata(path, write_index=False)
- with StataReader(path) as sr:
- sr._ensure_open() # The `_*list` variables are initialized here
- for variable, fmt, typ in zip(sr._varlist, sr._fmtlist, sr._typlist):
- assert int(variable[1:]) == int(fmt[1:-1])
- assert int(variable[1:]) == typ
+ with StataReader(path) as sr:
+ sr._ensure_open() # The `_*list` variables are initialized here
+ for variable, fmt, typ in zip(sr._varlist, sr._fmtlist, sr._typlist):
+ assert int(variable[1:]) == int(fmt[1:-1])
+ assert int(variable[1:]) == typ
- def test_excessively_long_string(self):
+ def test_excessively_long_string(self, temp_file):
str_lens = (1, 244, 500)
s = {}
for str_len in str_lens:
@@ -800,16 +802,16 @@ def test_excessively_long_string(self):
r"the newer \(Stata 13 and later\) format\."
)
with pytest.raises(ValueError, match=msg):
- with tm.ensure_clean() as path:
- original.to_stata(path)
+ path = temp_file
+ original.to_stata(path)
- def test_missing_value_generator(self):
+ def test_missing_value_generator(self, temp_file):
types = ("b", "h", "l")
df = DataFrame([[0.0]], columns=["float_"])
- with tm.ensure_clean() as path:
- df.to_stata(path)
- with StataReader(path) as rdr:
- valid_range = rdr.VALID_RANGE
+ path = temp_file
+ df.to_stata(path)
+ with StataReader(path) as rdr:
+ valid_range = rdr.VALID_RANGE
expected_values = ["." + chr(97 + i) for i in range(26)]
expected_values.insert(0, ".")
for t in types:
@@ -850,7 +852,7 @@ def test_missing_value_conversion(self, file, datapath):
)
tm.assert_frame_equal(parsed, expected)
- def test_big_dates(self, datapath):
+ def test_big_dates(self, datapath, temp_file):
yr = [1960, 2000, 9999, 100, 2262, 1677]
mo = [1, 1, 12, 1, 4, 9]
dd = [1, 1, 31, 1, 22, 23]
@@ -906,10 +908,10 @@ def test_big_dates(self, datapath):
date_conversion = {c: c[-2:] for c in columns}
# {c : c[-2:] for c in columns}
- with tm.ensure_clean() as path:
- expected.index.name = "index"
- expected.to_stata(path, convert_dates=date_conversion)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ expected.index.name = "index"
+ expected.to_stata(path, convert_dates=date_conversion)
+ written_and_read_again = self.read_dta(path)
tm.assert_frame_equal(
written_and_read_again.set_index("index"),
@@ -994,7 +996,7 @@ def test_drop_column(self, datapath):
@pytest.mark.filterwarnings(
"ignore:\\nStata value:pandas.io.stata.ValueLabelTypeMismatch"
)
- def test_categorical_writing(self, version):
+ def test_categorical_writing(self, version, temp_file):
original = DataFrame.from_records(
[
["one", "ten", "one", "one", "one", 1],
@@ -1017,9 +1019,9 @@ def test_categorical_writing(self, version):
"unlabeled",
],
)
- with tm.ensure_clean() as path:
- original.astype("category").to_stata(path, version=version)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.astype("category").to_stata(path, version=version)
+ written_and_read_again = self.read_dta(path)
res = written_and_read_again.set_index("index")
@@ -1042,7 +1044,7 @@ def test_categorical_writing(self, version):
tm.assert_frame_equal(res, expected)
- def test_categorical_warnings_and_errors(self):
+ def test_categorical_warnings_and_errors(self, temp_file):
# Warning for non-string labels
# Error for labels too long
original = DataFrame.from_records(
@@ -1051,13 +1053,13 @@ def test_categorical_warnings_and_errors(self):
)
original = original.astype("category")
- with tm.ensure_clean() as path:
- msg = (
- "Stata value labels for a single variable must have "
- r"a combined length less than 32,000 characters\."
- )
- with pytest.raises(ValueError, match=msg):
- original.to_stata(path)
+ path = temp_file
+ msg = (
+ "Stata value labels for a single variable must have "
+ r"a combined length less than 32,000 characters\."
+ )
+ with pytest.raises(ValueError, match=msg):
+ original.to_stata(path)
original = DataFrame.from_records(
[["a"], ["b"], ["c"], ["d"], [1]], columns=["Too_long"]
@@ -1068,7 +1070,7 @@ def test_categorical_warnings_and_errors(self):
# should get a warning for mixed content
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_categorical_with_stata_missing_values(self, version):
+ def test_categorical_with_stata_missing_values(self, version, temp_file):
values = [["a" + str(i)] for i in range(120)]
values.append([np.nan])
original = DataFrame.from_records(values, columns=["many_labels"])
@@ -1076,9 +1078,9 @@ def test_categorical_with_stata_missing_values(self, version):
[original[col].astype("category") for col in original], axis=1
)
original.index.name = "index"
- with tm.ensure_clean() as path:
- original.to_stata(path, version=version)
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(path, version=version)
+ written_and_read_again = self.read_dta(path)
res = written_and_read_again.set_index("index")
@@ -1313,54 +1315,50 @@ def test_read_chunks_columns(self, datapath):
pos += chunksize
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_write_variable_labels(self, version, mixed_frame):
+ def test_write_variable_labels(self, version, mixed_frame, temp_file):
# GH 13631, add support for writing variable labels
mixed_frame.index.name = "index"
variable_labels = {"a": "City Rank", "b": "City Exponent", "c": "City"}
- with tm.ensure_clean() as path:
- mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
- with StataReader(path) as sr:
- read_labels = sr.variable_labels()
- expected_labels = {
- "index": "",
- "a": "City Rank",
- "b": "City Exponent",
- "c": "City",
- }
- assert read_labels == expected_labels
+ path = temp_file
+ mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
+ with StataReader(path) as sr:
+ read_labels = sr.variable_labels()
+ expected_labels = {
+ "index": "",
+ "a": "City Rank",
+ "b": "City Exponent",
+ "c": "City",
+ }
+ assert read_labels == expected_labels
variable_labels["index"] = "The Index"
- with tm.ensure_clean() as path:
- mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
- with StataReader(path) as sr:
- read_labels = sr.variable_labels()
- assert read_labels == variable_labels
+ path = temp_file
+ mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
+ with StataReader(path) as sr:
+ read_labels = sr.variable_labels()
+ assert read_labels == variable_labels
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_invalid_variable_labels(self, version, mixed_frame):
+ def test_invalid_variable_labels(self, version, mixed_frame, temp_file):
mixed_frame.index.name = "index"
variable_labels = {"a": "very long" * 10, "b": "City Exponent", "c": "City"}
- with tm.ensure_clean() as path:
- msg = "Variable labels must be 80 characters or fewer"
- with pytest.raises(ValueError, match=msg):
- mixed_frame.to_stata(
- path, variable_labels=variable_labels, version=version
- )
+ path = temp_file
+ msg = "Variable labels must be 80 characters or fewer"
+ with pytest.raises(ValueError, match=msg):
+ mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
@pytest.mark.parametrize("version", [114, 117])
- def test_invalid_variable_label_encoding(self, version, mixed_frame):
+ def test_invalid_variable_label_encoding(self, version, mixed_frame, temp_file):
mixed_frame.index.name = "index"
variable_labels = {"a": "very long" * 10, "b": "City Exponent", "c": "City"}
variable_labels["a"] = "invalid character Œ"
- with tm.ensure_clean() as path:
- with pytest.raises(
- ValueError, match="Variable labels must contain only characters"
- ):
- mixed_frame.to_stata(
- path, variable_labels=variable_labels, version=version
- )
+ path = temp_file
+ with pytest.raises(
+ ValueError, match="Variable labels must contain only characters"
+ ):
+ mixed_frame.to_stata(path, variable_labels=variable_labels, version=version)
- def test_write_variable_label_errors(self, mixed_frame):
+ def test_write_variable_label_errors(self, mixed_frame, temp_file):
values = ["\u03a1", "\u0391", "\u039d", "\u0394", "\u0391", "\u03a3"]
variable_labels_utf8 = {
@@ -1374,8 +1372,8 @@ def test_write_variable_label_errors(self, mixed_frame):
"encoded in Latin-1"
)
with pytest.raises(ValueError, match=msg):
- with tm.ensure_clean() as path:
- mixed_frame.to_stata(path, variable_labels=variable_labels_utf8)
+ path = temp_file
+ mixed_frame.to_stata(path, variable_labels=variable_labels_utf8)
variable_labels_long = {
"a": "City Rank",
@@ -1387,10 +1385,10 @@ def test_write_variable_label_errors(self, mixed_frame):
msg = "Variable labels must be 80 characters or fewer"
with pytest.raises(ValueError, match=msg):
- with tm.ensure_clean() as path:
- mixed_frame.to_stata(path, variable_labels=variable_labels_long)
+ path = temp_file
+ mixed_frame.to_stata(path, variable_labels=variable_labels_long)
- def test_default_date_conversion(self):
+ def test_default_date_conversion(self, temp_file):
# GH 12259
dates = [
dt.datetime(1999, 12, 31, 12, 12, 12, 12000),
@@ -1409,29 +1407,29 @@ def test_default_date_conversion(self):
# "tc" for convert_dates below stores with "ms" resolution
expected["dates"] = expected["dates"].astype("M8[ms]")
- with tm.ensure_clean() as path:
- original.to_stata(path, write_index=False)
- reread = read_stata(path, convert_dates=True)
- tm.assert_frame_equal(expected, reread)
+ path = temp_file
+ original.to_stata(path, write_index=False)
+ reread = read_stata(path, convert_dates=True)
+ tm.assert_frame_equal(expected, reread)
- original.to_stata(path, write_index=False, convert_dates={"dates": "tc"})
- direct = read_stata(path, convert_dates=True)
- tm.assert_frame_equal(reread, direct)
+ original.to_stata(path, write_index=False, convert_dates={"dates": "tc"})
+ direct = read_stata(path, convert_dates=True)
+ tm.assert_frame_equal(reread, direct)
- dates_idx = original.columns.tolist().index("dates")
- original.to_stata(path, write_index=False, convert_dates={dates_idx: "tc"})
- direct = read_stata(path, convert_dates=True)
- tm.assert_frame_equal(reread, direct)
+ dates_idx = original.columns.tolist().index("dates")
+ original.to_stata(path, write_index=False, convert_dates={dates_idx: "tc"})
+ direct = read_stata(path, convert_dates=True)
+ tm.assert_frame_equal(reread, direct)
- def test_unsupported_type(self):
+ def test_unsupported_type(self, temp_file):
original = DataFrame({"a": [1 + 2j, 2 + 4j]})
msg = "Data type complex128 not supported"
with pytest.raises(NotImplementedError, match=msg):
- with tm.ensure_clean() as path:
- original.to_stata(path)
+ path = temp_file
+ original.to_stata(path)
- def test_unsupported_datetype(self):
+ def test_unsupported_datetype(self, temp_file):
dates = [
dt.datetime(1999, 12, 31, 12, 12, 12, 12000),
dt.datetime(2012, 12, 21, 12, 21, 12, 21000),
@@ -1447,8 +1445,8 @@ def test_unsupported_datetype(self):
msg = "Format %tC not implemented"
with pytest.raises(NotImplementedError, match=msg):
- with tm.ensure_clean() as path:
- original.to_stata(path, convert_dates={"dates": "tC"})
+ path = temp_file
+ original.to_stata(path, convert_dates={"dates": "tC"})
dates = pd.date_range("1-1-1990", periods=3, tz="Asia/Hong_Kong")
original = DataFrame(
@@ -1459,8 +1457,8 @@ def test_unsupported_datetype(self):
}
)
with pytest.raises(NotImplementedError, match="Data type datetime64"):
- with tm.ensure_clean() as path:
- original.to_stata(path)
+ path = temp_file
+ original.to_stata(path)
def test_repeated_column_labels(self, datapath):
# GH 13923, 25772
@@ -1496,7 +1494,7 @@ def test_stata_111(self, datapath):
original = original[["y", "x", "w", "z"]]
tm.assert_frame_equal(original, df)
- def test_out_of_range_double(self):
+ def test_out_of_range_double(self, temp_file):
# GH 14618
df = DataFrame(
{
@@ -1509,10 +1507,10 @@ def test_out_of_range_double(self):
r"supported by Stata \(.+\)"
)
with pytest.raises(ValueError, match=msg):
- with tm.ensure_clean() as path:
- df.to_stata(path)
+ path = temp_file
+ df.to_stata(path)
- def test_out_of_range_float(self):
+ def test_out_of_range_float(self, temp_file):
original = DataFrame(
{
"ColumnOk": [
@@ -1531,16 +1529,16 @@ def test_out_of_range_float(self):
for col in original:
original[col] = original[col].astype(np.float32)
- with tm.ensure_clean() as path:
- original.to_stata(path)
- reread = read_stata(path)
+ path = temp_file
+ original.to_stata(path)
+ reread = read_stata(path)
original["ColumnTooBig"] = original["ColumnTooBig"].astype(np.float64)
expected = original
tm.assert_frame_equal(reread.set_index("index"), expected)
@pytest.mark.parametrize("infval", [np.inf, -np.inf])
- def test_inf(self, infval):
+ def test_inf(self, infval, temp_file):
# GH 45350
df = DataFrame({"WithoutInf": [0.0, 1.0], "WithInf": [2.0, infval]})
msg = (
@@ -1548,8 +1546,8 @@ def test_inf(self, infval):
"which is outside the range supported by Stata."
)
with pytest.raises(ValueError, match=msg):
- with tm.ensure_clean() as path:
- df.to_stata(path)
+ path = temp_file
+ df.to_stata(path)
def test_path_pathlib(self):
df = DataFrame(
@@ -1563,19 +1561,19 @@ def test_path_pathlib(self):
tm.assert_frame_equal(df, result)
@pytest.mark.parametrize("write_index", [True, False])
- def test_value_labels_iterator(self, write_index):
+ def test_value_labels_iterator(self, write_index, temp_file):
# GH 16923
d = {"A": ["B", "E", "C", "A", "E"]}
df = DataFrame(data=d)
df["A"] = df["A"].astype("category")
- with tm.ensure_clean() as path:
- df.to_stata(path, write_index=write_index)
+ path = temp_file
+ df.to_stata(path, write_index=write_index)
- with read_stata(path, iterator=True) as dta_iter:
- value_labels = dta_iter.value_labels()
+ with read_stata(path, iterator=True) as dta_iter:
+ value_labels = dta_iter.value_labels()
assert value_labels == {"A": {0: "A", 1: "B", 2: "C", 3: "E"}}
- def test_set_index(self):
+ def test_set_index(self, temp_file):
# GH 17328
df = DataFrame(
1.1 * np.arange(120).reshape((30, 4)),
@@ -1583,9 +1581,9 @@ def test_set_index(self):
index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
)
df.index.name = "index"
- with tm.ensure_clean() as path:
- df.to_stata(path)
- reread = read_stata(path, index_col="index")
+ path = temp_file
+ df.to_stata(path)
+ reread = read_stata(path, index_col="index")
tm.assert_frame_equal(df, reread)
@pytest.mark.parametrize(
@@ -1608,7 +1606,7 @@ def test_date_parsing_ignores_format_details(self, column, datapath):
formatted = df.loc[0, column + "_fmt"]
assert unformatted == formatted
- def test_writer_117(self):
+ def test_writer_117(self, temp_file):
original = DataFrame(
data=[
[
@@ -1662,14 +1660,14 @@ def test_writer_117(self):
original["float32"] = Series(original["float32"], dtype=np.float32)
original.index.name = "index"
copy = original.copy()
- with tm.ensure_clean() as path:
- original.to_stata(
- path,
- convert_dates={"datetime": "tc"},
- convert_strl=["forced_strl"],
- version=117,
- )
- written_and_read_again = self.read_dta(path)
+ path = temp_file
+ original.to_stata(
+ path,
+ convert_dates={"datetime": "tc"},
+ convert_strl=["forced_strl"],
+ version=117,
+ )
+ written_and_read_again = self.read_dta(path)
expected = original[:]
# "tc" for convert_dates means we store with "ms" resolution
@@ -1681,7 +1679,7 @@ def test_writer_117(self):
)
tm.assert_frame_equal(original, copy)
- def test_convert_strl_name_swap(self):
+ def test_convert_strl_name_swap(self, temp_file):
original = DataFrame(
[["a" * 3000, "A", "apple"], ["b" * 1000, "B", "banana"]],
columns=["long1" * 10, "long", 1],
@@ -1689,14 +1687,14 @@ def test_convert_strl_name_swap(self):
original.index.name = "index"
with tm.assert_produces_warning(InvalidColumnName):
- with tm.ensure_clean() as path:
- original.to_stata(path, convert_strl=["long", 1], version=117)
- reread = self.read_dta(path)
- reread = reread.set_index("index")
- reread.columns = original.columns
- tm.assert_frame_equal(reread, original, check_index_type=False)
-
- def test_invalid_date_conversion(self):
+ path = temp_file
+ original.to_stata(path, convert_strl=["long", 1], version=117)
+ reread = self.read_dta(path)
+ reread = reread.set_index("index")
+ reread.columns = original.columns
+ tm.assert_frame_equal(reread, original, check_index_type=False)
+
+ def test_invalid_date_conversion(self, temp_file):
# GH 12259
dates = [
dt.datetime(1999, 12, 31, 12, 12, 12, 12000),
@@ -1711,13 +1709,13 @@ def test_invalid_date_conversion(self):
}
)
- with tm.ensure_clean() as path:
- msg = "convert_dates key must be a column or an integer"
- with pytest.raises(ValueError, match=msg):
- original.to_stata(path, convert_dates={"wrong_name": "tc"})
+ path = temp_file
+ msg = "convert_dates key must be a column or an integer"
+ with pytest.raises(ValueError, match=msg):
+ original.to_stata(path, convert_dates={"wrong_name": "tc"})
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_nonfile_writing(self, version):
+ def test_nonfile_writing(self, version, temp_file):
# GH 21041
bio = io.BytesIO()
df = DataFrame(
@@ -1726,15 +1724,15 @@ def test_nonfile_writing(self, version):
index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
)
df.index.name = "index"
- with tm.ensure_clean() as path:
- df.to_stata(bio, version=version)
- bio.seek(0)
- with open(path, "wb") as dta:
- dta.write(bio.read())
- reread = read_stata(path, index_col="index")
+ path = temp_file
+ df.to_stata(bio, version=version)
+ bio.seek(0)
+ with open(path, "wb") as dta:
+ dta.write(bio.read())
+ reread = read_stata(path, index_col="index")
tm.assert_frame_equal(df, reread)
- def test_gzip_writing(self):
+ def test_gzip_writing(self, temp_file):
# writing version 117 requires seek and cannot be used with gzip
df = DataFrame(
1.1 * np.arange(120).reshape((30, 4)),
@@ -1742,11 +1740,11 @@ def test_gzip_writing(self):
index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
)
df.index.name = "index"
- with tm.ensure_clean() as path:
- with gzip.GzipFile(path, "wb") as gz:
- df.to_stata(gz, version=114)
- with gzip.GzipFile(path, "rb") as gz:
- reread = read_stata(gz, index_col="index")
+ path = temp_file
+ with gzip.GzipFile(path, "wb") as gz:
+ df.to_stata(gz, version=114)
+ with gzip.GzipFile(path, "rb") as gz:
+ reread = read_stata(gz, index_col="index")
tm.assert_frame_equal(df, reread)
def test_unicode_dta_118(self, datapath):
@@ -1766,70 +1764,65 @@ def test_unicode_dta_118(self, datapath):
tm.assert_frame_equal(unicode_df, expected)
- def test_mixed_string_strl(self):
+ def test_mixed_string_strl(self, temp_file):
# GH 23633
output = [{"mixed": "string" * 500, "number": 0}, {"mixed": None, "number": 1}]
output = DataFrame(output)
output.number = output.number.astype("int32")
- with tm.ensure_clean() as path:
- output.to_stata(path, write_index=False, version=117)
- reread = read_stata(path)
- expected = output.fillna("")
- tm.assert_frame_equal(reread, expected)
+ path = temp_file
+ output.to_stata(path, write_index=False, version=117)
+ reread = read_stata(path)
+ expected = output.fillna("")
+ tm.assert_frame_equal(reread, expected)
- # Check strl supports all None (null)
- output["mixed"] = None
- output.to_stata(
- path, write_index=False, convert_strl=["mixed"], version=117
- )
- reread = read_stata(path)
- expected = output.fillna("")
- tm.assert_frame_equal(reread, expected)
+ # Check strl supports all None (null)
+ output["mixed"] = None
+ output.to_stata(path, write_index=False, convert_strl=["mixed"], version=117)
+ reread = read_stata(path)
+ expected = output.fillna("")
+ tm.assert_frame_equal(reread, expected)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_all_none_exception(self, version):
+ def test_all_none_exception(self, version, temp_file):
output = [{"none": "none", "number": 0}, {"none": None, "number": 1}]
output = DataFrame(output)
output["none"] = None
- with tm.ensure_clean() as path:
- with pytest.raises(ValueError, match="Column `none` cannot be exported"):
- output.to_stata(path, version=version)
+ with pytest.raises(ValueError, match="Column `none` cannot be exported"):
+ output.to_stata(temp_file, version=version)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
- def test_invalid_file_not_written(self, version):
+ def test_invalid_file_not_written(self, version, temp_file):
content = "Here is one __�__ Another one __·__ Another one __½__"
df = DataFrame([content], columns=["invalid"])
- with tm.ensure_clean() as path:
- msg1 = (
- r"'latin-1' codec can't encode character '\\ufffd' "
- r"in position 14: ordinal not in range\(256\)"
- )
- msg2 = (
- "'ascii' codec can't decode byte 0xef in position 14: "
- r"ordinal not in range\(128\)"
- )
- with pytest.raises(UnicodeEncodeError, match=f"{msg1}|{msg2}"):
- df.to_stata(path)
+ msg1 = (
+ r"'latin-1' codec can't encode character '\\ufffd' "
+ r"in position 14: ordinal not in range\(256\)"
+ )
+ msg2 = (
+ "'ascii' codec can't decode byte 0xef in position 14: "
+ r"ordinal not in range\(128\)"
+ )
+ with pytest.raises(UnicodeEncodeError, match=f"{msg1}|{msg2}"):
+ df.to_stata(temp_file)
- def test_strl_latin1(self):
+ def test_strl_latin1(self, temp_file):
# GH 23573, correct GSO data to reflect correct size
output = DataFrame(
[["pandas"] * 2, ["þâÑÐŧ"] * 2], columns=["var_str", "var_strl"]
)
- with tm.ensure_clean() as path:
- output.to_stata(path, version=117, convert_strl=["var_strl"])
- with open(path, "rb") as reread:
- content = reread.read()
- expected = "þâÑÐŧ"
- assert expected.encode("latin-1") in content
- assert expected.encode("utf-8") in content
- gsos = content.split(b"strls")[1][1:-2]
- for gso in gsos.split(b"GSO")[1:]:
- val = gso.split(b"\x00")[-2]
- size = gso[gso.find(b"\x82") + 1]
- assert len(val) == size - 1
+ output.to_stata(temp_file, version=117, convert_strl=["var_strl"])
+ with open(temp_file, "rb") as reread:
+ content = reread.read()
+ expected = "þâÑÐŧ"
+ assert expected.encode("latin-1") in content
+ assert expected.encode("utf-8") in content
+ gsos = content.split(b"strls")[1][1:-2]
+ for gso in gsos.split(b"GSO")[1:]:
+ val = gso.split(b"\x00")[-2]
+ size = gso[gso.find(b"\x82") + 1]
+ assert len(val) == size - 1
def test_encoding_latin1_118(self, datapath):
# GH 25960
@@ -1864,7 +1857,7 @@ def test_stata_119(self, datapath):
assert reader._nvar == 32999
@pytest.mark.parametrize("version", [118, 119, None])
- def test_utf8_writer(self, version):
+ def test_utf8_writer(self, version, temp_file):
cat = pd.Categorical(["a", "β", "ĉ"], ordered=True)
data = DataFrame(
[
@@ -1885,48 +1878,45 @@ def test_utf8_writer(self, version):
data_label = "ᴅaᵀa-label"
value_labels = {"β": {1: "label", 2: "æøå", 3: "ŋot valid latin-1"}}
data["β"] = data["β"].astype(np.int32)
- with tm.ensure_clean() as path:
- writer = StataWriterUTF8(
- path,
- data,
- data_label=data_label,
- convert_strl=["strls"],
- variable_labels=variable_labels,
- write_index=False,
- version=version,
- value_labels=value_labels,
- )
- writer.write_file()
- reread_encoded = read_stata(path)
- # Missing is intentionally converted to empty strl
- data["strls"] = data["strls"].fillna("")
- # Variable with value labels is reread as categorical
- data["β"] = (
- data["β"].replace(value_labels["β"]).astype("category").cat.as_ordered()
- )
- tm.assert_frame_equal(data, reread_encoded)
- with StataReader(path) as reader:
- assert reader.data_label == data_label
- assert reader.variable_labels() == variable_labels
+ writer = StataWriterUTF8(
+ temp_file,
+ data,
+ data_label=data_label,
+ convert_strl=["strls"],
+ variable_labels=variable_labels,
+ write_index=False,
+ version=version,
+ value_labels=value_labels,
+ )
+ writer.write_file()
+ reread_encoded = read_stata(temp_file)
+ # Missing is intentionally converted to empty strl
+ data["strls"] = data["strls"].fillna("")
+ # Variable with value labels is reread as categorical
+ data["β"] = (
+ data["β"].replace(value_labels["β"]).astype("category").cat.as_ordered()
+ )
+ tm.assert_frame_equal(data, reread_encoded)
+ with StataReader(temp_file) as reader:
+ assert reader.data_label == data_label
+ assert reader.variable_labels() == variable_labels
- data.to_stata(path, version=version, write_index=False)
- reread_to_stata = read_stata(path)
- tm.assert_frame_equal(data, reread_to_stata)
+ data.to_stata(temp_file, version=version, write_index=False)
+ reread_to_stata = read_stata(temp_file)
+ tm.assert_frame_equal(data, reread_to_stata)
- def test_writer_118_exceptions(self):
+ def test_writer_118_exceptions(self, temp_file):
df = DataFrame(np.zeros((1, 33000), dtype=np.int8))
- with tm.ensure_clean() as path:
- with pytest.raises(ValueError, match="version must be either 118 or 119."):
- StataWriterUTF8(path, df, version=117)
- with tm.ensure_clean() as path:
- with pytest.raises(ValueError, match="You must use version 119"):
- StataWriterUTF8(path, df, version=118)
+ with pytest.raises(ValueError, match="version must be either 118 or 119."):
+ StataWriterUTF8(temp_file, df, version=117)
+ with pytest.raises(ValueError, match="You must use version 119"):
+ StataWriterUTF8(temp_file, df, version=118)
@pytest.mark.parametrize(
"dtype_backend",
["numpy_nullable", pytest.param("pyarrow", marks=td.skip_if_no("pyarrow"))],
)
- def test_read_write_ea_dtypes(self, dtype_backend):
+ def test_read_write_ea_dtypes(self, dtype_backend, temp_file):
df = DataFrame(
{
"a": [1, 2, None],
@@ -1940,9 +1930,8 @@ def test_read_write_ea_dtypes(self, dtype_backend):
df = df.convert_dtypes(dtype_backend=dtype_backend)
df.to_stata("test_stata.dta", version=118)
- with tm.ensure_clean() as path:
- df.to_stata(path)
- written_and_read_again = self.read_dta(path)
+ df.to_stata(temp_file)
+ written_and_read_again = self.read_dta(temp_file)
expected = DataFrame(
{
@@ -1995,7 +1984,9 @@ def test_direct_read(datapath, monkeypatch):
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
@pytest.mark.parametrize("use_dict", [True, False])
@pytest.mark.parametrize("infer", [True, False])
-def test_compression(compression, version, use_dict, infer, compression_to_extension):
+def test_compression(
+ compression, version, use_dict, infer, compression_to_extension, tmp_path
+):
file_name = "dta_inferred_compression.dta"
if compression:
if use_dict:
@@ -2013,31 +2004,32 @@ def test_compression(compression, version, use_dict, infer, compression_to_exten
np.random.default_rng(2).standard_normal((10, 2)), columns=list("AB")
)
df.index.name = "index"
- with tm.ensure_clean(file_name) as path:
- df.to_stata(path, version=version, compression=compression_arg)
- if compression == "gzip":
- with gzip.open(path, "rb") as comp:
- fp = io.BytesIO(comp.read())
- elif compression == "zip":
- with zipfile.ZipFile(path, "r") as comp:
- fp = io.BytesIO(comp.read(comp.filelist[0]))
- elif compression == "tar":
- with tarfile.open(path) as tar:
- fp = io.BytesIO(tar.extractfile(tar.getnames()[0]).read())
- elif compression == "bz2":
- with bz2.open(path, "rb") as comp:
- fp = io.BytesIO(comp.read())
- elif compression == "zstd":
- zstd = pytest.importorskip("zstandard")
- with zstd.open(path, "rb") as comp:
- fp = io.BytesIO(comp.read())
- elif compression == "xz":
- lzma = pytest.importorskip("lzma")
- with lzma.open(path, "rb") as comp:
- fp = io.BytesIO(comp.read())
- elif compression is None:
- fp = path
- reread = read_stata(fp, index_col="index")
+ path = tmp_path / file_name
+ path.touch()
+ df.to_stata(path, version=version, compression=compression_arg)
+ if compression == "gzip":
+ with gzip.open(path, "rb") as comp:
+ fp = io.BytesIO(comp.read())
+ elif compression == "zip":
+ with zipfile.ZipFile(path, "r") as comp:
+ fp = io.BytesIO(comp.read(comp.filelist[0]))
+ elif compression == "tar":
+ with tarfile.open(path) as tar:
+ fp = io.BytesIO(tar.extractfile(tar.getnames()[0]).read())
+ elif compression == "bz2":
+ with bz2.open(path, "rb") as comp:
+ fp = io.BytesIO(comp.read())
+ elif compression == "zstd":
+ zstd = pytest.importorskip("zstandard")
+ with zstd.open(path, "rb") as comp:
+ fp = io.BytesIO(comp.read())
+ elif compression == "xz":
+ lzma = pytest.importorskip("lzma")
+ with lzma.open(path, "rb") as comp:
+ fp = io.BytesIO(comp.read())
+ elif compression is None:
+ fp = path
+ reread = read_stata(fp, index_col="index")
expected = df
tm.assert_frame_equal(reread, expected)
@@ -2045,47 +2037,47 @@ def test_compression(compression, version, use_dict, infer, compression_to_exten
@pytest.mark.parametrize("method", ["zip", "infer"])
@pytest.mark.parametrize("file_ext", [None, "dta", "zip"])
-def test_compression_dict(method, file_ext):
+def test_compression_dict(method, file_ext, tmp_path):
file_name = f"test.{file_ext}"
archive_name = "test.dta"
df = DataFrame(
np.random.default_rng(2).standard_normal((10, 2)), columns=list("AB")
)
df.index.name = "index"
- with tm.ensure_clean(file_name) as path:
- compression = {"method": method, "archive_name": archive_name}
- df.to_stata(path, compression=compression)
- if method == "zip" or file_ext == "zip":
- with zipfile.ZipFile(path, "r") as zp:
- assert len(zp.filelist) == 1
- assert zp.filelist[0].filename == archive_name
- fp = io.BytesIO(zp.read(zp.filelist[0]))
- else:
- fp = path
- reread = read_stata(fp, index_col="index")
+ compression = {"method": method, "archive_name": archive_name}
+ path = tmp_path / file_name
+ path.touch()
+ df.to_stata(path, compression=compression)
+ if method == "zip" or file_ext == "zip":
+ with zipfile.ZipFile(path, "r") as zp:
+ assert len(zp.filelist) == 1
+ assert zp.filelist[0].filename == archive_name
+ fp = io.BytesIO(zp.read(zp.filelist[0]))
+ else:
+ fp = path
+ reread = read_stata(fp, index_col="index")
expected = df
tm.assert_frame_equal(reread, expected)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
-def test_chunked_categorical(version):
+def test_chunked_categorical(version, temp_file):
df = DataFrame({"cats": Series(["a", "b", "a", "b", "c"], dtype="category")})
df.index.name = "index"
expected = df.copy()
- with tm.ensure_clean() as path:
- df.to_stata(path, version=version)
- with StataReader(path, chunksize=2, order_categoricals=False) as reader:
- for i, block in enumerate(reader):
- block = block.set_index("index")
- assert "cats" in block
- tm.assert_series_equal(
- block.cats,
- expected.cats.iloc[2 * i : 2 * (i + 1)],
- check_index_type=len(block) > 1,
- )
+ df.to_stata(temp_file, version=version)
+ with StataReader(temp_file, chunksize=2, order_categoricals=False) as reader:
+ for i, block in enumerate(reader):
+ block = block.set_index("index")
+ assert "cats" in block
+ tm.assert_series_equal(
+ block.cats,
+ expected.cats.iloc[2 * i : 2 * (i + 1)],
+ check_index_type=len(block) > 1,
+ )
def test_chunked_categorical_partial(datapath):
@@ -2115,38 +2107,36 @@ def test_iterator_errors(datapath, chunksize):
pass
-def test_iterator_value_labels():
+def test_iterator_value_labels(temp_file):
# GH 31544
values = ["c_label", "b_label"] + ["a_label"] * 500
df = DataFrame({f"col{k}": pd.Categorical(values, ordered=True) for k in range(2)})
- with tm.ensure_clean() as path:
- df.to_stata(path, write_index=False)
- expected = pd.Index(["a_label", "b_label", "c_label"], dtype="object")
- with read_stata(path, chunksize=100) as reader:
- for j, chunk in enumerate(reader):
- for i in range(2):
- tm.assert_index_equal(chunk.dtypes.iloc[i].categories, expected)
- tm.assert_frame_equal(chunk, df.iloc[j * 100 : (j + 1) * 100])
+ df.to_stata(temp_file, write_index=False)
+ expected = pd.Index(["a_label", "b_label", "c_label"], dtype="object")
+ with read_stata(temp_file, chunksize=100) as reader:
+ for j, chunk in enumerate(reader):
+ for i in range(2):
+ tm.assert_index_equal(chunk.dtypes.iloc[i].categories, expected)
+ tm.assert_frame_equal(chunk, df.iloc[j * 100 : (j + 1) * 100])
-def test_precision_loss():
+def test_precision_loss(temp_file):
df = DataFrame(
[[sum(2**i for i in range(60)), sum(2**i for i in range(52))]],
columns=["big", "little"],
)
- with tm.ensure_clean() as path:
- with tm.assert_produces_warning(
- PossiblePrecisionLoss, match="Column converted from int64 to float64"
- ):
- df.to_stata(path, write_index=False)
- reread = read_stata(path)
- expected_dt = Series([np.float64, np.float64], index=["big", "little"])
- tm.assert_series_equal(reread.dtypes, expected_dt)
- assert reread.loc[0, "little"] == df.loc[0, "little"]
- assert reread.loc[0, "big"] == float(df.loc[0, "big"])
+ with tm.assert_produces_warning(
+ PossiblePrecisionLoss, match="Column converted from int64 to float64"
+ ):
+ df.to_stata(temp_file, write_index=False)
+ reread = read_stata(temp_file)
+ expected_dt = Series([np.float64, np.float64], index=["big", "little"])
+ tm.assert_series_equal(reread.dtypes, expected_dt)
+ assert reread.loc[0, "little"] == df.loc[0, "little"]
+ assert reread.loc[0, "big"] == float(df.loc[0, "big"])
-def test_compression_roundtrip(compression):
+def test_compression_roundtrip(compression, temp_file):
df = DataFrame(
[[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
index=["A", "B"],
@@ -2154,22 +2144,21 @@ def test_compression_roundtrip(compression):
)
df.index.name = "index"
- with tm.ensure_clean() as path:
- df.to_stata(path, compression=compression)
- reread = read_stata(path, compression=compression, index_col="index")
- tm.assert_frame_equal(df, reread)
+ df.to_stata(temp_file, compression=compression)
+ reread = read_stata(temp_file, compression=compression, index_col="index")
+ tm.assert_frame_equal(df, reread)
- # explicitly ensure file was compressed.
- with tm.decompress_file(path, compression) as fh:
- contents = io.BytesIO(fh.read())
- reread = read_stata(contents, index_col="index")
- tm.assert_frame_equal(df, reread)
+ # explicitly ensure file was compressed.
+ with tm.decompress_file(temp_file, compression) as fh:
+ contents = io.BytesIO(fh.read())
+ reread = read_stata(contents, index_col="index")
+ tm.assert_frame_equal(df, reread)
@pytest.mark.parametrize("to_infer", [True, False])
@pytest.mark.parametrize("read_infer", [True, False])
def test_stata_compression(
- compression_only, read_infer, to_infer, compression_to_extension
+ compression_only, read_infer, to_infer, compression_to_extension, tmp_path
):
compression = compression_only
@@ -2186,13 +2175,14 @@ def test_stata_compression(
to_compression = "infer" if to_infer else compression
read_compression = "infer" if read_infer else compression
- with tm.ensure_clean(filename) as path:
- df.to_stata(path, compression=to_compression)
- result = read_stata(path, compression=read_compression, index_col="index")
- tm.assert_frame_equal(result, df)
+ path = tmp_path / filename
+ path.touch()
+ df.to_stata(path, compression=to_compression)
+ result = read_stata(path, compression=read_compression, index_col="index")
+ tm.assert_frame_equal(result, df)
-def test_non_categorical_value_labels():
+def test_non_categorical_value_labels(temp_file):
data = DataFrame(
{
"fully_labelled": [1, 2, 3, 3, 1],
@@ -2202,35 +2192,35 @@ def test_non_categorical_value_labels():
}
)
- with tm.ensure_clean() as path:
- value_labels = {
- "fully_labelled": {1: "one", 2: "two", 3: "three"},
- "partially_labelled": {1.0: "one", 2.0: "two"},
- }
- expected = {**value_labels, "Z": {0: "j", 1: "k", 2: "l"}}
+ path = temp_file
+ value_labels = {
+ "fully_labelled": {1: "one", 2: "two", 3: "three"},
+ "partially_labelled": {1.0: "one", 2.0: "two"},
+ }
+ expected = {**value_labels, "Z": {0: "j", 1: "k", 2: "l"}}
- writer = StataWriter(path, data, value_labels=value_labels)
- writer.write_file()
+ writer = StataWriter(path, data, value_labels=value_labels)
+ writer.write_file()
- with StataReader(path) as reader:
- reader_value_labels = reader.value_labels()
- assert reader_value_labels == expected
+ with StataReader(path) as reader:
+ reader_value_labels = reader.value_labels()
+ assert reader_value_labels == expected
- msg = "Can't create value labels for notY, it wasn't found in the dataset."
- value_labels = {"notY": {7: "label1", 8: "label2"}}
- with pytest.raises(KeyError, match=msg):
- StataWriter(path, data, value_labels=value_labels)
+ msg = "Can't create value labels for notY, it wasn't found in the dataset."
+ value_labels = {"notY": {7: "label1", 8: "label2"}}
+ with pytest.raises(KeyError, match=msg):
+ StataWriter(path, data, value_labels=value_labels)
- msg = (
- "Can't create value labels for Z, value labels "
- "can only be applied to numeric columns."
- )
- value_labels = {"Z": {1: "a", 2: "k", 3: "j", 4: "i"}}
- with pytest.raises(ValueError, match=msg):
- StataWriter(path, data, value_labels=value_labels)
+ msg = (
+ "Can't create value labels for Z, value labels "
+ "can only be applied to numeric columns."
+ )
+ value_labels = {"Z": {1: "a", 2: "k", 3: "j", 4: "i"}}
+ with pytest.raises(ValueError, match=msg):
+ StataWriter(path, data, value_labels=value_labels)
-def test_non_categorical_value_label_name_conversion():
+def test_non_categorical_value_label_name_conversion(temp_file):
# Check conversion of invalid variable names
data = DataFrame(
{
@@ -2258,16 +2248,15 @@ def test_non_categorical_value_label_name_conversion():
"_1__2_": {3: "three"},
}
- with tm.ensure_clean() as path:
- with tm.assert_produces_warning(InvalidColumnName):
- data.to_stata(path, value_labels=value_labels)
+ with tm.assert_produces_warning(InvalidColumnName):
+ data.to_stata(temp_file, value_labels=value_labels)
- with StataReader(path) as reader:
- reader_value_labels = reader.value_labels()
- assert reader_value_labels == expected
+ with StataReader(temp_file) as reader:
+ reader_value_labels = reader.value_labels()
+ assert reader_value_labels == expected
-def test_non_categorical_value_label_convert_categoricals_error():
+def test_non_categorical_value_label_convert_categoricals_error(temp_file):
# Mapping more than one value to the same label is valid for Stata
# labels, but can't be read with convert_categoricals=True
value_labels = {
@@ -2280,17 +2269,16 @@ def test_non_categorical_value_label_convert_categoricals_error():
}
)
- with tm.ensure_clean() as path:
- data.to_stata(path, value_labels=value_labels)
+ data.to_stata(temp_file, value_labels=value_labels)
- with StataReader(path, convert_categoricals=False) as reader:
- reader_value_labels = reader.value_labels()
- assert reader_value_labels == value_labels
+ with StataReader(temp_file, convert_categoricals=False) as reader:
+ reader_value_labels = reader.value_labels()
+ assert reader_value_labels == value_labels
- col = "repeated_labels"
- repeats = "-" * 80 + "\n" + "\n".join(["More than ten"])
+ col = "repeated_labels"
+ repeats = "-" * 80 + "\n" + "\n".join(["More than ten"])
- msg = f"""
+ msg = f"""
Value labels for column {col} are not unique. These cannot be converted to
pandas categoricals.
@@ -2301,8 +2289,8 @@ def test_non_categorical_value_label_convert_categoricals_error():
The repeated labels are:
{repeats}
"""
- with pytest.raises(ValueError, match=msg):
- read_stata(path, convert_categoricals=True)
+ with pytest.raises(ValueError, match=msg):
+ read_stata(temp_file, convert_categoricals=True)
@pytest.mark.parametrize("version", [114, 117, 118, 119, None])
@@ -2320,7 +2308,7 @@ def test_non_categorical_value_label_convert_categoricals_error():
pd.UInt64Dtype,
],
)
-def test_nullable_support(dtype, version):
+def test_nullable_support(dtype, version, temp_file):
df = DataFrame(
{
"a": Series([1.0, 2.0, 3.0]),
@@ -2339,27 +2327,26 @@ def test_nullable_support(dtype, version):
smv = StataMissingValue(value)
expected_b = Series([1, smv, smv], dtype=object, name="b")
expected_c = Series(["a", "b", ""], name="c")
- with tm.ensure_clean() as path:
- df.to_stata(path, write_index=False, version=version)
- reread = read_stata(path, convert_missing=True)
- tm.assert_series_equal(df.a, reread.a)
- tm.assert_series_equal(reread.b, expected_b)
- tm.assert_series_equal(reread.c, expected_c)
+ df.to_stata(temp_file, write_index=False, version=version)
+ reread = read_stata(temp_file, convert_missing=True)
+ tm.assert_series_equal(df.a, reread.a)
+ tm.assert_series_equal(reread.b, expected_b)
+ tm.assert_series_equal(reread.c, expected_c)
-def test_empty_frame():
+def test_empty_frame(temp_file):
# GH 46240
# create an empty DataFrame with int64 and float64 dtypes
df = DataFrame(data={"a": range(3), "b": [1.0, 2.0, 3.0]}).head(0)
- with tm.ensure_clean() as path:
- df.to_stata(path, write_index=False, version=117)
- # Read entire dataframe
- df2 = read_stata(path)
- assert "b" in df2
- # Dtypes don't match since no support for int32
- dtypes = Series({"a": np.dtype("int32"), "b": np.dtype("float64")})
- tm.assert_series_equal(df2.dtypes, dtypes)
- # read one column of empty .dta file
- df3 = read_stata(path, columns=["a"])
- assert "b" not in df3
- tm.assert_series_equal(df3.dtypes, dtypes.loc[["a"]])
+ path = temp_file
+ df.to_stata(path, write_index=False, version=117)
+ # Read entire dataframe
+ df2 = read_stata(path)
+ assert "b" in df2
+ # Dtypes don't match since no support for int32
+ dtypes = Series({"a": np.dtype("int32"), "b": np.dtype("float64")})
+ tm.assert_series_equal(df2.dtypes, dtypes)
+ # read one column of empty .dta file
+ df3 = read_stata(path, columns=["a"])
+ assert "b" not in df3
+ tm.assert_series_equal(df3.dtypes, dtypes.loc[["a"]])
diff --git a/pandas/tests/series/methods/test_to_csv.py b/pandas/tests/series/methods/test_to_csv.py
index e292861012c8f..f7dec02ab0e5b 100644
--- a/pandas/tests/series/methods/test_to_csv.py
+++ b/pandas/tests/series/methods/test_to_csv.py
@@ -24,58 +24,55 @@ def read_csv(self, path, **kwargs):
return out
- def test_from_csv(self, datetime_series, string_series):
+ def test_from_csv(self, datetime_series, string_series, temp_file):
# freq doesn't round-trip
datetime_series.index = datetime_series.index._with_freq(None)
- with tm.ensure_clean() as path:
- datetime_series.to_csv(path, header=False)
- ts = self.read_csv(path, parse_dates=True)
- tm.assert_series_equal(datetime_series, ts, check_names=False)
+ path = temp_file
+ datetime_series.to_csv(path, header=False)
+ ts = self.read_csv(path, parse_dates=True)
+ tm.assert_series_equal(datetime_series, ts, check_names=False)
- assert ts.name is None
- assert ts.index.name is None
+ assert ts.name is None
+ assert ts.index.name is None
- # see gh-10483
- datetime_series.to_csv(path, header=True)
- ts_h = self.read_csv(path, header=0)
- assert ts_h.name == "ts"
+ # see gh-10483
+ datetime_series.to_csv(path, header=True)
+ ts_h = self.read_csv(path, header=0)
+ assert ts_h.name == "ts"
- string_series.to_csv(path, header=False)
- series = self.read_csv(path)
- tm.assert_series_equal(string_series, series, check_names=False)
+ string_series.to_csv(path, header=False)
+ series = self.read_csv(path)
+ tm.assert_series_equal(string_series, series, check_names=False)
- assert series.name is None
- assert series.index.name is None
+ assert series.name is None
+ assert series.index.name is None
- string_series.to_csv(path, header=True)
- series_h = self.read_csv(path, header=0)
- assert series_h.name == "series"
+ string_series.to_csv(path, header=True)
+ series_h = self.read_csv(path, header=0)
+ assert series_h.name == "series"
- with open(path, "w", encoding="utf-8") as outfile:
- outfile.write("1998-01-01|1.0\n1999-01-01|2.0")
+ with open(path, "w", encoding="utf-8") as outfile:
+ outfile.write("1998-01-01|1.0\n1999-01-01|2.0")
- series = self.read_csv(path, sep="|", parse_dates=True)
- check_series = Series(
- {datetime(1998, 1, 1): 1.0, datetime(1999, 1, 1): 2.0}
- )
- tm.assert_series_equal(check_series, series)
+ series = self.read_csv(path, sep="|", parse_dates=True)
+ check_series = Series({datetime(1998, 1, 1): 1.0, datetime(1999, 1, 1): 2.0})
+ tm.assert_series_equal(check_series, series)
- series = self.read_csv(path, sep="|", parse_dates=False)
- check_series = Series({"1998-01-01": 1.0, "1999-01-01": 2.0})
- tm.assert_series_equal(check_series, series)
+ series = self.read_csv(path, sep="|", parse_dates=False)
+ check_series = Series({"1998-01-01": 1.0, "1999-01-01": 2.0})
+ tm.assert_series_equal(check_series, series)
- def test_to_csv(self, datetime_series):
- with tm.ensure_clean() as path:
- datetime_series.to_csv(path, header=False)
+ def test_to_csv(self, datetime_series, temp_file):
+ datetime_series.to_csv(temp_file, header=False)
- with open(path, newline=None, encoding="utf-8") as f:
- lines = f.readlines()
- assert lines[1] != "\n"
+ with open(temp_file, newline=None, encoding="utf-8") as f:
+ lines = f.readlines()
+ assert lines[1] != "\n"
- datetime_series.to_csv(path, index=False, header=False)
- arr = np.loadtxt(path)
- tm.assert_almost_equal(arr, datetime_series.values)
+ datetime_series.to_csv(temp_file, index=False, header=False)
+ arr = np.loadtxt(temp_file)
+ tm.assert_almost_equal(arr, datetime_series.values)
def test_to_csv_unicode_index(self):
buf = StringIO()
@@ -87,14 +84,13 @@ def test_to_csv_unicode_index(self):
s2 = self.read_csv(buf, index_col=0, encoding="UTF-8")
tm.assert_series_equal(s, s2)
- def test_to_csv_float_format(self):
- with tm.ensure_clean() as filename:
- ser = Series([0.123456, 0.234567, 0.567567])
- ser.to_csv(filename, float_format="%.2f", header=False)
+ def test_to_csv_float_format(self, temp_file):
+ ser = Series([0.123456, 0.234567, 0.567567])
+ ser.to_csv(temp_file, float_format="%.2f", header=False)
- rs = self.read_csv(filename)
- xp = Series([0.12, 0.23, 0.57])
- tm.assert_series_equal(rs, xp)
+ rs = self.read_csv(temp_file)
+ xp = Series([0.12, 0.23, 0.57])
+ tm.assert_series_equal(rs, xp)
def test_to_csv_list_entries(self):
s = Series(["jack and jill", "jesse and frank"])
@@ -128,50 +124,49 @@ def test_to_csv_path_is_none(self):
),
],
)
- def test_to_csv_compression(self, s, encoding, compression):
- with tm.ensure_clean() as filename:
- s.to_csv(filename, compression=compression, encoding=encoding, header=True)
- # test the round trip - to_csv -> read_csv
- result = pd.read_csv(
- filename,
- compression=compression,
- encoding=encoding,
- index_col=0,
- ).squeeze("columns")
- tm.assert_series_equal(s, result)
-
- # test the round trip using file handle - to_csv -> read_csv
- with get_handle(
- filename, "w", compression=compression, encoding=encoding
- ) as handles:
- s.to_csv(handles.handle, encoding=encoding, header=True)
-
- result = pd.read_csv(
- filename,
- compression=compression,
- encoding=encoding,
- index_col=0,
- ).squeeze("columns")
- tm.assert_series_equal(s, result)
-
- # explicitly ensure file was compressed
- with tm.decompress_file(filename, compression) as fh:
- text = fh.read().decode(encoding or "utf8")
- assert s.name in text
-
- with tm.decompress_file(filename, compression) as fh:
- tm.assert_series_equal(
- s,
- pd.read_csv(fh, index_col=0, encoding=encoding).squeeze("columns"),
- )
-
- def test_to_csv_interval_index(self, using_infer_string):
+ def test_to_csv_compression(self, s, encoding, compression, temp_file):
+ filename = temp_file
+ s.to_csv(filename, compression=compression, encoding=encoding, header=True)
+ # test the round trip - to_csv -> read_csv
+ result = pd.read_csv(
+ filename,
+ compression=compression,
+ encoding=encoding,
+ index_col=0,
+ ).squeeze("columns")
+ tm.assert_series_equal(s, result)
+
+ # test the round trip using file handle - to_csv -> read_csv
+ with get_handle(
+ filename, "w", compression=compression, encoding=encoding
+ ) as handles:
+ s.to_csv(handles.handle, encoding=encoding, header=True)
+
+ result = pd.read_csv(
+ filename,
+ compression=compression,
+ encoding=encoding,
+ index_col=0,
+ ).squeeze("columns")
+ tm.assert_series_equal(s, result)
+
+ # explicitly ensure file was compressed
+ with tm.decompress_file(filename, compression) as fh:
+ text = fh.read().decode(encoding or "utf8")
+ assert s.name in text
+
+ with tm.decompress_file(filename, compression) as fh:
+ tm.assert_series_equal(
+ s,
+ pd.read_csv(fh, index_col=0, encoding=encoding).squeeze("columns"),
+ )
+
+ def test_to_csv_interval_index(self, using_infer_string, temp_file):
# GH 28210
s = Series(["foo", "bar", "baz"], index=pd.interval_range(0, 3))
- with tm.ensure_clean("__tmp_to_csv_interval_index__.csv") as path:
- s.to_csv(path, header=False)
- result = self.read_csv(path, index_col=0)
+ s.to_csv(temp_file, header=False)
+ result = self.read_csv(temp_file, index_col=0)
# can't roundtrip intervalindex via read_csv so check string repr (GH 23595)
expected = s
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/58166 | 2024-04-05T20:14:49Z | 2024-04-09T13:11:36Z | 2024-04-09T13:11:36Z | 2024-04-09T16:32:00Z |
STY: Add flake8-slots and flake8-raise rules | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index b8726e058a52b..8eec5d5515239 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -30,12 +30,6 @@ repos:
files: ^pandas
exclude: ^pandas/tests
args: [--select, "ANN001,ANN2", --fix-only, --exit-non-zero-on-fix]
- - id: ruff
- name: ruff-use-pd_array-in-core
- alias: ruff-use-pd_array-in-core
- files: ^pandas/core/
- exclude: ^pandas/core/api\.py$
- args: [--select, "ICN001", --exit-non-zero-on-fix]
- id: ruff-format
exclude: ^scripts
- repo: https://github.com/jendrikseipp/vulture
diff --git a/pandas/core/api.py b/pandas/core/api.py
index 3d2e855831c05..c8a4e9d8a23b2 100644
--- a/pandas/core/api.py
+++ b/pandas/core/api.py
@@ -41,7 +41,7 @@
UInt64Dtype,
)
from pandas.core.arrays.string_ import StringDtype
-from pandas.core.construction import array
+from pandas.core.construction import array # noqa: ICN001
from pandas.core.flags import Flags
from pandas.core.groupby import (
Grouper,
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 99462917599e1..8af9503a3691d 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -6729,7 +6729,7 @@ def _pad_or_backfill(
if axis == 1:
if not self._mgr.is_single_block and inplace:
- raise NotImplementedError()
+ raise NotImplementedError
# e.g. test_align_fill_method
result = self.T._pad_or_backfill(
method=method, limit=limit, limit_area=limit_area
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 982e305b7e471..a834d3e54d30b 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -1191,13 +1191,13 @@ def __getitem__(self, key):
return self._getitem_axis(maybe_callable, axis=axis)
def _is_scalar_access(self, key: tuple):
- raise NotImplementedError()
+ raise NotImplementedError
def _getitem_tuple(self, tup: tuple):
raise AbstractMethodError(self)
def _getitem_axis(self, key, axis: AxisInt):
- raise NotImplementedError()
+ raise NotImplementedError
def _has_valid_setitem_indexer(self, indexer) -> bool:
raise AbstractMethodError(self)
diff --git a/pandas/core/interchange/buffer.py b/pandas/core/interchange/buffer.py
index 5d24325e67f62..62bf396256f2a 100644
--- a/pandas/core/interchange/buffer.py
+++ b/pandas/core/interchange/buffer.py
@@ -114,7 +114,7 @@ def __dlpack__(self) -> Any:
"""
Represent this structure as DLPack interface.
"""
- raise NotImplementedError()
+ raise NotImplementedError
def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]:
"""
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index 3ec077806d6c4..50ee2d52ee51d 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -1376,7 +1376,7 @@ def _get_time_stamp(self) -> str:
elif self._format_version > 104:
return self._decode(self._path_or_buf.read(18))
else:
- raise ValueError()
+ raise ValueError
def _get_seek_variable_labels(self) -> int:
if self._format_version == 117:
@@ -1388,7 +1388,7 @@ def _get_seek_variable_labels(self) -> int:
elif self._format_version >= 118:
return self._read_int64() + 17
else:
- raise ValueError()
+ raise ValueError
def _read_old_header(self, first_char: bytes) -> None:
self._format_version = int(first_char[0])
diff --git a/pandas/tests/config/test_localization.py b/pandas/tests/config/test_localization.py
index 844f67cd2d0ea..b9a0a44bf8c89 100644
--- a/pandas/tests/config/test_localization.py
+++ b/pandas/tests/config/test_localization.py
@@ -92,7 +92,7 @@ def test_can_set_locale_invalid_get(monkeypatch):
# but a subsequent getlocale() raises a ValueError.
def mock_get_locale():
- raise ValueError()
+ raise ValueError
with monkeypatch.context() as m:
m.setattr(locale, "getlocale", mock_get_locale)
diff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py
index 658fafd3ea2cc..3f98f49cd1877 100644
--- a/pandas/tests/frame/indexing/test_setitem.py
+++ b/pandas/tests/frame/indexing/test_setitem.py
@@ -41,7 +41,7 @@ class TestDataFrameSetItem:
def test_setitem_str_subclass(self):
# GH#37366
class mystring(str):
- pass
+ __slots__ = ()
data = ["2020-10-22 01:21:00+00:00"]
index = DatetimeIndex(data)
diff --git a/pyproject.toml b/pyproject.toml
index c9180cf04e7f5..0a0a3e8b484f0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -234,6 +234,12 @@ select = [
"G",
# flake8-future-annotations
"FA",
+ # unconventional-import-alias
+ "ICN001",
+ # flake8-slots
+ "SLOT",
+ # flake8-raise
+ "RSE"
]
ignore = [
| Also moves `ICN001` to the main ruff linter | https://api.github.com/repos/pandas-dev/pandas/pulls/58161 | 2024-04-05T17:48:52Z | 2024-04-08T16:45:42Z | 2024-04-08T16:45:41Z | 2024-04-08T16:45:45Z |
DEPR: PandasArray alias | diff --git a/doc/redirects.csv b/doc/redirects.csv
index e71a031bd67fd..c11e4e242f128 100644
--- a/doc/redirects.csv
+++ b/doc/redirects.csv
@@ -1422,7 +1422,6 @@ reference/api/pandas.Series.transpose,pandas.Series.T
reference/api/pandas.Index.transpose,pandas.Index.T
reference/api/pandas.Index.notnull,pandas.Index.notna
reference/api/pandas.Index.tolist,pandas.Index.to_list
-reference/api/pandas.arrays.PandasArray,pandas.arrays.NumpyExtensionArray
reference/api/pandas.core.groupby.DataFrameGroupBy.backfill,pandas.core.groupby.DataFrameGroupBy.bfill
reference/api/pandas.core.groupby.GroupBy.backfill,pandas.core.groupby.DataFrameGroupBy.bfill
reference/api/pandas.core.resample.Resampler.backfill,pandas.core.resample.Resampler.bfill
diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index d2d5707f32bf3..6e6d80eb5c138 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -212,6 +212,7 @@ Removal of prior version deprecations/changes
- Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
- Disallow units other than "s", "ms", "us", "ns" for datetime64 and timedelta64 dtypes in :func:`array` (:issue:`53817`)
- Removed "freq" keyword from :class:`PeriodArray` constructor, use "dtype" instead (:issue:`52462`)
+- Removed alias :class:`arrays.PandasArray` for :class:`arrays.NumpyExtensionArray` (:issue:`53694`)
- Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
- Removed extension test classes ``BaseNoReduceTests``, ``BaseNumericReduceTests``, ``BaseBooleanReduceTests`` (:issue:`54663`)
- Removed the "closed" and "normalize" keywords in :meth:`DatetimeIndex.__new__` (:issue:`52628`)
diff --git a/pandas/arrays/__init__.py b/pandas/arrays/__init__.py
index bcf295fd6b490..b5c1c98da1c78 100644
--- a/pandas/arrays/__init__.py
+++ b/pandas/arrays/__init__.py
@@ -35,20 +35,3 @@
"StringArray",
"TimedeltaArray",
]
-
-
-def __getattr__(name: str) -> type[NumpyExtensionArray]:
- if name == "PandasArray":
- # GH#53694
- import warnings
-
- from pandas.util._exceptions import find_stack_level
-
- warnings.warn(
- "PandasArray has been renamed NumpyExtensionArray. Use that "
- "instead. This alias will be removed in a future version.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
- return NumpyExtensionArray
- raise AttributeError(f"module 'pandas.arrays' has no attribute '{name}'")
diff --git a/pandas/tests/api/test_api.py b/pandas/tests/api/test_api.py
index 82c5c305b574c..e32e5a268d46d 100644
--- a/pandas/tests/api/test_api.py
+++ b/pandas/tests/api/test_api.py
@@ -395,13 +395,5 @@ def test_util_in_top_level(self):
pd.util.foo
-def test_pandas_array_alias():
- msg = "PandasArray has been renamed NumpyExtensionArray"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- res = pd.arrays.PandasArray
-
- assert res is pd.arrays.NumpyExtensionArray
-
-
def test_set_module():
assert pd.DataFrame.__module__ == "pandas"
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58158 | 2024-04-05T15:58:26Z | 2024-04-05T17:01:56Z | 2024-04-05T17:01:55Z | 2024-04-05T18:02:17Z |
DEPR: Categorical fastpath | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 983768e0f67da..bb1e0b33c2ab8 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -212,6 +212,7 @@ Removal of prior version deprecations/changes
- Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
- Disallow units other than "s", "ms", "us", "ns" for datetime64 and timedelta64 dtypes in :func:`array` (:issue:`53817`)
- Removed "freq" keyword from :class:`PeriodArray` constructor, use "dtype" instead (:issue:`52462`)
+- Removed 'fastpath' keyword in :class:`Categorical` constructor (:issue:`20110`)
- Removed alias :class:`arrays.PandasArray` for :class:`arrays.NumpyExtensionArray` (:issue:`53694`)
- Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
- Removed extension test classes ``BaseNoReduceTests``, ``BaseNumericReduceTests``, ``BaseBooleanReduceTests`` (:issue:`54663`)
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 416331a260e9f..3af4c528ceae8 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -276,9 +276,6 @@ class Categorical(NDArrayBackedExtensionArray, PandasObject, ObjectStringArrayMi
provided).
dtype : CategoricalDtype
An instance of ``CategoricalDtype`` to use for this categorical.
- fastpath : bool
- The 'fastpath' keyword in Categorical is deprecated and will be
- removed in a future version. Use Categorical.from_codes instead.
copy : bool, default True
Whether to copy if the codes are unchanged.
@@ -391,20 +388,8 @@ def __init__(
categories=None,
ordered=None,
dtype: Dtype | None = None,
- fastpath: bool | lib.NoDefault = lib.no_default,
copy: bool = True,
) -> None:
- if fastpath is not lib.no_default:
- # GH#20110
- warnings.warn(
- "The 'fastpath' keyword in Categorical is deprecated and will "
- "be removed in a future version. Use Categorical.from_codes instead",
- DeprecationWarning,
- stacklevel=find_stack_level(),
- )
- else:
- fastpath = False
-
dtype = CategoricalDtype._from_values_or_dtype(
values, categories, ordered, dtype
)
@@ -412,12 +397,6 @@ def __init__(
# we may have dtype.categories be None, and we need to
# infer categories in a factorization step further below
- if fastpath:
- codes = coerce_indexer_dtype(values, dtype.categories)
- dtype = CategoricalDtype(ordered=False).update_dtype(dtype)
- super().__init__(codes, dtype)
- return
-
if not is_list_like(values):
# GH#38433
raise TypeError("Categorical input must be list-like")
diff --git a/pandas/tests/arrays/categorical/test_constructors.py b/pandas/tests/arrays/categorical/test_constructors.py
index 857b14e2a2558..1069a9e5aaa90 100644
--- a/pandas/tests/arrays/categorical/test_constructors.py
+++ b/pandas/tests/arrays/categorical/test_constructors.py
@@ -35,13 +35,6 @@
class TestCategoricalConstructors:
- def test_fastpath_deprecated(self):
- codes = np.array([1, 2, 3])
- dtype = CategoricalDtype(categories=["a", "b", "c", "d"], ordered=False)
- msg = "The 'fastpath' keyword in Categorical is deprecated"
- with tm.assert_produces_warning(DeprecationWarning, match=msg):
- Categorical(codes, dtype=dtype, fastpath=True)
-
def test_categorical_from_cat_and_dtype_str_preserve_ordered(self):
# GH#49309 we should preserve orderedness in `res`
cat = Categorical([3, 1], categories=[3, 2, 1], ordered=True)
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58157 | 2024-04-05T15:56:26Z | 2024-04-05T19:45:43Z | 2024-04-05T19:45:43Z | 2024-04-06T00:13:28Z |
ENH: Add support for reading value labels from 108-format and prior Stata dta files | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 19b448a1871c2..0f71b52120a47 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -33,6 +33,7 @@ Other enhancements
- :meth:`Styler.set_tooltips` provides alternative method to storing tooltips by using title attribute of td elements. (:issue:`56981`)
- Allow dictionaries to be passed to :meth:`pandas.Series.str.replace` via ``pat`` parameter (:issue:`51748`)
- Support passing a :class:`Series` input to :func:`json_normalize` that retains the :class:`Series` :class:`Index` (:issue:`51452`)
+- Support reading value labels from Stata 108-format (Stata 6) and earlier files (:issue:`58154`)
- Users can globally disable any ``PerformanceWarning`` by setting the option ``mode.performance_warnings`` to ``False`` (:issue:`56920`)
- :meth:`Styler.format_index_names` can now be used to format the index and column names (:issue:`48936` and :issue:`47489`)
-
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index 50ee2d52ee51d..47d879c022ee6 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -1122,6 +1122,7 @@ def __init__(
# State variables for the file
self._close_file: Callable[[], None] | None = None
self._column_selector_set = False
+ self._value_label_dict: dict[str, dict[int, str]] = {}
self._value_labels_read = False
self._dtype: np.dtype | None = None
self._lines_read = 0
@@ -1502,17 +1503,8 @@ def _decode(self, s: bytes) -> str:
)
return s.decode("latin-1")
- def _read_value_labels(self) -> None:
- self._ensure_open()
- if self._value_labels_read:
- # Don't read twice
- return
- if self._format_version <= 108:
- # Value labels are not supported in version 108 and earlier.
- self._value_labels_read = True
- self._value_label_dict: dict[str, dict[float, str]] = {}
- return
-
+ def _read_new_value_labels(self) -> None:
+ """Reads value labels with variable length strings (108 and later format)"""
if self._format_version >= 117:
self._path_or_buf.seek(self._seek_value_labels)
else:
@@ -1520,9 +1512,6 @@ def _read_value_labels(self) -> None:
offset = self._nobs * self._dtype.itemsize
self._path_or_buf.seek(self._data_location + offset)
- self._value_labels_read = True
- self._value_label_dict = {}
-
while True:
if self._format_version >= 117:
if self._path_or_buf.read(5) == b"</val": # <lbl>
@@ -1530,8 +1519,10 @@ def _read_value_labels(self) -> None:
slength = self._path_or_buf.read(4)
if not slength:
- break # end of value label table (format < 117)
- if self._format_version <= 117:
+ break # end of value label table (format < 117), or end-of-file
+ if self._format_version == 108:
+ labname = self._decode(self._path_or_buf.read(9))
+ elif self._format_version <= 117:
labname = self._decode(self._path_or_buf.read(33))
else:
labname = self._decode(self._path_or_buf.read(129))
@@ -1555,8 +1546,45 @@ def _read_value_labels(self) -> None:
self._value_label_dict[labname][val[i]] = self._decode(
txt[off[i] : end]
)
+
if self._format_version >= 117:
self._path_or_buf.read(6) # </lbl>
+
+ def _read_old_value_labels(self) -> None:
+ """Reads value labels with fixed-length strings (105 and earlier format)"""
+ assert self._dtype is not None
+ offset = self._nobs * self._dtype.itemsize
+ self._path_or_buf.seek(self._data_location + offset)
+
+ while True:
+ if not self._path_or_buf.read(2):
+ # end-of-file may have been reached, if so stop here
+ break
+
+ # otherwise back up and read again, taking byteorder into account
+ self._path_or_buf.seek(-2, os.SEEK_CUR)
+ n = self._read_uint16()
+ labname = self._decode(self._path_or_buf.read(9))
+ self._path_or_buf.read(1) # padding
+ codes = np.frombuffer(
+ self._path_or_buf.read(2 * n), dtype=f"{self._byteorder}i2", count=n
+ )
+ self._value_label_dict[labname] = {}
+ for i in range(n):
+ self._value_label_dict[labname][codes[i]] = self._decode(
+ self._path_or_buf.read(8)
+ )
+
+ def _read_value_labels(self) -> None:
+ self._ensure_open()
+ if self._value_labels_read:
+ # Don't read twice
+ return
+
+ if self._format_version >= 108:
+ self._read_new_value_labels()
+ else:
+ self._read_old_value_labels()
self._value_labels_read = True
def _read_strls(self) -> None:
@@ -1729,7 +1757,7 @@ def read(
i, _stata_elapsed_date_to_datetime_vec(data.iloc[:, i], fmt)
)
- if convert_categoricals and self._format_version > 108:
+ if convert_categoricals:
data = self._do_convert_categoricals(
data, self._value_label_dict, self._lbllist, order_categoricals
)
@@ -1845,7 +1873,7 @@ def _do_select_columns(self, data: DataFrame, columns: Sequence[str]) -> DataFra
def _do_convert_categoricals(
self,
data: DataFrame,
- value_label_dict: dict[str, dict[float, str]],
+ value_label_dict: dict[str, dict[int, str]],
lbllist: Sequence[str],
order_categoricals: bool,
) -> DataFrame:
@@ -1983,7 +2011,7 @@ def variable_labels(self) -> dict[str, str]:
self._ensure_open()
return dict(zip(self._varlist, self._variable_labels))
- def value_labels(self) -> dict[str, dict[float, str]]:
+ def value_labels(self) -> dict[str, dict[int, str]]:
"""
Return a nested dict associating each variable name to its value and label.
diff --git a/pandas/tests/io/data/stata/stata4_105.dta b/pandas/tests/io/data/stata/stata4_105.dta
new file mode 100644
index 0000000000000..f804c315b344b
Binary files /dev/null and b/pandas/tests/io/data/stata/stata4_105.dta differ
diff --git a/pandas/tests/io/data/stata/stata4_108.dta b/pandas/tests/io/data/stata/stata4_108.dta
new file mode 100644
index 0000000000000..e78c24b319e47
Binary files /dev/null and b/pandas/tests/io/data/stata/stata4_108.dta differ
diff --git a/pandas/tests/io/data/stata/stata4_111.dta b/pandas/tests/io/data/stata/stata4_111.dta
new file mode 100644
index 0000000000000..b69034174fcfe
Binary files /dev/null and b/pandas/tests/io/data/stata/stata4_111.dta differ
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index 0cc8018ea6213..a58655d91a417 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -225,7 +225,7 @@ def test_read_dta3(self, file, datapath):
tm.assert_frame_equal(parsed, expected)
@pytest.mark.parametrize(
- "file", ["stata4_113", "stata4_114", "stata4_115", "stata4_117"]
+ "file", ["stata4_111", "stata4_113", "stata4_114", "stata4_115", "stata4_117"]
)
def test_read_dta4(self, file, datapath):
file = datapath("io", "data", "stata", f"{file}.dta")
@@ -270,6 +270,52 @@ def test_read_dta4(self, file, datapath):
# stata doesn't save .category metadata
tm.assert_frame_equal(parsed, expected)
+ @pytest.mark.parametrize("file", ["stata4_105", "stata4_108"])
+ def test_readold_dta4(self, file, datapath):
+ # This test is the same as test_read_dta4 above except that the columns
+ # had to be renamed to match the restrictions in older file format
+ file = datapath("io", "data", "stata", f"{file}.dta")
+ parsed = self.read_dta(file)
+
+ expected = DataFrame.from_records(
+ [
+ ["one", "ten", "one", "one", "one"],
+ ["two", "nine", "two", "two", "two"],
+ ["three", "eight", "three", "three", "three"],
+ ["four", "seven", 4, "four", "four"],
+ ["five", "six", 5, np.nan, "five"],
+ ["six", "five", 6, np.nan, "six"],
+ ["seven", "four", 7, np.nan, "seven"],
+ ["eight", "three", 8, np.nan, "eight"],
+ ["nine", "two", 9, np.nan, "nine"],
+ ["ten", "one", "ten", np.nan, "ten"],
+ ],
+ columns=[
+ "fulllab",
+ "fulllab2",
+ "incmplab",
+ "misslab",
+ "floatlab",
+ ],
+ )
+
+ # these are all categoricals
+ for col in expected:
+ orig = expected[col].copy()
+
+ categories = np.asarray(expected["fulllab"][orig.notna()])
+ if col == "incmplab":
+ categories = orig
+
+ cat = orig.astype("category")._values
+ cat = cat.set_categories(categories, ordered=True)
+ cat.categories.rename(None, inplace=True)
+
+ expected[col] = cat
+
+ # stata doesn't save .category metadata
+ tm.assert_frame_equal(parsed, expected)
+
# File containing strls
def test_read_dta12(self, datapath):
parsed_117 = self.read_dta(datapath("io", "data", "stata", "stata12_117.dta"))
| - [x] closes #58154
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
This change extends support for reading value labels to Stata 108-format (Stata 6) and earlier dta files. | https://api.github.com/repos/pandas-dev/pandas/pulls/58155 | 2024-04-05T13:23:31Z | 2024-04-09T16:55:40Z | 2024-04-09T16:55:40Z | 2024-04-09T16:55:47Z |
BUG: Fix Index.sort_values with natsort_key raises | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index d2d5707f32bf3..46ecb8ac9db5d 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -448,6 +448,7 @@ Other
- Bug in :func:`unique` on :class:`Index` not always returning :class:`Index` (:issue:`57043`)
- Bug in :meth:`DataFrame.sort_index` when passing ``axis="columns"`` and ``ignore_index=True`` and ``ascending=False`` not returning a :class:`RangeIndex` columns (:issue:`57293`)
- Bug in :meth:`DataFrame.where` where using a non-bool type array in the function would return a ``ValueError`` instead of a ``TypeError`` (:issue:`56330`)
+- Bug in :meth:`Index.sort_values` when passing a key function that turns values into tuples, e.g. ``key=natsort.natsort_key``, would raise ``TypeError`` (:issue:`56081`)
- Bug in Dataframe Interchange Protocol implementation was returning incorrect results for data buffers' associated dtype, for string and datetime columns (:issue:`54781`)
.. ***DO NOT USE THIS SECTION***
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
index 493e856c6dcc6..002efec1d8b52 100644
--- a/pandas/core/sorting.py
+++ b/pandas/core/sorting.py
@@ -577,7 +577,7 @@ def ensure_key_mapped(
if isinstance(
values, Index
): # convert to a new Index subclass, not necessarily the same
- result = Index(result)
+ result = Index(result, tupleize_cols=False)
else:
# try to revert to original type otherwise
type_of_values = type(values)
diff --git a/pandas/tests/indexes/test_common.py b/pandas/tests/indexes/test_common.py
index a2dee61295c74..732f7cc624f86 100644
--- a/pandas/tests/indexes/test_common.py
+++ b/pandas/tests/indexes/test_common.py
@@ -479,6 +479,17 @@ def test_sort_values_with_missing(index_with_missing, na_position, request):
tm.assert_index_equal(result, expected)
+def test_sort_values_natsort_key():
+ # GH#56081
+ def split_convert(s):
+ return tuple(int(x) for x in s.split("."))
+
+ idx = pd.Index(["1.9", "2.0", "1.11", "1.10"])
+ expected = pd.Index(["1.9", "1.10", "1.11", "2.0"])
+ result = idx.sort_values(key=lambda x: tuple(map(split_convert, x)))
+ tm.assert_index_equal(result, expected)
+
+
def test_ndarray_compat_properties(index):
if isinstance(index, PeriodIndex) and not IS64:
pytest.skip("Overflow")
| - [x] closes #56081 (Replace xxxx with the GitHub issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58148 | 2024-04-04T12:09:08Z | 2024-04-05T16:50:15Z | 2024-04-05T16:50:15Z | 2024-04-06T04:16:14Z |
Backport PR #58138 on branch 2.2.x (BLD: Fix nightlies not building) | diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index 470c044d2e99e..b9bfc766fb45c 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -139,8 +139,7 @@ jobs:
shell: bash -el {0}
run: echo "sdist_name=$(cd ./dist && ls -d */)" >> "$GITHUB_ENV"
- - name: Build normal wheels
- if: ${{ (env.IS_SCHEDULE_DISPATCH != 'true' || env.IS_PUSH == 'true') }}
+ - name: Build wheels
uses: pypa/cibuildwheel@v2.17.0
with:
package-dir: ./dist/${{ startsWith(matrix.buildplat[1], 'macosx') && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
| Backport PR #58138: BLD: Fix nightlies not building | https://api.github.com/repos/pandas-dev/pandas/pulls/58140 | 2024-04-03T19:30:17Z | 2024-04-03T22:02:48Z | 2024-04-03T22:02:48Z | 2024-04-03T22:02:48Z |
BLD: Fix nightlies not building | diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index d6cfd3b0ad257..4bd9068e91b67 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -139,8 +139,7 @@ jobs:
shell: bash -el {0}
run: echo "sdist_name=$(cd ./dist && ls -d */)" >> "$GITHUB_ENV"
- - name: Build normal wheels
- if: ${{ (env.IS_SCHEDULE_DISPATCH != 'true' || env.IS_PUSH == 'true') }}
+ - name: Build wheels
uses: pypa/cibuildwheel@v2.17.0
with:
package-dir: ./dist/${{ startsWith(matrix.buildplat[1], 'macosx') && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58138 | 2024-04-03T17:46:00Z | 2024-04-03T19:29:37Z | 2024-04-03T19:29:37Z | 2024-04-03T19:30:43Z |
Backport PR #58100 on branch 2.2.x (MNT: fix compatibility with beautifulsoup4 4.13.0b2) | diff --git a/pandas/io/html.py b/pandas/io/html.py
index 26e71c9546ffd..4eeeb1b655f8a 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -591,14 +591,8 @@ class _BeautifulSoupHtml5LibFrameParser(_HtmlFrameParser):
:class:`pandas.io.html._HtmlFrameParser`.
"""
- def __init__(self, *args, **kwargs) -> None:
- super().__init__(*args, **kwargs)
- from bs4 import SoupStrainer
-
- self._strainer = SoupStrainer("table")
-
def _parse_tables(self, document, match, attrs):
- element_name = self._strainer.name
+ element_name = "table"
tables = document.find_all(element_name, attrs=attrs)
if not tables:
raise ValueError("No tables found")
| Backport PR #58100: MNT: fix compatibility with beautifulsoup4 4.13.0b2 | https://api.github.com/repos/pandas-dev/pandas/pulls/58137 | 2024-04-03T17:28:29Z | 2024-04-03T19:29:53Z | 2024-04-03T19:29:53Z | 2024-04-03T19:29:53Z |
DOC: Add return value for Index.slice_locs when label not found #32680 | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 73e564f95cf65..feb58a4806047 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -6453,6 +6453,10 @@ def slice_locs(self, start=None, end=None, step=None) -> tuple[int, int]:
>>> idx = pd.Index(list("abcd"))
>>> idx.slice_locs(start="b", end="c")
(1, 3)
+
+ >>> idx = pd.Index(list("bcde"))
+ >>> idx.slice_locs(start="a", end="c")
+ (0, 2)
"""
inc = step is None or step >= 0
| - [ ] Add return value for Index.slice_locs when label not found #32680
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58135 | 2024-04-03T16:38:26Z | 2024-04-03T21:36:34Z | 2024-04-03T21:36:34Z | 2024-04-03T21:36:41Z |
Backport PR #58126: BLD: Build wheels with numpy 2.0rc1 | diff --git a/pyproject.toml b/pyproject.toml
index c225ed80dcb10..b2764b137a1f8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,12 +6,9 @@ requires = [
"meson==1.2.1",
"wheel",
"Cython==3.0.5", # Note: sync with setup.py, environment.yml and asv.conf.json
- # Any NumPy version should be fine for compiling. Users are unlikely
- # to get a NumPy<1.25 so the result will be compatible with all relevant
- # NumPy versions (if not it is presumably compatible with their version).
- # Pin <2.0 for releases until tested against an RC. But explicitly allow
- # testing the `.dev0` nightlies (which require the extra index).
- "numpy>1.22.4,<=2.0.0.dev0",
+ # Force numpy higher than 2.0rc1, so that built wheels are compatible
+ # with both numpy 1 and 2
+ "numpy>=2.0.0rc1",
"versioneer[toml]"
]
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58127 | 2024-04-03T02:04:55Z | 2024-04-03T02:57:16Z | 2024-04-03T02:57:16Z | 2024-04-03T02:57:16Z |
BLD: Build wheels with numpy 2.0rc1 | diff --git a/pyproject.toml b/pyproject.toml
index 259d003de92d5..c9180cf04e7f5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,12 +6,9 @@ requires = [
"meson==1.2.1",
"wheel",
"Cython~=3.0.5", # Note: sync with setup.py, environment.yml and asv.conf.json
- # Any NumPy version should be fine for compiling. Users are unlikely
- # to get a NumPy<1.25 so the result will be compatible with all relevant
- # NumPy versions (if not it is presumably compatible with their version).
- # Pin <2.0 for releases until tested against an RC. But explicitly allow
- # testing the `.dev0` nightlies (which require the extra index).
- "numpy>1.22.4,<=2.0.0.dev0",
+ # Force numpy higher than 2.0rc1, so that built wheels are compatible
+ # with both numpy 1 and 2
+ "numpy>=2.0.0rc1",
"versioneer[toml]"
]
@@ -152,9 +149,6 @@ setup = ['--vsenv'] # For Windows
skip = "cp36-* cp37-* cp38-* pp* *_i686 *_ppc64le *_s390x"
build-verbosity = "3"
environment = {LDFLAGS="-Wl,--strip-all"}
-# TODO: remove this once numpy 2.0 proper releases
-# and specify numpy 2.0 as a dependency in [build-system] requires in pyproject.toml
-before-build = "pip install numpy==2.0.0rc1"
test-requires = "hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0"
test-command = """
PANDAS_CI='1' python -c 'import pandas as pd; \
@@ -163,9 +157,7 @@ test-command = """
"""
[tool.cibuildwheel.windows]
-# TODO: remove this once numpy 2.0 proper releases
-# and specify numpy 2.0 as a dependency in [build-system] requires in pyproject.toml
-before-build = "pip install delvewheel numpy==2.0.0rc1"
+before-build = "pip install delvewheel"
repair-wheel-command = "delvewheel repair -w {dest_dir} {wheel}"
[[tool.cibuildwheel.overrides]]
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58126 | 2024-04-02T23:15:29Z | 2024-04-03T00:23:49Z | 2024-04-03T00:23:49Z | 2024-04-03T02:04:15Z |
DEPR: keyword-only arguments for DataFrame/Series statistical methods | diff --git a/doc/source/user_guide/basics.rst b/doc/source/user_guide/basics.rst
index eed3fc149263a..92799359a61d2 100644
--- a/doc/source/user_guide/basics.rst
+++ b/doc/source/user_guide/basics.rst
@@ -476,15 +476,15 @@ For example:
.. ipython:: python
df
- df.mean(0)
- df.mean(1)
+ df.mean(axis=0)
+ df.mean(axis=1)
All such methods have a ``skipna`` option signaling whether to exclude missing
data (``True`` by default):
.. ipython:: python
- df.sum(0, skipna=False)
+ df.sum(axis=0, skipna=False)
df.sum(axis=1, skipna=True)
Combined with the broadcasting / arithmetic behavior, one can describe various
@@ -495,8 +495,8 @@ standard deviation of 1), very concisely:
ts_stand = (df - df.mean()) / df.std()
ts_stand.std()
- xs_stand = df.sub(df.mean(1), axis=0).div(df.std(1), axis=0)
- xs_stand.std(1)
+ xs_stand = df.sub(df.mean(axis=1), axis=0).div(df.std(axis=1), axis=0)
+ xs_stand.std(axis=1)
Note that methods like :meth:`~DataFrame.cumsum` and :meth:`~DataFrame.cumprod`
preserve the location of ``NaN`` values. This is somewhat different from
diff --git a/doc/source/user_guide/indexing.rst b/doc/source/user_guide/indexing.rst
index fd843ca68a60b..0da87e1d31fec 100644
--- a/doc/source/user_guide/indexing.rst
+++ b/doc/source/user_guide/indexing.rst
@@ -952,7 +952,7 @@ To select a row where each column meets its own criterion:
values = {'ids': ['a', 'b'], 'ids2': ['a', 'c'], 'vals': [1, 3]}
- row_mask = df.isin(values).all(1)
+ row_mask = df.isin(values).all(axis=1)
df[row_mask]
diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 4debd41de213f..e4711f6f215cd 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -190,6 +190,7 @@ Other Deprecations
- Deprecated :meth:`Timestamp.utcfromtimestamp`, use ``Timestamp.fromtimestamp(ts, "UTC")`` instead (:issue:`56680`)
- Deprecated :meth:`Timestamp.utcnow`, use ``Timestamp.now("UTC")`` instead (:issue:`56680`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.all`, :meth:`DataFrame.min`, :meth:`DataFrame.max`, :meth:`DataFrame.sum`, :meth:`DataFrame.prod`, :meth:`DataFrame.mean`, :meth:`DataFrame.median`, :meth:`DataFrame.sem`, :meth:`DataFrame.var`, :meth:`DataFrame.std`, :meth:`DataFrame.skew`, :meth:`DataFrame.kurt`, :meth:`Series.all`, :meth:`Series.min`, :meth:`Series.max`, :meth:`Series.sum`, :meth:`Series.prod`, :meth:`Series.mean`, :meth:`Series.median`, :meth:`Series.sem`, :meth:`Series.var`, :meth:`Series.std`, :meth:`Series.skew`, and :meth:`Series.kurt`. (:issue:`57087`)
- Deprecated allowing non-keyword arguments in :meth:`Series.to_markdown` except ``buf``. (:issue:`57280`)
- Deprecated allowing non-keyword arguments in :meth:`Series.to_string` except ``buf``. (:issue:`57280`)
-
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 66a68755a2a09..97cf86d45812d 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -64,6 +64,7 @@
from pandas.util._decorators import (
Appender,
Substitution,
+ deprecate_nonkeyword_arguments,
doc,
set_module,
)
@@ -11543,6 +11544,7 @@ def all(
**kwargs,
) -> Series | bool: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="all")
@doc(make_doc("all", ndim=1))
def all(
self,
@@ -11589,6 +11591,7 @@ def min(
**kwargs,
) -> Series | Any: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="min")
@doc(make_doc("min", ndim=2))
def min(
self,
@@ -11635,6 +11638,7 @@ def max(
**kwargs,
) -> Series | Any: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="max")
@doc(make_doc("max", ndim=2))
def max(
self,
@@ -11650,6 +11654,7 @@ def max(
result = result.__finalize__(self, method="max")
return result
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="sum")
@doc(make_doc("sum", ndim=2))
def sum(
self,
@@ -11670,6 +11675,7 @@ def sum(
result = result.__finalize__(self, method="sum")
return result
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="prod")
@doc(make_doc("prod", ndim=2))
def prod(
self,
@@ -11721,6 +11727,7 @@ def mean(
**kwargs,
) -> Series | Any: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="mean")
@doc(make_doc("mean", ndim=2))
def mean(
self,
@@ -11767,6 +11774,7 @@ def median(
**kwargs,
) -> Series | Any: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="median")
@doc(make_doc("median", ndim=2))
def median(
self,
@@ -11816,6 +11824,7 @@ def sem(
**kwargs,
) -> Series | Any: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="sem")
@doc(make_doc("sem", ndim=2))
def sem(
self,
@@ -11866,6 +11875,7 @@ def var(
**kwargs,
) -> Series | Any: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="var")
@doc(make_doc("var", ndim=2))
def var(
self,
@@ -11916,6 +11926,7 @@ def std(
**kwargs,
) -> Series | Any: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="std")
@doc(make_doc("std", ndim=2))
def std(
self,
@@ -11963,6 +11974,7 @@ def skew(
**kwargs,
) -> Series | Any: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="skew")
@doc(make_doc("skew", ndim=2))
def skew(
self,
@@ -12009,6 +12021,7 @@ def kurt(
**kwargs,
) -> Series | Any: ...
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="kurt")
@doc(make_doc("kurt", ndim=2))
def kurt(
self,
diff --git a/pandas/core/series.py b/pandas/core/series.py
index ee496a355f6ca..d6f3c5990820d 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -6189,6 +6189,7 @@ def any( # type: ignore[override]
filter_type="bool",
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="all")
@Appender(make_doc("all", ndim=1))
def all(
self,
@@ -6208,6 +6209,7 @@ def all(
filter_type="bool",
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="min")
@doc(make_doc("min", ndim=1))
def min(
self,
@@ -6220,6 +6222,7 @@ def min(
self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="max")
@doc(make_doc("max", ndim=1))
def max(
self,
@@ -6232,6 +6235,7 @@ def max(
self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="sum")
@doc(make_doc("sum", ndim=1))
def sum(
self,
@@ -6250,6 +6254,7 @@ def sum(
**kwargs,
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="prod")
@doc(make_doc("prod", ndim=1))
def prod(
self,
@@ -6268,6 +6273,7 @@ def prod(
**kwargs,
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="mean")
@doc(make_doc("mean", ndim=1))
def mean(
self,
@@ -6280,6 +6286,7 @@ def mean(
self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="median")
@doc(make_doc("median", ndim=1))
def median(
self,
@@ -6292,6 +6299,7 @@ def median(
self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="sem")
@doc(make_doc("sem", ndim=1))
def sem(
self,
@@ -6310,6 +6318,7 @@ def sem(
**kwargs,
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="var")
@doc(make_doc("var", ndim=1))
def var(
self,
@@ -6328,6 +6337,7 @@ def var(
**kwargs,
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="std")
@doc(make_doc("std", ndim=1))
def std(
self,
@@ -6346,6 +6356,7 @@ def std(
**kwargs,
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="skew")
@doc(make_doc("skew", ndim=1))
def skew(
self,
@@ -6358,6 +6369,7 @@ def skew(
self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs
)
+ @deprecate_nonkeyword_arguments(version="3.0", allowed_args=["self"], name="kurt")
@doc(make_doc("kurt", ndim=1))
def kurt(
self,
diff --git a/pandas/tests/apply/test_frame_apply.py b/pandas/tests/apply/test_frame_apply.py
index 9f3fee686a056..ba551fef3a42d 100644
--- a/pandas/tests/apply/test_frame_apply.py
+++ b/pandas/tests/apply/test_frame_apply.py
@@ -402,7 +402,7 @@ def test_apply_yield_list(float_frame):
def test_apply_reduce_Series(float_frame):
float_frame.iloc[::2, float_frame.columns.get_loc("A")] = np.nan
- expected = float_frame.mean(1)
+ expected = float_frame.mean(axis=1)
result = float_frame.apply(np.mean, axis=1)
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/apply/test_str.py b/pandas/tests/apply/test_str.py
index e9192dae66a46..50cf0f0ed3e84 100644
--- a/pandas/tests/apply/test_str.py
+++ b/pandas/tests/apply/test_str.py
@@ -19,27 +19,18 @@
@pytest.mark.parametrize("func", ["sum", "mean", "min", "max", "std"])
@pytest.mark.parametrize(
- "args,kwds",
+ "kwds",
[
- pytest.param([], {}, id="no_args_or_kwds"),
- pytest.param([1], {}, id="axis_from_args"),
- pytest.param([], {"axis": 1}, id="axis_from_kwds"),
- pytest.param([], {"numeric_only": True}, id="optional_kwds"),
- pytest.param([1, True], {"numeric_only": True}, id="args_and_kwds"),
+ pytest.param({}, id="no_kwds"),
+ pytest.param({"axis": 1}, id="on_axis"),
+ pytest.param({"numeric_only": True}, id="func_kwds"),
+ pytest.param({"axis": 1, "numeric_only": True}, id="axis_and_func_kwds"),
],
)
@pytest.mark.parametrize("how", ["agg", "apply"])
-def test_apply_with_string_funcs(request, float_frame, func, args, kwds, how):
- if len(args) > 1 and how == "agg":
- request.applymarker(
- pytest.mark.xfail(
- raises=TypeError,
- reason="agg/apply signature mismatch - agg passes 2nd "
- "argument to func",
- )
- )
- result = getattr(float_frame, how)(func, *args, **kwds)
- expected = getattr(float_frame, func)(*args, **kwds)
+def test_apply_with_string_funcs(request, float_frame, func, kwds, how):
+ result = getattr(float_frame, how)(func, **kwds)
+ expected = getattr(float_frame, func)(**kwds)
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_asof.py b/pandas/tests/frame/methods/test_asof.py
index 029aa3a5b8f05..c510ef78d03aa 100644
--- a/pandas/tests/frame/methods/test_asof.py
+++ b/pandas/tests/frame/methods/test_asof.py
@@ -36,18 +36,18 @@ def test_basic(self, date_range_frame):
dates = date_range("1/1/1990", periods=N * 3, freq="25s")
result = df.asof(dates)
- assert result.notna().all(1).all()
+ assert result.notna().all(axis=1).all()
lb = df.index[14]
ub = df.index[30]
dates = list(dates)
result = df.asof(dates)
- assert result.notna().all(1).all()
+ assert result.notna().all(axis=1).all()
mask = (result.index >= lb) & (result.index < ub)
rs = result[mask]
- assert (rs == 14).all(1).all()
+ assert (rs == 14).all(axis=1).all()
def test_subset(self, date_range_frame):
N = 10
diff --git a/pandas/tests/frame/methods/test_fillna.py b/pandas/tests/frame/methods/test_fillna.py
index 81f66cfd48b0a..b8f67138889cc 100644
--- a/pandas/tests/frame/methods/test_fillna.py
+++ b/pandas/tests/frame/methods/test_fillna.py
@@ -466,7 +466,7 @@ def test_fillna_dict_series(self):
# disable this for now
with pytest.raises(NotImplementedError, match="column by column"):
- df.fillna(df.max(1), axis=1)
+ df.fillna(df.max(axis=1), axis=1)
def test_fillna_dataframe(self):
# GH#8377
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index bb79072d389db..82cdd34e59f11 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -773,7 +773,7 @@ def test_operators_timedelta64(self):
tm.assert_series_equal(result, expected)
# works when only those columns are selected
- result = mixed[["A", "B"]].min(1)
+ result = mixed[["A", "B"]].min(axis=1)
expected = Series([timedelta(days=-1)] * 3)
tm.assert_series_equal(result, expected)
@@ -832,8 +832,8 @@ def test_std_datetime64_with_nat(self, values, skipna, request, unit):
def test_sum_corner(self):
empty_frame = DataFrame()
- axis0 = empty_frame.sum(0)
- axis1 = empty_frame.sum(1)
+ axis0 = empty_frame.sum(axis=0)
+ axis1 = empty_frame.sum(axis=1)
assert isinstance(axis0, Series)
assert isinstance(axis1, Series)
assert len(axis0) == 0
@@ -967,8 +967,8 @@ def test_sum_object(self, float_frame):
def test_sum_bool(self, float_frame):
# ensure this works, bug report
bools = np.isnan(float_frame)
- bools.sum(1)
- bools.sum(0)
+ bools.sum(axis=1)
+ bools.sum(axis=0)
def test_sum_mixed_datetime(self):
# GH#30886
@@ -990,7 +990,7 @@ def test_mean_corner(self, float_frame, float_string_frame):
# take mean of boolean column
float_frame["bool"] = float_frame["A"] > 0
- means = float_frame.mean(0)
+ means = float_frame.mean(axis=0)
assert means["bool"] == float_frame["bool"].values.mean()
def test_mean_datetimelike(self):
@@ -1043,13 +1043,13 @@ def test_mean_extensionarray_numeric_only_true(self):
def test_stats_mixed_type(self, float_string_frame):
with pytest.raises(TypeError, match="could not convert"):
- float_string_frame.std(1)
+ float_string_frame.std(axis=1)
with pytest.raises(TypeError, match="could not convert"):
- float_string_frame.var(1)
+ float_string_frame.var(axis=1)
with pytest.raises(TypeError, match="unsupported operand type"):
- float_string_frame.mean(1)
+ float_string_frame.mean(axis=1)
with pytest.raises(TypeError, match="could not convert"):
- float_string_frame.skew(1)
+ float_string_frame.skew(axis=1)
def test_sum_bools(self):
df = DataFrame(index=range(1), columns=range(10))
@@ -1331,11 +1331,11 @@ def test_any_all_extra(self):
result = df[["A", "B"]].any(axis=1, bool_only=True)
tm.assert_series_equal(result, expected)
- result = df.all(1)
+ result = df.all(axis=1)
expected = Series([True, False, False], index=["a", "b", "c"])
tm.assert_series_equal(result, expected)
- result = df.all(1, bool_only=True)
+ result = df.all(axis=1, bool_only=True)
tm.assert_series_equal(result, expected)
# Axis is None
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index 73ac5d0d8f62e..ba283e807a219 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -665,7 +665,7 @@ def test_empty(self, method, unit, use_bottleneck, dtype):
# GH#844 (changed in GH#9422)
df = DataFrame(np.empty((10, 0)), dtype=dtype)
- assert (getattr(df, method)(1) == unit).all()
+ assert (getattr(df, method)(axis=1) == unit).all()
s = Series([1], dtype=dtype)
result = getattr(s, method)(min_count=2)
diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py
index 7b45a267a4572..a63ffbbd3a5a1 100644
--- a/pandas/tests/series/test_api.py
+++ b/pandas/tests/series/test_api.py
@@ -107,7 +107,7 @@ def test_contains(self, datetime_series):
def test_axis_alias(self):
s = Series([1, 2, np.nan])
tm.assert_series_equal(s.dropna(axis="rows"), s.dropna(axis="index"))
- assert s.dropna().sum("rows") == 3
+ assert s.dropna().sum(axis="rows") == 3
assert s._get_axis_number("rows") == 0
assert s._get_axis_name("rows") == "index"
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index 4e2af9fef377b..97e0fa93c90ef 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -135,7 +135,7 @@ def test_multilevel_consolidate(self):
df = DataFrame(
np.random.default_rng(2).standard_normal((4, 4)), index=index, columns=index
)
- df["Totals", ""] = df.sum(1)
+ df["Totals", ""] = df.sum(axis=1)
df = df._consolidate()
def test_level_with_tuples(self):
diff --git a/scripts/tests/test_validate_docstrings.py b/scripts/tests/test_validate_docstrings.py
index d2e92bb971888..3bffd1f1987aa 100644
--- a/scripts/tests/test_validate_docstrings.py
+++ b/scripts/tests/test_validate_docstrings.py
@@ -36,7 +36,7 @@ def redundant_import(self, paramx=None, paramy=None) -> None:
>>> import pandas as pd
>>> df = pd.DataFrame(np.ones((3, 3)),
... columns=('a', 'b', 'c'))
- >>> df.all(1)
+ >>> df.all(axis=1)
0 True
1 True
2 True
| - [x] closes #57087 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58122 | 2024-04-02T19:19:01Z | 2024-04-09T16:58:28Z | 2024-04-09T16:58:28Z | 2024-04-09T16:58:36Z |
PERF: concat([Series, DataFrame], axis=0) returns RangeIndex columns when possible | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 78ee359397df5..d2d5707f32bf3 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -298,6 +298,7 @@ Performance improvements
- :attr:`Categorical.categories` returns a :class:`RangeIndex` columns instead of an :class:`Index` if the constructed ``values`` was a ``range``. (:issue:`57787`)
- :class:`DataFrame` returns a :class:`RangeIndex` columns when possible when ``data`` is a ``dict`` (:issue:`57943`)
- :class:`Series` returns a :class:`RangeIndex` index when possible when ``data`` is a ``dict`` (:issue:`58118`)
+- :func:`concat` returns a :class:`RangeIndex` column when possible when ``objs`` contains :class:`Series` and :class:`DataFrame` and ``axis=0`` (:issue:`58119`)
- :func:`concat` returns a :class:`RangeIndex` level in the :class:`MultiIndex` result when ``keys`` is a ``range`` or :class:`RangeIndex` (:issue:`57542`)
- :meth:`RangeIndex.append` returns a :class:`RangeIndex` instead of a :class:`Index` when appending values that could continue the :class:`RangeIndex` (:issue:`57467`)
- :meth:`Series.str.extract` returns a :class:`RangeIndex` columns instead of an :class:`Index` column when possible (:issue:`57542`)
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index 0868f711093d6..d17e5b475ae57 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -518,8 +518,11 @@ def _sanitize_mixed_ndim(
# to have unique names
name = current_column
current_column += 1
-
- obj = sample._constructor({name: obj}, copy=False)
+ obj = sample._constructor(obj, copy=False)
+ if isinstance(obj, ABCDataFrame):
+ obj.columns = range(name, name + 1, 1)
+ else:
+ obj = sample._constructor({name: obj}, copy=False)
new_objs.append(obj)
diff --git a/pandas/tests/reshape/concat/test_concat.py b/pandas/tests/reshape/concat/test_concat.py
index b986aa8182219..92e756756547d 100644
--- a/pandas/tests/reshape/concat/test_concat.py
+++ b/pandas/tests/reshape/concat/test_concat.py
@@ -912,3 +912,11 @@ def test_concat_none_with_timezone_timestamp():
result = concat([df1, df2], ignore_index=True)
expected = DataFrame({"A": [None, pd.Timestamp("1990-12-20 00:00:00+00:00")]})
tm.assert_frame_equal(result, expected)
+
+
+def test_concat_with_series_and_frame_returns_rangeindex_columns():
+ ser = Series([0])
+ df = DataFrame([1, 2])
+ result = concat([ser, df])
+ expected = DataFrame([0, 1, 2], index=[0, 0, 1])
+ tm.assert_frame_equal(result, expected, check_column_type=True)
| Discovered in #57441 | https://api.github.com/repos/pandas-dev/pandas/pulls/58119 | 2024-04-02T18:13:03Z | 2024-04-03T20:14:07Z | 2024-04-03T20:14:07Z | 2024-04-03T20:15:11Z |
PERF: Series(dict) returns RangeIndex when possible | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 4debd41de213f..78ee359397df5 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -297,6 +297,7 @@ Performance improvements
~~~~~~~~~~~~~~~~~~~~~~~~
- :attr:`Categorical.categories` returns a :class:`RangeIndex` columns instead of an :class:`Index` if the constructed ``values`` was a ``range``. (:issue:`57787`)
- :class:`DataFrame` returns a :class:`RangeIndex` columns when possible when ``data`` is a ``dict`` (:issue:`57943`)
+- :class:`Series` returns a :class:`RangeIndex` index when possible when ``data`` is a ``dict`` (:issue:`58118`)
- :func:`concat` returns a :class:`RangeIndex` level in the :class:`MultiIndex` result when ``keys`` is a ``range`` or :class:`RangeIndex` (:issue:`57542`)
- :meth:`RangeIndex.append` returns a :class:`RangeIndex` instead of a :class:`Index` when appending values that could continue the :class:`RangeIndex` (:issue:`57467`)
- :meth:`Series.str.extract` returns a :class:`RangeIndex` columns instead of an :class:`Index` column when possible (:issue:`57542`)
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index a4b58445289ad..73e564f95cf65 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -7144,7 +7144,10 @@ def maybe_sequence_to_range(sequence) -> Any | range:
return sequence
if len(sequence) == 0:
return range(0)
- np_sequence = np.asarray(sequence, dtype=np.int64)
+ try:
+ np_sequence = np.asarray(sequence, dtype=np.int64)
+ except OverflowError:
+ return sequence
diff = np_sequence[1] - np_sequence[0]
if diff == 0:
return sequence
diff --git a/pandas/core/series.py b/pandas/core/series.py
index ee496a355f6ca..967aea15fff60 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -132,6 +132,7 @@
PeriodIndex,
default_index,
ensure_index,
+ maybe_sequence_to_range,
)
import pandas.core.indexes.base as ibase
from pandas.core.indexes.multi import maybe_droplevels
@@ -538,8 +539,6 @@ def _init_dict(
_data : BlockManager for the new Series
index : index for the new Series
"""
- keys: Index | tuple
-
# Looking for NaN in dict doesn't work ({np.nan : 1}[float('nan')]
# raises KeyError), so we iterate the entire dict, and align
if data:
@@ -547,7 +546,7 @@ def _init_dict(
# using generators in effects the performance.
# Below is the new way of extracting the keys and values
- keys = tuple(data.keys())
+ keys = maybe_sequence_to_range(tuple(data.keys()))
values = list(data.values()) # Generating list of values- faster way
elif index is not None:
# fastpath for Series(data=None). Just use broadcasting a scalar
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 68737e86f0c6a..97faba532e94a 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -2251,3 +2251,9 @@ def test_series_with_complex_nan(input_list):
result = Series(ser.array)
assert ser.dtype == "complex128"
tm.assert_series_equal(ser, result)
+
+
+def test_dict_keys_rangeindex():
+ result = Series({0: 1, 1: 2})
+ expected = Series([1, 2], index=RangeIndex(2))
+ tm.assert_series_equal(result, expected, check_index_type=True)
| Discovered in https://github.com/pandas-dev/pandas/pull/57441 | https://api.github.com/repos/pandas-dev/pandas/pulls/58118 | 2024-04-02T17:24:14Z | 2024-04-03T18:42:13Z | 2024-04-03T18:42:13Z | 2024-04-03T18:59:18Z |
PERF: groupby returns a RangeIndex from groups when possible | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 4debd41de213f..65db6ee499616 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -296,6 +296,7 @@ Removal of prior version deprecations/changes
Performance improvements
~~~~~~~~~~~~~~~~~~~~~~~~
- :attr:`Categorical.categories` returns a :class:`RangeIndex` columns instead of an :class:`Index` if the constructed ``values`` was a ``range``. (:issue:`57787`)
+- :class:`DataFrameGroupBy` and :class:`SeriesGroupBy` returns a :class:`RangeIndex` index when possible. (:issue:`58117`)
- :class:`DataFrame` returns a :class:`RangeIndex` columns when possible when ``data`` is a ``dict`` (:issue:`57943`)
- :func:`concat` returns a :class:`RangeIndex` level in the :class:`MultiIndex` result when ``keys`` is a ``range`` or :class:`RangeIndex` (:issue:`57542`)
- :meth:`RangeIndex.append` returns a :class:`RangeIndex` instead of a :class:`Index` when appending values that could continue the :class:`RangeIndex` (:issue:`57467`)
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 8585ae3828247..63c7aa6e23dfa 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -58,6 +58,7 @@
Index,
MultiIndex,
ensure_index,
+ maybe_sequence_to_range,
)
from pandas.core.series import Series
from pandas.core.sorting import (
@@ -754,7 +755,10 @@ def ids(self) -> npt.NDArray[np.intp]:
@cache_readonly
def result_index_and_ids(self) -> tuple[Index, npt.NDArray[np.intp]]:
- levels = [Index._with_infer(ping.uniques) for ping in self.groupings]
+ levels = [
+ Index._with_infer(maybe_sequence_to_range(ping.uniques))
+ for ping in self.groupings
+ ]
obs = [
ping._observed or not ping._passed_categorical for ping in self.groupings
]
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index a4b58445289ad..73e564f95cf65 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -7144,7 +7144,10 @@ def maybe_sequence_to_range(sequence) -> Any | range:
return sequence
if len(sequence) == 0:
return range(0)
- np_sequence = np.asarray(sequence, dtype=np.int64)
+ try:
+ np_sequence = np.asarray(sequence, dtype=np.int64)
+ except OverflowError:
+ return sequence
diff = np_sequence[1] - np_sequence[0]
if diff == 0:
return sequence
diff --git a/pandas/core/series.py b/pandas/core/series.py
index ee496a355f6ca..967aea15fff60 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -132,6 +132,7 @@
PeriodIndex,
default_index,
ensure_index,
+ maybe_sequence_to_range,
)
import pandas.core.indexes.base as ibase
from pandas.core.indexes.multi import maybe_droplevels
@@ -538,8 +539,6 @@ def _init_dict(
_data : BlockManager for the new Series
index : index for the new Series
"""
- keys: Index | tuple
-
# Looking for NaN in dict doesn't work ({np.nan : 1}[float('nan')]
# raises KeyError), so we iterate the entire dict, and align
if data:
@@ -547,7 +546,7 @@ def _init_dict(
# using generators in effects the performance.
# Below is the new way of extracting the keys and values
- keys = tuple(data.keys())
+ keys = maybe_sequence_to_range(tuple(data.keys()))
values = list(data.values()) # Generating list of values- faster way
elif index is not None:
# fastpath for Series(data=None). Just use broadcasting a scalar
diff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py
index 2b9df1b7079da..822dfbc620538 100644
--- a/pandas/tests/groupby/aggregate/test_aggregate.py
+++ b/pandas/tests/groupby/aggregate/test_aggregate.py
@@ -19,6 +19,7 @@
DataFrame,
Index,
MultiIndex,
+ RangeIndex,
Series,
concat,
to_datetime,
@@ -517,7 +518,7 @@ def test_callable_result_dtype_frame(
df["c"] = df["c"].astype(input_dtype)
op = getattr(df.groupby(keys)[["c"]], method)
result = op(lambda x: x.astype(result_dtype).iloc[0])
- expected_index = pd.RangeIndex(0, 1) if method == "transform" else agg_index
+ expected_index = RangeIndex(0, 1) if method == "transform" else agg_index
expected = DataFrame({"c": [df["c"].iloc[0]]}, index=expected_index).astype(
result_dtype
)
@@ -541,7 +542,7 @@ def test_callable_result_dtype_series(keys, agg_index, input, dtype, method):
df = DataFrame({"a": [1], "b": [2], "c": [input]})
op = getattr(df.groupby(keys)["c"], method)
result = op(lambda x: x.astype(dtype).iloc[0])
- expected_index = pd.RangeIndex(0, 1) if method == "transform" else agg_index
+ expected_index = RangeIndex(0, 1) if method == "transform" else agg_index
expected = Series([df["c"].iloc[0]], index=expected_index, name="c").astype(dtype)
tm.assert_series_equal(result, expected)
@@ -1663,3 +1664,12 @@ def func(x):
msg = "length must not be 0"
with pytest.raises(ValueError, match=msg):
df.groupby("A", observed=False).agg(func)
+
+
+def test_agg_groups_returns_rangeindex():
+ df = DataFrame({"group": [1, 1, 2], "value": [1, 2, 3]})
+ result = df.groupby("group").agg(max)
+ expected = DataFrame(
+ [2, 3], index=RangeIndex(1, 3, name="group"), columns=["value"]
+ )
+ tm.assert_frame_equal(result, expected, check_index_type=True)
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index be8f5d73fe7e8..4e5da6494a5a8 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -46,9 +46,7 @@ def test_groupby_nonobject_dtype(multiindex_dataframe_random_data):
result = grouped.sum()
expected = multiindex_dataframe_random_data.groupby(key.astype("O")).sum()
- assert result.index.dtype == np.int8
- assert expected.index.dtype == np.int64
- tm.assert_frame_equal(result, expected, check_index_type=False)
+ tm.assert_frame_equal(result, expected, check_index_type=True)
def test_groupby_nonobject_dtype_mixed():
@@ -2955,3 +2953,12 @@ def test_groupby_dropna_with_nunique_unique():
)
tm.assert_frame_equal(result, expected)
+
+
+def test_groupby_groups_returns_rangeindex():
+ df = DataFrame({"group": [1, 1, 2], "value": [1, 2, 3]})
+ result = df.groupby("group").max()
+ expected = DataFrame(
+ [2, 3], index=RangeIndex(1, 3, name="group"), columns=["value"]
+ )
+ tm.assert_frame_equal(result, expected, check_index_type=True)
diff --git a/pandas/tests/groupby/test_reductions.py b/pandas/tests/groupby/test_reductions.py
index edc94b2beeec1..9923d4ec4dbf7 100644
--- a/pandas/tests/groupby/test_reductions.py
+++ b/pandas/tests/groupby/test_reductions.py
@@ -258,9 +258,12 @@ def test_idxmin_idxmax_extremes(how, any_real_numpy_dtype):
)
gb = df.groupby("a")
result = getattr(gb, how)()
- expected = DataFrame(
- {"b": [1, 0]}, index=pd.Index([1, 2], name="a", dtype=any_real_numpy_dtype)
+ exp_idx = (
+ pd.Index([1, 2], name="a", dtype=any_real_numpy_dtype)
+ if "float" in any_real_numpy_dtype
+ else pd.RangeIndex(range(1, 3), name="a")
)
+ expected = DataFrame({"b": [1, 0]}, index=exp_idx)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index 245fb9c7babd7..2a08e1111232f 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -13,6 +13,7 @@
DataFrame,
Index,
MultiIndex,
+ RangeIndex,
Series,
Timestamp,
concat,
@@ -290,7 +291,7 @@ def test_transform_casting():
),
"DATETIME": pd.to_datetime([f"2014-10-08 {time}" for time in times]),
},
- index=pd.RangeIndex(11, name="idx"),
+ index=RangeIndex(11, name="idx"),
)
result = df.groupby("ID3")["DATETIME"].transform(lambda x: x.diff())
@@ -1535,3 +1536,10 @@ def test_transform_sum_one_column_with_matching_labels_and_missing_labels():
result = df.groupby(series, as_index=False).transform("sum")
expected = DataFrame({"X": [-93203.0, -93203.0, np.nan]})
tm.assert_frame_equal(result, expected)
+
+
+def test_transform_groups_returns_rangeindex():
+ df = DataFrame({"group": [1, 1, 2], "value": [1, 2, 3]})
+ result = df.groupby("group").transform(lambda x: x + 1)
+ expected = DataFrame([2, 3, 4], index=RangeIndex(0, 3), columns=["value"])
+ tm.assert_frame_equal(result, expected, check_index_type=True)
diff --git a/pandas/tests/resample/test_resampler_grouper.py b/pandas/tests/resample/test_resampler_grouper.py
index b312d708ade1e..67860fde89a97 100644
--- a/pandas/tests/resample/test_resampler_grouper.py
+++ b/pandas/tests/resample/test_resampler_grouper.py
@@ -3,8 +3,6 @@
import numpy as np
import pytest
-from pandas.compat import is_platform_windows
-
import pandas as pd
from pandas import (
DataFrame,
@@ -587,14 +585,12 @@ def test_resample_no_columns():
)
expected = DataFrame(
index=pd.MultiIndex(
- levels=[np.array([0, 1], dtype=np.intp), index],
+ levels=[range(2), index],
codes=[[0, 0, 0, 1], [0, 1, 2, 3]],
names=[None, "date"],
)
)
-
- # GH#52710 - Index comes out as 32-bit on 64-bit Windows
- tm.assert_frame_equal(result, expected, check_index_type=not is_platform_windows())
+ tm.assert_frame_equal(result, expected)
def test_groupby_resample_size_all_index_same():
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 2ccb622c7a250..3d1a16c6d82a8 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -20,6 +20,7 @@
Grouper,
Index,
MultiIndex,
+ RangeIndex,
Series,
concat,
date_range,
@@ -424,12 +425,10 @@ def test_pivot_no_values(self):
res = df.pivot_table(index=df.index.month, columns=df.index.day)
exp_columns = MultiIndex.from_tuples([("A", 1), ("A", 2)])
- exp_columns = exp_columns.set_levels(
- exp_columns.levels[1].astype(np.int32), level=1
- )
+ exp_columns = exp_columns.set_levels(exp_columns.levels[1], level=1)
exp = DataFrame(
[[2.5, 4.0], [2.0, np.nan]],
- index=Index([1, 2], dtype=np.int32),
+ index=range(1, 3),
columns=exp_columns,
)
tm.assert_frame_equal(res, exp)
@@ -446,9 +445,7 @@ def test_pivot_no_values(self):
[["A"], pd.DatetimeIndex(["2011-01-31"], dtype="M8[ns]")],
names=[None, "dt"],
)
- exp = DataFrame(
- [3.25, 2.0], index=Index([1, 2], dtype=np.int32), columns=exp_columns
- )
+ exp = DataFrame([3.25, 2.0], index=range(1, 3), columns=exp_columns)
tm.assert_frame_equal(res, exp)
res = df.pivot_table(
@@ -1671,7 +1668,7 @@ def test_pivot_dtaccessor(self):
expected = DataFrame(
{7: [0.0, 3.0], 8: [1.0, 4.0], 9: [2.0, 5.0]},
index=exp_idx,
- columns=Index([7, 8, 9], dtype=np.int32, name="dt1"),
+ columns=RangeIndex(range(7, 10), name="dt1"),
)
tm.assert_frame_equal(result, expected)
@@ -1681,8 +1678,8 @@ def test_pivot_dtaccessor(self):
expected = DataFrame(
{7: [0.0, 3.0], 8: [1.0, 4.0], 9: [2.0, 5.0]},
- index=Index([1, 2], dtype=np.int32, name="dt2"),
- columns=Index([7, 8, 9], dtype=np.int32, name="dt1"),
+ index=RangeIndex(range(1, 3), name="dt2"),
+ columns=RangeIndex(range(7, 10), name="dt1"),
)
tm.assert_frame_equal(result, expected)
@@ -1693,11 +1690,12 @@ def test_pivot_dtaccessor(self):
values="value1",
)
- exp_col = MultiIndex.from_arrays(
- [
- np.array([7, 7, 8, 8, 9, 9], dtype=np.int32),
- np.array([1, 2] * 3, dtype=np.int32),
- ],
+ exp_col = MultiIndex(
+ levels=(
+ RangeIndex(start=7, stop=10, step=1, name="dt1"),
+ RangeIndex(start=1, stop=3, step=1, name="dt2"),
+ ),
+ codes=([0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]),
names=["dt1", "dt2"],
)
expected = DataFrame(
@@ -1737,8 +1735,7 @@ def test_daily(self):
for y in ts.index.year.unique().values:
mask = ts.index.year == y
expected[y] = Series(ts.values[mask], index=doy[mask])
- expected = DataFrame(expected, dtype=float).T
- expected.index = expected.index.astype(np.int32)
+ expected = DataFrame(expected, dtype=float, index=range(1, 367)).T
tm.assert_frame_equal(result, expected)
def test_monthly(self):
@@ -1753,8 +1750,7 @@ def test_monthly(self):
for y in ts.index.year.unique().values:
mask = ts.index.year == y
expected[y] = Series(ts.values[mask], index=month[mask])
- expected = DataFrame(expected, dtype=float).T
- expected.index = expected.index.astype(np.int32)
+ expected = DataFrame(expected, dtype=float, index=range(1, 13)).T
tm.assert_frame_equal(result, expected)
def test_pivot_table_with_iterator_values(self, data):
| Discovered in #57441 | https://api.github.com/repos/pandas-dev/pandas/pulls/58117 | 2024-04-02T17:11:16Z | 2024-04-09T17:33:12Z | null | 2024-04-09T17:33:17Z |
Add note for name field in groupby | diff --git a/doc/source/user_guide/groupby.rst b/doc/source/user_guide/groupby.rst
index 7f957a8b16787..8c222aff52fd7 100644
--- a/doc/source/user_guide/groupby.rst
+++ b/doc/source/user_guide/groupby.rst
@@ -416,6 +416,12 @@ You can also include the grouping columns if you want to operate on them.
grouped[["A", "B"]].sum()
+.. note::
+
+ The ``groupby`` operation in Pandas drops the ``name`` field of the columns Index object
+ after the operation. This change ensures consistency in syntax between different
+ column selection methods within groupby operations.
+
.. _groupby.iterating-label:
Iterating through groups
| - [x] closes #58024
- [N/A] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [N/A] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [N/A] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58114 | 2024-04-02T02:53:32Z | 2024-04-02T18:18:58Z | 2024-04-02T18:18:58Z | 2024-04-02T19:25:27Z |
Pixee branch | diff --git a/.github/pixeebot.yaml b/.github/pixeebot.yaml
new file mode 100644
index 0000000000000..90590a58f907c
--- /dev/null
+++ b/.github/pixeebot.yaml
@@ -0,0 +1,32 @@
+name: Format Pixeebot PRs
+
+on:
+ pull_request:
+ types: [opened, synchronize]
+
+jobs:
+ apply-black:
+ if: github.event.pull_request.user.login == 'pixeebot[bot]'
+ runs-on: ubuntu-latest
+ permissions:
+ contents: write
+
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: "3.12"
+
+ - name: Install black
+ run: pip install black
+
+ - name: Apply black formatting
+ run: black .
+
+ - name: Commit and push changes
+ uses: stefanzweifel/git-auto-commit-action@v5
+ with:
+ commit_message: ":art: Apply formatting"
diff --git a/README.md b/README.md
index e5329d66c2d89..c36d29dc1903e 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,6 @@
+
+WOOOOHHHHOOOOO
+
<picture align="center">
<source media="(prefers-color-scheme: dark)" srcset="https://pandas.pydata.org/static/img/pandas_white.svg">
<img alt="Pandas Logo" src="https://pandas.pydata.org/static/img/pandas.svg">
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58112 | 2024-04-01T20:45:31Z | 2024-04-01T20:47:25Z | null | 2024-04-01T20:47:25Z |
Pixee branch | diff --git a/README.md b/README.md
index e5329d66c2d89..6672193e06b8f 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+
<picture align="center">
<source media="(prefers-color-scheme: dark)" srcset="https://pandas.pydata.org/static/img/pandas_white.svg">
<img alt="Pandas Logo" src="https://pandas.pydata.org/static/img/pandas.svg">
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58111 | 2024-04-01T20:34:08Z | 2024-04-01T20:43:09Z | null | 2024-04-01T20:43:09Z |
DEPR: rename startingMonth to starting_month (argument in BQuarterBegin) | null | https://api.github.com/repos/pandas-dev/pandas/pulls/58109 | 2024-04-01T18:37:14Z | 2024-04-01T18:37:30Z | null | 2024-04-01T18:39:48Z | |
BUG: Remove "Mean of empty slice" warning in nanmedian | diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index a124e8679ae8e..2bc5f031ce69d 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -745,6 +745,10 @@ def nanmedian(values, *, axis: AxisInt | None = None, skipna: bool = True, mask=
>>> s = pd.Series([1, np.nan, 2, 2])
>>> nanops.nanmedian(s.values)
2.0
+
+ >>> s = pd.Series([np.nan, np.nan, np.nan])
+ >>> nanops.nanmedian(s.values)
+ nan
"""
# for floats without mask, the data already uses NaN as missing value
# indicator, and `mask` will be calculated from that below -> in those
@@ -763,6 +767,7 @@ def get_median(x, _mask=None):
warnings.filterwarnings(
"ignore", "All-NaN slice encountered", RuntimeWarning
)
+ warnings.filterwarnings("ignore", "Mean of empty slice", RuntimeWarning)
res = np.nanmedian(x[_mask])
return res
| This PR supresses a warning when calculating the `median` of a `pd.Series` that is full of `NA`s. The warning is just letting you know that `numpy` got an empty array but correctly returns `np.nan`.
The warning is issued as follows:
1. When the series has `NA`s and you try to calculate the `median`, `nanops.nanmedian` is called.
2. When the array is full of NAs, the `_mask` in `nanops.nanmedian.get_median` is all `False`, so `np.nanmedian(x[_mask])` gets an empty array.
3. `np.nanmedian` calls `numpy.lib.nanfunctions._nanmedian` which has a short-circuit path when the array is empty [[ref](https://github.com/numpy/numpy/blob/1c8b03bf2c87f081eea211a5061e423285c548af/numpy/lib/_nanfunctions_impl.py#L1215-L1216)].
4. This path calls `np.nanmean`. This creates an empty mask [[ref](https://github.com/numpy/numpy/blob/1c8b03bf2c87f081eea211a5061e423285c548af/numpy/lib/_nanfunctions_impl.py#L1033)] because the array is empty.
5. Then, the sum of the negated mask is used as the denominator of the `mean`, which causes the result to be `np.nan` (correct!).
6. The method issues a warning because the array was empty.
Another way to solve this would be to change `get_median` to explicitly return `np.nan` before the call to `np.nanmedian`, but that would involve tampering with the condition in the if, which has no comments so I'm unsure if changing it makes sense.
```python
def get_median(x, _mask=None):
if _mask is None:
_mask = notna(x)
else:
_mask = ~_mask
all_na = _mask.all()
if (not skipna and not all_na) or all_na:
return np.nan
with warnings.catch_warnings():
# Suppress RuntimeWarning about All-NaN slice
warnings.filterwarnings(
"ignore", "All-NaN slice encountered", RuntimeWarning
)
res = np.nanmedian(x[_mask])
return res
```
which simplifies to `if skipna: return np.nan` I think.
I haven't added tests nor ensured all of the below passed not added comments because I want to ensure this is the preferred solution. Otherwise, I can edit `get_median`. Let me know!
---
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58107 | 2024-04-01T18:21:54Z | 2024-04-01T22:40:49Z | 2024-04-01T22:40:49Z | 2024-04-01T22:40:55Z |
BUG: Timestamp.unit is now reflecting changes in components after Timestamp.replace | diff --git a/.circleci/config.yml b/.circleci/config.yml
index ea93575ac9430..6f134c9a7a7bd 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -72,10 +72,6 @@ jobs:
no_output_timeout: 30m # Sometimes the tests won't generate any output, make sure the job doesn't get killed by that
command: |
pip3 install cibuildwheel==2.15.0
- # When this is a nightly wheel build, allow picking up NumPy 2.0 dev wheels:
- if [[ "$IS_SCHEDULE_DISPATCH" == "true" || "$IS_PUSH" != 'true' ]]; then
- export CIBW_ENVIRONMENT="PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple"
- fi
cibuildwheel --prerelease-pythons --output-dir wheelhouse
environment:
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index 470c044d2e99e..d6cfd3b0ad257 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -148,18 +148,6 @@ jobs:
CIBW_PRERELEASE_PYTHONS: True
CIBW_BUILD: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
- - name: Build nightly wheels (with NumPy pre-release)
- if: ${{ (env.IS_SCHEDULE_DISPATCH == 'true' && env.IS_PUSH != 'true') }}
- uses: pypa/cibuildwheel@v2.17.0
- with:
- package-dir: ./dist/${{ startsWith(matrix.buildplat[1], 'macosx') && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
- env:
- # The nightly wheels should be build witht he NumPy 2.0 pre-releases
- # which requires the additional URL.
- CIBW_ENVIRONMENT: PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple
- CIBW_PRERELEASE_PYTHONS: True
- CIBW_BUILD: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
-
- name: Set up Python
uses: mamba-org/setup-micromamba@v1
with:
diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 0c4e6641444f1..f4ea0a1e2bc28 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -84,7 +84,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.assign SA01" \
-i "pandas.DataFrame.at_time PR01" \
-i "pandas.DataFrame.axes SA01" \
- -i "pandas.DataFrame.backfill PR01,SA01" \
-i "pandas.DataFrame.bfill SA01" \
-i "pandas.DataFrame.columns SA01" \
-i "pandas.DataFrame.copy SA01" \
@@ -104,7 +103,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.mean RT03,SA01" \
-i "pandas.DataFrame.median RT03,SA01" \
-i "pandas.DataFrame.min RT03" \
- -i "pandas.DataFrame.pad PR01,SA01" \
-i "pandas.DataFrame.plot PR02,SA01" \
-i "pandas.DataFrame.pop SA01" \
-i "pandas.DataFrame.prod RT03" \
@@ -119,7 +117,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.sparse.to_dense SA01" \
-i "pandas.DataFrame.std PR01,RT03,SA01" \
-i "pandas.DataFrame.sum RT03" \
- -i "pandas.DataFrame.swapaxes PR01,SA01" \
-i "pandas.DataFrame.swaplevel SA01" \
-i "pandas.DataFrame.to_feather SA01" \
-i "pandas.DataFrame.to_markdown SA01" \
@@ -127,9 +124,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.to_period SA01" \
-i "pandas.DataFrame.to_timestamp SA01" \
-i "pandas.DataFrame.tz_convert SA01" \
- -i "pandas.DataFrame.tz_localize SA01" \
- -i "pandas.DataFrame.unstack RT03" \
- -i "pandas.DataFrame.value_counts RT03" \
-i "pandas.DataFrame.var PR01,RT03,SA01" \
-i "pandas.DataFrame.where RT03" \
-i "pandas.DatetimeIndex.ceil SA01" \
@@ -226,7 +220,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Index.to_list RT03" \
-i "pandas.Index.union PR07,RT03,SA01" \
-i "pandas.Index.unique RT03" \
- -i "pandas.Index.value_counts RT03" \
-i "pandas.Index.view GL08" \
-i "pandas.Int16Dtype SA01" \
-i "pandas.Int32Dtype SA01" \
@@ -482,10 +475,7 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Series.to_timestamp RT03,SA01" \
-i "pandas.Series.truediv PR07" \
-i "pandas.Series.tz_convert SA01" \
- -i "pandas.Series.tz_localize SA01" \
- -i "pandas.Series.unstack SA01" \
-i "pandas.Series.update PR07,SA01" \
- -i "pandas.Series.value_counts RT03" \
-i "pandas.Series.var PR01,RT03,SA01" \
-i "pandas.Series.where RT03" \
-i "pandas.SparseDtype SA01" \
diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 15e85d0f90c5e..1f220c51d436c 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -338,6 +338,7 @@ Bug fixes
- Fixed bug in :meth:`Series.diff` allowing non-integer values for the ``periods`` argument. (:issue:`56607`)
- Fixed bug in :meth:`Series.rank` that doesn't preserve missing values for nullable integers when ``na_option='keep'``. (:issue:`56976`)
- Fixed bug in :meth:`Series.replace` and :meth:`DataFrame.replace` inconsistently replacing matching instances when ``regex=True`` and missing values are present. (:issue:`56599`)
+- Fixed bug in :meth:`Timestamp.replace` which was not reflecting the resulting changes in :meth:`Timestamp.unit`. (:issue:`57749`)
Categorical
^^^^^^^^^^^
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index d4cd90613ca5b..4c87132fbeeda 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -2439,10 +2439,12 @@ default 'raise'
datetime ts_input
tzinfo_type tzobj
_TSObject ts
+ NPY_DATETIMEUNIT rep_reso
# set to naive if needed
tzobj = self.tzinfo
value = self._value
+ rep_reso = self._creso
# GH 37610. Preserve fold when replacing.
if fold is None:
@@ -2466,40 +2468,54 @@ default 'raise'
if year is not None:
dts.year = validate("year", year)
+ rep_reso = NPY_DATETIMEUNIT.NPY_FR_Y
if month is not None:
dts.month = validate("month", month)
+ rep_reso = NPY_DATETIMEUNIT.NPY_FR_M
if day is not None:
dts.day = validate("day", day)
+ rep_reso = NPY_DATETIMEUNIT.NPY_FR_D
if hour is not None:
dts.hour = validate("hour", hour)
+ rep_reso = NPY_DATETIMEUNIT.NPY_FR_h
if minute is not None:
dts.min = validate("minute", minute)
+ rep_reso = NPY_DATETIMEUNIT.NPY_FR_m
if second is not None:
dts.sec = validate("second", second)
+ rep_reso = NPY_DATETIMEUNIT.NPY_FR_s
if microsecond is not None:
dts.us = validate("microsecond", microsecond)
+ if microsecond > 999:
+ rep_reso = NPY_DATETIMEUNIT.NPY_FR_us
+ else:
+ rep_reso = NPY_DATETIMEUNIT.NPY_FR_ms
if nanosecond is not None:
dts.ps = validate("nanosecond", nanosecond) * 1000
+ rep_reso = NPY_DATETIMEUNIT.NPY_FR_ns
if tzinfo is not object:
tzobj = tzinfo
+ if rep_reso < self._creso:
+ rep_reso = self._creso
+
# reconstruct & check bounds
if tzobj is None:
# We can avoid going through pydatetime paths, which is robust
# to datetimes outside of pydatetime range.
ts = _TSObject()
try:
- ts.value = npy_datetimestruct_to_datetime(self._creso, &dts)
+ ts.value = npy_datetimestruct_to_datetime(rep_reso, &dts)
except OverflowError as err:
fmt = dts_to_iso_string(&dts)
raise OutOfBoundsDatetime(
f"Out of bounds timestamp: {fmt} with frequency '{self.unit}'"
) from err
ts.dts = dts
- ts.creso = self._creso
+ ts.creso = rep_reso
ts.fold = fold
return create_timestamp_from_ts(
- ts.value, dts, tzobj, fold, reso=self._creso
+ ts.value, dts, tzobj, fold, reso=rep_reso
)
elif tzobj is not None and treat_tz_as_pytz(tzobj):
@@ -2518,10 +2534,10 @@ default 'raise'
ts_input = datetime(**kwargs)
ts = convert_datetime_to_tsobject(
- ts_input, tzobj, nanos=dts.ps // 1000, reso=self._creso
+ ts_input, tzobj, nanos=dts.ps // 1000, reso=rep_reso
)
return create_timestamp_from_ts(
- ts.value, dts, tzobj, fold, reso=self._creso
+ ts.value, dts, tzobj, fold, reso=rep_reso
)
def to_julian_date(self) -> np.float64:
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 263265701691b..f923106e967b7 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -924,6 +924,7 @@ def value_counts(
Returns
-------
Series
+ Series containing counts of unique values.
See Also
--------
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 50a93994dc76b..4715164a4208a 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7162,7 +7162,7 @@ def value_counts(
dropna: bool = True,
) -> Series:
"""
- Return a Series containing the frequency of each distinct row in the Dataframe.
+ Return a Series containing the frequency of each distinct row in the DataFrame.
Parameters
----------
@@ -7175,13 +7175,14 @@ def value_counts(
ascending : bool, default False
Sort in ascending order.
dropna : bool, default True
- Don't include counts of rows that contain NA values.
+ Do not include counts of rows that contain NA values.
.. versionadded:: 1.3.0
Returns
-------
Series
+ Series containing the frequency of each distinct row in the DataFrame.
See Also
--------
@@ -7192,8 +7193,8 @@ def value_counts(
The returned Series will have a MultiIndex with one level per input
column but an Index (non-multi) for a single label. By default, rows
that contain any NA values are omitted from the result. By default,
- the resulting Series will be in descending order so that the first
- element is the most frequently-occurring row.
+ the resulting Series will be sorted by frequencies in descending order so that
+ the first element is the most frequently-occurring row.
Examples
--------
@@ -9658,6 +9659,8 @@ def unstack(
Returns
-------
Series or DataFrame
+ If index is a MultiIndex: DataFrame with pivoted index labels as new
+ inner-most level column labels, else Series.
See Also
--------
@@ -11494,7 +11497,7 @@ def any(
**kwargs,
) -> Series | bool: ...
- @doc(make_doc("any", ndim=2))
+ @doc(make_doc("any", ndim=1))
def any(
self,
*,
@@ -11540,7 +11543,7 @@ def all(
**kwargs,
) -> Series | bool: ...
- @doc(make_doc("all", ndim=2))
+ @doc(make_doc("all", ndim=1))
def all(
self,
axis: Axis | None = 0,
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 858d2ba82a969..bfee4ced2b3d8 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -10485,10 +10485,10 @@ def tz_localize(
nonexistent: TimeNonexistent = "raise",
) -> Self:
"""
- Localize tz-naive index of a Series or DataFrame to target time zone.
+ Localize time zone naive index of a Series or DataFrame to target time zone.
This operation localizes the Index. To localize the values in a
- timezone-naive Series, use :meth:`Series.dt.tz_localize`.
+ time zone naive Series, use :meth:`Series.dt.tz_localize`.
Parameters
----------
@@ -10548,13 +10548,19 @@ def tz_localize(
Returns
-------
{klass}
- Same type as the input.
+ Same type as the input, with time zone naive or aware index, depending on
+ ``tz``.
Raises
------
TypeError
If the TimeSeries is tz-aware and tz is not None.
+ See Also
+ --------
+ Series.dt.tz_localize: Localize the values in a time zone naive Series.
+ Timestamp.tz_localize: Localize the Timestamp to a timezone.
+
Examples
--------
Localize local times:
@@ -11712,7 +11718,7 @@ def last_valid_index(self) -> Hashable:
skipna : bool, default True
Exclude NA/null values when computing the result.
numeric_only : bool, default False
- Include only float, int, boolean columns. Not implemented for Series.
+ Include only float, int, boolean columns.
{min_count}\
**kwargs
@@ -11881,9 +11887,9 @@ def last_valid_index(self) -> Hashable:
Returns
-------
-{name1} or {name2}
- If level is specified, then, {name2} is returned; otherwise, {name1}
- is returned.
+{name2} or {name1}
+ If axis=None, then a scalar boolean is returned.
+ Otherwise a Series is returned with index matching the index argument.
{see_also}
{examples}"""
diff --git a/pandas/core/series.py b/pandas/core/series.py
index b0dc05fce7913..843788273a6ef 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -4257,6 +4257,10 @@ def unstack(
DataFrame
Unstacked Series.
+ See Also
+ --------
+ DataFrame.unstack : Pivot the MultiIndex of a DataFrame.
+
Notes
-----
Reference :ref:`the user guide <reshaping.stacking>` for more examples.
diff --git a/pandas/io/html.py b/pandas/io/html.py
index b4f6a5508726b..42f5266e7649b 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -584,14 +584,8 @@ class _BeautifulSoupHtml5LibFrameParser(_HtmlFrameParser):
:class:`pandas.io.html._HtmlFrameParser`.
"""
- def __init__(self, *args, **kwargs) -> None:
- super().__init__(*args, **kwargs)
- from bs4 import SoupStrainer
-
- self._strainer = SoupStrainer("table")
-
def _parse_tables(self, document, match, attrs):
- element_name = self._strainer.name
+ element_name = "table"
tables = document.find_all(element_name, attrs=attrs)
if not tables:
raise ValueError("No tables found")
diff --git a/pandas/tests/scalar/timestamp/methods/test_replace.py b/pandas/tests/scalar/timestamp/methods/test_replace.py
index d67de79a8dd10..70ab1a7580bda 100644
--- a/pandas/tests/scalar/timestamp/methods/test_replace.py
+++ b/pandas/tests/scalar/timestamp/methods/test_replace.py
@@ -189,3 +189,13 @@ def test_replace_preserves_fold(self, fold):
ts_replaced = ts.replace(second=1)
assert ts_replaced.fold == fold
+
+ def test_replace_unit(self):
+ # GH#57749
+ ts = Timestamp("2023-07-15 23:08:12")
+ ts1 = Timestamp("2023-07-15 23:08:12.134567")
+ ts2 = Timestamp("2023-07-15 23:08:12.134567123")
+ ts = ts.replace(microsecond=ts1.microsecond)
+ assert ts == ts1
+ ts = ts.replace(nanosecond=ts2.nanosecond)
+ assert ts == ts2
diff --git a/pyproject.toml b/pyproject.toml
index 5f5b013ca8461..259d003de92d5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -152,6 +152,9 @@ setup = ['--vsenv'] # For Windows
skip = "cp36-* cp37-* cp38-* pp* *_i686 *_ppc64le *_s390x"
build-verbosity = "3"
environment = {LDFLAGS="-Wl,--strip-all"}
+# TODO: remove this once numpy 2.0 proper releases
+# and specify numpy 2.0 as a dependency in [build-system] requires in pyproject.toml
+before-build = "pip install numpy==2.0.0rc1"
test-requires = "hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0"
test-command = """
PANDAS_CI='1' python -c 'import pandas as pd; \
@@ -160,7 +163,9 @@ test-command = """
"""
[tool.cibuildwheel.windows]
-before-build = "pip install delvewheel"
+# TODO: remove this once numpy 2.0 proper releases
+# and specify numpy 2.0 as a dependency in [build-system] requires in pyproject.toml
+before-build = "pip install delvewheel numpy==2.0.0rc1"
repair-wheel-command = "delvewheel repair -w {dest_dir} {wheel}"
[[tool.cibuildwheel.overrides]]
| Sorry for the inconvenience. Closed because of a hiccup with the commits. I'll open another requesting the same changes soon. | https://api.github.com/repos/pandas-dev/pandas/pulls/58106 | 2024-04-01T18:03:13Z | 2024-04-01T21:00:07Z | null | 2024-04-01T21:20:51Z |
Backport PR #58087 on branch 2.2.x (BLD: Build wheels using numpy 2.0rc1) | diff --git a/.circleci/config.yml b/.circleci/config.yml
index ea93575ac9430..6f134c9a7a7bd 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -72,10 +72,6 @@ jobs:
no_output_timeout: 30m # Sometimes the tests won't generate any output, make sure the job doesn't get killed by that
command: |
pip3 install cibuildwheel==2.15.0
- # When this is a nightly wheel build, allow picking up NumPy 2.0 dev wheels:
- if [[ "$IS_SCHEDULE_DISPATCH" == "true" || "$IS_PUSH" != 'true' ]]; then
- export CIBW_ENVIRONMENT="PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple"
- fi
cibuildwheel --prerelease-pythons --output-dir wheelhouse
environment:
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index 470c044d2e99e..d6cfd3b0ad257 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -148,18 +148,6 @@ jobs:
CIBW_PRERELEASE_PYTHONS: True
CIBW_BUILD: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
- - name: Build nightly wheels (with NumPy pre-release)
- if: ${{ (env.IS_SCHEDULE_DISPATCH == 'true' && env.IS_PUSH != 'true') }}
- uses: pypa/cibuildwheel@v2.17.0
- with:
- package-dir: ./dist/${{ startsWith(matrix.buildplat[1], 'macosx') && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
- env:
- # The nightly wheels should be build witht he NumPy 2.0 pre-releases
- # which requires the additional URL.
- CIBW_ENVIRONMENT: PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple
- CIBW_PRERELEASE_PYTHONS: True
- CIBW_BUILD: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
-
- name: Set up Python
uses: mamba-org/setup-micromamba@v1
with:
diff --git a/pyproject.toml b/pyproject.toml
index c225ed80dcb10..375ff72250f26 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -156,6 +156,9 @@ setup = ['--vsenv'] # For Windows
skip = "cp36-* cp37-* cp38-* pp* *_i686 *_ppc64le *_s390x"
build-verbosity = "3"
environment = {LDFLAGS="-Wl,--strip-all"}
+# TODO: remove this once numpy 2.0 proper releases
+# and specify numpy 2.0 as a dependency in [build-system] requires in pyproject.toml
+before-build = "pip install numpy==2.0.0rc1"
test-requires = "hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0"
test-command = """
PANDAS_CI='1' python -c 'import pandas as pd; \
@@ -164,7 +167,9 @@ test-command = """
"""
[tool.cibuildwheel.windows]
-before-build = "pip install delvewheel"
+# TODO: remove this once numpy 2.0 proper releases
+# and specify numpy 2.0 as a dependency in [build-system] requires in pyproject.toml
+before-build = "pip install delvewheel numpy==2.0.0rc1"
repair-wheel-command = "delvewheel repair -w {dest_dir} {wheel}"
[[tool.cibuildwheel.overrides]]
| Backport PR #58087: BLD: Build wheels using numpy 2.0rc1 | https://api.github.com/repos/pandas-dev/pandas/pulls/58105 | 2024-04-01T17:37:14Z | 2024-04-09T22:40:19Z | 2024-04-09T22:40:19Z | 2024-04-09T22:40:20Z |
[pre-commit.ci] pre-commit autoupdate | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 41f1c4c6892a3..b8726e058a52b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -19,7 +19,7 @@ ci:
skip: [pylint, pyright, mypy]
repos:
- repo: https://github.com/astral-sh/ruff-pre-commit
- rev: v0.3.1
+ rev: v0.3.4
hooks:
- id: ruff
args: [--exit-non-zero-on-fix]
@@ -39,7 +39,7 @@ repos:
- id: ruff-format
exclude: ^scripts
- repo: https://github.com/jendrikseipp/vulture
- rev: 'v2.10'
+ rev: 'v2.11'
hooks:
- id: vulture
entry: python scripts/run_vulture.py
@@ -93,11 +93,11 @@ repos:
args: [--disable=all, --enable=redefined-outer-name]
stages: [manual]
- repo: https://github.com/PyCQA/isort
- rev: 5.12.0
+ rev: 5.13.2
hooks:
- id: isort
- repo: https://github.com/asottile/pyupgrade
- rev: v3.15.0
+ rev: v3.15.2
hooks:
- id: pyupgrade
args: [--py39-plus]
@@ -116,7 +116,7 @@ repos:
hooks:
- id: sphinx-lint
- repo: https://github.com/pre-commit/mirrors-clang-format
- rev: v17.0.6
+ rev: v18.1.2
hooks:
- id: clang-format
files: ^pandas/_libs/src|^pandas/_libs/include
| <!--pre-commit.ci start-->
updates:
- [github.com/astral-sh/ruff-pre-commit: v0.3.1 → v0.3.4](https://github.com/astral-sh/ruff-pre-commit/compare/v0.3.1...v0.3.4)
- [github.com/jendrikseipp/vulture: v2.10 → v2.11](https://github.com/jendrikseipp/vulture/compare/v2.10...v2.11)
- [github.com/pylint-dev/pylint: v3.0.1 → v3.1.0](https://github.com/pylint-dev/pylint/compare/v3.0.1...v3.1.0)
- [github.com/PyCQA/isort: 5.12.0 → 5.13.2](https://github.com/PyCQA/isort/compare/5.12.0...5.13.2)
- [github.com/asottile/pyupgrade: v3.15.0 → v3.15.2](https://github.com/asottile/pyupgrade/compare/v3.15.0...v3.15.2)
- [github.com/pre-commit/mirrors-clang-format: v17.0.6 → v18.1.2](https://github.com/pre-commit/mirrors-clang-format/compare/v17.0.6...v18.1.2)
<!--pre-commit.ci end--> | https://api.github.com/repos/pandas-dev/pandas/pulls/58103 | 2024-04-01T16:29:30Z | 2024-04-01T20:45:20Z | 2024-04-01T20:45:20Z | 2024-04-01T20:45:23Z |
DOC: Fix docstring error for pandas.DataFrame.axes | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 76df5c82e6239..c176532c8269d 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -995,6 +995,11 @@ def axes(self) -> list[Index]:
It has the row axis labels and column axis labels as the only members.
They are returned in that order.
+ See Also
+ --------
+ DataFrame.index: The index (row labels) of the DataFrame.
+ DataFrame.columns: The column labels of the DataFrame.
+
Examples
--------
>>> df = pd.DataFrame({"col1": [1, 2], "col2": [3, 4]})
| - Fixes docstring error for pandas.DataFrame.axes method (https://github.com/pandas-dev/pandas/issues/58065).
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58102 | 2024-04-01T13:59:02Z | 2024-04-11T16:59:32Z | null | 2024-04-11T16:59:33Z |
DOC: fix docstring for DataFrame.to_period, pandas.DataFrame.to_timestamp, pandas.DataFrame.tz_convert #58065 | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index f4ea0a1e2bc28..49f93a8589ac4 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -121,9 +121,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.to_feather SA01" \
-i "pandas.DataFrame.to_markdown SA01" \
-i "pandas.DataFrame.to_parquet RT03" \
- -i "pandas.DataFrame.to_period SA01" \
- -i "pandas.DataFrame.to_timestamp SA01" \
- -i "pandas.DataFrame.tz_convert SA01" \
-i "pandas.DataFrame.var PR01,RT03,SA01" \
-i "pandas.DataFrame.where RT03" \
-i "pandas.DatetimeIndex.ceil SA01" \
@@ -470,11 +467,8 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Series.to_frame SA01" \
-i "pandas.Series.to_list RT03" \
-i "pandas.Series.to_markdown SA01" \
- -i "pandas.Series.to_period SA01" \
-i "pandas.Series.to_string SA01" \
- -i "pandas.Series.to_timestamp RT03,SA01" \
-i "pandas.Series.truediv PR07" \
- -i "pandas.Series.tz_convert SA01" \
-i "pandas.Series.update PR07,SA01" \
-i "pandas.Series.var PR01,RT03,SA01" \
-i "pandas.Series.where RT03" \
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 4715164a4208a..66a68755a2a09 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -12482,7 +12482,9 @@ def to_timestamp(
copy: bool | lib.NoDefault = lib.no_default,
) -> DataFrame:
"""
- Cast to DatetimeIndex of timestamps, at *beginning* of period.
+ Cast PeriodIndex to DatetimeIndex of timestamps, at *beginning* of period.
+
+ This can be changed to the *end* of the period, by specifying `how="e"`.
Parameters
----------
@@ -12512,8 +12514,13 @@ def to_timestamp(
Returns
-------
- DataFrame
- The DataFrame has a DatetimeIndex.
+ DataFrame with DatetimeIndex
+ DataFrame with the PeriodIndex cast to DatetimeIndex.
+
+ See Also
+ --------
+ DataFrame.to_period: Inverse method to cast DatetimeIndex to PeriodIndex.
+ Series.to_timestamp: Equivalent method for Series.
Examples
--------
@@ -12569,7 +12576,8 @@ def to_period(
Convert DataFrame from DatetimeIndex to PeriodIndex.
Convert DataFrame from DatetimeIndex to PeriodIndex with desired
- frequency (inferred from index if not passed).
+ frequency (inferred from index if not passed). Either index of columns can be
+ converted, depending on `axis` argument.
Parameters
----------
@@ -12597,7 +12605,12 @@ def to_period(
Returns
-------
DataFrame
- The DataFrame has a PeriodIndex.
+ The DataFrame with the converted PeriodIndex.
+
+ See Also
+ --------
+ Series.to_period: Equivalent method for Series.
+ Series.dt.to_period: Convert DateTime column values.
Examples
--------
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index bfee4ced2b3d8..13fa28003f775 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -10423,6 +10423,11 @@ def tz_convert(
TypeError
If the axis is tz-naive.
+ See Also
+ --------
+ DataFrame.tz_localize: Localize tz-naive index of DataFrame to target time zone.
+ Series.tz_localize: Localize tz-naive index of Series to target time zone.
+
Examples
--------
Change to another time zone:
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 843788273a6ef..ba04013749637 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -5648,6 +5648,8 @@ def to_timestamp(
"""
Cast to DatetimeIndex of Timestamps, at *beginning* of period.
+ This can be changed to the *end* of the period, by specifying `how="e"`.
+
Parameters
----------
freq : str, default frequency of PeriodIndex
@@ -5675,6 +5677,12 @@ def to_timestamp(
Returns
-------
Series with DatetimeIndex
+ Series with the PeriodIndex cast to DatetimeIndex.
+
+ See Also
+ --------
+ Series.to_period: Inverse method to cast DatetimeIndex to PeriodIndex.
+ DataFrame.to_timestamp: Equivalent method for DataFrame.
Examples
--------
@@ -5748,6 +5756,11 @@ def to_period(
Series
Series with index converted to PeriodIndex.
+ See Also
+ --------
+ DataFrame.to_period: Equivalent method for DataFrame.
+ Series.dt.to_period: Convert DateTime column values.
+
Examples
--------
>>> idx = pd.DatetimeIndex(["2023", "2024", "2025"])
| Fixes docstring errorrs for DataFrame and Series for methods `pandas.DataFrame.to_period` ,`pandas.DataFrame.to_timestamp` ,`pandas.DataFrame.tz_convert`. (issue #58065)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58101 | 2024-04-01T13:39:31Z | 2024-04-01T18:54:45Z | 2024-04-01T18:54:44Z | 2024-04-01T18:54:51Z |
MNT: fix compatibility with beautifulsoup4 4.13.0b2 | diff --git a/pandas/io/html.py b/pandas/io/html.py
index b4f6a5508726b..42f5266e7649b 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -584,14 +584,8 @@ class _BeautifulSoupHtml5LibFrameParser(_HtmlFrameParser):
:class:`pandas.io.html._HtmlFrameParser`.
"""
- def __init__(self, *args, **kwargs) -> None:
- super().__init__(*args, **kwargs)
- from bs4 import SoupStrainer
-
- self._strainer = SoupStrainer("table")
-
def _parse_tables(self, document, match, attrs):
- element_name = self._strainer.name
+ element_name = "table"
tables = document.find_all(element_name, attrs=attrs)
if not tables:
raise ValueError("No tables found")
| Closes #58086
- [x] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58100 | 2024-04-01T12:26:18Z | 2024-04-01T17:08:54Z | 2024-04-01T17:08:53Z | 2024-04-03T19:55:22Z |
DOC: Fix docstring errors for pandas.DataFrame.unstack, pandas.DataFrame.value_counts and pandas.DataFrame.tz_localize | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 0c4e6641444f1..a9f69ee4f6c57 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -127,9 +127,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.to_period SA01" \
-i "pandas.DataFrame.to_timestamp SA01" \
-i "pandas.DataFrame.tz_convert SA01" \
- -i "pandas.DataFrame.tz_localize SA01" \
- -i "pandas.DataFrame.unstack RT03" \
- -i "pandas.DataFrame.value_counts RT03" \
-i "pandas.DataFrame.var PR01,RT03,SA01" \
-i "pandas.DataFrame.where RT03" \
-i "pandas.DatetimeIndex.ceil SA01" \
@@ -226,7 +223,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Index.to_list RT03" \
-i "pandas.Index.union PR07,RT03,SA01" \
-i "pandas.Index.unique RT03" \
- -i "pandas.Index.value_counts RT03" \
-i "pandas.Index.view GL08" \
-i "pandas.Int16Dtype SA01" \
-i "pandas.Int32Dtype SA01" \
@@ -482,10 +478,7 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Series.to_timestamp RT03,SA01" \
-i "pandas.Series.truediv PR07" \
-i "pandas.Series.tz_convert SA01" \
- -i "pandas.Series.tz_localize SA01" \
- -i "pandas.Series.unstack SA01" \
-i "pandas.Series.update PR07,SA01" \
- -i "pandas.Series.value_counts RT03" \
-i "pandas.Series.var PR01,RT03,SA01" \
-i "pandas.Series.where RT03" \
-i "pandas.SparseDtype SA01" \
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 263265701691b..f923106e967b7 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -924,6 +924,7 @@ def value_counts(
Returns
-------
Series
+ Series containing counts of unique values.
See Also
--------
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 50a93994dc76b..abb8d13342c9d 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7162,7 +7162,7 @@ def value_counts(
dropna: bool = True,
) -> Series:
"""
- Return a Series containing the frequency of each distinct row in the Dataframe.
+ Return a Series containing the frequency of each distinct row in the DataFrame.
Parameters
----------
@@ -7175,13 +7175,14 @@ def value_counts(
ascending : bool, default False
Sort in ascending order.
dropna : bool, default True
- Don't include counts of rows that contain NA values.
+ Do not include counts of rows that contain NA values.
.. versionadded:: 1.3.0
Returns
-------
Series
+ Series containing the frequency of each distinct row in the DataFrame.
See Also
--------
@@ -7192,8 +7193,8 @@ def value_counts(
The returned Series will have a MultiIndex with one level per input
column but an Index (non-multi) for a single label. By default, rows
that contain any NA values are omitted from the result. By default,
- the resulting Series will be in descending order so that the first
- element is the most frequently-occurring row.
+ the resulting Series will be sorted by frequencies in descending order so that
+ the first element is the most frequently-occurring row.
Examples
--------
@@ -9658,6 +9659,8 @@ def unstack(
Returns
-------
Series or DataFrame
+ If index is a MultiIndex: DataFrame with pivoted index labels as new
+ inner-most level column labels, else Series.
See Also
--------
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 858d2ba82a969..ee1ce2f817b6c 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -10485,10 +10485,10 @@ def tz_localize(
nonexistent: TimeNonexistent = "raise",
) -> Self:
"""
- Localize tz-naive index of a Series or DataFrame to target time zone.
+ Localize time zone naive index of a Series or DataFrame to target time zone.
This operation localizes the Index. To localize the values in a
- timezone-naive Series, use :meth:`Series.dt.tz_localize`.
+ time zone naive Series, use :meth:`Series.dt.tz_localize`.
Parameters
----------
@@ -10548,13 +10548,19 @@ def tz_localize(
Returns
-------
{klass}
- Same type as the input.
+ Same type as the input, with time zone naive or aware index, depending on
+ ``tz``.
Raises
------
TypeError
If the TimeSeries is tz-aware and tz is not None.
+ See Also
+ --------
+ Series.dt.tz_localize: Localize the values in a time zone naive Series.
+ Timestamp.tz_localize: Localize the Timestamp to a timezone.
+
Examples
--------
Localize local times:
diff --git a/pandas/core/series.py b/pandas/core/series.py
index b0dc05fce7913..843788273a6ef 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -4257,6 +4257,10 @@ def unstack(
DataFrame
Unstacked Series.
+ See Also
+ --------
+ DataFrame.unstack : Pivot the MultiIndex of a DataFrame.
+
Notes
-----
Reference :ref:`the user guide <reshaping.stacking>` for more examples.
| - Fixes docstring erros for following methods (https://github.com/pandas-dev/pandas/issues/58065):
`pandas.DataFrame.unstack`, `pandas.DataFrame.value_counts` and `pandas.DataFrame.tz_localize`
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58097 | 2024-03-31T23:12:27Z | 2024-04-01T17:11:43Z | 2024-04-01T17:11:43Z | 2024-04-01T17:11:51Z |
Remove 'Not implemented for Series' from _num_doc in generic.py | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 858d2ba82a969..b5cdafeb57134 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -11712,7 +11712,7 @@ def last_valid_index(self) -> Hashable:
skipna : bool, default True
Exclude NA/null values when computing the result.
numeric_only : bool, default False
- Include only float, int, boolean columns. Not implemented for Series.
+ Include only float, int, boolean columns.
{min_count}\
**kwargs
| Documentation fix in `generic.py`
line 11715: Removed 'Not implemented for Series' in _num_doc given that `numeric_only` is now implemented for Series in all the methods min, max, mean, median, skew, kurt
- [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58096 | 2024-03-31T22:27:34Z | 2024-04-01T17:19:57Z | 2024-04-01T17:19:57Z | 2024-04-01T17:20:04Z |
DOC: read_sql_query docstring contraine wrong examples #58094 | diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index aa9d0d88ae69a..8c4c4bac884e5 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -473,8 +473,9 @@ def read_sql_query(
--------
>>> from sqlalchemy import create_engine # doctest: +SKIP
>>> engine = create_engine("sqlite:///database.db") # doctest: +SKIP
+ >>> sql_query = "SELECT int_column FROM test_data" # doctest: +SKIP
>>> with engine.connect() as conn, conn.begin(): # doctest: +SKIP
- ... data = pd.read_sql_table("data", conn) # doctest: +SKIP
+ ... data = pd.read_sql_query(sql_query, conn) # doctest: +SKIP
"""
check_dtype_backend(dtype_backend)
| - [x] closes #58094
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58095 | 2024-03-31T20:07:44Z | 2024-04-02T01:41:32Z | 2024-04-02T01:41:32Z | 2024-04-02T01:41:40Z |
Revert "BLD: Pin numpy on 2.2.x" | diff --git a/pyproject.toml b/pyproject.toml
index b2764b137a1f8..778146bbcd909 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,9 +27,9 @@ authors = [
license = {file = 'LICENSE'}
requires-python = '>=3.9'
dependencies = [
- "numpy>=1.22.4,<2; python_version<'3.11'",
- "numpy>=1.23.2,<2; python_version=='3.11'",
- "numpy>=1.26.0,<2; python_version>='3.12'",
+ "numpy>=1.22.4; python_version<'3.11'",
+ "numpy>=1.23.2; python_version=='3.11'",
+ "numpy>=1.26.0; python_version>='3.12'",
"python-dateutil>=2.8.2",
"pytz>=2020.1",
"tzdata>=2022.7"
| Reverts pandas-dev/pandas#56812
Waiting for #58087 to be merged and backported | https://api.github.com/repos/pandas-dev/pandas/pulls/58093 | 2024-03-31T15:06:52Z | 2024-04-03T17:28:27Z | 2024-04-03T17:28:27Z | 2024-04-03T17:28:30Z |
DOC: Changed ndim to 1, modified doc as suggested. #57088 | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 50a93994dc76b..932344ae91eab 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -11494,7 +11494,7 @@ def any(
**kwargs,
) -> Series | bool: ...
- @doc(make_doc("any", ndim=2))
+ @doc(make_doc("any", ndim=1))
def any(
self,
*,
@@ -11540,7 +11540,7 @@ def all(
**kwargs,
) -> Series | bool: ...
- @doc(make_doc("all", ndim=2))
+ @doc(make_doc("all", ndim=1))
def all(
self,
axis: Axis | None = 0,
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 858d2ba82a969..4b5a3b5ffdb40 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -11881,9 +11881,9 @@ def last_valid_index(self) -> Hashable:
Returns
-------
-{name1} or {name2}
- If level is specified, then, {name2} is returned; otherwise, {name1}
- is returned.
+{name2} or {name1}
+ If axis=None, then a scalar boolean is returned.
+ Otherwise a Series is returned with index matching the index argument.
{see_also}
{examples}"""
| - [ ] closes #57088 | https://api.github.com/repos/pandas-dev/pandas/pulls/58091 | 2024-03-31T01:28:35Z | 2024-04-01T17:32:02Z | 2024-04-01T17:32:02Z | 2024-04-01T17:32:08Z |
CI: Remove deprecated methods from code_checks.sh | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 0c4e6641444f1..3cdbbc2b93a01 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -84,7 +84,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.assign SA01" \
-i "pandas.DataFrame.at_time PR01" \
-i "pandas.DataFrame.axes SA01" \
- -i "pandas.DataFrame.backfill PR01,SA01" \
-i "pandas.DataFrame.bfill SA01" \
-i "pandas.DataFrame.columns SA01" \
-i "pandas.DataFrame.copy SA01" \
@@ -104,7 +103,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.mean RT03,SA01" \
-i "pandas.DataFrame.median RT03,SA01" \
-i "pandas.DataFrame.min RT03" \
- -i "pandas.DataFrame.pad PR01,SA01" \
-i "pandas.DataFrame.plot PR02,SA01" \
-i "pandas.DataFrame.pop SA01" \
-i "pandas.DataFrame.prod RT03" \
@@ -119,7 +117,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.sparse.to_dense SA01" \
-i "pandas.DataFrame.std PR01,RT03,SA01" \
-i "pandas.DataFrame.sum RT03" \
- -i "pandas.DataFrame.swapaxes PR01,SA01" \
-i "pandas.DataFrame.swaplevel SA01" \
-i "pandas.DataFrame.to_feather SA01" \
-i "pandas.DataFrame.to_markdown SA01" \
| - [ ] xref #58065
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58090 | 2024-03-31T00:22:21Z | 2024-04-01T17:27:25Z | 2024-04-01T17:27:25Z | 2024-04-01T17:27:31Z |
BLD: Build wheels using numpy 2.0rc1 | diff --git a/.circleci/config.yml b/.circleci/config.yml
index ea93575ac9430..6f134c9a7a7bd 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -72,10 +72,6 @@ jobs:
no_output_timeout: 30m # Sometimes the tests won't generate any output, make sure the job doesn't get killed by that
command: |
pip3 install cibuildwheel==2.15.0
- # When this is a nightly wheel build, allow picking up NumPy 2.0 dev wheels:
- if [[ "$IS_SCHEDULE_DISPATCH" == "true" || "$IS_PUSH" != 'true' ]]; then
- export CIBW_ENVIRONMENT="PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple"
- fi
cibuildwheel --prerelease-pythons --output-dir wheelhouse
environment:
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index 470c044d2e99e..d6cfd3b0ad257 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -148,18 +148,6 @@ jobs:
CIBW_PRERELEASE_PYTHONS: True
CIBW_BUILD: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
- - name: Build nightly wheels (with NumPy pre-release)
- if: ${{ (env.IS_SCHEDULE_DISPATCH == 'true' && env.IS_PUSH != 'true') }}
- uses: pypa/cibuildwheel@v2.17.0
- with:
- package-dir: ./dist/${{ startsWith(matrix.buildplat[1], 'macosx') && env.sdist_name || needs.build_sdist.outputs.sdist_file }}
- env:
- # The nightly wheels should be build witht he NumPy 2.0 pre-releases
- # which requires the additional URL.
- CIBW_ENVIRONMENT: PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple
- CIBW_PRERELEASE_PYTHONS: True
- CIBW_BUILD: ${{ matrix.python[0] }}-${{ matrix.buildplat[1] }}
-
- name: Set up Python
uses: mamba-org/setup-micromamba@v1
with:
diff --git a/pyproject.toml b/pyproject.toml
index 5f5b013ca8461..259d003de92d5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -152,6 +152,9 @@ setup = ['--vsenv'] # For Windows
skip = "cp36-* cp37-* cp38-* pp* *_i686 *_ppc64le *_s390x"
build-verbosity = "3"
environment = {LDFLAGS="-Wl,--strip-all"}
+# TODO: remove this once numpy 2.0 proper releases
+# and specify numpy 2.0 as a dependency in [build-system] requires in pyproject.toml
+before-build = "pip install numpy==2.0.0rc1"
test-requires = "hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0"
test-command = """
PANDAS_CI='1' python -c 'import pandas as pd; \
@@ -160,7 +163,9 @@ test-command = """
"""
[tool.cibuildwheel.windows]
-before-build = "pip install delvewheel"
+# TODO: remove this once numpy 2.0 proper releases
+# and specify numpy 2.0 as a dependency in [build-system] requires in pyproject.toml
+before-build = "pip install delvewheel numpy==2.0.0rc1"
repair-wheel-command = "delvewheel repair -w {dest_dir} {wheel}"
[[tool.cibuildwheel.overrides]]
| - [ ] closes #55519 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58087 | 2024-03-30T17:21:12Z | 2024-04-01T17:36:41Z | 2024-04-01T17:36:41Z | 2024-04-02T02:45:12Z |
ENH: Enable fillna(value=None) | diff --git a/doc/source/user_guide/missing_data.rst b/doc/source/user_guide/missing_data.rst
index 2e104ac06f9f4..5149bd30dbbef 100644
--- a/doc/source/user_guide/missing_data.rst
+++ b/doc/source/user_guide/missing_data.rst
@@ -386,6 +386,27 @@ Replace NA with a scalar value
df
df.fillna(0)
+When the data has object dtype, you can control what type of NA values are present.
+
+.. ipython:: python
+
+ df = pd.DataFrame({"a": [pd.NA, np.nan, None]}, dtype=object)
+ df
+ df.fillna(None)
+ df.fillna(np.nan)
+ df.fillna(pd.NA)
+
+However when the dtype is not object, these will all be replaced with the proper NA value for the dtype.
+
+.. ipython:: python
+
+ data = {"np": [1.0, np.nan, np.nan, 2], "arrow": pd.array([1.0, pd.NA, pd.NA, 2], dtype="float64[pyarrow]")}
+ df = pd.DataFrame(data)
+ df
+ df.fillna(None)
+ df.fillna(np.nan)
+ df.fillna(pd.NA)
+
Fill gaps forward or backward
.. ipython:: python
diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index e05cc87d1af14..e4a5f5e855fc7 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -37,6 +37,7 @@ Other enhancements
- Users can globally disable any ``PerformanceWarning`` by setting the option ``mode.performance_warnings`` to ``False`` (:issue:`56920`)
- :meth:`Styler.format_index_names` can now be used to format the index and column names (:issue:`48936` and :issue:`47489`)
- :meth:`DataFrame.cummin`, :meth:`DataFrame.cummax`, :meth:`DataFrame.cumprod` and :meth:`DataFrame.cumsum` methods now have a ``numeric_only`` parameter (:issue:`53072`)
+- :meth:`DataFrame.fillna` and :meth:`Series.fillna` can now accept ``value=None``; for non-object dtype the corresponding NA value will be used (:issue:`57723`)
.. ---------------------------------------------------------------------------
.. _whatsnew_300.notable_bug_fixes:
diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index 123dc679a83ea..cbd0221cc2082 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -328,7 +328,7 @@ def _pad_or_backfill(
return new_values
@doc(ExtensionArray.fillna)
- def fillna(self, value=None, limit: int | None = None, copy: bool = True) -> Self:
+ def fillna(self, value, limit: int | None = None, copy: bool = True) -> Self:
mask = self.isna()
# error: Argument 2 to "check_value_size" has incompatible type
# "ExtensionArray"; expected "ndarray"
@@ -347,8 +347,7 @@ def fillna(self, value=None, limit: int | None = None, copy: bool = True) -> Sel
new_values[mask] = value
else:
# We validate the fill_value even if there is nothing to fill
- if value is not None:
- self._validate_setitem_value(value)
+ self._validate_setitem_value(value)
if not copy:
new_values = self[:]
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 34ca81e36cbc5..1154130b9bed3 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -1077,7 +1077,7 @@ def _pad_or_backfill(
@doc(ExtensionArray.fillna)
def fillna(
self,
- value: object | ArrayLike | None = None,
+ value: object | ArrayLike,
limit: int | None = None,
copy: bool = True,
) -> Self:
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index af666a591b1bc..86f58b48ea3be 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -892,7 +892,7 @@ def max(self, *, axis: AxisInt | None = None, skipna: bool = True) -> IntervalOr
indexer = obj.argsort()[-1]
return obj[indexer]
- def fillna(self, value=None, limit: int | None = None, copy: bool = True) -> Self:
+ def fillna(self, value, limit: int | None = None, copy: bool = True) -> Self:
"""
Fill NA/NaN values using the specified method.
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index d20d7f98b8aa8..190888d281ea9 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -236,7 +236,7 @@ def _pad_or_backfill(
return new_values
@doc(ExtensionArray.fillna)
- def fillna(self, value=None, limit: int | None = None, copy: bool = True) -> Self:
+ def fillna(self, value, limit: int | None = None, copy: bool = True) -> Self:
mask = self._mask
value = missing.check_value_size(value, mask, len(self))
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 134702099371d..522d86fb165f6 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -706,7 +706,7 @@ def isna(self) -> Self: # type: ignore[override]
def fillna(
self,
- value=None,
+ value,
limit: int | None = None,
copy: bool = True,
) -> Self:
@@ -736,8 +736,6 @@ def fillna(
When ``self.fill_value`` is not NA, the result dtype will be
``self.dtype``. Again, this preserves the amount of memory used.
"""
- if value is None:
- raise ValueError("Must specify 'value'.")
new_values = np.where(isna(self.sp_values), value, self.sp_values)
if self._null_fill_value:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index e1c1b21249362..523ca9de201bf 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -6752,7 +6752,7 @@ def _pad_or_backfill(
@overload
def fillna(
self,
- value: Hashable | Mapping | Series | DataFrame = ...,
+ value: Hashable | Mapping | Series | DataFrame,
*,
axis: Axis | None = ...,
inplace: Literal[False] = ...,
@@ -6762,7 +6762,7 @@ def fillna(
@overload
def fillna(
self,
- value: Hashable | Mapping | Series | DataFrame = ...,
+ value: Hashable | Mapping | Series | DataFrame,
*,
axis: Axis | None = ...,
inplace: Literal[True],
@@ -6772,7 +6772,7 @@ def fillna(
@overload
def fillna(
self,
- value: Hashable | Mapping | Series | DataFrame = ...,
+ value: Hashable | Mapping | Series | DataFrame,
*,
axis: Axis | None = ...,
inplace: bool = ...,
@@ -6786,7 +6786,7 @@ def fillna(
)
def fillna(
self,
- value: Hashable | Mapping | Series | DataFrame | None = None,
+ value: Hashable | Mapping | Series | DataFrame,
*,
axis: Axis | None = None,
inplace: bool = False,
@@ -6827,6 +6827,12 @@ def fillna(
reindex : Conform object to new index.
asfreq : Convert TimeSeries to specified frequency.
+ Notes
+ -----
+ For non-object dtype, ``value=None`` will use the NA value of the dtype.
+ See more details in the :ref:`Filling missing data<missing_data.fillna>`
+ section.
+
Examples
--------
>>> df = pd.DataFrame(
@@ -6909,101 +6915,92 @@ def fillna(
axis = 0
axis = self._get_axis_number(axis)
- if value is None:
- raise ValueError("Must specify a fill 'value'.")
- else:
- if self.ndim == 1:
- if isinstance(value, (dict, ABCSeries)):
- if not len(value):
- # test_fillna_nonscalar
- if inplace:
- return None
- return self.copy(deep=False)
- from pandas import Series
-
- value = Series(value)
- value = value.reindex(self.index)
- value = value._values
- elif not is_list_like(value):
- pass
- else:
- raise TypeError(
- '"value" parameter must be a scalar, dict '
- "or Series, but you passed a "
- f'"{type(value).__name__}"'
- )
+ if self.ndim == 1:
+ if isinstance(value, (dict, ABCSeries)):
+ if not len(value):
+ # test_fillna_nonscalar
+ if inplace:
+ return None
+ return self.copy(deep=False)
+ from pandas import Series
+
+ value = Series(value)
+ value = value.reindex(self.index)
+ value = value._values
+ elif not is_list_like(value):
+ pass
+ else:
+ raise TypeError(
+ '"value" parameter must be a scalar, dict '
+ "or Series, but you passed a "
+ f'"{type(value).__name__}"'
+ )
- new_data = self._mgr.fillna(value=value, limit=limit, inplace=inplace)
+ new_data = self._mgr.fillna(value=value, limit=limit, inplace=inplace)
- elif isinstance(value, (dict, ABCSeries)):
- if axis == 1:
- raise NotImplementedError(
- "Currently only can fill "
- "with dict/Series column "
- "by column"
- )
- result = self if inplace else self.copy(deep=False)
- for k, v in value.items():
- if k not in result:
- continue
+ elif isinstance(value, (dict, ABCSeries)):
+ if axis == 1:
+ raise NotImplementedError(
+ "Currently only can fill with dict/Series column by column"
+ )
+ result = self if inplace else self.copy(deep=False)
+ for k, v in value.items():
+ if k not in result:
+ continue
- res_k = result[k].fillna(v, limit=limit)
+ res_k = result[k].fillna(v, limit=limit)
- if not inplace:
- result[k] = res_k
+ if not inplace:
+ result[k] = res_k
+ else:
+ # We can write into our existing column(s) iff dtype
+ # was preserved.
+ if isinstance(res_k, ABCSeries):
+ # i.e. 'k' only shows up once in self.columns
+ if res_k.dtype == result[k].dtype:
+ result.loc[:, k] = res_k
+ else:
+ # Different dtype -> no way to do inplace.
+ result[k] = res_k
else:
- # We can write into our existing column(s) iff dtype
- # was preserved.
- if isinstance(res_k, ABCSeries):
- # i.e. 'k' only shows up once in self.columns
- if res_k.dtype == result[k].dtype:
- result.loc[:, k] = res_k
+ # see test_fillna_dict_inplace_nonunique_columns
+ locs = result.columns.get_loc(k)
+ if isinstance(locs, slice):
+ locs = np.arange(self.shape[1])[locs]
+ elif isinstance(locs, np.ndarray) and locs.dtype.kind == "b":
+ locs = locs.nonzero()[0]
+ elif not (
+ isinstance(locs, np.ndarray) and locs.dtype.kind == "i"
+ ):
+ # Should never be reached, but let's cover our bases
+ raise NotImplementedError(
+ "Unexpected get_loc result, please report a bug at "
+ "https://github.com/pandas-dev/pandas"
+ )
+
+ for i, loc in enumerate(locs):
+ res_loc = res_k.iloc[:, i]
+ target = self.iloc[:, loc]
+
+ if res_loc.dtype == target.dtype:
+ result.iloc[:, loc] = res_loc
else:
- # Different dtype -> no way to do inplace.
- result[k] = res_k
- else:
- # see test_fillna_dict_inplace_nonunique_columns
- locs = result.columns.get_loc(k)
- if isinstance(locs, slice):
- locs = np.arange(self.shape[1])[locs]
- elif (
- isinstance(locs, np.ndarray) and locs.dtype.kind == "b"
- ):
- locs = locs.nonzero()[0]
- elif not (
- isinstance(locs, np.ndarray) and locs.dtype.kind == "i"
- ):
- # Should never be reached, but let's cover our bases
- raise NotImplementedError(
- "Unexpected get_loc result, please report a bug at "
- "https://github.com/pandas-dev/pandas"
- )
-
- for i, loc in enumerate(locs):
- res_loc = res_k.iloc[:, i]
- target = self.iloc[:, loc]
-
- if res_loc.dtype == target.dtype:
- result.iloc[:, loc] = res_loc
- else:
- result.isetitem(loc, res_loc)
- if inplace:
- return self._update_inplace(result)
- else:
- return result
+ result.isetitem(loc, res_loc)
+ if inplace:
+ return self._update_inplace(result)
+ else:
+ return result
- elif not is_list_like(value):
- if axis == 1:
- result = self.T.fillna(value=value, limit=limit).T
- new_data = result._mgr
- else:
- new_data = self._mgr.fillna(
- value=value, limit=limit, inplace=inplace
- )
- elif isinstance(value, ABCDataFrame) and self.ndim == 2:
- new_data = self.where(self.notna(), value)._mgr
+ elif not is_list_like(value):
+ if axis == 1:
+ result = self.T.fillna(value=value, limit=limit).T
+ new_data = result._mgr
else:
- raise ValueError(f"invalid fill value with a {type(value)}")
+ new_data = self._mgr.fillna(value=value, limit=limit, inplace=inplace)
+ elif isinstance(value, ABCDataFrame) and self.ndim == 2:
+ new_data = self.where(self.notna(), value)._mgr
+ else:
+ raise ValueError(f"invalid fill value with a {type(value)}")
result = self._constructor_from_mgr(new_data, axes=new_data.axes)
if inplace:
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index d5517a210b39d..69f916bb3f769 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -2543,7 +2543,7 @@ def notna(self) -> npt.NDArray[np.bool_]:
notnull = notna
- def fillna(self, value=None):
+ def fillna(self, value):
"""
Fill NA/NaN values with the specified value.
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 4affa1337aa2a..9df0d26ce622a 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -1675,7 +1675,7 @@ def duplicated(self, keep: DropKeep = "first") -> npt.NDArray[np.bool_]:
# (previously declared in base class "IndexOpsMixin")
_duplicated = duplicated # type: ignore[misc]
- def fillna(self, value=None, downcast=None):
+ def fillna(self, value, downcast=None):
"""
fillna is not implemented for MultiIndex
"""
diff --git a/pandas/tests/extension/base/missing.py b/pandas/tests/extension/base/missing.py
index 328c6cd6164fb..4b9234a9904a2 100644
--- a/pandas/tests/extension/base/missing.py
+++ b/pandas/tests/extension/base/missing.py
@@ -68,6 +68,12 @@ def test_fillna_scalar(self, data_missing):
expected = data_missing.fillna(valid)
tm.assert_extension_array_equal(result, expected)
+ def test_fillna_with_none(self, data_missing):
+ # GH#57723
+ result = data_missing.fillna(None)
+ expected = data_missing
+ tm.assert_extension_array_equal(result, expected)
+
def test_fillna_limit_pad(self, data_missing):
arr = data_missing.take([1, 0, 0, 0, 1])
result = pd.Series(arr).ffill(limit=2)
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index a2721908e858f..504bafc145108 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -144,6 +144,14 @@ def test_fillna_series(self, data_missing):
):
super().test_fillna_series(data_missing)
+ def test_fillna_with_none(self, data_missing):
+ # GH#57723
+ # EAs that don't have special logic for None will raise, unlike pandas'
+ # which interpret None as the NA value for the dtype.
+ msg = "conversion from NoneType to Decimal is not supported"
+ with pytest.raises(TypeError, match=msg):
+ super().test_fillna_with_none(data_missing)
+
@pytest.mark.parametrize("dropna", [True, False])
def test_value_counts(self, all_data, dropna):
all_data = all_data[:10]
diff --git a/pandas/tests/extension/json/test_json.py b/pandas/tests/extension/json/test_json.py
index 6ecbf2063f203..22ac9627f6cda 100644
--- a/pandas/tests/extension/json/test_json.py
+++ b/pandas/tests/extension/json/test_json.py
@@ -149,6 +149,13 @@ def test_fillna_frame(self):
"""We treat dictionaries as a mapping in fillna, not a scalar."""
super().test_fillna_frame()
+ def test_fillna_with_none(self, data_missing):
+ # GH#57723
+ # EAs that don't have special logic for None will raise, unlike pandas'
+ # which interpret None as the NA value for the dtype.
+ with pytest.raises(AssertionError):
+ super().test_fillna_with_none(data_missing)
+
@pytest.mark.parametrize(
"limit_area, input_ilocs, expected_ilocs",
[
diff --git a/pandas/tests/frame/methods/test_fillna.py b/pandas/tests/frame/methods/test_fillna.py
index b8f67138889cc..e858c123e4dae 100644
--- a/pandas/tests/frame/methods/test_fillna.py
+++ b/pandas/tests/frame/methods/test_fillna.py
@@ -64,8 +64,8 @@ def test_fillna_datetime(self, datetime_frame):
padded.loc[padded.index[-5:], "A"] == padded.loc[padded.index[-5], "A"]
).all()
- msg = "Must specify a fill 'value'"
- with pytest.raises(ValueError, match=msg):
+ msg = r"missing 1 required positional argument: 'value'"
+ with pytest.raises(TypeError, match=msg):
datetime_frame.fillna()
@pytest.mark.xfail(using_pyarrow_string_dtype(), reason="can't fill 0 in string")
@@ -779,3 +779,17 @@ def test_ffill_bfill_limit_area(data, expected_data, method, kwargs):
expected = DataFrame(expected_data)
result = getattr(df, method)(**kwargs)
tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("test_frame", [True, False])
+@pytest.mark.parametrize("dtype", ["float", "object"])
+def test_fillna_with_none_object(test_frame, dtype):
+ # GH#57723
+ obj = Series([1, np.nan, 3], dtype=dtype)
+ if test_frame:
+ obj = obj.to_frame()
+ result = obj.fillna(value=None)
+ expected = Series([1, None, 3], dtype=dtype)
+ if test_frame:
+ expected = expected.to_frame()
+ tm.assert_equal(result, expected)
| - [x] closes #57723 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
The one behavior introduced here I think is important to highlight is using `None` with non-object dtypes. In such a case we treat `None` as the NA value for the given dtype for NumPy float/datetime and pandas' EA dtypes. However for external EAs, by default we try to put `None` in the values and raise if this fails.
For object dtype, we replace any NA value with `None`.
cc @Dr-Irv | https://api.github.com/repos/pandas-dev/pandas/pulls/58085 | 2024-03-30T14:14:53Z | 2024-04-15T17:22:40Z | 2024-04-15T17:22:40Z | 2024-04-15T20:32:33Z |
CLN: move raising TypeError for `interpolate` with `object` dtype to Block | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 858d2ba82a969..c6f7e6296bc13 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -7749,11 +7749,6 @@ def interpolate(
raise ValueError("'method' should be a string, not None.")
obj, should_transpose = (self.T, True) if axis == 1 else (self, False)
- # GH#53631
- if np.any(obj.dtypes == object):
- raise TypeError(
- f"{type(self).__name__} cannot interpolate with object dtype."
- )
if isinstance(obj.index, MultiIndex) and method != "linear":
raise ValueError(
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 468ec32ce7760..7be1d5d95ffdf 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1388,12 +1388,10 @@ def interpolate(
# If there are no NAs, then interpolate is a no-op
return [self.copy(deep=False)]
- # TODO(3.0): this case will not be reachable once GH#53638 is enforced
if self.dtype == _dtype_obj:
- # only deal with floats
- # bc we already checked that can_hold_na, we don't have int dtype here
- # test_interp_basic checks that we make a copy here
- return [self.copy(deep=False)]
+ # GH#53631
+ name = {1: "Series", 2: "DataFrame"}[self.ndim]
+ raise TypeError(f"{name} cannot interpolate with object dtype.")
copy, refs = self._get_refs_and_copy(inplace)
diff --git a/pandas/tests/series/methods/test_interpolate.py b/pandas/tests/series/methods/test_interpolate.py
index c5df1fd498938..1008c2c87dc9e 100644
--- a/pandas/tests/series/methods/test_interpolate.py
+++ b/pandas/tests/series/methods/test_interpolate.py
@@ -790,11 +790,9 @@ def test_interpolate_unsorted_index(self, ascending, expected_values):
def test_interpolate_asfreq_raises(self):
ser = Series(["a", None, "b"], dtype=object)
- msg2 = "Series cannot interpolate with object dtype"
- msg = "Invalid fill method"
- with pytest.raises(TypeError, match=msg2):
- with pytest.raises(ValueError, match=msg):
- ser.interpolate(method="asfreq")
+ msg = "Can not interpolate with method=asfreq"
+ with pytest.raises(ValueError, match=msg):
+ ser.interpolate(method="asfreq")
def test_interpolate_fill_value(self):
# GH#54920
| xref #57820
moved raising `TypeError` for `interpolate` with object dtype from ``NDFrame`` to ``Block`` | https://api.github.com/repos/pandas-dev/pandas/pulls/58083 | 2024-03-30T00:45:24Z | 2024-04-01T20:49:57Z | 2024-04-01T20:49:57Z | 2024-04-01T20:50:04Z |
ENH: Implement round dunder methods for Timestamp and Timedelta | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 74a19472ec835..5d49e12627838 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -35,6 +35,7 @@ Other enhancements
- Support passing a :class:`Series` input to :func:`json_normalize` that retains the :class:`Series` :class:`Index` (:issue:`51452`)
- Users can globally disable any ``PerformanceWarning`` by setting the option ``mode.performance_warnings`` to ``False`` (:issue:`56920`)
- :meth:`Styler.format_index_names` can now be used to format the index and column names (:issue:`48936` and :issue:`47489`)
+- Implemented built-in round for :class:`Timestamp` and :class:`Timedelta` such that ``round(Timestamp)`` and ``round(Timedelta)`` now work. (:issue:`58071`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 9078fd4116899..59f9b339478b6 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -2290,6 +2290,9 @@ class Timedelta(_Timedelta):
div = other // self
return div, other - div * self
+ def __round__(self, freq):
+ return self.round(freq)
+
def truediv_object_array(ndarray left, ndarray right):
cdef:
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index d4cd90613ca5b..84eb92a912c82 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -2193,6 +2193,9 @@ timedelta}, default 'raise'
"""
return self._round(freq, RoundTo.PLUS_INFTY, ambiguous, nonexistent)
+ def __round__(self, freq):
+ return self.round(freq)
+
@property
def tz(self):
"""
| - [x] closes #58071
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58081 | 2024-03-29T22:02:44Z | 2024-04-01T18:11:25Z | null | 2024-04-08T13:36:39Z |
Backport PR #58075 on branch 2.2.x (DOC: whatsnew note for #57553) | diff --git a/doc/source/whatsnew/v2.2.2.rst b/doc/source/whatsnew/v2.2.2.rst
index 9e1a883d47cf8..0dac3660c76b2 100644
--- a/doc/source/whatsnew/v2.2.2.rst
+++ b/doc/source/whatsnew/v2.2.2.rst
@@ -15,6 +15,7 @@ Fixed regressions
~~~~~~~~~~~~~~~~~
- :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the a column's type was a pandas nullable on with missing values (:issue:`56702`)
- :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the a column's type was a pyarrow nullable on with missing values (:issue:`57664`)
+- Avoid issuing a spurious ``DeprecationWarning`` when a custom :class:`DataFrame` or :class:`Series` subclass method is called (:issue:`57553`)
- Fixed regression in precision of :func:`to_datetime` with string and ``unit`` input (:issue:`57051`)
.. ---------------------------------------------------------------------------
| Backport PR #58075: DOC: whatsnew note for #57553 | https://api.github.com/repos/pandas-dev/pandas/pulls/58080 | 2024-03-29T21:40:25Z | 2024-04-01T21:23:48Z | 2024-04-01T21:23:48Z | 2024-04-01T21:23:50Z |
CLN: Remove unnecessary block in apply_str | diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index de2fd9394e2fa..e8df24850f7a8 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -564,22 +564,10 @@ def apply_str(self) -> DataFrame | Series:
"axis" not in arg_names or func in ("corrwith", "skew")
):
raise ValueError(f"Operation {func} does not support axis=1")
- if "axis" in arg_names:
- if isinstance(obj, (SeriesGroupBy, DataFrameGroupBy)):
- # Try to avoid FutureWarning for deprecated axis keyword;
- # If self.axis matches the axis we would get by not passing
- # axis, we safely exclude the keyword.
-
- default_axis = 0
- if func in ["idxmax", "idxmin"]:
- # DataFrameGroupBy.idxmax, idxmin axis defaults to self.axis,
- # whereas other axis keywords default to 0
- default_axis = self.obj.axis
-
- if default_axis != self.axis:
- self.kwargs["axis"] = self.axis
- else:
- self.kwargs["axis"] = self.axis
+ if "axis" in arg_names and not isinstance(
+ obj, (SeriesGroupBy, DataFrameGroupBy)
+ ):
+ self.kwargs["axis"] = self.axis
return self._apply_str(obj, func, *self.args, **self.kwargs)
def apply_list_or_dict_like(self) -> DataFrame | Series:
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
Due to #57109, "axis" will not be an argument for groupby ops.
Hat tip to @jbrockmendel for finding this. | https://api.github.com/repos/pandas-dev/pandas/pulls/58077 | 2024-03-29T19:30:21Z | 2024-03-29T21:39:18Z | 2024-03-29T21:39:18Z | 2024-03-29T22:07:23Z |
DOC: docstring fix for pandas.DataFrame.where method | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 0c4e6641444f1..3521c44eda312 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -99,7 +99,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.kurt RT03,SA01" \
-i "pandas.DataFrame.kurtosis RT03,SA01" \
-i "pandas.DataFrame.last_valid_index SA01" \
- -i "pandas.DataFrame.mask RT03" \
-i "pandas.DataFrame.max RT03" \
-i "pandas.DataFrame.mean RT03,SA01" \
-i "pandas.DataFrame.median RT03,SA01" \
@@ -131,7 +130,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.DataFrame.unstack RT03" \
-i "pandas.DataFrame.value_counts RT03" \
-i "pandas.DataFrame.var PR01,RT03,SA01" \
- -i "pandas.DataFrame.where RT03" \
-i "pandas.DatetimeIndex.ceil SA01" \
-i "pandas.DatetimeIndex.date SA01" \
-i "pandas.DatetimeIndex.day SA01" \
@@ -400,7 +398,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Series.list.flatten SA01" \
-i "pandas.Series.list.len SA01" \
-i "pandas.Series.lt PR07,SA01" \
- -i "pandas.Series.mask RT03" \
-i "pandas.Series.max RT03" \
-i "pandas.Series.mean RT03,SA01" \
-i "pandas.Series.median RT03,SA01" \
@@ -487,7 +484,6 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
-i "pandas.Series.update PR07,SA01" \
-i "pandas.Series.value_counts RT03" \
-i "pandas.Series.var PR01,RT03,SA01" \
- -i "pandas.Series.where RT03" \
-i "pandas.SparseDtype SA01" \
-i "pandas.Timedelta PR07,SA01" \
-i "pandas.Timedelta.as_unit SA01" \
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 858d2ba82a969..862c6756ebb28 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -9807,8 +9807,10 @@ def where(
Returns
-------
- Series or DataFrame unless ``inplace=True`` in which case
- returns None.
+ Series or DataFrame or None
+ When applied to a Series, the function will return a Series,
+ and when applied to a DataFrame, it will return a DataFrame;
+ if ``inplace=True``, it will return None.
See Also
--------
| - [x] xref #58065 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58076 | 2024-03-29T18:54:10Z | 2024-04-01T17:53:03Z | 2024-04-01T17:53:03Z | 2024-04-01T17:53:10Z |
DOC: whatsnew note for #57553 | diff --git a/doc/source/whatsnew/v2.2.2.rst b/doc/source/whatsnew/v2.2.2.rst
index 9e1a883d47cf8..0dac3660c76b2 100644
--- a/doc/source/whatsnew/v2.2.2.rst
+++ b/doc/source/whatsnew/v2.2.2.rst
@@ -15,6 +15,7 @@ Fixed regressions
~~~~~~~~~~~~~~~~~
- :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the a column's type was a pandas nullable on with missing values (:issue:`56702`)
- :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the a column's type was a pyarrow nullable on with missing values (:issue:`57664`)
+- Avoid issuing a spurious ``DeprecationWarning`` when a custom :class:`DataFrame` or :class:`Series` subclass method is called (:issue:`57553`)
- Fixed regression in precision of :func:`to_datetime` with string and ``unit`` input (:issue:`57051`)
.. ---------------------------------------------------------------------------
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
xref #58008 | https://api.github.com/repos/pandas-dev/pandas/pulls/58075 | 2024-03-29T18:37:58Z | 2024-03-29T21:39:56Z | 2024-03-29T21:39:56Z | 2024-03-29T21:42:48Z |
Pandas dev main | diff --git a/doc/source/whatsnew/v2.2.2.rst b/doc/source/whatsnew/v2.2.2.rst
index 9e1a883d47cf8..b7330e4b1cbb6 100644
--- a/doc/source/whatsnew/v2.2.2.rst
+++ b/doc/source/whatsnew/v2.2.2.rst
@@ -22,10 +22,12 @@ Fixed regressions
Bug fixes
~~~~~~~~~
+
- :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the column's type was nullable boolean (:issue:`55332`)
- :meth:`DataFrame.__dataframe__` was showing bytemask instead of bitmask for ``'string[pyarrow]'`` validity buffer (:issue:`57762`)
- :meth:`DataFrame.__dataframe__` was showing non-null validity buffer (instead of ``None``) ``'string[pyarrow]'`` without missing values (:issue:`57761`)
- :meth:`DataFrame.to_sql` was failing to find the right table when using the schema argument (:issue:`57539`)
+- Fixed bug in :func:`pandas.io.json_normalize` raising with errors='ignore' while traversing empty list (:issue:`57810`)
.. ---------------------------------------------------------------------------
.. _whatsnew_222.other:
diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 2ebd6fb62b424..549d49aaa1853 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -206,23 +206,18 @@ Removal of prior version deprecations/changes
- :meth:`SeriesGroupBy.agg` no longer pins the name of the group to the input passed to the provided ``func`` (:issue:`51703`)
- All arguments except ``name`` in :meth:`Index.rename` are now keyword only (:issue:`56493`)
- All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`)
-- Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
-- Removed "freq" keyword from :class:`PeriodArray` constructor, use "dtype" instead (:issue:`52462`)
-- Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
- Removed the "closed" and "normalize" keywords in :meth:`DatetimeIndex.__new__` (:issue:`52628`)
- Removed the "closed" and "unit" keywords in :meth:`TimedeltaIndex.__new__` (:issue:`52628`, :issue:`55499`)
- All arguments in :meth:`Index.sort_values` are now keyword only (:issue:`56493`)
- All arguments in :meth:`Series.to_dict` are now keyword only (:issue:`56493`)
- Changed the default value of ``observed`` in :meth:`DataFrame.groupby` and :meth:`Series.groupby` to ``True`` (:issue:`51811`)
- Enforce deprecation in :func:`testing.assert_series_equal` and :func:`testing.assert_frame_equal` with object dtype and mismatched null-like values, which are now considered not-equal (:issue:`18463`)
-- Enforced deprecation ``all`` and ``any`` reductions with ``datetime64`` and :class:`DatetimeTZDtype` dtypes (:issue:`58029`)
- Enforced deprecation disallowing parsing datetimes with mixed time zones unless user passes ``utc=True`` to :func:`to_datetime` (:issue:`57275`)
- Enforced deprecation in :meth:`Series.value_counts` and :meth:`Index.value_counts` with object dtype performing dtype inference on the ``.index`` of the result (:issue:`56161`)
- Enforced deprecation of :meth:`.DataFrameGroupBy.get_group` and :meth:`.SeriesGroupBy.get_group` allowing the ``name`` argument to be a non-tuple when grouping by a list of length 1 (:issue:`54155`)
- Enforced deprecation of :meth:`Series.interpolate` and :meth:`DataFrame.interpolate` for object-dtype (:issue:`57820`)
- Enforced deprecation of :meth:`offsets.Tick.delta`, use ``pd.Timedelta(obj)`` instead (:issue:`55498`)
- Enforced deprecation of ``axis=None`` acting the same as ``axis=0`` in the DataFrame reductions ``sum``, ``prod``, ``std``, ``var``, and ``sem``, passing ``axis=None`` will now reduce over both axes; this is particularly the case when doing e.g. ``numpy.sum(df)`` (:issue:`21597`)
-- Enforced deprecation of non-standard (``np.ndarray``, :class:`ExtensionArray`, :class:`Index`, or :class:`Series`) argument to :func:`api.extensions.take` (:issue:`52981`)
- Enforced deprecation of parsing system timezone strings to ``tzlocal``, which depended on system timezone, pass the 'tz' keyword instead (:issue:`50791`)
- Enforced deprecation of passing a dictionary to :meth:`SeriesGroupBy.agg` (:issue:`52268`)
- Enforced deprecation of string ``AS`` denoting frequency in :class:`YearBegin` and strings ``AS-DEC``, ``AS-JAN``, etc. denoting annual frequencies with various fiscal year starts (:issue:`57793`)
@@ -302,7 +297,6 @@ Performance improvements
- Performance improvement in :meth:`DataFrameGroupBy.ffill`, :meth:`DataFrameGroupBy.bfill`, :meth:`SeriesGroupBy.ffill`, and :meth:`SeriesGroupBy.bfill` (:issue:`56902`)
- Performance improvement in :meth:`Index.join` by propagating cached attributes in cases where the result matches one of the inputs (:issue:`57023`)
- Performance improvement in :meth:`Index.take` when ``indices`` is a full range indexer from zero to length of index (:issue:`56806`)
-- Performance improvement in :meth:`Index.to_frame` returning a :class:`RangeIndex` columns of a :class:`Index` when possible. (:issue:`58018`)
- Performance improvement in :meth:`MultiIndex.equals` for equal length indexes (:issue:`56990`)
- Performance improvement in :meth:`RangeIndex.__getitem__` with a boolean mask or integers returning a :class:`RangeIndex` instead of a :class:`Index` when possible. (:issue:`57588`)
- Performance improvement in :meth:`RangeIndex.append` when appending the same index (:issue:`57252`)
@@ -324,10 +318,8 @@ Bug fixes
~~~~~~~~~
- Fixed bug in :class:`SparseDtype` for equal comparison with na fill value. (:issue:`54770`)
- Fixed bug in :meth:`.DataFrameGroupBy.median` where nat values gave an incorrect result. (:issue:`57926`)
-- Fixed bug in :meth:`DataFrame.cumsum` which was raising ``IndexError`` if dtype is ``timedelta64[ns]`` (:issue:`57956`)
- Fixed bug in :meth:`DataFrame.join` inconsistently setting result index name (:issue:`55815`)
- Fixed bug in :meth:`DataFrame.to_string` that raised ``StopIteration`` with nested DataFrames. (:issue:`16098`)
-- Fixed bug in :meth:`DataFrame.transform` that was returning the wrong order unless the index was monotonically increasing. (:issue:`57069`)
- Fixed bug in :meth:`DataFrame.update` bool dtype being converted to object (:issue:`55509`)
- Fixed bug in :meth:`DataFrameGroupBy.apply` that was returning a completely empty DataFrame when all return values of ``func`` were ``None`` instead of returning an empty DataFrame with the original columns and dtypes. (:issue:`57775`)
- Fixed bug in :meth:`Series.diff` allowing non-integer values for the ``periods`` argument. (:issue:`56607`)
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 34489bb70575a..65410c3c09494 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -150,6 +150,7 @@ def pytest_collection_modifyitems(items, config) -> None:
("is_categorical_dtype", "is_categorical_dtype is deprecated"),
("is_sparse", "is_sparse is deprecated"),
("DataFrameGroupBy.fillna", "DataFrameGroupBy.fillna is deprecated"),
+ ("NDFrame.replace", "The 'method' keyword"),
("NDFrame.replace", "Series.replace without 'value'"),
("NDFrame.clip", "Downcasting behavior in Series and DataFrame methods"),
("Series.idxmin", "The behavior of Series.idxmin"),
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 6a6096567c65d..8620aafd97528 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -43,6 +43,7 @@
ensure_float64,
ensure_object,
ensure_platform_int,
+ is_array_like,
is_bool_dtype,
is_complex_dtype,
is_dict_like,
@@ -1162,30 +1163,28 @@ def take(
"""
if not isinstance(arr, (np.ndarray, ABCExtensionArray, ABCIndex, ABCSeries)):
# GH#52981
- raise TypeError(
- "pd.api.extensions.take requires a numpy.ndarray, "
- f"ExtensionArray, Index, or Series, got {type(arr).__name__}."
+ warnings.warn(
+ "pd.api.extensions.take accepting non-standard inputs is deprecated "
+ "and will raise in a future version. Pass either a numpy.ndarray, "
+ "ExtensionArray, Index, or Series instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
)
+ if not is_array_like(arr):
+ arr = np.asarray(arr)
+
indices = ensure_platform_int(indices)
if allow_fill:
# Pandas style, -1 means NA
validate_indices(indices, arr.shape[axis])
- # error: Argument 1 to "take_nd" has incompatible type
- # "ndarray[Any, Any] | ExtensionArray | Index | Series"; expected
- # "ndarray[Any, Any]"
result = take_nd(
- arr, # type: ignore[arg-type]
- indices,
- axis=axis,
- allow_fill=True,
- fill_value=fill_value,
+ arr, indices, axis=axis, allow_fill=True, fill_value=fill_value
)
else:
# NumPy style
- # error: Unexpected keyword argument "axis" for "take" of "ExtensionArray"
- result = arr.take(indices, axis=axis) # type: ignore[call-arg,assignment]
+ result = arr.take(indices, axis=axis)
return result
diff --git a/pandas/core/array_algos/datetimelike_accumulations.py b/pandas/core/array_algos/datetimelike_accumulations.py
index c3a7c2e4fefb2..55942f2c9350d 100644
--- a/pandas/core/array_algos/datetimelike_accumulations.py
+++ b/pandas/core/array_algos/datetimelike_accumulations.py
@@ -49,8 +49,7 @@ def _cum_func(
if not skipna:
mask = np.maximum.accumulate(mask)
- # GH 57956
- result = func(y, axis=0)
+ result = func(y)
result[mask] = iNaT
if values.dtype.kind in "mM":
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 52cb175ca79a2..3dc2d77bb5a19 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -1661,8 +1661,16 @@ def _groupby_op(
dtype = self.dtype
if dtype.kind == "M":
# Adding/multiplying datetimes is not valid
- if how in ["any", "all", "sum", "prod", "cumsum", "cumprod", "var", "skew"]:
- raise TypeError(f"datetime64 type does not support operation: '{how}'")
+ if how in ["sum", "prod", "cumsum", "cumprod", "var", "skew"]:
+ raise TypeError(f"datetime64 type does not support {how} operations")
+ if how in ["any", "all"]:
+ # GH#34479
+ warnings.warn(
+ f"'{how}' with datetime64 dtypes is deprecated and will raise in a "
+ f"future version. Use (obj != pd.Timestamp(0)).{how}() instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
elif isinstance(dtype, PeriodDtype):
# Adding/multiplying Periods is not valid
@@ -2209,11 +2217,11 @@ def ceil(
# Reductions
def any(self, *, axis: AxisInt | None = None, skipna: bool = True) -> bool:
- # GH#34479 the nanops call will raise a TypeError for non-td64 dtype
+ # GH#34479 the nanops call will issue a FutureWarning for non-td64 dtype
return nanops.nanany(self._ndarray, axis=axis, skipna=skipna, mask=self.isna())
def all(self, *, axis: AxisInt | None = None, skipna: bool = True) -> bool:
- # GH#34479 the nanops call will raise a TypeError for non-td64 dtype
+ # GH#34479 the nanops call will issue a FutureWarning for non-td64 dtype
return nanops.nanall(self._ndarray, axis=axis, skipna=skipna, mask=self.isna())
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 8baf363b909fb..e73eba710ec39 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -54,6 +54,7 @@
cache_readonly,
doc,
)
+from pandas.util._exceptions import find_stack_level
from pandas.core.dtypes.common import (
ensure_object,
@@ -134,6 +135,11 @@ class PeriodArray(dtl.DatelikeOps, libperiod.PeriodMixin): # type: ignore[misc]
dtype : PeriodDtype, optional
A PeriodDtype instance from which to extract a `freq`. If both
`freq` and `dtype` are specified, then the frequencies must match.
+ freq : str or DateOffset
+ The `freq` to use for the array. Mostly applicable when `values`
+ is an ndarray of integers, when `freq` is required. When `values`
+ is a PeriodArray (or box around), it's checked that ``values.freq``
+ matches `freq`.
copy : bool, default False
Whether to copy the ordinals before storing.
@@ -218,7 +224,20 @@ def _scalar_type(self) -> type[Period]:
# --------------------------------------------------------------------
# Constructors
- def __init__(self, values, dtype: Dtype | None = None, copy: bool = False) -> None:
+ def __init__(
+ self, values, dtype: Dtype | None = None, freq=None, copy: bool = False
+ ) -> None:
+ if freq is not None:
+ # GH#52462
+ warnings.warn(
+ "The 'freq' keyword in the PeriodArray constructor is deprecated "
+ "and will be removed in a future version. Pass 'dtype' instead",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ freq = validate_dtype_freq(dtype, freq)
+ dtype = PeriodDtype(freq)
+
if dtype is not None:
dtype = pandas_dtype(dtype)
if not isinstance(dtype, PeriodDtype):
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 858d2ba82a969..a7545fb8d98de 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -6727,10 +6727,12 @@ def _pad_or_backfill(
axis = self._get_axis_number(axis)
method = clean_fill_method(method)
- if axis == 1:
- if not self._mgr.is_single_block and inplace:
- raise NotImplementedError()
+ if not self._mgr.is_single_block and axis == 1:
# e.g. test_align_fill_method
+ # TODO(3.0): once downcast is removed, we can do the .T
+ # in all axis=1 cases, and remove axis kward from mgr.pad_or_backfill.
+ if inplace:
+ raise NotImplementedError()
result = self.T._pad_or_backfill(
method=method, limit=limit, limit_area=limit_area
).T
@@ -6739,6 +6741,7 @@ def _pad_or_backfill(
new_mgr = self._mgr.pad_or_backfill(
method=method,
+ axis=self._get_block_manager_axis(axis),
limit=limit,
limit_area=limit_area,
inplace=inplace,
@@ -7282,7 +7285,9 @@ def replace(
value=...,
*,
inplace: Literal[False] = ...,
+ limit: int | None = ...,
regex: bool = ...,
+ method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
) -> Self: ...
@overload
@@ -7292,7 +7297,9 @@ def replace(
value=...,
*,
inplace: Literal[True],
+ limit: int | None = ...,
regex: bool = ...,
+ method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
) -> None: ...
@overload
@@ -7302,7 +7309,9 @@ def replace(
value=...,
*,
inplace: bool = ...,
+ limit: int | None = ...,
regex: bool = ...,
+ method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = ...,
) -> Self | None: ...
@final
@@ -7317,9 +7326,32 @@ def replace(
value=lib.no_default,
*,
inplace: bool = False,
+ limit: int | None = None,
regex: bool = False,
+ method: Literal["pad", "ffill", "bfill"] | lib.NoDefault = lib.no_default,
) -> Self | None:
- if value is lib.no_default and not is_dict_like(to_replace) and regex is False:
+ if method is not lib.no_default:
+ warnings.warn(
+ # GH#33302
+ f"The 'method' keyword in {type(self).__name__}.replace is "
+ "deprecated and will be removed in a future version.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ elif limit is not None:
+ warnings.warn(
+ # GH#33302
+ f"The 'limit' keyword in {type(self).__name__}.replace is "
+ "deprecated and will be removed in a future version.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ if (
+ value is lib.no_default
+ and method is lib.no_default
+ and not is_dict_like(to_replace)
+ and regex is False
+ ):
# case that goes through _replace_single and defaults to method="pad"
warnings.warn(
# GH#33302
@@ -7355,11 +7387,14 @@ def replace(
if not is_bool(regex) and to_replace is not None:
raise ValueError("'to_replace' must be 'None' if 'regex' is not a bool")
- if value is lib.no_default:
+ if value is lib.no_default or method is not lib.no_default:
# GH#36984 if the user explicitly passes value=None we want to
# respect that. We have the corner case where the user explicitly
# passes value=None *and* a method, which we interpret as meaning
# they want the (documented) default behavior.
+ if method is lib.no_default:
+ # TODO: get this to show up as the default in the docs?
+ method = "pad"
# passing a single value that is scalar like
# when value is None (GH5319), for compat
@@ -7373,12 +7408,12 @@ def replace(
result = self.apply(
Series._replace_single,
- args=(to_replace, inplace),
+ args=(to_replace, method, inplace, limit),
)
if inplace:
return None
return result
- return self._replace_single(to_replace, inplace)
+ return self._replace_single(to_replace, method, inplace, limit)
if not is_dict_like(to_replace):
if not is_dict_like(regex):
@@ -7423,7 +7458,9 @@ def replace(
else:
to_replace, value = keys, values
- return self.replace(to_replace, value, inplace=inplace, regex=regex)
+ return self.replace(
+ to_replace, value, inplace=inplace, limit=limit, regex=regex
+ )
else:
# need a non-zero len on all axes
if not self.size:
@@ -7487,7 +7524,9 @@ def replace(
f"or a list or dict of strings or regular expressions, "
f"you passed a {type(regex).__name__!r}"
)
- return self.replace(regex, value, inplace=inplace, regex=True)
+ return self.replace(
+ regex, value, inplace=inplace, limit=limit, regex=True
+ )
else:
# dest iterable dict-like
if is_dict_like(value): # NA -> {'A' : 0, 'B' : -1}
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index bd8e222831d0c..0b61938d474b9 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -1439,7 +1439,6 @@ def _transform_with_numba(self, func, *args, engine_kwargs=None, **kwargs):
data and indices into a Numba jitted function.
"""
data = self._obj_with_exclusions
- index_sorting = self._grouper.result_ilocs
df = data if data.ndim == 2 else data.to_frame()
starts, ends, sorted_index, sorted_data = self._numba_prep(df)
@@ -1457,7 +1456,7 @@ def _transform_with_numba(self, func, *args, engine_kwargs=None, **kwargs):
)
# result values needs to be resorted to their original positions since we
# evaluated the data sorted by group
- result = result.take(np.argsort(index_sorting), axis=0)
+ result = result.take(np.argsort(sorted_index), axis=0)
index = data.index
if data.ndim == 1:
result_kwargs = {"name": data.name}
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index ae9b0eb4e48aa..76dd19a9424f5 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1013,7 +1013,7 @@ def ravel(self, order: str_t = "C") -> Self:
def view(self, cls=None):
# we need to see if we are subclassing an
# index type here
- if cls is not None:
+ if cls is not None and not hasattr(cls, "_typ"):
dtype = cls
if isinstance(cls, str):
dtype = pandas_dtype(cls)
@@ -1030,6 +1030,16 @@ def view(self, cls=None):
result = self._data.view(cls)
else:
+ if cls is not None:
+ warnings.warn(
+ # GH#55709
+ f"Passing a type in {type(self).__name__}.view is deprecated "
+ "and will raise in a future version. "
+ "Call view without any argument to retain the old behavior.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+
result = self._view()
if isinstance(result, Index):
result._id = self._id
@@ -1364,19 +1374,16 @@ def _format_attrs(self) -> list[tuple[str_t, str_t | int | bool | None]]:
return attrs
@final
- def _get_level_names(self) -> range | Sequence[Hashable]:
+ def _get_level_names(self) -> Hashable | Sequence[Hashable]:
"""
Return a name or list of names with None replaced by the level number.
"""
if self._is_multi:
- return maybe_sequence_to_range(
- [
- level if name is None else name
- for level, name in enumerate(self.names)
- ]
- )
+ return [
+ level if name is None else name for level, name in enumerate(self.names)
+ ]
else:
- return range(1) if self.name is None else [self.name]
+ return 0 if self.name is None else self.name
@final
def _mpl_repr(self) -> np.ndarray:
@@ -1623,11 +1630,8 @@ def to_frame(
from pandas import DataFrame
if name is lib.no_default:
- result_name = self._get_level_names()
- else:
- result_name = Index([name]) # type: ignore[assignment]
- result = DataFrame(self, copy=False)
- result.columns = result_name
+ name = self._get_level_names()
+ result = DataFrame({name: self}, copy=False)
if index:
result.index = self
diff --git a/pandas/core/interchange/utils.py b/pandas/core/interchange/utils.py
index fd1c7c9639242..2a19dd5046aa3 100644
--- a/pandas/core/interchange/utils.py
+++ b/pandas/core/interchange/utils.py
@@ -144,9 +144,6 @@ def dtype_to_arrow_c_fmt(dtype: DtypeObj) -> str:
elif isinstance(dtype, DatetimeTZDtype):
return ArrowCTypes.TIMESTAMP.format(resolution=dtype.unit[0], tz=dtype.tz)
- elif isinstance(dtype, pd.BooleanDtype):
- return ArrowCTypes.BOOL
-
raise NotImplementedError(
f"Conversion of {dtype} to Arrow C format string is not implemented."
)
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 468ec32ce7760..a7cdc7c39754d 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1343,6 +1343,7 @@ def pad_or_backfill(
self,
*,
method: FillnaOptions,
+ axis: AxisInt = 0,
inplace: bool = False,
limit: int | None = None,
limit_area: Literal["inside", "outside"] | None = None,
@@ -1356,12 +1357,16 @@ def pad_or_backfill(
# Dispatch to the NumpyExtensionArray method.
# We know self.array_values is a NumpyExtensionArray bc EABlock overrides
vals = cast(NumpyExtensionArray, self.array_values)
- new_values = vals.T._pad_or_backfill(
+ if axis == 1:
+ vals = vals.T
+ new_values = vals._pad_or_backfill(
method=method,
limit=limit,
limit_area=limit_area,
copy=copy,
- ).T
+ )
+ if axis == 1:
+ new_values = new_values.T
data = extract_array(new_values, extract_numpy=True)
return [self.make_block_same_class(data, refs=refs)]
@@ -1809,6 +1814,7 @@ def pad_or_backfill(
self,
*,
method: FillnaOptions,
+ axis: AxisInt = 0,
inplace: bool = False,
limit: int | None = None,
limit_area: Literal["inside", "outside"] | None = None,
@@ -1821,11 +1827,11 @@ def pad_or_backfill(
elif limit_area is not None:
raise NotImplementedError(
f"{type(values).__name__} does not implement limit_area "
- "(added in pandas 2.2). 3rd-party ExtensionArray authors "
+ "(added in pandas 2.2). 3rd-party ExtnsionArray authors "
"need to add this argument to _pad_or_backfill."
)
- if values.ndim == 2:
+ if values.ndim == 2 and axis == 1:
# NDArrayBackedExtensionArray.fillna assumes axis=0
new_values = values.T._pad_or_backfill(**kwargs).T
else:
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index a124e8679ae8e..b68337d9e0de9 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -31,6 +31,7 @@
npt,
)
from pandas.compat._optional import import_optional_dependency
+from pandas.util._exceptions import find_stack_level
from pandas.core.dtypes.common import (
is_complex,
@@ -520,7 +521,12 @@ def nanany(
if values.dtype.kind == "M":
# GH#34479
- raise TypeError("datetime64 type does not support operation: 'any'")
+ warnings.warn(
+ "'any' with datetime64 dtypes is deprecated and will raise in a "
+ "future version. Use (obj != pd.Timestamp(0)).any() instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
values, _ = _get_values(values, skipna, fill_value=False, mask=mask)
@@ -576,7 +582,12 @@ def nanall(
if values.dtype.kind == "M":
# GH#34479
- raise TypeError("datetime64 type does not support operation: 'all'")
+ warnings.warn(
+ "'all' with datetime64 dtypes is deprecated and will raise in a "
+ "future version. Use (obj != pd.Timestamp(0)).all() instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
values, _ = _get_values(values, skipna, fill_value=True, mask=mask)
diff --git a/pandas/core/series.py b/pandas/core/series.py
index b0dc05fce7913..0761dc17ab147 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -5113,22 +5113,28 @@ def info(
)
@overload
- def _replace_single(self, to_replace, inplace: Literal[False]) -> Self: ...
+ def _replace_single(
+ self, to_replace, method: str, inplace: Literal[False], limit
+ ) -> Self: ...
@overload
- def _replace_single(self, to_replace, inplace: Literal[True]) -> None: ...
+ def _replace_single(
+ self, to_replace, method: str, inplace: Literal[True], limit
+ ) -> None: ...
@overload
- def _replace_single(self, to_replace, inplace: bool) -> Self | None: ...
+ def _replace_single(
+ self, to_replace, method: str, inplace: bool, limit
+ ) -> Self | None: ...
# TODO(3.0): this can be removed once GH#33302 deprecation is enforced
- def _replace_single(self, to_replace, inplace: bool) -> Self | None:
+ def _replace_single(
+ self, to_replace, method: str, inplace: bool, limit
+ ) -> Self | None:
"""
Replaces values in a Series using the fill method specified when no
replacement value is given in the replace method
"""
- limit = None
- method = "pad"
result = self if inplace else self.copy()
diff --git a/pandas/core/shared_docs.py b/pandas/core/shared_docs.py
index 2d8517693a2f8..a2b5439f9e12f 100644
--- a/pandas/core/shared_docs.py
+++ b/pandas/core/shared_docs.py
@@ -429,11 +429,20 @@
filled). Regular expressions, strings and lists or dicts of such
objects are also allowed.
{inplace}
+ limit : int, default None
+ Maximum size gap to forward or backward fill.
+
+ .. deprecated:: 2.1.0
regex : bool or same types as `to_replace`, default False
Whether to interpret `to_replace` and/or `value` as regular
expressions. Alternatively, this could be a regular expression or a
list, dict, or array of regular expressions in which case
`to_replace` must be ``None``.
+ method : {{'pad', 'ffill', 'bfill'}}
+ The method to use when for replacement, when `to_replace` is a
+ scalar, list or tuple and `value` is ``None``.
+
+ .. deprecated:: 2.1.0
Returns
-------
@@ -529,6 +538,14 @@
3 1 8 d
4 4 9 e
+ >>> s.replace([1, 2], method='bfill')
+ 0 3
+ 1 3
+ 2 3
+ 3 4
+ 4 5
+ dtype: int64
+
**dict-like `to_replace`**
>>> df.replace({{0: 10, 1: 100}})
@@ -598,7 +615,7 @@
When one uses a dict as the `to_replace` value, it is like the
value(s) in the dict are equal to the `value` parameter.
``s.replace({{'a': None}})`` is equivalent to
- ``s.replace(to_replace={{'a': None}}, value=None)``:
+ ``s.replace(to_replace={{'a': None}}, value=None, method=None)``:
>>> s.replace({{'a': None}})
0 10
diff --git a/pandas/io/json/_normalize.py b/pandas/io/json/_normalize.py
index ef717dd9b7ef8..7941fc2ce18cd 100644
--- a/pandas/io/json/_normalize.py
+++ b/pandas/io/json/_normalize.py
@@ -432,14 +432,14 @@ def _pull_field(
) -> Scalar | Iterable:
"""Internal function to pull field"""
result = js
+ if not isinstance(spec, list):
+ spec = [spec]
try:
- if isinstance(spec, list):
- for field in spec:
- if result is None:
- raise KeyError(field)
- result = result[field]
- else:
- result = result[spec]
+ for field in spec:
+ # GH 57810
+ if result is None or not len(result):
+ raise KeyError(field)
+ result = result[field]
except KeyError as e:
if extract_record:
raise KeyError(
diff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py
index 7ecd8cd6d5012..b234a6b78e051 100644
--- a/pandas/io/parsers/readers.py
+++ b/pandas/io/parsers/readers.py
@@ -1310,16 +1310,6 @@ def _check_file_or_buffer(self, f, engine: CSVEngine) -> None:
raise ValueError(
"The 'python' engine cannot iterate through this file buffer."
)
- if hasattr(f, "encoding"):
- file_encoding = f.encoding
- orig_reader_enc = self.orig_options.get("encoding", None)
- any_none = file_encoding is None or orig_reader_enc is None
- if file_encoding != orig_reader_enc and not any_none:
- file_path = getattr(f, "name", None)
- raise ValueError(
- f"The specified reader encoding {orig_reader_enc} is different "
- f"from the encoding {file_encoding} of file {file_path}."
- )
def _clean_options(
self, options: dict[str, Any], engine: CSVEngine
@@ -1495,7 +1485,6 @@ def _make_engine(
"pyarrow": ArrowParserWrapper,
"python-fwf": FixedWidthFieldParser,
}
-
if engine not in mapping:
raise ValueError(
f"Unknown engine: {engine} (valid options are {mapping.keys()})"
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index aa9d0d88ae69a..b80487abbc4ab 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -2380,9 +2380,7 @@ def to_sql(
raise ValueError("datatypes not supported") from exc
with self.con.cursor() as cur:
- total_inserted = cur.adbc_ingest(
- table_name=name, data=tbl, mode=mode, db_schema_name=schema
- )
+ total_inserted = cur.adbc_ingest(table_name, tbl, mode=mode)
self.con.commit()
return total_inserted
diff --git a/pandas/tests/arrays/period/test_constructors.py b/pandas/tests/arrays/period/test_constructors.py
index 63b0e456c4566..d034162f1b46e 100644
--- a/pandas/tests/arrays/period/test_constructors.py
+++ b/pandas/tests/arrays/period/test_constructors.py
@@ -135,6 +135,17 @@ def test_from_td64nat_sequence_raises():
pd.DataFrame(arr, dtype=dtype)
+def test_freq_deprecated():
+ # GH#52462
+ data = np.arange(5).astype(np.int64)
+ msg = "The 'freq' keyword in the PeriodArray constructor is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ res = PeriodArray(data, freq="M")
+
+ expected = PeriodArray(data, dtype="period[M]")
+ tm.assert_equal(res, expected)
+
+
def test_period_array_from_datetime64():
arr = np.array(
["2020-01-01T00:00:00", "2020-02-02T00:00:00"], dtype="datetime64[ns]"
diff --git a/pandas/tests/extension/base/groupby.py b/pandas/tests/extension/base/groupby.py
index dcbbac44d083a..414683b02dcba 100644
--- a/pandas/tests/extension/base/groupby.py
+++ b/pandas/tests/extension/base/groupby.py
@@ -162,10 +162,8 @@ def test_in_numeric_groupby(self, data_for_grouping):
msg = "|".join(
[
- # period
+ # period/datetime
"does not support sum operations",
- # datetime
- "does not support operation: 'sum'",
# all others
re.escape(f"agg function failed [how->sum,dtype->{dtype}"),
]
diff --git a/pandas/tests/extension/test_datetime.py b/pandas/tests/extension/test_datetime.py
index 5de4865feb6f9..06e85f5c92913 100644
--- a/pandas/tests/extension/test_datetime.py
+++ b/pandas/tests/extension/test_datetime.py
@@ -104,8 +104,10 @@ def _supports_reduction(self, obj, op_name: str) -> bool:
@pytest.mark.parametrize("skipna", [True, False])
def test_reduce_series_boolean(self, data, all_boolean_reductions, skipna):
meth = all_boolean_reductions
- msg = f"datetime64 type does not support operation: '{meth}'"
- with pytest.raises(TypeError, match=msg):
+ msg = f"'{meth}' with datetime64 dtypes is deprecated and will raise in"
+ with tm.assert_produces_warning(
+ FutureWarning, match=msg, check_stacklevel=False
+ ):
super().test_reduce_series_boolean(data, all_boolean_reductions, skipna)
def test_series_constructor(self, data):
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index 3b9c342f35a71..eb6d649c296fc 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -1171,6 +1171,48 @@ def test_replace_with_empty_dictlike(self, mix_abc):
tm.assert_frame_equal(df, df.replace({"b": {}}))
tm.assert_frame_equal(df, df.replace(Series({"b": {}})))
+ @pytest.mark.parametrize(
+ "to_replace, method, expected",
+ [
+ (0, "bfill", {"A": [1, 1, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]}),
+ (
+ np.nan,
+ "bfill",
+ {"A": [0, 1, 2], "B": [5.0, 7.0, 7.0], "C": ["a", "b", "c"]},
+ ),
+ ("d", "ffill", {"A": [0, 1, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]}),
+ (
+ [0, 2],
+ "bfill",
+ {"A": [1, 1, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]},
+ ),
+ (
+ [1, 2],
+ "pad",
+ {"A": [0, 0, 0], "B": [5, np.nan, 7], "C": ["a", "b", "c"]},
+ ),
+ (
+ (1, 2),
+ "bfill",
+ {"A": [0, 2, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]},
+ ),
+ (
+ ["b", "c"],
+ "ffill",
+ {"A": [0, 1, 2], "B": [5, np.nan, 7], "C": ["a", "a", "a"]},
+ ),
+ ],
+ )
+ def test_replace_method(self, to_replace, method, expected):
+ # GH 19632
+ df = DataFrame({"A": [0, 1, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]})
+
+ msg = "The 'method' keyword in DataFrame.replace is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ result = df.replace(to_replace=to_replace, value=None, method=method)
+ expected = DataFrame(expected)
+ tm.assert_frame_equal(result, expected)
+
@pytest.mark.parametrize(
"replace_dict, final_data",
[({"a": 1, "b": 1}, [[3, 3], [2, 2]]), ({"a": 1, "b": 2}, [[3, 1], [2, 3]])],
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index fd3dad37da1f9..5b9dd9e5b8aa6 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -1370,6 +1370,10 @@ def test_any_all_object_dtype(
expected = Series([True, True, val, True])
tm.assert_series_equal(result, expected)
+ # GH#50947 deprecates this but it is not emitting a warning in some builds.
+ @pytest.mark.filterwarnings(
+ "ignore:'any' with datetime64 dtypes is deprecated.*:FutureWarning"
+ )
def test_any_datetime(self):
# GH 23070
float_data = [1, np.nan, 3, np.nan]
@@ -1381,9 +1385,10 @@ def test_any_datetime(self):
]
df = DataFrame({"A": float_data, "B": datetime_data})
- msg = "datetime64 type does not support operation: 'any'"
- with pytest.raises(TypeError, match=msg):
- df.any(axis=1)
+ result = df.any(axis=1)
+
+ expected = Series([True, True, True, False])
+ tm.assert_series_equal(result, expected)
def test_any_all_bool_only(self):
# GH 25101
@@ -1475,23 +1480,23 @@ def test_any_all_np_func(self, func, data, expected):
TypeError, match="dtype category does not support reduction"
):
getattr(DataFrame(data), func.__name__)(axis=None)
- if data.dtypes.apply(lambda x: x.kind == "M").any():
- # GH#34479
- msg = "datetime64 type does not support operation: '(any|all)'"
- with pytest.raises(TypeError, match=msg):
- func(data)
-
- # method version
- with pytest.raises(TypeError, match=msg):
- getattr(DataFrame(data), func.__name__)(axis=None)
+ else:
+ msg = "'(any|all)' with datetime64 dtypes is deprecated"
+ if data.dtypes.apply(lambda x: x.kind == "M").any():
+ warn = FutureWarning
+ else:
+ warn = None
- elif data.dtypes.apply(lambda x: x != "category").any():
- result = func(data)
+ with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
+ # GH#34479
+ result = func(data)
assert isinstance(result, np.bool_)
assert result.item() is expected
# method version
- result = getattr(DataFrame(data), func.__name__)(axis=None)
+ with tm.assert_produces_warning(warn, match=msg):
+ # GH#34479
+ result = getattr(DataFrame(data), func.__name__)(axis=None)
assert isinstance(result, np.bool_)
assert result.item() is expected
diff --git a/pandas/tests/frame/test_subclass.py b/pandas/tests/frame/test_subclass.py
index 7d18ef28a722d..355953eac9d51 100644
--- a/pandas/tests/frame/test_subclass.py
+++ b/pandas/tests/frame/test_subclass.py
@@ -742,6 +742,18 @@ def test_equals_subclass(self):
assert df1.equals(df2)
assert df2.equals(df1)
+ def test_replace_list_method(self):
+ # https://github.com/pandas-dev/pandas/pull/46018
+ df = tm.SubclassedDataFrame({"A": [0, 1, 2]})
+ msg = "The 'method' keyword in SubclassedDataFrame.replace is deprecated"
+ with tm.assert_produces_warning(
+ FutureWarning, match=msg, raise_on_extra_warnings=False
+ ):
+ result = df.replace([1, 2], method="ffill")
+ expected = tm.SubclassedDataFrame({"A": [0, 0, 0]})
+ assert isinstance(result, tm.SubclassedDataFrame)
+ tm.assert_frame_equal(result, expected)
+
class MySubclassWithMetadata(DataFrame):
_metadata = ["my_metadata"]
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index bcad88bdecabb..7ec1598abf403 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -674,7 +674,7 @@ def test_raises_on_nuisance(df):
df = df.loc[:, ["A", "C", "D"]]
df["E"] = datetime.now()
grouped = df.groupby("A")
- msg = "datetime64 type does not support operation: 'sum'"
+ msg = "datetime64 type does not support sum operations"
with pytest.raises(TypeError, match=msg):
grouped.agg("sum")
with pytest.raises(TypeError, match=msg):
diff --git a/pandas/tests/groupby/test_raises.py b/pandas/tests/groupby/test_raises.py
index 7af27d7227035..f9d5de72eda1d 100644
--- a/pandas/tests/groupby/test_raises.py
+++ b/pandas/tests/groupby/test_raises.py
@@ -241,16 +241,16 @@ def test_groupby_raises_datetime(
return
klass, msg = {
- "all": (TypeError, "datetime64 type does not support operation: 'all'"),
- "any": (TypeError, "datetime64 type does not support operation: 'any'"),
+ "all": (None, ""),
+ "any": (None, ""),
"bfill": (None, ""),
"corrwith": (TypeError, "cannot perform __mul__ with this index type"),
"count": (None, ""),
"cumcount": (None, ""),
"cummax": (None, ""),
"cummin": (None, ""),
- "cumprod": (TypeError, "datetime64 type does not support operation: 'cumprod'"),
- "cumsum": (TypeError, "datetime64 type does not support operation: 'cumsum'"),
+ "cumprod": (TypeError, "datetime64 type does not support cumprod operations"),
+ "cumsum": (TypeError, "datetime64 type does not support cumsum operations"),
"diff": (None, ""),
"ffill": (None, ""),
"fillna": (None, ""),
@@ -265,7 +265,7 @@ def test_groupby_raises_datetime(
"ngroup": (None, ""),
"nunique": (None, ""),
"pct_change": (TypeError, "cannot perform __truediv__ with this index type"),
- "prod": (TypeError, "datetime64 type does not support operation: 'prod'"),
+ "prod": (TypeError, "datetime64 type does not support prod"),
"quantile": (None, ""),
"rank": (None, ""),
"sem": (None, ""),
@@ -276,16 +276,18 @@ def test_groupby_raises_datetime(
"|".join(
[
r"dtype datetime64\[ns\] does not support reduction",
- "datetime64 type does not support operation: 'skew'",
+ "datetime64 type does not support skew operations",
]
),
),
"std": (None, ""),
- "sum": (TypeError, "datetime64 type does not support operation: 'sum"),
- "var": (TypeError, "datetime64 type does not support operation: 'var'"),
+ "sum": (TypeError, "datetime64 type does not support sum operations"),
+ "var": (TypeError, "datetime64 type does not support var operations"),
}[groupby_func]
- if groupby_func == "fillna":
+ if groupby_func in ["any", "all"]:
+ warn_msg = f"'{groupby_func}' with datetime64 dtypes is deprecated"
+ elif groupby_func == "fillna":
kind = "Series" if groupby_series else "DataFrame"
warn_msg = f"{kind}GroupBy.fillna is deprecated"
else:
diff --git a/pandas/tests/groupby/transform/test_numba.py b/pandas/tests/groupby/transform/test_numba.py
index a17d25b2e7e2e..b75113d3f4e14 100644
--- a/pandas/tests/groupby/transform/test_numba.py
+++ b/pandas/tests/groupby/transform/test_numba.py
@@ -181,25 +181,10 @@ def f(values, index):
df = DataFrame({"group": ["A", "A", "B"], "v": [4, 5, 6]}, index=[-1, -2, -3])
result = df.groupby("group").transform(f, engine="numba")
- expected = DataFrame([-2.0, -3.0, -4.0], columns=["v"], index=[-1, -2, -3])
+ expected = DataFrame([-4.0, -3.0, -2.0], columns=["v"], index=[-1, -2, -3])
tm.assert_frame_equal(result, expected)
-def test_index_order_consistency_preserved():
- # GH 57069
- pytest.importorskip("numba")
-
- def f(values, index):
- return values
-
- df = DataFrame(
- {"vals": [0.0, 1.0, 2.0, 3.0], "group": [0, 1, 0, 1]}, index=range(3, -1, -1)
- )
- result = df.groupby("group")["vals"].transform(f, engine="numba")
- expected = Series([0.0, 1.0, 2.0, 3.0], index=range(3, -1, -1), name="vals")
- tm.assert_series_equal(result, expected)
-
-
def test_engine_kwargs_not_cached():
# If the user passes a different set of engine_kwargs don't return the same
# jitted function
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index 245fb9c7babd7..46f6367fbb3ed 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -749,7 +749,6 @@ def test_cython_transform_frame_column(
msg = "|".join(
[
"does not support .* operations",
- "does not support operation",
".* is not supported for object dtype",
"is not implemented for this dtype",
]
@@ -1491,47 +1490,3 @@ def test_idxmin_idxmax_transform_args(how, skipna, numeric_only):
msg = f"DataFrameGroupBy.{how} with skipna=False encountered an NA value"
with pytest.raises(ValueError, match=msg):
gb.transform(how, skipna, numeric_only)
-
-
-def test_transform_sum_one_column_no_matching_labels():
- df = DataFrame({"X": [1.0]})
- series = Series(["Y"])
- result = df.groupby(series, as_index=False).transform("sum")
- expected = DataFrame({"X": [1.0]})
- tm.assert_frame_equal(result, expected)
-
-
-def test_transform_sum_no_matching_labels():
- df = DataFrame({"X": [1.0, -93204, 4935]})
- series = Series(["A", "B", "C"])
-
- result = df.groupby(series, as_index=False).transform("sum")
- expected = DataFrame({"X": [1.0, -93204, 4935]})
- tm.assert_frame_equal(result, expected)
-
-
-def test_transform_sum_one_column_with_matching_labels():
- df = DataFrame({"X": [1.0, -93204, 4935]})
- series = Series(["A", "B", "A"])
-
- result = df.groupby(series, as_index=False).transform("sum")
- expected = DataFrame({"X": [4936.0, -93204, 4936.0]})
- tm.assert_frame_equal(result, expected)
-
-
-def test_transform_sum_one_column_with_missing_labels():
- df = DataFrame({"X": [1.0, -93204, 4935]})
- series = Series(["A", "C"])
-
- result = df.groupby(series, as_index=False).transform("sum")
- expected = DataFrame({"X": [1.0, -93204, np.nan]})
- tm.assert_frame_equal(result, expected)
-
-
-def test_transform_sum_one_column_with_matching_labels_and_missing_labels():
- df = DataFrame({"X": [1.0, -93204, 4935]})
- series = Series(["A", "A"])
-
- result = df.groupby(series, as_index=False).transform("sum")
- expected = DataFrame({"X": [-93203.0, -93203.0, np.nan]})
- tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexes/multi/test_conversion.py b/pandas/tests/indexes/multi/test_conversion.py
index f6b10c989326f..3c2ca045d6f99 100644
--- a/pandas/tests/indexes/multi/test_conversion.py
+++ b/pandas/tests/indexes/multi/test_conversion.py
@@ -5,7 +5,6 @@
from pandas import (
DataFrame,
MultiIndex,
- RangeIndex,
)
import pandas._testing as tm
@@ -149,13 +148,6 @@ def test_to_frame_duplicate_labels():
tm.assert_frame_equal(result, expected)
-def test_to_frame_column_rangeindex():
- mi = MultiIndex.from_arrays([[1, 2], ["a", "b"]])
- result = mi.to_frame().columns
- expected = RangeIndex(2)
- tm.assert_index_equal(result, expected, exact=True)
-
-
def test_to_flat_index(idx):
expected = pd.Index(
(
diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index 088fcfcd7d75f..4416034795463 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -312,8 +312,8 @@ def test_cant_or_shouldnt_cast(self, dtype):
def test_view_index(self, simple_index):
index = simple_index
- msg = "Cannot change data-type for object array"
- with pytest.raises(TypeError, match=msg):
+ msg = "Passing a type in .*Index.view is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
index.view(Index)
def test_prevent_casting(self, simple_index):
diff --git a/pandas/tests/indexes/ranges/test_range.py b/pandas/tests/indexes/ranges/test_range.py
index 8d41efa586411..c9ddbf4464b29 100644
--- a/pandas/tests/indexes/ranges/test_range.py
+++ b/pandas/tests/indexes/ranges/test_range.py
@@ -200,6 +200,11 @@ def test_view(self):
i_view = i.view("i8")
tm.assert_numpy_array_equal(i.values, i_view)
+ msg = "Passing a type in RangeIndex.view is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ i_view = i.view(RangeIndex)
+ tm.assert_index_equal(i, i_view)
+
def test_dtype(self, simple_index):
index = simple_index
assert index.dtype == np.int64
@@ -375,8 +380,8 @@ def test_cant_or_shouldnt_cast(self, start, stop, step):
def test_view_index(self, simple_index):
index = simple_index
- msg = "Cannot change data-type for object array"
- with pytest.raises(TypeError, match=msg):
+ msg = "Passing a type in RangeIndex.view is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
index.view(Index)
def test_prevent_casting(self, simple_index):
diff --git a/pandas/tests/indexes/test_common.py b/pandas/tests/indexes/test_common.py
index a2dee61295c74..eb0010066a7f6 100644
--- a/pandas/tests/indexes/test_common.py
+++ b/pandas/tests/indexes/test_common.py
@@ -508,17 +508,3 @@ def test_compare_read_only_array():
idx = pd.Index(arr)
result = idx > 69
assert result.dtype == bool
-
-
-def test_to_frame_column_rangeindex():
- idx = pd.Index([1])
- result = idx.to_frame().columns
- expected = RangeIndex(1)
- tm.assert_index_equal(result, expected, exact=True)
-
-
-def test_to_frame_name_tuple_multiindex():
- idx = pd.Index([1])
- result = idx.to_frame(name=(1, 2))
- expected = pd.DataFrame([1], columns=MultiIndex.from_arrays([[1], [2]]), index=idx)
- tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexes/test_datetimelike.py b/pandas/tests/indexes/test_datetimelike.py
index 0ad5888a44392..7ec73070836b8 100644
--- a/pandas/tests/indexes/test_datetimelike.py
+++ b/pandas/tests/indexes/test_datetimelike.py
@@ -85,12 +85,15 @@ def test_str(self, simple_index):
def test_view(self, simple_index):
idx = simple_index
+ idx_view = idx.view("i8")
result = type(simple_index)(idx)
tm.assert_index_equal(result, idx)
- msg = "Cannot change data-type for object array"
- with pytest.raises(TypeError, match=msg):
- idx.view(type(simple_index))
+ msg = "Passing a type in .*Index.view is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ idx_view = idx.view(type(simple_index))
+ result = type(simple_index)(idx)
+ tm.assert_index_equal(result, idx_view)
def test_map_callable(self, simple_index):
index = simple_index
diff --git a/pandas/tests/indexes/test_old_base.py b/pandas/tests/indexes/test_old_base.py
index d4dc248b39dc5..85eec7b7c018d 100644
--- a/pandas/tests/indexes/test_old_base.py
+++ b/pandas/tests/indexes/test_old_base.py
@@ -891,10 +891,10 @@ def test_view(self, simple_index):
idx_view = idx.view(dtype)
tm.assert_index_equal(idx, index_cls(idx_view, name="Foo"), exact=True)
- msg = "Cannot change data-type for object array"
- with pytest.raises(TypeError, match=msg):
- # GH#55709
- idx.view(index_cls)
+ msg = "Passing a type in .*Index.view is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ idx_view = idx.view(index_cls)
+ tm.assert_index_equal(idx, index_cls(idx_view, name="Foo"), exact=True)
def test_insert_non_na(self, simple_index):
# GH#43921 inserting an element that we know we can hold should
diff --git a/pandas/tests/interchange/test_impl.py b/pandas/tests/interchange/test_impl.py
index 60e05c2c65124..83574e8630d6f 100644
--- a/pandas/tests/interchange/test_impl.py
+++ b/pandas/tests/interchange/test_impl.py
@@ -459,7 +459,6 @@ def test_non_str_names_w_duplicates():
),
([1.0, 2.25, None], "Float32", "float32"),
([1.0, 2.25, None], "Float32[pyarrow]", "float32"),
- ([True, False, None], "boolean", "bool"),
([True, False, None], "boolean[pyarrow]", "bool"),
(["much ado", "about", None], "string[pyarrow_numpy]", "large_string"),
(["much ado", "about", None], "string[pyarrow]", "large_string"),
@@ -522,7 +521,6 @@ def test_pandas_nullable_with_missing_values(
),
([1.0, 2.25, 5.0], "Float32", "float32"),
([1.0, 2.25, 5.0], "Float32[pyarrow]", "float32"),
- ([True, False, False], "boolean", "bool"),
([True, False, False], "boolean[pyarrow]", "bool"),
(["much ado", "about", "nothing"], "string[pyarrow_numpy]", "large_string"),
(["much ado", "about", "nothing"], "string[pyarrow]", "large_string"),
diff --git a/pandas/tests/io/json/test_normalize.py b/pandas/tests/io/json/test_normalize.py
index d83e7b4641e88..7098903359e28 100644
--- a/pandas/tests/io/json/test_normalize.py
+++ b/pandas/tests/io/json/test_normalize.py
@@ -106,6 +106,15 @@ def missing_metadata():
],
"previous_residences": {"cities": [{"city_name": "Barmingham"}]},
},
+ {
+ "name": "Minnie",
+ "addresses": [
+ {
+ "number": 8449,
+ }
+ ],
+ "previous_residences": {"cities": []},
+ },
]
@@ -631,14 +640,15 @@ def test_missing_meta(self, missing_metadata):
ex_data = [
[9562, "Morris St.", "Massillon", "OH", 44646, "Alice"],
[8449, "Spring St.", "Elizabethton", "TN", 37643, np.nan],
+ [8449, np.nan, np.nan, np.nan, np.nan, "Minnie"],
]
columns = ["number", "street", "city", "state", "zip", "name"]
expected = DataFrame(ex_data, columns=columns)
tm.assert_frame_equal(result, expected)
- def test_missing_nested_meta(self):
+ def test_missing_nested_meta_traverse_none_errors_ignore(self):
# GH44312
- # If errors="ignore" and nested metadata is null, we should return nan
+ # If errors="ignore" and nested metadata is nullable, return nan
data = {"meta": "foo", "nested_meta": None, "value": [{"rec": 1}, {"rec": 2}]}
result = json_normalize(
data,
@@ -653,8 +663,11 @@ def test_missing_nested_meta(self):
)
tm.assert_frame_equal(result, expected)
- # If errors="raise" and nested metadata is null, we should raise with the
- # key of the first missing level
+ def test_missing_nested_meta_traverse_none_errors_raise(self):
+ # GH44312
+ # If errors="raise" and nested metadata is null, should raise
+ data = {"meta": "foo", "nested_meta": None, "value": [{"rec": 1}, {"rec": 2}]}
+
with pytest.raises(KeyError, match="'leaf' not found"):
json_normalize(
data,
@@ -663,6 +676,22 @@ def test_missing_nested_meta(self):
errors="raise",
)
+ def test_missing_nested_meta_traverse_empty_list_errors_ignore(self):
+ # If errors="ignore" and nested metadata is nullable, return nan
+ data = {"meta": "foo", "nested_meta": [], "value": [{"rec": 1}, {"rec": 2}]}
+ result = json_normalize(
+ data,
+ record_path="value",
+ meta=["meta", ["nested_meta", "leaf"]],
+ errors="ignore",
+ )
+ ex_data = [[1, "foo", np.nan], [2, "foo", np.nan]]
+ columns = ["rec", "meta", "nested_meta.leaf"]
+ expected = DataFrame(ex_data, columns=columns).astype(
+ {"nested_meta.leaf": object}
+ )
+ tm.assert_frame_equal(result, expected)
+
def test_missing_meta_multilevel_record_path_errors_raise(self, missing_metadata):
# GH41876
# Ensure errors='raise' works as intended even when a record_path of length
@@ -681,8 +710,8 @@ def test_missing_meta_multilevel_record_path_errors_raise(self, missing_metadata
def test_missing_meta_multilevel_record_path_errors_ignore(self, missing_metadata):
# GH41876
- # Ensure errors='ignore' works as intended even when a record_path of length
- # greater than one is passed in
+ # Ensure errors='ignore' works as intended
+ # even when a record_path of length greater than one is passed in
result = json_normalize(
data=missing_metadata,
record_path=["previous_residences", "cities"],
diff --git a/pandas/tests/io/parser/test_c_parser_only.py b/pandas/tests/io/parser/test_c_parser_only.py
index 98a460f221592..090235c862a2a 100644
--- a/pandas/tests/io/parser/test_c_parser_only.py
+++ b/pandas/tests/io/parser/test_c_parser_only.py
@@ -511,7 +511,7 @@ def __next__(self):
def test_buffer_rd_bytes_bad_unicode(c_parser_only):
# see gh-22748
t = BytesIO(b"\xb0")
- t = TextIOWrapper(t, encoding="UTF-8", errors="surrogateescape")
+ t = TextIOWrapper(t, encoding="ascii", errors="surrogateescape")
msg = "'utf-8' codec can't encode character"
with pytest.raises(UnicodeError, match=msg):
c_parser_only.read_csv(t, encoding="UTF-8")
diff --git a/pandas/tests/io/parser/test_textreader.py b/pandas/tests/io/parser/test_textreader.py
index eeb783f1957b7..6aeed2377a3aa 100644
--- a/pandas/tests/io/parser/test_textreader.py
+++ b/pandas/tests/io/parser/test_textreader.py
@@ -48,13 +48,6 @@ def test_StringIO(self, csv_path):
reader = TextReader(src, header=None)
reader.read()
- def test_encoding_mismatch_warning(self, csv_path):
- # GH-57954
- with open(csv_path, encoding="UTF-8") as f:
- msg = "latin1 is different from the encoding"
- with pytest.raises(ValueError, match=msg):
- read_csv(f, encoding="latin1")
-
def test_string_factorize(self):
# should this be optional?
data = "a\nb\na\nb\na"
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 67b1311a5a798..c8f4d68230e5b 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -1373,30 +1373,6 @@ def insert_on_conflict(table, conn, keys, data_iter):
pandasSQL.drop_table("test_insert_conflict")
-@pytest.mark.parametrize("conn", all_connectable)
-def test_to_sql_on_public_schema(conn, request):
- if "sqlite" in conn or "mysql" in conn:
- request.applymarker(
- pytest.mark.xfail(
- reason="test for public schema only specific to postgresql"
- )
- )
-
- conn = request.getfixturevalue(conn)
-
- test_data = DataFrame([[1, 2.1, "a"], [2, 3.1, "b"]], columns=list("abc"))
- test_data.to_sql(
- name="test_public_schema",
- con=conn,
- if_exists="append",
- index=False,
- schema="public",
- )
-
- df_out = sql.read_sql_table("test_public_schema", conn, schema="public")
- tm.assert_frame_equal(test_data, df_out)
-
-
@pytest.mark.parametrize("conn", mysql_connectable)
def test_insertion_method_on_conflict_update(conn, request):
# GH 14553: Example in to_sql docstring
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index 048553330c1ce..b10319f5380e7 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -1009,41 +1009,32 @@ def test_any_all_datetimelike(self):
ser = Series(dta)
df = DataFrame(ser)
- # GH#34479
- msg = "datetime64 type does not support operation: '(any|all)'"
- with pytest.raises(TypeError, match=msg):
- dta.all()
- with pytest.raises(TypeError, match=msg):
- dta.any()
+ msg = "'(any|all)' with datetime64 dtypes is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ # GH#34479
+ assert dta.all()
+ assert dta.any()
- with pytest.raises(TypeError, match=msg):
- ser.all()
- with pytest.raises(TypeError, match=msg):
- ser.any()
+ assert ser.all()
+ assert ser.any()
- with pytest.raises(TypeError, match=msg):
- df.any().all()
- with pytest.raises(TypeError, match=msg):
- df.all().all()
+ assert df.any().all()
+ assert df.all().all()
dta = dta.tz_localize("UTC")
ser = Series(dta)
df = DataFrame(ser)
- # GH#34479
- with pytest.raises(TypeError, match=msg):
- dta.all()
- with pytest.raises(TypeError, match=msg):
- dta.any()
- with pytest.raises(TypeError, match=msg):
- ser.all()
- with pytest.raises(TypeError, match=msg):
- ser.any()
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ # GH#34479
+ assert dta.all()
+ assert dta.any()
- with pytest.raises(TypeError, match=msg):
- df.any().all()
- with pytest.raises(TypeError, match=msg):
- df.all().all()
+ assert ser.all()
+ assert ser.any()
+
+ assert df.any().all()
+ assert df.all().all()
tda = dta - dta[0]
ser = Series(tda)
diff --git a/pandas/tests/resample/test_resample_api.py b/pandas/tests/resample/test_resample_api.py
index 9b442fa7dbd07..f3b9c909290a8 100644
--- a/pandas/tests/resample/test_resample_api.py
+++ b/pandas/tests/resample/test_resample_api.py
@@ -708,9 +708,7 @@ def test_selection_api_validation():
tm.assert_frame_equal(exp, result)
exp.index.name = "d"
- with pytest.raises(
- TypeError, match="datetime64 type does not support operation: 'sum'"
- ):
+ with pytest.raises(TypeError, match="datetime64 type does not support sum"):
df.resample("2D", level="d").sum()
result = df.resample("2D", level="d").sum(numeric_only=True)
tm.assert_frame_equal(exp, result)
diff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py
index 09a3469e73462..c7b894e73d0dd 100644
--- a/pandas/tests/series/methods/test_replace.py
+++ b/pandas/tests/series/methods/test_replace.py
@@ -196,6 +196,19 @@ def test_replace_with_single_list(self):
assert return_value is None
tm.assert_series_equal(s, pd.Series([0, 0, 0, 0, 4]))
+ # make sure things don't get corrupted when fillna call fails
+ s = ser.copy()
+ msg = (
+ r"Invalid fill method\. Expecting pad \(ffill\) or backfill "
+ r"\(bfill\)\. Got crash_cymbal"
+ )
+ msg3 = "The 'method' keyword in Series.replace is deprecated"
+ with pytest.raises(ValueError, match=msg):
+ with tm.assert_produces_warning(FutureWarning, match=msg3):
+ return_value = s.replace([1, 2, 3], inplace=True, method="crash_cymbal")
+ assert return_value is None
+ tm.assert_series_equal(s, ser)
+
def test_replace_mixed_types(self):
ser = pd.Series(np.arange(5), dtype="int64")
@@ -537,6 +550,62 @@ def test_replace_extension_other(self, frame_or_series):
# should not have changed dtype
tm.assert_equal(obj, result)
+ def _check_replace_with_method(self, ser: pd.Series):
+ df = ser.to_frame()
+
+ msg1 = "The 'method' keyword in Series.replace is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg1):
+ res = ser.replace(ser[1], method="pad")
+ expected = pd.Series([ser[0], ser[0]] + list(ser[2:]), dtype=ser.dtype)
+ tm.assert_series_equal(res, expected)
+
+ msg2 = "The 'method' keyword in DataFrame.replace is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg2):
+ res_df = df.replace(ser[1], method="pad")
+ tm.assert_frame_equal(res_df, expected.to_frame())
+
+ ser2 = ser.copy()
+ with tm.assert_produces_warning(FutureWarning, match=msg1):
+ res2 = ser2.replace(ser[1], method="pad", inplace=True)
+ assert res2 is None
+ tm.assert_series_equal(ser2, expected)
+
+ with tm.assert_produces_warning(FutureWarning, match=msg2):
+ res_df2 = df.replace(ser[1], method="pad", inplace=True)
+ assert res_df2 is None
+ tm.assert_frame_equal(df, expected.to_frame())
+
+ def test_replace_ea_dtype_with_method(self, any_numeric_ea_dtype):
+ arr = pd.array([1, 2, pd.NA, 4], dtype=any_numeric_ea_dtype)
+ ser = pd.Series(arr)
+
+ self._check_replace_with_method(ser)
+
+ @pytest.mark.parametrize("as_categorical", [True, False])
+ def test_replace_interval_with_method(self, as_categorical):
+ # in particular interval that can't hold NA
+
+ idx = pd.IntervalIndex.from_breaks(range(4))
+ ser = pd.Series(idx)
+ if as_categorical:
+ ser = ser.astype("category")
+
+ self._check_replace_with_method(ser)
+
+ @pytest.mark.parametrize("as_period", [True, False])
+ @pytest.mark.parametrize("as_categorical", [True, False])
+ def test_replace_datetimelike_with_method(self, as_period, as_categorical):
+ idx = pd.date_range("2016-01-01", periods=5, tz="US/Pacific")
+ if as_period:
+ idx = idx.tz_localize(None).to_period("D")
+
+ ser = pd.Series(idx)
+ ser.iloc[-2] = pd.NaT
+ if as_categorical:
+ ser = ser.astype("category")
+
+ self._check_replace_with_method(ser)
+
def test_replace_with_compiled_regex(self):
# https://github.com/pandas-dev/pandas/issues/35680
s = pd.Series(["a", "b", "c"])
diff --git a/pandas/tests/series/test_cumulative.py b/pandas/tests/series/test_cumulative.py
index 9b7b08127a550..68d7fd8b90df2 100644
--- a/pandas/tests/series/test_cumulative.py
+++ b/pandas/tests/series/test_cumulative.py
@@ -91,25 +91,6 @@ def test_cummin_cummax_datetimelike(self, ts, method, skipna, exp_tdi):
result = getattr(ser, method)(skipna=skipna)
tm.assert_series_equal(expected, result)
- def test_cumsum_datetimelike(self):
- # GH#57956
- df = pd.DataFrame(
- [
- [pd.Timedelta(0), pd.Timedelta(days=1)],
- [pd.Timedelta(days=2), pd.NaT],
- [pd.Timedelta(hours=-6), pd.Timedelta(hours=12)],
- ]
- )
- result = df.cumsum()
- expected = pd.DataFrame(
- [
- [pd.Timedelta(0), pd.Timedelta(days=1)],
- [pd.Timedelta(days=2), pd.NaT],
- [pd.Timedelta(days=1, hours=18), pd.Timedelta(days=1, hours=12)],
- ]
- )
- tm.assert_frame_equal(result, expected)
-
@pytest.mark.parametrize(
"func, exp",
[
diff --git a/pandas/tests/test_take.py b/pandas/tests/test_take.py
index ce2e4e0f6cec5..4f34ab34c35f0 100644
--- a/pandas/tests/test_take.py
+++ b/pandas/tests/test_take.py
@@ -299,11 +299,9 @@ def test_take_na_empty(self):
tm.assert_numpy_array_equal(result, expected)
def test_take_coerces_list(self):
- # GH#52981 coercing is deprecated, disabled in 3.0
arr = [1, 2, 3]
- msg = (
- "pd.api.extensions.take requires a numpy.ndarray, ExtensionArray, "
- "Index, or Series, got list"
- )
- with pytest.raises(TypeError, match=msg):
- algos.take(arr, [0, 0])
+ msg = "take accepting non-standard inputs is deprecated"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ result = algos.take(arr, [0, 0])
+ expected = np.array([1, 1])
+ tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/tseries/holiday/test_holiday.py b/pandas/tests/tseries/holiday/test_holiday.py
index 08f4a1250392e..b2eefd04ef93b 100644
--- a/pandas/tests/tseries/holiday/test_holiday.py
+++ b/pandas/tests/tseries/holiday/test_holiday.py
@@ -271,25 +271,6 @@ def test_both_offset_observance_raises():
)
-def test_list_of_list_of_offsets_raises():
- # see gh-29049
- # Test that the offsets of offsets are forbidden
- holiday1 = Holiday(
- "Holiday1",
- month=USThanksgivingDay.month,
- day=USThanksgivingDay.day,
- offset=[USThanksgivingDay.offset, DateOffset(1)],
- )
- msg = "Only BaseOffsets and flat lists of them are supported for offset."
- with pytest.raises(ValueError, match=msg):
- Holiday(
- "Holiday2",
- month=holiday1.month,
- day=holiday1.day,
- offset=[holiday1.offset, DateOffset(3)],
- )
-
-
def test_half_open_interval_with_observance():
# Prompted by GH 49075
# Check for holidays that have a half-open date interval where
diff --git a/pandas/tseries/holiday.py b/pandas/tseries/holiday.py
index 8e51183138b5c..cc9e2e3be8c38 100644
--- a/pandas/tseries/holiday.py
+++ b/pandas/tseries/holiday.py
@@ -4,7 +4,6 @@
datetime,
timedelta,
)
-from typing import Callable
import warnings
from dateutil.relativedelta import (
@@ -18,7 +17,6 @@
)
import numpy as np
-from pandas._libs.tslibs.offsets import BaseOffset
from pandas.errors import PerformanceWarning
from pandas import (
@@ -161,34 +159,24 @@ def __init__(
year=None,
month=None,
day=None,
- offset: BaseOffset | list[BaseOffset] | None = None,
- observance: Callable | None = None,
+ offset=None,
+ observance=None,
start_date=None,
end_date=None,
- days_of_week: tuple | None = None,
+ days_of_week=None,
) -> None:
"""
Parameters
----------
name : str
Name of the holiday , defaults to class name
- year : int, default None
- Year of the holiday
- month : int, default None
- Month of the holiday
- day : int, default None
- Day of the holiday
- offset : list of pandas.tseries.offsets or
- class from pandas.tseries.offsets, default None
- Computes offset from date
- observance : function, default None
- Computes when holiday is given a pandas Timestamp
- start_date : datetime-like, default None
- First date the holiday is observed
- end_date : datetime-like, default None
- Last date the holiday is observed
- days_of_week : tuple of int or dateutil.relativedelta weekday strs, default None
- Provide a tuple of days e.g (0,1,2,3,) for Monday Through Thursday
+ offset : array of pandas.tseries.offsets or
+ class from pandas.tseries.offsets
+ computes offset from date
+ observance: function
+ computes when holiday is given a pandas Timestamp
+ days_of_week:
+ provide a tuple of days e.g (0,1,2,3,) for Monday Through Thursday
Monday=0,..,Sunday=6
Examples
@@ -228,19 +216,8 @@ class from pandas.tseries.offsets, default None
>>> July3rd
Holiday: July 3rd (month=7, day=3, )
"""
- if offset is not None:
- if observance is not None:
- raise NotImplementedError("Cannot use both offset and observance.")
- if not (
- isinstance(offset, BaseOffset)
- or (
- isinstance(offset, list)
- and all(isinstance(off, BaseOffset) for off in offset)
- )
- ):
- raise ValueError(
- "Only BaseOffsets and flat lists of them are supported for offset."
- )
+ if offset is not None and observance is not None:
+ raise NotImplementedError("Cannot use both offset and observance.")
self.name = name
self.year = year
diff --git a/web/pandas/community/ecosystem.md b/web/pandas/community/ecosystem.md
index 6cd67302b2a0e..715a2fafbe87a 100644
--- a/web/pandas/community/ecosystem.md
+++ b/web/pandas/community/ecosystem.md
@@ -82,20 +82,6 @@ pd.set_option("plotting.backend", "pandas_bokeh")
It is very similar to the matplotlib plotting backend, but provides
interactive web-based charts and maps.
-### [pygwalker](https://github.com/Kanaries/pygwalker)
-
-PyGWalker is an interactive data visualization and
-exploratory data analysis tool built upon Graphic Walker
-with support for visualization, cleaning, and annotation workflows.
-
-pygwalker can save interactively created charts
-to Graphic-Walker and Vega-Lite JSON.
-
-```
-import pygwalker as pyg
-pyg.walk(df)
-```
-
### [seaborn](https://seaborn.pydata.org)
Seaborn is a Python visualization library based on
@@ -108,11 +94,6 @@ pandas with the option to perform statistical estimation while plotting,
aggregating across observations and visualizing the fit of statistical
models to emphasize patterns in a dataset.
-```
-import seaborn as sns
-sns.set_theme()
-```
-
### [plotnine](https://github.com/has2k1/plotnine/)
Hadley Wickham's [ggplot2](https://ggplot2.tidyverse.org/) is a
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58073 | 2024-03-29T15:08:28Z | 2024-03-29T15:08:56Z | null | 2024-03-29T15:09:01Z |
DEPR: unsupported dt64/td64 dtypes in pd.array | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 2ebd6fb62b424..7ee31fdf88082 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -207,6 +207,7 @@ Removal of prior version deprecations/changes
- All arguments except ``name`` in :meth:`Index.rename` are now keyword only (:issue:`56493`)
- All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`)
- Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
+- Disallow units other than "s", "ms", "us", "ns" for datetime64 and timedelta64 dtypes in :func:`array` (:issue:`53817`)
- Removed "freq" keyword from :class:`PeriodArray` constructor, use "dtype" instead (:issue:`52462`)
- Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
- Removed the "closed" and "normalize" keywords in :meth:`DatetimeIndex.__new__` (:issue:`52628`)
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index e6d99ab773db9..ec49340e9a516 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -15,7 +15,6 @@
cast,
overload,
)
-import warnings
import numpy as np
from numpy import ma
@@ -35,7 +34,6 @@
DtypeObj,
T,
)
-from pandas.util._exceptions import find_stack_level
from pandas.core.dtypes.base import ExtensionDtype
from pandas.core.dtypes.cast import (
@@ -373,13 +371,10 @@ def array(
return TimedeltaArray._from_sequence(data, dtype=dtype, copy=copy)
elif lib.is_np_dtype(dtype, "mM"):
- warnings.warn(
+ raise ValueError(
+ # GH#53817
r"datetime64 and timedelta64 dtype resolutions other than "
- r"'s', 'ms', 'us', and 'ns' are deprecated. "
- r"In future releases passing unsupported resolutions will "
- r"raise an exception.",
- FutureWarning,
- stacklevel=find_stack_level(),
+ r"'s', 'ms', 'us', and 'ns' are no longer supported."
)
return NumpyExtensionArray._from_sequence(data, dtype=dtype, copy=copy)
diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index a84fefebf044c..50dafb5dbbb06 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -1,6 +1,5 @@
import datetime
import decimal
-import re
import numpy as np
import pytest
@@ -31,15 +30,13 @@
@pytest.mark.parametrize("dtype_unit", ["M8[h]", "M8[m]", "m8[h]"])
def test_dt64_array(dtype_unit):
- # PR 53817
+ # GH#53817
dtype_var = np.dtype(dtype_unit)
msg = (
r"datetime64 and timedelta64 dtype resolutions other than "
- r"'s', 'ms', 'us', and 'ns' are deprecated. "
- r"In future releases passing unsupported resolutions will "
- r"raise an exception."
+ r"'s', 'ms', 'us', and 'ns' are no longer supported."
)
- with tm.assert_produces_warning(FutureWarning, match=re.escape(msg)):
+ with pytest.raises(ValueError, match=msg):
pd.array([], dtype=dtype_var)
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58060 | 2024-03-29T02:29:08Z | 2024-03-29T18:16:10Z | 2024-03-29T18:16:10Z | 2024-03-29T18:35:49Z |
DEPR: Index.insert dtype inference | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index c91cc6ab7acdb..ccac930d533fd 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -209,6 +209,7 @@ Removal of prior version deprecations/changes
- Removed "freq" keyword from :class:`PeriodArray` constructor, use "dtype" instead (:issue:`52462`)
- Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
- Removed the "closed" and "normalize" keywords in :meth:`DatetimeIndex.__new__` (:issue:`52628`)
+- Stopped performing dtype inference with in :meth:`Index.insert` with object-dtype index; this often affects the index/columns that result when setting new entries into an empty :class:`Series` or :class:`DataFrame` (:issue:`51363`)
- Removed the "closed" and "unit" keywords in :meth:`TimedeltaIndex.__new__` (:issue:`52628`, :issue:`55499`)
- All arguments in :meth:`Index.sort_values` are now keyword only (:issue:`56493`)
- All arguments in :meth:`Series.to_dict` are now keyword only (:issue:`56493`)
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 76dd19a9424f5..76f36f1fbac5f 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -20,10 +20,7 @@
import numpy as np
-from pandas._config import (
- get_option,
- using_pyarrow_string_dtype,
-)
+from pandas._config import get_option
from pandas._libs import (
NaT,
@@ -6614,23 +6611,8 @@ def insert(self, loc: int, item) -> Index:
loc = loc if loc >= 0 else loc - 1
new_values[loc] = item
- out = Index._with_infer(new_values, name=self.name)
- if (
- using_pyarrow_string_dtype()
- and is_string_dtype(out.dtype)
- and new_values.dtype == object
- ):
- out = out.astype(new_values.dtype)
- if self.dtype == object and out.dtype != object:
- # GH#51363
- warnings.warn(
- "The behavior of Index.insert with object-dtype is deprecated, "
- "in a future version this will return an object-dtype Index "
- "instead of inferring a non-object dtype. To retain the old "
- "behavior, do `idx.insert(loc, item).infer_objects(copy=False)`",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
+ # GH#51363 stopped doing dtype inference here
+ out = Index(new_values, dtype=new_values.dtype, name=self.name)
return out
def drop(
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 6b4070ed6349c..982e305b7e471 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -1896,15 +1896,7 @@ def _setitem_with_indexer(self, indexer, value, name: str = "iloc") -> None:
# just replacing the block manager here
# so the object is the same
index = self.obj._get_axis(i)
- with warnings.catch_warnings():
- # TODO: re-issue this with setitem-specific message?
- warnings.filterwarnings(
- "ignore",
- "The behavior of Index.insert with object-dtype "
- "is deprecated",
- category=FutureWarning,
- )
- labels = index.insert(len(index), key)
+ labels = index.insert(len(index), key)
# We are expanding the Series/DataFrame values to match
# the length of thenew index `labels`. GH#40096 ensure
@@ -2222,14 +2214,7 @@ def _setitem_with_indexer_missing(self, indexer, value):
# and set inplace
if self.ndim == 1:
index = self.obj.index
- with warnings.catch_warnings():
- # TODO: re-issue this with setitem-specific message?
- warnings.filterwarnings(
- "ignore",
- "The behavior of Index.insert with object-dtype is deprecated",
- category=FutureWarning,
- )
- new_index = index.insert(len(index), indexer)
+ new_index = index.insert(len(index), indexer)
# we have a coerced indexer, e.g. a float
# that matches in an int64 Index, so
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index af851e1fc8224..8fda9cd23b508 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -1480,14 +1480,7 @@ def insert(self, loc: int, item: Hashable, value: ArrayLike, refs=None) -> None:
value : np.ndarray or ExtensionArray
refs : The reference tracking object of the value to set.
"""
- with warnings.catch_warnings():
- # TODO: re-issue this with setitem-specific message?
- warnings.filterwarnings(
- "ignore",
- "The behavior of Index.insert with object-dtype is deprecated",
- category=FutureWarning,
- )
- new_axis = self.items.insert(loc, item)
+ new_axis = self.items.insert(loc, item)
if value.ndim == 2:
value = value.T
diff --git a/pandas/tests/indexes/test_old_base.py b/pandas/tests/indexes/test_old_base.py
index 85eec7b7c018d..2c0e257efa9c3 100644
--- a/pandas/tests/indexes/test_old_base.py
+++ b/pandas/tests/indexes/test_old_base.py
@@ -409,19 +409,13 @@ def test_where(self, listlike_box, simple_index):
tm.assert_index_equal(result, expected)
def test_insert_base(self, index):
+ # GH#51363
trimmed = index[1:4]
if not len(index):
pytest.skip("Not applicable for empty index")
- # test 0th element
- warn = None
- if index.dtype == object and index.inferred_type == "boolean":
- # GH#51363
- warn = FutureWarning
- msg = "The behavior of Index.insert with object-dtype is deprecated"
- with tm.assert_produces_warning(warn, match=msg):
- result = trimmed.insert(0, index[0])
+ result = trimmed.insert(0, index[0])
assert index[0:4].equals(result)
@pytest.mark.skipif(
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index c01a8647dd07d..01dab14c7e528 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -2025,7 +2025,7 @@ def test_loc_setitem_incremental_with_dst(self):
ids=["self", "to_datetime64", "to_pydatetime", "np.datetime64"],
)
def test_loc_setitem_datetime_keys_cast(self, conv):
- # GH#9516
+ # GH#9516, GH#51363 changed in 3.0 to not cast on Index.insert
dt1 = Timestamp("20130101 09:00:00")
dt2 = Timestamp("20130101 10:00:00")
df = DataFrame()
@@ -2034,7 +2034,7 @@ def test_loc_setitem_datetime_keys_cast(self, conv):
expected = DataFrame(
{"one": [100.0, 200.0]},
- index=[dt1, dt2],
+ index=Index([conv(dt1), conv(dt2)], dtype=object),
columns=Index(["one"], dtype=object),
)
tm.assert_frame_equal(df, expected)
diff --git a/pandas/tests/series/indexing/test_set_value.py b/pandas/tests/series/indexing/test_set_value.py
index cbe1a8bf296c8..99e71fa4b804b 100644
--- a/pandas/tests/series/indexing/test_set_value.py
+++ b/pandas/tests/series/indexing/test_set_value.py
@@ -3,17 +3,17 @@
import numpy as np
from pandas import (
- DatetimeIndex,
+ Index,
Series,
)
import pandas._testing as tm
def test_series_set_value():
- # GH#1561
+ # GH#1561, GH#51363 as of 3.0 we do not do inference in Index.insert
dates = [datetime(2001, 1, 1), datetime(2001, 1, 2)]
- index = DatetimeIndex(dates)
+ index = Index(dates, dtype=object)
s = Series(dtype=object)
s._set_value(dates[0], 1.0)
diff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py
index 6be325073bb67..99535f273075c 100644
--- a/pandas/tests/series/indexing/test_setitem.py
+++ b/pandas/tests/series/indexing/test_setitem.py
@@ -495,11 +495,11 @@ def test_setitem_callable_other(self):
class TestSetitemWithExpansion:
def test_setitem_empty_series(self):
- # GH#10193
+ # GH#10193, GH#51363 changed in 3.0 to not do inference in Index.insert
key = Timestamp("2012-01-01")
series = Series(dtype=object)
series[key] = 47
- expected = Series(47, [key])
+ expected = Series(47, Index([key], dtype=object))
tm.assert_series_equal(series, expected)
def test_setitem_empty_series_datetimeindex_preserves_freq(self):
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58059 | 2024-03-29T02:06:49Z | 2024-03-29T18:17:51Z | 2024-03-29T18:17:51Z | 2024-03-29T18:35:38Z |
DEPR: allowing non-standard types in unique, factorize, isin | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 98b497bd6988b..bd1610cab1ecd 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -206,6 +206,7 @@ Removal of prior version deprecations/changes
- :meth:`SeriesGroupBy.agg` no longer pins the name of the group to the input passed to the provided ``func`` (:issue:`51703`)
- All arguments except ``name`` in :meth:`Index.rename` are now keyword only (:issue:`56493`)
- All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`)
+- Disallow non-standard (``np.ndarray``, :class:`Index`, :class:`ExtensionArray`, or :class:`Series`) to :func:`isin`, :func:`unique`, :func:`factorize` (:issue:`52986`)
- Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
- Removed "freq" keyword from :class:`PeriodArray` constructor, use "dtype" instead (:issue:`52462`)
- Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 6a6096567c65d..33beef23197bd 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -226,12 +226,9 @@ def _ensure_arraylike(values, func_name: str) -> ArrayLike:
# GH#52986
if func_name != "isin-targets":
# Make an exception for the comps argument in isin.
- warnings.warn(
- f"{func_name} with argument that is not not a Series, Index, "
- "ExtensionArray, or np.ndarray is deprecated and will raise in a "
- "future version.",
- FutureWarning,
- stacklevel=find_stack_level(),
+ raise TypeError(
+ f"{func_name} requires a Series, Index, "
+ f"ExtensionArray, or np.ndarray, got {type(values).__name__}."
)
inferred = lib.infer_dtype(values, skipna=False)
diff --git a/pandas/tests/libs/test_hashtable.py b/pandas/tests/libs/test_hashtable.py
index e54764f9ac4a6..b70386191d9d9 100644
--- a/pandas/tests/libs/test_hashtable.py
+++ b/pandas/tests/libs/test_hashtable.py
@@ -730,12 +730,11 @@ def test_mode(self, dtype):
def test_ismember_tuple_with_nans():
# GH-41836
- values = [("a", float("nan")), ("b", 1)]
+ values = np.empty(2, dtype=object)
+ values[:] = [("a", float("nan")), ("b", 1)]
comps = [("a", float("nan"))]
- msg = "isin with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = isin(values, comps)
+ result = isin(values, comps)
expected = np.array([True, False], dtype=np.bool_)
tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index 365ec452a7f25..1b5d33fc10595 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -54,16 +54,13 @@
class TestFactorize:
def test_factorize_complex(self):
# GH#17927
- array = [1, 2, 2 + 1j]
- msg = "factorize with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- labels, uniques = algos.factorize(array)
+ array = np.array([1, 2, 2 + 1j], dtype=complex)
+ labels, uniques = algos.factorize(array)
expected_labels = np.array([0, 1, 2], dtype=np.intp)
tm.assert_numpy_array_equal(labels, expected_labels)
- # Should return a complex dtype in the future
- expected_uniques = np.array([(1 + 0j), (2 + 0j), (2 + 1j)], dtype=object)
+ expected_uniques = np.array([(1 + 0j), (2 + 0j), (2 + 1j)], dtype=complex)
tm.assert_numpy_array_equal(uniques, expected_uniques)
def test_factorize(self, index_or_series_obj, sort):
@@ -265,9 +262,8 @@ def test_factorizer_object_with_nan(self):
)
def test_factorize_tuple_list(self, data, expected_codes, expected_uniques):
# GH9454
- msg = "factorize with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- codes, uniques = pd.factorize(data)
+ data = com.asarray_tuplesafe(data, dtype=object)
+ codes, uniques = pd.factorize(data)
tm.assert_numpy_array_equal(codes, np.array(expected_codes, dtype=np.intp))
@@ -488,12 +484,12 @@ def test_object_factorize_use_na_sentinel_false(
"data, expected_codes, expected_uniques",
[
(
- [1, None, 1, 2],
+ np.array([1, None, 1, 2], dtype=object),
np.array([0, 1, 0, 2], dtype=np.dtype("intp")),
np.array([1, np.nan, 2], dtype="O"),
),
(
- [1, np.nan, 1, 2],
+ np.array([1, np.nan, 1, 2], dtype=np.float64),
np.array([0, 1, 0, 2], dtype=np.dtype("intp")),
np.array([1, np.nan, 2], dtype=np.float64),
),
@@ -502,9 +498,7 @@ def test_object_factorize_use_na_sentinel_false(
def test_int_factorize_use_na_sentinel_false(
self, data, expected_codes, expected_uniques
):
- msg = "factorize with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- codes, uniques = algos.factorize(data, use_na_sentinel=False)
+ codes, uniques = algos.factorize(data, use_na_sentinel=False)
tm.assert_numpy_array_equal(uniques, expected_uniques, strict_nan=True)
tm.assert_numpy_array_equal(codes, expected_codes, strict_nan=True)
@@ -777,9 +771,8 @@ def test_order_of_appearance(self):
result = pd.unique(Series([2] + [1] * 5))
tm.assert_numpy_array_equal(result, np.array([2, 1], dtype="int64"))
- msg = "unique with argument that is not not a Series, Index,"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = pd.unique(list("aabc"))
+ data = np.array(["a", "a", "b", "c"], dtype=object)
+ result = pd.unique(data)
expected = np.array(["a", "b", "c"], dtype=object)
tm.assert_numpy_array_equal(result, expected)
@@ -815,9 +808,8 @@ def test_order_of_appearance_dt64tz(self, unit):
)
def test_tuple_with_strings(self, arg, expected):
# see GH 17108
- msg = "unique with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = pd.unique(arg)
+ arg = com.asarray_tuplesafe(arg, dtype=object)
+ result = pd.unique(arg)
tm.assert_numpy_array_equal(result, expected)
def test_obj_none_preservation(self):
@@ -904,12 +896,6 @@ def test_invalid(self):
algos.isin([1], 1)
def test_basic(self):
- msg = "isin with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = algos.isin([1, 2], [1])
- expected = np.array([True, False])
- tm.assert_numpy_array_equal(result, expected)
-
result = algos.isin(np.array([1, 2]), [1])
expected = np.array([True, False])
tm.assert_numpy_array_equal(result, expected)
@@ -926,21 +912,20 @@ def test_basic(self):
expected = np.array([True, False])
tm.assert_numpy_array_equal(result, expected)
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = algos.isin(["a", "b"], ["a"])
+ arg = np.array(["a", "b"], dtype=object)
+ result = algos.isin(arg, ["a"])
expected = np.array([True, False])
tm.assert_numpy_array_equal(result, expected)
- result = algos.isin(Series(["a", "b"]), Series(["a"]))
+ result = algos.isin(Series(arg), Series(["a"]))
expected = np.array([True, False])
tm.assert_numpy_array_equal(result, expected)
- result = algos.isin(Series(["a", "b"]), {"a"})
+ result = algos.isin(Series(arg), {"a"})
expected = np.array([True, False])
tm.assert_numpy_array_equal(result, expected)
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = algos.isin(["a", "b"], [1])
+ result = algos.isin(arg, [1])
expected = np.array([False, False])
tm.assert_numpy_array_equal(result, expected)
@@ -1058,12 +1043,10 @@ def test_same_nan_is_in(self):
# at least, isin() should follow python's "np.nan in [nan] == True"
# casting to -> np.float64 -> another float-object somewhere on
# the way could lead jeopardize this behavior
- comps = [np.nan] # could be casted to float64
+ comps = np.array([np.nan], dtype=object) # could be casted to float64
values = [np.nan]
expected = np.array([True])
- msg = "isin with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = algos.isin(comps, values)
+ result = algos.isin(comps, values)
tm.assert_numpy_array_equal(expected, result)
def test_same_nan_is_in_large(self):
@@ -1098,12 +1081,12 @@ def __hash__(self):
a, b = LikeNan(), LikeNan()
- msg = "isin with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- # same object -> True
- tm.assert_numpy_array_equal(algos.isin([a], [a]), np.array([True]))
- # different objects -> False
- tm.assert_numpy_array_equal(algos.isin([a], [b]), np.array([False]))
+ arg = np.array([a], dtype=object)
+
+ # same object -> True
+ tm.assert_numpy_array_equal(algos.isin(arg, [a]), np.array([True]))
+ # different objects -> False
+ tm.assert_numpy_array_equal(algos.isin(arg, [b]), np.array([False]))
def test_different_nans(self):
# GH 22160
@@ -1132,12 +1115,11 @@ def test_different_nans(self):
def test_no_cast(self):
# GH 22160
# ensure 42 is not casted to a string
- comps = ["ss", 42]
+ comps = np.array(["ss", 42], dtype=object)
values = ["42"]
expected = np.array([False, False])
- msg = "isin with argument that is not not a Series, Index"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = algos.isin(comps, values)
+
+ result = algos.isin(comps, values)
tm.assert_numpy_array_equal(expected, result)
@pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
@@ -1658,27 +1640,32 @@ def test_unique_tuples(self, arr, uniques):
expected = np.empty(len(uniques), dtype=object)
expected[:] = uniques
- msg = "unique with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = pd.unique(arr)
- tm.assert_numpy_array_equal(result, expected)
+ msg = "unique requires a Series, Index, ExtensionArray, or np.ndarray, got list"
+ with pytest.raises(TypeError, match=msg):
+ # GH#52986
+ pd.unique(arr)
+
+ res = pd.unique(com.asarray_tuplesafe(arr, dtype=object))
+ tm.assert_numpy_array_equal(res, expected)
@pytest.mark.parametrize(
"array,expected",
[
(
[1 + 1j, 0, 1, 1j, 1 + 2j, 1 + 2j],
- # Should return a complex dtype in the future
- np.array([(1 + 1j), 0j, (1 + 0j), 1j, (1 + 2j)], dtype=object),
+ np.array([(1 + 1j), 0j, (1 + 0j), 1j, (1 + 2j)], dtype=complex),
)
],
)
def test_unique_complex_numbers(self, array, expected):
# GH 17927
- msg = "unique with argument that is not not a Series"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = pd.unique(array)
- tm.assert_numpy_array_equal(result, expected)
+ msg = "unique requires a Series, Index, ExtensionArray, or np.ndarray, got list"
+ with pytest.raises(TypeError, match=msg):
+ # GH#52986
+ pd.unique(array)
+
+ res = pd.unique(np.array(array))
+ tm.assert_numpy_array_equal(res, expected)
class TestHashTable:
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58058 | 2024-03-29T01:48:32Z | 2024-03-29T18:20:16Z | 2024-03-29T18:20:16Z | 2024-03-29T18:35:27Z |
BUG: Allow using numpy in `DataFrame.eval` and `DataFrame.query` via @-notation | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 2ebd6fb62b424..8d0adccfd480d 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -325,6 +325,7 @@ Bug fixes
- Fixed bug in :class:`SparseDtype` for equal comparison with na fill value. (:issue:`54770`)
- Fixed bug in :meth:`.DataFrameGroupBy.median` where nat values gave an incorrect result. (:issue:`57926`)
- Fixed bug in :meth:`DataFrame.cumsum` which was raising ``IndexError`` if dtype is ``timedelta64[ns]`` (:issue:`57956`)
+- Fixed bug in :meth:`DataFrame.eval` and :meth:`DataFrame.query` which caused an exception when using NumPy attributes via ``@`` notation, e.g., ``df.eval("@np.floor(a)")``. (:issue:`58041`)
- Fixed bug in :meth:`DataFrame.join` inconsistently setting result index name (:issue:`55815`)
- Fixed bug in :meth:`DataFrame.to_string` that raised ``StopIteration`` with nested DataFrames. (:issue:`16098`)
- Fixed bug in :meth:`DataFrame.transform` that was returning the wrong order unless the index was monotonically increasing. (:issue:`57069`)
diff --git a/pandas/core/computation/ops.py b/pandas/core/computation/ops.py
index cd9aa1833d586..7d8e23abf43b6 100644
--- a/pandas/core/computation/ops.py
+++ b/pandas/core/computation/ops.py
@@ -115,7 +115,7 @@ def _resolve_name(self):
res = self.env.resolve(local_name, is_local=is_local)
self.update(res)
- if hasattr(res, "ndim") and res.ndim > 2:
+ if hasattr(res, "ndim") and isinstance(res.ndim, int) and res.ndim > 2:
raise NotImplementedError(
"N-dimensional objects, where N > 2, are not supported with eval"
)
diff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py
index d2e36eb6147e7..94e8e469f21e7 100644
--- a/pandas/tests/frame/test_query_eval.py
+++ b/pandas/tests/frame/test_query_eval.py
@@ -188,6 +188,16 @@ def test_eval_object_dtype_binop(self):
expected = DataFrame({"a1": ["Y", "N"], "c": [True, False]})
tm.assert_frame_equal(res, expected)
+ def test_using_numpy(self, engine, parser):
+ # GH 58041
+ skip_if_no_pandas_parser(parser)
+ df = Series([0.2, 1.5, 2.8], name="a").to_frame()
+ res = df.eval("@np.floor(a)", engine=engine, parser=parser)
+ expected = np.floor(df["a"])
+ if engine == "numexpr":
+ expected.name = None # See GH 58069
+ tm.assert_series_equal(expected, res)
+
class TestDataFrameQueryWithMultiIndex:
def test_query_with_named_multiindex(self, parser, engine):
| - [x] closes #58041
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] ~~Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.~~ (not applicable)
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58057 | 2024-03-28T23:01:38Z | 2024-04-08T16:48:31Z | 2024-04-08T16:48:31Z | 2024-04-09T08:35:24Z |
DEPR: ignoring empty entries in pd.concat | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 98b497bd6988b..3a2cadd6b1cd5 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -200,6 +200,7 @@ Other Deprecations
Removal of prior version deprecations/changes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- :class:`.DataFrameGroupBy.idxmin`, :class:`.DataFrameGroupBy.idxmax`, :class:`.SeriesGroupBy.idxmin`, and :class:`.SeriesGroupBy.idxmax` will now raise a ``ValueError`` when used with ``skipna=False`` and an NA value is encountered (:issue:`10694`)
+- :func:`concat` no longer ignores empty objects when determining output dtypes (:issue:`39122`)
- :func:`read_excel`, :func:`read_json`, :func:`read_html`, and :func:`read_xml` no longer accept raw string or byte representation of the data. That type of data must be wrapped in a :py:class:`StringIO` or :py:class:`BytesIO` (:issue:`53767`)
- :meth:`DataFrame.groupby` with ``as_index=False`` and aggregation methods will no longer exclude from the result the groupings that do not arise from the input (:issue:`49519`)
- :meth:`Series.dt.to_pydatetime` now returns a :class:`Series` of :py:class:`datetime.datetime` objects (:issue:`52459`)
diff --git a/pandas/core/dtypes/concat.py b/pandas/core/dtypes/concat.py
index 3a34481ab3f33..17e68b0e19a68 100644
--- a/pandas/core/dtypes/concat.py
+++ b/pandas/core/dtypes/concat.py
@@ -8,12 +8,10 @@
TYPE_CHECKING,
cast,
)
-import warnings
import numpy as np
from pandas._libs import lib
-from pandas.util._exceptions import find_stack_level
from pandas.core.dtypes.astype import astype_array
from pandas.core.dtypes.cast import (
@@ -101,28 +99,10 @@ def concat_compat(
# Creating an empty array directly is tempting, but the winnings would be
# marginal given that it would still require shape & dtype calculation and
# np.concatenate which has them both implemented is compiled.
- orig = to_concat
non_empties = [x for x in to_concat if _is_nonempty(x, axis)]
- if non_empties and axis == 0 and not ea_compat_axis:
- # ea_compat_axis see GH#39574
- to_concat = non_empties
any_ea, kinds, target_dtype = _get_result_dtype(to_concat, non_empties)
- if len(to_concat) < len(orig):
- _, _, alt_dtype = _get_result_dtype(orig, non_empties)
- if alt_dtype != target_dtype:
- # GH#39122
- warnings.warn(
- "The behavior of array concatenation with empty entries is "
- "deprecated. In a future version, this will no longer exclude "
- "empty items when determining the result dtype. "
- "To retain the old behavior, exclude the empty entries before "
- "the concat operation.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
-
if target_dtype is not None:
to_concat = [astype_array(arr, target_dtype, copy=False) for arr in to_concat]
diff --git a/pandas/tests/dtypes/test_concat.py b/pandas/tests/dtypes/test_concat.py
index 1652c9254061b..d4fe6c5264007 100644
--- a/pandas/tests/dtypes/test_concat.py
+++ b/pandas/tests/dtypes/test_concat.py
@@ -12,12 +12,9 @@ def test_concat_mismatched_categoricals_with_empty():
ser1 = Series(["a", "b", "c"], dtype="category")
ser2 = Series([], dtype="category")
- msg = "The behavior of array concatenation with empty entries is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = _concat.concat_compat([ser1._values, ser2._values])
- with tm.assert_produces_warning(FutureWarning, match=msg):
- expected = pd.concat([ser1, ser2])._values
- tm.assert_categorical_equal(result, expected)
+ result = _concat.concat_compat([ser1._values, ser2._values])
+ expected = pd.concat([ser1, ser2])._values
+ tm.assert_numpy_array_equal(result, expected)
def test_concat_single_dataframe_tz_aware():
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index bcad88bdecabb..be8f5d73fe7e8 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -224,8 +224,6 @@ def f3(x):
df2 = DataFrame({"a": [3, 2, 2, 2], "b": range(4), "c": range(5, 9)})
- depr_msg = "The behavior of array concatenation with empty entries is deprecated"
-
# correct result
msg = "DataFrameGroupBy.apply operated on the grouping columns"
with tm.assert_produces_warning(DeprecationWarning, match=msg):
@@ -245,8 +243,7 @@ def f3(x):
with pytest.raises(AssertionError, match=msg):
df.groupby("a").apply(f3)
with pytest.raises(AssertionError, match=msg):
- with tm.assert_produces_warning(FutureWarning, match=depr_msg):
- df2.groupby("a").apply(f3)
+ df2.groupby("a").apply(f3)
def test_attr_wrapper(ts):
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index beee14197bfb8..997276ef544f7 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -636,9 +636,7 @@ def test_append_empty_preserve_name(self, name, expected):
left = Index([], name="foo")
right = Index([1, 2, 3], name=name)
- msg = "The behavior of array concatenation with empty entries is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = left.append(right)
+ result = left.append(right)
assert result.name == expected
@pytest.mark.parametrize(
diff --git a/pandas/tests/reshape/concat/test_append.py b/pandas/tests/reshape/concat/test_append.py
index 3fb6a3fb61396..81b5914fef402 100644
--- a/pandas/tests/reshape/concat/test_append.py
+++ b/pandas/tests/reshape/concat/test_append.py
@@ -162,9 +162,7 @@ def test_append_preserve_index_name(self):
df2 = DataFrame(data=[[1, 4, 7], [2, 5, 8], [3, 6, 9]], columns=["A", "B", "C"])
df2 = df2.set_index(["A"])
- msg = "The behavior of array concatenation with empty entries is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = df1._append(df2)
+ result = df1._append(df2)
assert result.index.name == "A"
indexes_can_append = [
diff --git a/pandas/tests/reshape/concat/test_append_common.py b/pandas/tests/reshape/concat/test_append_common.py
index 31c3ef3176222..c831cb8293943 100644
--- a/pandas/tests/reshape/concat/test_append_common.py
+++ b/pandas/tests/reshape/concat/test_append_common.py
@@ -691,15 +691,12 @@ def test_concat_categorical_empty(self):
s1 = Series([], dtype="category")
s2 = Series([1, 2], dtype="category")
+ exp = s2.astype(object)
+ tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+ tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
- msg = "The behavior of array concatenation with empty entries is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), s2)
- tm.assert_series_equal(s1._append(s2, ignore_index=True), s2)
-
- with tm.assert_produces_warning(FutureWarning, match=msg):
- tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), s2)
- tm.assert_series_equal(s2._append(s1, ignore_index=True), s2)
+ tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
+ tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
s1 = Series([], dtype="category")
s2 = Series([], dtype="category")
@@ -719,15 +716,12 @@ def test_concat_categorical_empty(self):
s1 = Series([], dtype="category")
s2 = Series([np.nan, np.nan])
- # empty Series is ignored
- exp = Series([np.nan, np.nan])
- with tm.assert_produces_warning(FutureWarning, match=msg):
- tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
- tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+ exp = Series([np.nan, np.nan], dtype=object)
+ tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+ tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
- with tm.assert_produces_warning(FutureWarning, match=msg):
- tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
- tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
+ tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
+ tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
def test_categorical_concat_append(self):
cat = Categorical(["a", "b"], categories=["a", "b"])
diff --git a/pandas/tests/reshape/concat/test_empty.py b/pandas/tests/reshape/concat/test_empty.py
index 30ef0a934157b..06d57c48df817 100644
--- a/pandas/tests/reshape/concat/test_empty.py
+++ b/pandas/tests/reshape/concat/test_empty.py
@@ -62,11 +62,9 @@ def test_concat_empty_series(self):
s1 = Series([1, 2, 3], name="x")
s2 = Series(name="y", dtype="float64")
- msg = "The behavior of array concatenation with empty entries is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- res = concat([s1, s2], axis=0)
+ res = concat([s1, s2], axis=0)
# name will be reset
- exp = Series([1, 2, 3])
+ exp = Series([1, 2, 3], dtype="float64")
tm.assert_series_equal(res, exp)
# empty Series with no name
diff --git a/pandas/tests/reshape/concat/test_series.py b/pandas/tests/reshape/concat/test_series.py
index 6ac51c0b55c4e..3523340bb2858 100644
--- a/pandas/tests/reshape/concat/test_series.py
+++ b/pandas/tests/reshape/concat/test_series.py
@@ -43,10 +43,8 @@ def test_concat_empty_and_non_empty_series_regression(self):
s1 = Series([1])
s2 = Series([], dtype=object)
- expected = s1
- msg = "The behavior of array concatenation with empty entries is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = concat([s1, s2])
+ expected = s1.astype(object)
+ result = concat([s1, s2])
tm.assert_series_equal(result, expected)
def test_concat_series_axis1(self):
diff --git a/pandas/tests/series/methods/test_combine_first.py b/pandas/tests/series/methods/test_combine_first.py
index e1ec8afda33a9..0f2f533c8feff 100644
--- a/pandas/tests/series/methods/test_combine_first.py
+++ b/pandas/tests/series/methods/test_combine_first.py
@@ -63,11 +63,9 @@ def test_combine_first(self):
# corner case
ser = Series([1.0, 2, 3], index=[0, 1, 2])
empty = Series([], index=[], dtype=object)
- msg = "The behavior of array concatenation with empty entries is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = ser.combine_first(empty)
+ result = ser.combine_first(empty)
ser.index = ser.index.astype("O")
- tm.assert_series_equal(ser, result)
+ tm.assert_series_equal(result, ser.astype(object))
def test_combine_first_dt64(self, unit):
s0 = to_datetime(Series(["2010", np.nan])).dt.as_unit(unit)
@@ -112,10 +110,8 @@ def test_combine_first_timezone_series_with_empty_series(self):
)
s1 = Series(range(10), index=time_index)
s2 = Series(index=time_index)
- msg = "The behavior of array concatenation with empty entries is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = s1.combine_first(s2)
- tm.assert_series_equal(result, s1)
+ result = s1.combine_first(s2)
+ tm.assert_series_equal(result, s1.astype(np.float64))
def test_combine_first_preserves_dtype(self):
# GH51764
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58056 | 2024-03-28T22:32:00Z | 2024-03-29T18:22:44Z | 2024-03-29T18:22:44Z | 2024-03-29T18:22:53Z |
DEPR: remove deprecated extension test classes | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 98b497bd6988b..947edc0cd119e 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -209,6 +209,7 @@ Removal of prior version deprecations/changes
- Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
- Removed "freq" keyword from :class:`PeriodArray` constructor, use "dtype" instead (:issue:`52462`)
- Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
+- Removed extension test classes ``BaseNoReduceTests``, ``BaseNumericReduceTests``, ``BaseBooleanReduceTests`` (:issue:`54663`)
- Removed the "closed" and "normalize" keywords in :meth:`DatetimeIndex.__new__` (:issue:`52628`)
- Removed the "closed" and "unit" keywords in :meth:`TimedeltaIndex.__new__` (:issue:`52628`, :issue:`55499`)
- All arguments in :meth:`Index.sort_values` are now keyword only (:issue:`56493`)
diff --git a/pandas/tests/extension/base/__init__.py b/pandas/tests/extension/base/__init__.py
index cfbc365568403..2abf739d2428d 100644
--- a/pandas/tests/extension/base/__init__.py
+++ b/pandas/tests/extension/base/__init__.py
@@ -64,9 +64,7 @@ class TestMyDtype(BaseDtypeTests):
# One test class that you can inherit as an alternative to inheriting all the
# test classes above.
-# Note 1) this excludes Dim2CompatTests and NDArrayBacked2DTests.
-# Note 2) this uses BaseReduceTests and and _not_ BaseBooleanReduceTests,
-# BaseNoReduceTests, or BaseNumericReduceTests
+# Note this excludes Dim2CompatTests and NDArrayBacked2DTests.
class ExtensionTests(
BaseAccumulateTests,
BaseCastingTests,
@@ -89,44 +87,3 @@ class ExtensionTests(
Dim2CompatTests,
):
pass
-
-
-def __getattr__(name: str):
- import warnings
-
- if name == "BaseNoReduceTests":
- warnings.warn(
- "BaseNoReduceTests is deprecated and will be removed in a "
- "future version. Use BaseReduceTests and override "
- "`_supports_reduction` instead.",
- FutureWarning,
- )
- from pandas.tests.extension.base.reduce import BaseNoReduceTests
-
- return BaseNoReduceTests
-
- elif name == "BaseNumericReduceTests":
- warnings.warn(
- "BaseNumericReduceTests is deprecated and will be removed in a "
- "future version. Use BaseReduceTests and override "
- "`_supports_reduction` instead.",
- FutureWarning,
- )
- from pandas.tests.extension.base.reduce import BaseNumericReduceTests
-
- return BaseNumericReduceTests
-
- elif name == "BaseBooleanReduceTests":
- warnings.warn(
- "BaseBooleanReduceTests is deprecated and will be removed in a "
- "future version. Use BaseReduceTests and override "
- "`_supports_reduction` instead.",
- FutureWarning,
- )
- from pandas.tests.extension.base.reduce import BaseBooleanReduceTests
-
- return BaseBooleanReduceTests
-
- raise AttributeError(
- f"module 'pandas.tests.extension.base' has no attribute '{name}'"
- )
diff --git a/pandas/tests/extension/base/reduce.py b/pandas/tests/extension/base/reduce.py
index 6ea1b3a6fbe9d..03952d87f0ac6 100644
--- a/pandas/tests/extension/base/reduce.py
+++ b/pandas/tests/extension/base/reduce.py
@@ -129,25 +129,3 @@ def test_reduce_frame(self, data, all_numeric_reductions, skipna):
pytest.skip(f"Reduction {op_name} not supported for this dtype")
self.check_reduce_frame(ser, op_name, skipna)
-
-
-# TODO(3.0): remove BaseNoReduceTests, BaseNumericReduceTests,
-# BaseBooleanReduceTests
-class BaseNoReduceTests(BaseReduceTests):
- """we don't define any reductions"""
-
-
-class BaseNumericReduceTests(BaseReduceTests):
- # For backward compatibility only, this only runs the numeric reductions
- def _supports_reduction(self, ser: pd.Series, op_name: str) -> bool:
- if op_name in ["any", "all"]:
- pytest.skip("These are tested in BaseBooleanReduceTests")
- return True
-
-
-class BaseBooleanReduceTests(BaseReduceTests):
- # For backward compatibility only, this only runs the numeric reductions
- def _supports_reduction(self, ser: pd.Series, op_name: str) -> bool:
- if op_name not in ["any", "all"]:
- pytest.skip("These are tested in BaseNumericReduceTests")
- return True
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58053 | 2024-03-28T20:08:09Z | 2024-03-29T18:23:43Z | 2024-03-29T18:23:43Z | 2024-03-29T18:35:16Z |
BUG: fixed to_numeric loss in precision when converting decimal type to integer | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index 98b497bd6988b..5dec933eb4407 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -332,6 +332,7 @@ Bug fixes
- Fixed bug in :meth:`Series.diff` allowing non-integer values for the ``periods`` argument. (:issue:`56607`)
- Fixed bug in :meth:`Series.rank` that doesn't preserve missing values for nullable integers when ``na_option='keep'``. (:issue:`56976`)
- Fixed bug in :meth:`Series.replace` and :meth:`DataFrame.replace` inconsistently replacing matching instances when ``regex=True`` and missing values are present. (:issue:`56599`)
+- Fixed bug in :func:`to_numeric` that resulted in precision loss when converting decimal type to integer. (:issue:`57213`)
Categorical
^^^^^^^^^^^
diff --git a/pandas/core/tools/numeric.py b/pandas/core/tools/numeric.py
index 3d28a73df99d1..36d2fccebca22 100644
--- a/pandas/core/tools/numeric.py
+++ b/pandas/core/tools/numeric.py
@@ -10,7 +10,6 @@
from pandas._libs import lib
from pandas.util._validators import check_dtype_backend
-from pandas.core.dtypes.cast import maybe_downcast_numeric
from pandas.core.dtypes.common import (
ensure_object,
is_bool_dtype,
@@ -209,6 +208,7 @@ def to_numeric(
values = values.view(np.int64)
else:
values = ensure_object(values)
+ old_values = values
coerce_numeric = errors != "raise"
values, new_mask = lib.maybe_convert_numeric( # type: ignore[call-overload]
values,
@@ -254,8 +254,8 @@ def to_numeric(
# from smallest to largest
for typecode in typecodes:
dtype = np.dtype(typecode)
- if dtype.itemsize <= values.dtype.itemsize:
- values = maybe_downcast_numeric(values, dtype)
+ if dtype.itemsize == values.dtype.itemsize:
+ values = np.array(old_values, dtype=dtype)
# successful conversion
if values.dtype == dtype:
diff --git a/pandas/tests/tools/test_to_numeric.py b/pandas/tests/tools/test_to_numeric.py
index 585b7ca94f730..95e700c66258e 100644
--- a/pandas/tests/tools/test_to_numeric.py
+++ b/pandas/tests/tools/test_to_numeric.py
@@ -1,4 +1,5 @@
import decimal
+from decimal import Decimal
import numpy as np
from numpy import iinfo
@@ -904,3 +905,10 @@ def test_coerce_pyarrow_backend():
result = to_numeric(ser, errors="coerce", dtype_backend="pyarrow")
expected = Series([1, 2, None], dtype=ArrowDtype(pa.int64()))
tm.assert_series_equal(result, expected)
+
+
+def test_decimal_precision():
+ df = DataFrame({"column1": [Decimal("1" * 19)]})
+ result = to_numeric(df["column1"], downcast="integer")
+ expected = df["column1"].astype("int64")
+ tm.assert_series_equal(result, expected)
| - [X] closes #57213
- [X] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [X] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [X] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions. _(Not applicable)_
- [X] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature. | https://api.github.com/repos/pandas-dev/pandas/pulls/58051 | 2024-03-28T18:59:54Z | 2024-03-28T19:49:05Z | null | 2024-03-28T20:15:32Z |
Backport PR #57974 on branch 2.2.x (BUG: Fixed ADBC to_sql creation of table when using public schema) | diff --git a/doc/source/whatsnew/v2.2.2.rst b/doc/source/whatsnew/v2.2.2.rst
index d0f8951ac07ad..9e1a883d47cf8 100644
--- a/doc/source/whatsnew/v2.2.2.rst
+++ b/doc/source/whatsnew/v2.2.2.rst
@@ -25,6 +25,7 @@ Bug fixes
- :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the column's type was nullable boolean (:issue:`55332`)
- :meth:`DataFrame.__dataframe__` was showing bytemask instead of bitmask for ``'string[pyarrow]'`` validity buffer (:issue:`57762`)
- :meth:`DataFrame.__dataframe__` was showing non-null validity buffer (instead of ``None``) ``'string[pyarrow]'`` without missing values (:issue:`57761`)
+- :meth:`DataFrame.to_sql` was failing to find the right table when using the schema argument (:issue:`57539`)
.. ---------------------------------------------------------------------------
.. _whatsnew_222.other:
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index 195a7c5040853..3e17175167f25 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -2400,7 +2400,9 @@ def to_sql(
raise ValueError("datatypes not supported") from exc
with self.con.cursor() as cur:
- total_inserted = cur.adbc_ingest(table_name, tbl, mode=mode)
+ total_inserted = cur.adbc_ingest(
+ table_name=name, data=tbl, mode=mode, db_schema_name=schema
+ )
self.con.commit()
return total_inserted
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 791b6da3deeca..4f1f965f26aa9 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -1373,6 +1373,30 @@ def insert_on_conflict(table, conn, keys, data_iter):
pandasSQL.drop_table("test_insert_conflict")
+@pytest.mark.parametrize("conn", all_connectable)
+def test_to_sql_on_public_schema(conn, request):
+ if "sqlite" in conn or "mysql" in conn:
+ request.applymarker(
+ pytest.mark.xfail(
+ reason="test for public schema only specific to postgresql"
+ )
+ )
+
+ conn = request.getfixturevalue(conn)
+
+ test_data = DataFrame([[1, 2.1, "a"], [2, 3.1, "b"]], columns=list("abc"))
+ test_data.to_sql(
+ name="test_public_schema",
+ con=conn,
+ if_exists="append",
+ index=False,
+ schema="public",
+ )
+
+ df_out = sql.read_sql_table("test_public_schema", conn, schema="public")
+ tm.assert_frame_equal(test_data, df_out)
+
+
@pytest.mark.parametrize("conn", mysql_connectable)
def test_insertion_method_on_conflict_update(conn, request):
# GH 14553: Example in to_sql docstring
| Backport PR #57974: BUG: Fixed ADBC to_sql creation of table when using public schema | https://api.github.com/repos/pandas-dev/pandas/pulls/58050 | 2024-03-28T17:56:24Z | 2024-03-28T22:26:08Z | 2024-03-28T22:26:08Z | 2024-03-28T22:26:08Z |
DEPR: passing pandas type to Index.view | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index e798f19bc1a23..d770054da5040 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -206,6 +206,7 @@ Removal of prior version deprecations/changes
- :meth:`SeriesGroupBy.agg` no longer pins the name of the group to the input passed to the provided ``func`` (:issue:`51703`)
- All arguments except ``name`` in :meth:`Index.rename` are now keyword only (:issue:`56493`)
- All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`)
+- Disallow passing a pandas type to :meth:`Index.view` (:issue:`55709`)
- Removed "freq" keyword from :class:`PeriodArray` constructor, use "dtype" instead (:issue:`52462`)
- Removed deprecated "method" and "limit" keywords from :meth:`Series.replace` and :meth:`DataFrame.replace` (:issue:`53492`)
- Removed the "closed" and "normalize" keywords in :meth:`DatetimeIndex.__new__` (:issue:`52628`)
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index e510d487ac954..ae9b0eb4e48aa 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1013,7 +1013,7 @@ def ravel(self, order: str_t = "C") -> Self:
def view(self, cls=None):
# we need to see if we are subclassing an
# index type here
- if cls is not None and not hasattr(cls, "_typ"):
+ if cls is not None:
dtype = cls
if isinstance(cls, str):
dtype = pandas_dtype(cls)
@@ -1030,16 +1030,6 @@ def view(self, cls=None):
result = self._data.view(cls)
else:
- if cls is not None:
- warnings.warn(
- # GH#55709
- f"Passing a type in {type(self).__name__}.view is deprecated "
- "and will raise in a future version. "
- "Call view without any argument to retain the old behavior.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
-
result = self._view()
if isinstance(result, Index):
result._id = self._id
diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index 4416034795463..088fcfcd7d75f 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -312,8 +312,8 @@ def test_cant_or_shouldnt_cast(self, dtype):
def test_view_index(self, simple_index):
index = simple_index
- msg = "Passing a type in .*Index.view is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ msg = "Cannot change data-type for object array"
+ with pytest.raises(TypeError, match=msg):
index.view(Index)
def test_prevent_casting(self, simple_index):
diff --git a/pandas/tests/indexes/ranges/test_range.py b/pandas/tests/indexes/ranges/test_range.py
index c9ddbf4464b29..8d41efa586411 100644
--- a/pandas/tests/indexes/ranges/test_range.py
+++ b/pandas/tests/indexes/ranges/test_range.py
@@ -200,11 +200,6 @@ def test_view(self):
i_view = i.view("i8")
tm.assert_numpy_array_equal(i.values, i_view)
- msg = "Passing a type in RangeIndex.view is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- i_view = i.view(RangeIndex)
- tm.assert_index_equal(i, i_view)
-
def test_dtype(self, simple_index):
index = simple_index
assert index.dtype == np.int64
@@ -380,8 +375,8 @@ def test_cant_or_shouldnt_cast(self, start, stop, step):
def test_view_index(self, simple_index):
index = simple_index
- msg = "Passing a type in RangeIndex.view is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ msg = "Cannot change data-type for object array"
+ with pytest.raises(TypeError, match=msg):
index.view(Index)
def test_prevent_casting(self, simple_index):
diff --git a/pandas/tests/indexes/test_datetimelike.py b/pandas/tests/indexes/test_datetimelike.py
index 7ec73070836b8..0ad5888a44392 100644
--- a/pandas/tests/indexes/test_datetimelike.py
+++ b/pandas/tests/indexes/test_datetimelike.py
@@ -85,15 +85,12 @@ def test_str(self, simple_index):
def test_view(self, simple_index):
idx = simple_index
- idx_view = idx.view("i8")
result = type(simple_index)(idx)
tm.assert_index_equal(result, idx)
- msg = "Passing a type in .*Index.view is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- idx_view = idx.view(type(simple_index))
- result = type(simple_index)(idx)
- tm.assert_index_equal(result, idx_view)
+ msg = "Cannot change data-type for object array"
+ with pytest.raises(TypeError, match=msg):
+ idx.view(type(simple_index))
def test_map_callable(self, simple_index):
index = simple_index
diff --git a/pandas/tests/indexes/test_old_base.py b/pandas/tests/indexes/test_old_base.py
index 85eec7b7c018d..d4dc248b39dc5 100644
--- a/pandas/tests/indexes/test_old_base.py
+++ b/pandas/tests/indexes/test_old_base.py
@@ -891,10 +891,10 @@ def test_view(self, simple_index):
idx_view = idx.view(dtype)
tm.assert_index_equal(idx, index_cls(idx_view, name="Foo"), exact=True)
- msg = "Passing a type in .*Index.view is deprecated"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- idx_view = idx.view(index_cls)
- tm.assert_index_equal(idx, index_cls(idx_view, name="Foo"), exact=True)
+ msg = "Cannot change data-type for object array"
+ with pytest.raises(TypeError, match=msg):
+ # GH#55709
+ idx.view(index_cls)
def test_insert_non_na(self, simple_index):
# GH#43921 inserting an element that we know we can hold should
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58047 | 2024-03-28T15:33:00Z | 2024-03-28T18:05:56Z | 2024-03-28T18:05:56Z | 2024-03-28T20:08:43Z |
read_csv(engine="pyarrow") fails with unknown column count | diff --git a/pandas/io/parsers/arrow_parser_wrapper.py b/pandas/io/parsers/arrow_parser_wrapper.py
index f8263a65ef5c7..7ee6f844e8e45 100644
--- a/pandas/io/parsers/arrow_parser_wrapper.py
+++ b/pandas/io/parsers/arrow_parser_wrapper.py
@@ -139,12 +139,15 @@ def handle_warning(invalid_row) -> str:
]
self.read_options = {
- "autogenerate_column_names": self.header is None,
"skip_rows": self.header
if self.header is not None
else self.kwds["skiprows"],
"encoding": self.encoding,
}
+ if self.header is None and self.names is not None:
+ self.read_options["column_names"] = self.names
+ else:
+ self.read_options["autogenerate_column_names"] = True
def _finalize_pandas_output(self, frame: DataFrame) -> DataFrame:
"""
diff --git a/pandas/tests/io/parser/test_header.py b/pandas/tests/io/parser/test_header.py
index d185e83bfc027..960a00105dfb0 100644
--- a/pandas/tests/io/parser/test_header.py
+++ b/pandas/tests/io/parser/test_header.py
@@ -730,3 +730,11 @@ def test_usecols_no_header_pyarrow(pyarrow_parser_only):
)
expected = DataFrame([["a", "i"], ["b", "j"]], dtype="string[pyarrow]")
tm.assert_frame_equal(result, expected)
+
+
+def test_names_pyarrow(pyarrow_parser_only):
+ result = pyarrow_parser_only.read_csv(
+ StringIO("1,2"), engine="pyarrow", names=["A", "B"], header=None
+ )
+ expected = DataFrame({"A": [1], "B": [2]})
+ tm.assert_frame_equal(result, expected)
| ```
>>> pd.read_csv(StringIO("1,2"), engine="pyarrow", dtype_backend="pyarrow", names=["A", "B"], header=None)
Traceback (most recent call last):
File "D:\ps_env_02_20\Lib\site-packages\pandas\io\parsers\arrow_parser_wrapper.py", line 266, in read
table = pyarrow_csv.read_csv(
^^^^^^^^^^^^^^^^^^^^^
File "pyarrow\_csv.pyx", line 1261, in pyarrow._csv.read_csv
File "pyarrow\_csv.pyx", line 1270, in pyarrow._csv.read_csv
File "pyarrow\error.pxi", line 154, in pyarrow.lib.pyarrow_internal_check_status
File "pyarrow\error.pxi", line 91, in pyarrow.lib.check_status
pyarrow.lib.ArrowInvalid: CSV parse error: Empty CSV file or block: cannot infer number of columns
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "D:\ps_env_02_20\Lib\site-packages\pandas\io\parsers\readers.py", line 1026, in read_csv
return _read(filepath_or_buffer, kwds)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\ps_env_02_20\Lib\site-packages\pandas\io\parsers\readers.py", line 626, in _read
return parser.read(nrows)
^^^^^^^^^^^^^^^^^^
File "D:\ps_env_02_20\Lib\site-packages\pandas\io\parsers\readers.py", line 1911, in read
df = self._engine.read() # type: ignore[attr-defined]
^^^^^^^^^^^^^^^^^^^
File "D:\ps_env_02_20\Lib\site-packages\pandas\io\parsers\arrow_parser_wrapper.py", line 273, in read
raise ParserError(e) from e
pandas.errors.ParserError: CSV parse error: Empty CSV file or block: cannot infer number of columns
>>>
```
But I use names parameter to pass number of columns, so error about "cannot infer number of columns" is confusing in this case, becuase I specified exactly number of columns so it doesn't need to be inferred. | https://api.github.com/repos/pandas-dev/pandas/pulls/58045 | 2024-03-28T14:35:38Z | 2024-03-28T16:26:19Z | null | 2024-03-28T16:26:19Z |
BUG: DataFrame slice selection treated as hashable in Python 3.12 #57500 | diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst
index f709bec842c86..27e7abe333d6f 100644
--- a/doc/source/whatsnew/v3.0.0.rst
+++ b/doc/source/whatsnew/v3.0.0.rst
@@ -395,7 +395,7 @@ Interval
Indexing
^^^^^^^^
--
+- Bug in :meth:`DataFrame.__getitem__` returning modified columns when called with ``slice`` in Python 3.12 (:issue:`57500`)
-
Missing
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 0b386efb5a867..cd4812c3f78ae 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3855,8 +3855,10 @@ def __getitem__(self, key):
key = lib.item_from_zerodim(key)
key = com.apply_if_callable(key, self)
- if is_hashable(key) and not is_iterator(key):
+ if is_hashable(key) and not is_iterator(key) and not isinstance(key, slice):
# is_iterator to exclude generator e.g. test_getitem_listlike
+ # As of Python 3.12, slice is hashable which breaks MultiIndex (GH#57500)
+
# shortcut if the key is in columns
is_mi = isinstance(self.columns, MultiIndex)
# GH#45316 Return view if key is not duplicated
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index 49e5c4aff5afe..5a6fe07aa007b 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -524,6 +524,16 @@ def test_loc_setitem_boolean_mask_allfalse(self):
result.loc[result.b.isna(), "a"] = result.a.copy()
tm.assert_frame_equal(result, df)
+ def test_getitem_slice_empty(self):
+ df = DataFrame([[1]], columns=MultiIndex.from_product([["A"], ["a"]]))
+ result = df[:]
+
+ expected = DataFrame([[1]], columns=MultiIndex.from_product([["A"], ["a"]]))
+
+ tm.assert_frame_equal(result, expected)
+ # Ensure df[:] returns a view of df, not the same object
+ assert result is not df
+
def test_getitem_fancy_slice_integers_step(self):
df = DataFrame(np.random.default_rng(2).standard_normal((10, 5)))
| - [X] closes #57500
- [X] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [X] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [X] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions. _(Not applicable)_
- [X] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/58043 | 2024-03-28T13:32:28Z | 2024-04-16T17:16:02Z | 2024-04-16T17:16:02Z | 2024-04-16T17:16:08Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.