diff --git a/doc/source/reference/frame.rst b/doc/source/reference/frame.rst index 9cd9d6a157aee..31a1c6008bce8 100644 --- a/doc/source/reference/frame.rst +++ b/doc/source/reference/frame.rst @@ -206,7 +206,6 @@ Missing data handling .. autosummary:: :toctree: api/ - DataFrame.backfill DataFrame.bfill DataFrame.dropna DataFrame.ffill @@ -216,7 +215,6 @@ Missing data handling DataFrame.isnull DataFrame.notna DataFrame.notnull - DataFrame.pad DataFrame.replace Reshaping, sorting, transposing diff --git a/doc/source/reference/series.rst b/doc/source/reference/series.rst index 02a9921bc252d..0654ed52e0cfb 100644 --- a/doc/source/reference/series.rst +++ b/doc/source/reference/series.rst @@ -207,7 +207,6 @@ Missing data handling .. autosummary:: :toctree: api/ - Series.backfill Series.bfill Series.dropna Series.ffill @@ -217,7 +216,6 @@ Missing data handling Series.isnull Series.notna Series.notnull - Series.pad Series.replace Reshaping, sorting diff --git a/doc/source/user_guide/basics.rst b/doc/source/user_guide/basics.rst index 73b7a0a7bc333..eed3fc149263a 100644 --- a/doc/source/user_guide/basics.rst +++ b/doc/source/user_guide/basics.rst @@ -1308,8 +1308,8 @@ filling method chosen from the following table: :header: "Method", "Action" :widths: 30, 50 - pad / ffill, Fill values forward - bfill / backfill, Fill values backward + ffill, Fill values forward + bfill, Fill values backward nearest, Fill from the nearest index value We illustrate these fill methods on a simple Series: diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst index d9ab0452c8334..9d29044c27833 100644 --- a/doc/source/whatsnew/v2.2.0.rst +++ b/doc/source/whatsnew/v2.2.0.rst @@ -619,6 +619,8 @@ For example: pd.date_range('2020-01-01', periods=3, freq='QE-NOV') +.. _whatsnew_220.silent_downcasting: + Deprecated automatic downcasting ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst index 915b7744302c0..f03735e516454 100644 --- a/doc/source/whatsnew/v3.0.0.rst +++ b/doc/source/whatsnew/v3.0.0.rst @@ -106,6 +106,7 @@ Removal of prior version deprecations/changes - :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`) - All arguments except the first ``path``-like argument in IO writers are now keyword only (:issue:`54229`) - Changed the default value of ``observed`` in :meth:`DataFrame.groupby` and :meth:`Series.groupby` to ``True`` (:issue:`51811`) +- Enforced silent-downcasting deprecation for :ref:`all relevant methods ` (:issue:`54710`) - Removed ``DataFrame.applymap``, ``Styler.applymap`` and ``Styler.applymap_index`` (:issue:`52364`) - Removed ``DataFrame.bool`` and ``Series.bool`` (:issue:`51756`) - Removed ``DataFrame.first`` and ``DataFrame.last`` (:issue:`53710`) diff --git a/pandas/core/generic.py b/pandas/core/generic.py index afdbf157a04fa..9cb0b317ad1d0 100644 --- a/pandas/core/generic.py +++ b/pandas/core/generic.py @@ -6648,22 +6648,6 @@ def convert_dtypes( # ---------------------------------------------------------------------- # Filling NA's - def _deprecate_downcast(self, downcast, method_name: str): - # GH#40988 - if downcast is not lib.no_default: - warnings.warn( - f"The 'downcast' keyword in {method_name} is deprecated and " - "will be removed in a future version. Use " - "res.infer_objects(copy=False) to infer non-object dtype, or " - "pd.to_numeric with the 'downcast' keyword to downcast numeric " - "results.", - FutureWarning, - stacklevel=find_stack_level(), - ) - else: - downcast = None - return downcast - @final def _pad_or_backfill( self, @@ -6673,7 +6657,6 @@ def _pad_or_backfill( inplace: bool = False, limit: None | int = None, limit_area: Literal["inside", "outside"] | None = None, - downcast: dict | None = None, ): if axis is None: axis = 0 @@ -6698,7 +6681,6 @@ def _pad_or_backfill( limit=limit, limit_area=limit_area, inplace=inplace, - downcast=downcast, ) result = self._constructor_from_mgr(new_mgr, axes=new_mgr.axes) if inplace: @@ -6715,7 +6697,6 @@ def fillna( axis: Axis | None = ..., inplace: Literal[False] = ..., limit: int | None = ..., - downcast: dict | None = ..., ) -> Self: ... @@ -6728,7 +6709,6 @@ def fillna( axis: Axis | None = ..., inplace: Literal[True], limit: int | None = ..., - downcast: dict | None = ..., ) -> None: ... @@ -6741,7 +6721,6 @@ def fillna( axis: Axis | None = ..., inplace: bool = ..., limit: int | None = ..., - downcast: dict | None = ..., ) -> Self | None: ... @@ -6758,7 +6737,6 @@ def fillna( axis: Axis | None = None, inplace: bool = False, limit: int | None = None, - downcast: dict | None | lib.NoDefault = lib.no_default, ) -> Self | None: """ Fill NA/NaN values using the specified method. @@ -6794,12 +6772,6 @@ def fillna( be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled. Must be greater than 0 if not None. - downcast : dict, default is None - A dict of item->dtype of what to downcast if possible, - 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 ------- @@ -6894,9 +6866,6 @@ def fillna( stacklevel=find_stack_level(), ) - was_no_default = downcast is lib.no_default - downcast = self._deprecate_downcast(downcast, "fillna") - # set the default here, so functions examining the signaure # can detect if something was set (e.g. in groupby) (GH9221) if axis is None: @@ -6912,11 +6881,6 @@ def fillna( axis=axis, limit=limit, inplace=inplace, - # error: Argument "downcast" to "_fillna_with_method" of "NDFrame" - # has incompatible type "Union[Dict[Any, Any], None, - # Literal[_NoDefault.no_default]]"; expected - # "Optional[Dict[Any, Any]]" - downcast=downcast, # type: ignore[arg-type] ) else: if self.ndim == 1: @@ -6940,9 +6904,7 @@ def fillna( f'"{type(value).__name__}"' ) - new_data = self._mgr.fillna( - value=value, limit=limit, inplace=inplace, downcast=downcast - ) + new_data = self._mgr.fillna(value=value, limit=limit, inplace=inplace) elif isinstance(value, (dict, ABCSeries)): if axis == 1: @@ -6952,27 +6914,11 @@ def fillna( "by column" ) result = self.copy(deep=False) - is_dict = isinstance(downcast, dict) for k, v in value.items(): if k not in result: continue - if was_no_default: - downcast_k = lib.no_default - else: - downcast_k = ( - # error: Incompatible types in assignment (expression - # has type "Union[Dict[Any, Any], None, - # Literal[_NoDefault.no_default], Any]", variable has - # type "_NoDefault") - downcast # type: ignore[assignment] - if not is_dict - # error: Item "None" of "Optional[Dict[Any, Any]]" has - # no attribute "get" - else downcast.get(k) # type: ignore[union-attr] - ) - - res_k = result[k].fillna(v, limit=limit, downcast=downcast_k) + res_k = result[k].fillna(v, limit=limit) if not inplace: result[k] = res_k @@ -7023,7 +6969,7 @@ def fillna( new_data = result._mgr else: new_data = self._mgr.fillna( - value=value, limit=limit, inplace=inplace, downcast=downcast + value=value, limit=limit, inplace=inplace ) elif isinstance(value, ABCDataFrame) and self.ndim == 2: new_data = self.where(self.notna(), value)._mgr @@ -7044,7 +6990,6 @@ def ffill( inplace: Literal[False] = ..., limit: None | int = ..., limit_area: Literal["inside", "outside"] | None = ..., - downcast: dict | None | lib.NoDefault = ..., ) -> Self: ... @@ -7056,7 +7001,6 @@ def ffill( inplace: Literal[True], limit: None | int = ..., limit_area: Literal["inside", "outside"] | None = ..., - downcast: dict | None | lib.NoDefault = ..., ) -> None: ... @@ -7068,7 +7012,6 @@ def ffill( inplace: bool = ..., limit: None | int = ..., limit_area: Literal["inside", "outside"] | None = ..., - downcast: dict | None | lib.NoDefault = ..., ) -> Self | None: ... @@ -7084,7 +7027,6 @@ def ffill( inplace: bool = False, limit: None | int = None, limit_area: Literal["inside", "outside"] | None = None, - downcast: dict | None | lib.NoDefault = lib.no_default, ) -> Self | None: """ Fill NA/NaN values by propagating the last valid observation to next valid. @@ -7116,13 +7058,6 @@ def ffill( .. versionadded:: 2.2.0 - downcast : dict, default is None - A dict of item->dtype of what to downcast if possible, - 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 @@ -7161,7 +7096,6 @@ def ffill( 3 3.0 dtype: float64 """ - downcast = self._deprecate_downcast(downcast, "ffill") inplace = validate_bool_kwarg(inplace, "inplace") if inplace: if not PYPY: @@ -7178,45 +7112,7 @@ def ffill( inplace=inplace, limit=limit, limit_area=limit_area, - # error: Argument "downcast" to "_fillna_with_method" of "NDFrame" - # has incompatible type "Union[Dict[Any, Any], None, - # Literal[_NoDefault.no_default]]"; expected "Optional[Dict[Any, Any]]" - downcast=downcast, # type: ignore[arg-type] - ) - - @final - @doc(klass=_shared_doc_kwargs["klass"]) - def pad( - self, - *, - axis: None | Axis = None, - inplace: bool = False, - limit: None | int = None, - downcast: dict | None | lib.NoDefault = lib.no_default, - ) -> Self | None: - """ - Fill NA/NaN values by propagating the last valid observation to next valid. - - .. deprecated:: 2.0 - - {klass}.pad is deprecated. Use {klass}.ffill instead. - - Returns - ------- - {klass} or None - Object with missing values filled or None if ``inplace=True``. - - Examples - -------- - Please see examples for :meth:`DataFrame.ffill` or :meth:`Series.ffill`. - """ - warnings.warn( - "DataFrame.pad/Series.pad is deprecated. Use " - "DataFrame.ffill/Series.ffill instead", - FutureWarning, - stacklevel=find_stack_level(), ) - return self.ffill(axis=axis, inplace=inplace, limit=limit, downcast=downcast) @overload def bfill( @@ -7226,7 +7122,6 @@ def bfill( inplace: Literal[False] = ..., limit: None | int = ..., limit_area: Literal["inside", "outside"] | None = ..., - downcast: dict | None | lib.NoDefault = ..., ) -> Self: ... @@ -7237,7 +7132,6 @@ def bfill( axis: None | Axis = ..., inplace: Literal[True], limit: None | int = ..., - downcast: dict | None | lib.NoDefault = ..., ) -> None: ... @@ -7249,7 +7143,6 @@ def bfill( inplace: bool = ..., limit: None | int = ..., limit_area: Literal["inside", "outside"] | None = ..., - downcast: dict | None | lib.NoDefault = ..., ) -> Self | None: ... @@ -7265,7 +7158,6 @@ def bfill( inplace: bool = False, limit: None | int = None, limit_area: Literal["inside", "outside"] | None = None, - downcast: dict | None | lib.NoDefault = lib.no_default, ) -> Self | None: """ Fill NA/NaN values by using the next valid observation to fill the gap. @@ -7297,13 +7189,6 @@ def bfill( .. versionadded:: 2.2.0 - downcast : dict, default is None - A dict of item->dtype of what to downcast if possible, - 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 @@ -7349,7 +7234,6 @@ def bfill( 2 4.0 7.0 3 4.0 7.0 """ - downcast = self._deprecate_downcast(downcast, "bfill") inplace = validate_bool_kwarg(inplace, "inplace") if inplace: if not PYPY: @@ -7366,46 +7250,8 @@ def bfill( inplace=inplace, limit=limit, limit_area=limit_area, - # error: Argument "downcast" to "_fillna_with_method" of "NDFrame" - # has incompatible type "Union[Dict[Any, Any], None, - # Literal[_NoDefault.no_default]]"; expected "Optional[Dict[Any, Any]]" - downcast=downcast, # type: ignore[arg-type] ) - @final - @doc(klass=_shared_doc_kwargs["klass"]) - def backfill( - self, - *, - axis: None | Axis = None, - inplace: bool = False, - limit: None | int = None, - downcast: dict | None | lib.NoDefault = lib.no_default, - ) -> Self | None: - """ - Fill NA/NaN values by using the next valid observation to fill the gap. - - .. deprecated:: 2.0 - - {klass}.backfill is deprecated. Use {klass}.bfill instead. - - Returns - ------- - {klass} or None - Object with missing values filled or None if ``inplace=True``. - - Examples - -------- - Please see examples for :meth:`DataFrame.bfill` or :meth:`Series.bfill`. - """ - warnings.warn( - "DataFrame.backfill/Series.backfill is deprecated. Use " - "DataFrame.bfill/Series.bfill instead", - FutureWarning, - stacklevel=find_stack_level(), - ) - return self.bfill(axis=axis, inplace=inplace, limit=limit, downcast=downcast) - @overload def replace( self, @@ -7703,7 +7549,6 @@ def interpolate( inplace: Literal[False] = ..., limit_direction: Literal["forward", "backward", "both"] | None = ..., limit_area: Literal["inside", "outside"] | None = ..., - downcast: Literal["infer"] | None | lib.NoDefault = ..., **kwargs, ) -> Self: ... @@ -7718,7 +7563,6 @@ def interpolate( inplace: Literal[True], limit_direction: Literal["forward", "backward", "both"] | None = ..., limit_area: Literal["inside", "outside"] | None = ..., - downcast: Literal["infer"] | None | lib.NoDefault = ..., **kwargs, ) -> None: ... @@ -7733,7 +7577,6 @@ def interpolate( inplace: bool = ..., limit_direction: Literal["forward", "backward", "both"] | None = ..., limit_area: Literal["inside", "outside"] | None = ..., - downcast: Literal["infer"] | None | lib.NoDefault = ..., **kwargs, ) -> Self | None: ... @@ -7748,7 +7591,6 @@ def interpolate( inplace: bool = False, limit_direction: Literal["forward", "backward", "both"] | None = None, limit_area: Literal["inside", "outside"] | None = None, - downcast: Literal["infer"] | None | lib.NoDefault = lib.no_default, **kwargs, ) -> Self | None: """ @@ -7817,11 +7659,6 @@ def interpolate( (interpolate). * 'outside': Only fill NaNs outside valid values (extrapolate). - downcast : optional, 'infer' or None, defaults to None - Downcast dtypes if possible. - - .. deprecated:: 2.1.0 - **kwargs : optional Keyword arguments to pass on to the interpolating function. @@ -7924,20 +7761,6 @@ def interpolate( 3 16.0 Name: d, dtype: float64 """ - if downcast is not lib.no_default: - # GH#40988 - warnings.warn( - f"The 'downcast' keyword in {type(self).__name__}.interpolate " - "is deprecated and will be removed in a future version. " - "Call result.infer_objects(copy=False) on the result instead.", - FutureWarning, - stacklevel=find_stack_level(), - ) - else: - downcast = None - if downcast is not None and downcast != "infer": - raise ValueError("downcast must be either None or 'infer'") - inplace = validate_bool_kwarg(inplace, "inplace") if inplace: @@ -8021,7 +7844,6 @@ def interpolate( limit=limit, limit_area=limit_area, inplace=inplace, - downcast=downcast, ) else: index = missing.get_interp_index(method, obj.index) @@ -8032,7 +7854,6 @@ def interpolate( limit_direction=limit_direction, limit_area=limit_area, inplace=inplace, - downcast=downcast, **kwargs, ) @@ -8576,11 +8397,11 @@ def clip( >>> df.clip(t, axis=0) col_0 col_1 - 0 9 2 - 1 -3 -4 - 2 0 6 - 3 6 8 - 4 5 3 + 0 9.0 2.0 + 1 -3.0 -4.0 + 2 0.0 6.0 + 3 6.0 8.0 + 4 5.0 3.0 """ inplace = validate_bool_kwarg(inplace, "inplace") diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py index af529c837089a..2e96366b2d17b 100644 --- a/pandas/core/internals/blocks.py +++ b/pandas/core/internals/blocks.py @@ -16,8 +16,6 @@ import numpy as np -from pandas._config import get_option - from pandas._libs import ( NaT, internals as libinternals, @@ -56,7 +54,6 @@ can_hold_element, convert_dtypes, find_result_type, - maybe_downcast_to_dtype, np_can_hold_element, ) from pandas.core.dtypes.common import ( @@ -526,92 +523,6 @@ def coerce_to_target_dtype(self, other, warn_on_upcast: bool = False) -> Block: ) return self.astype(new_dtype) - @final - def _maybe_downcast( - self, - blocks: list[Block], - downcast, - caller: str, - ) -> list[Block]: - if downcast is False: - return blocks - - if self.dtype == _dtype_obj: - # TODO: does it matter that self.dtype might not match blocks[i].dtype? - # GH#44241 We downcast regardless of the argument; - # respecting 'downcast=None' may be worthwhile at some point, - # but ATM it breaks too much existing code. - # split and convert the blocks - - if caller == "fillna" and get_option("future.no_silent_downcasting"): - return blocks - - nbs = extend_blocks([blk.convert() for blk in blocks]) - if caller == "fillna": - if len(nbs) != len(blocks) or not all( - x.dtype == y.dtype for x, y in zip(nbs, blocks) - ): - # GH#54261 - warnings.warn( - "Downcasting object dtype arrays on .fillna, .ffill, .bfill " - "is deprecated and will change in a future version. " - "Call result.infer_objects(copy=False) instead. " - "To opt-in to the future " - "behavior, set " - "`pd.set_option('future.no_silent_downcasting', True)`", - FutureWarning, - stacklevel=find_stack_level(), - ) - - return nbs - - elif downcast is None: - return blocks - elif caller == "where" and get_option("future.no_silent_downcasting") is True: - return blocks - else: - nbs = extend_blocks([b._downcast_2d(downcast) for b in blocks]) - - # When _maybe_downcast is called with caller="where", it is either - # a) with downcast=False, which is a no-op (the desired future behavior) - # b) with downcast="infer", which is _not_ passed by the user. - # In the latter case the future behavior is to stop doing inference, - # so we issue a warning if and only if some inference occurred. - if caller == "where": - # GH#53656 - if len(blocks) != len(nbs) or any( - left.dtype != right.dtype for left, right in zip(blocks, nbs) - ): - # In this case _maybe_downcast was _not_ a no-op, so the behavior - # will change, so we issue a warning. - warnings.warn( - "Downcasting behavior in Series and DataFrame methods 'where', " - "'mask', and 'clip' is deprecated. In a future " - "version this will not infer object dtypes or cast all-round " - "floats to integers. Instead call " - "result.infer_objects(copy=False) for object inference, " - "or cast round floats explicitly. To opt-in to the future " - "behavior, set " - "`pd.set_option('future.no_silent_downcasting', True)`", - FutureWarning, - stacklevel=find_stack_level(), - ) - - return nbs - - @final - @maybe_split - def _downcast_2d(self, dtype) -> list[Block]: - """ - downcast specialized to 2D case post-validation. - - Refactored to allow use of maybe_split. - """ - new_values = maybe_downcast_to_dtype(self.values, dtype=dtype) - new_values = maybe_coerce_values(new_values) - refs = self.refs if new_values is self.values else None - return [self.make_block(new_values, refs=refs)] - @final def convert(self) -> list[Block]: """ @@ -840,30 +751,7 @@ def replace( # and rest? blk = self._maybe_copy(inplace) putmask_inplace(blk.values, mask, value) - - if not (self.is_object and value is None): - # if the user *explicitly* gave None, we keep None, otherwise - # may downcast to NaN - if get_option("future.no_silent_downcasting") is True: - blocks = [blk] - else: - blocks = blk.convert() - if len(blocks) > 1 or blocks[0].dtype != blk.dtype: - warnings.warn( - # GH#54710 - "Downcasting behavior in `replace` is deprecated and " - "will be removed in a future version. To retain the old " - "behavior, explicitly call " - "`result.infer_objects(copy=False)`. " - "To opt-in to the future " - "behavior, set " - "`pd.set_option('future.no_silent_downcasting', True)`", - FutureWarning, - stacklevel=find_stack_level(), - ) - else: - blocks = [blk] - return blocks + return [blk] elif self.ndim == 1 or self.shape[0] == 1: if value is None or value is NA: @@ -928,22 +816,7 @@ def _replace_regex( block = self._maybe_copy(inplace) replace_regex(block.values, rx, value, mask) - - nbs = block.convert() - opt = get_option("future.no_silent_downcasting") - if (len(nbs) > 1 or nbs[0].dtype != block.dtype) and not opt: - warnings.warn( - # GH#54710 - "Downcasting behavior in `replace` is deprecated and " - "will be removed in a future version. To retain the old " - "behavior, explicitly call `result.infer_objects(copy=False)`. " - "To opt-in to the future " - "behavior, set " - "`pd.set_option('future.no_silent_downcasting', True)`", - FutureWarning, - stacklevel=find_stack_level(), - ) - return nbs + return [block] @final def replace_list( @@ -1002,9 +875,7 @@ def replace_list( # references when we check again later rb = [self] - opt = get_option("future.no_silent_downcasting") for i, ((src, dest), mask) in enumerate(zip(pairs, masks)): - convert = i == src_len # only convert once at the end new_rb: list[Block] = [] # GH-39338: _replace_coerce can split a block into @@ -1038,32 +909,6 @@ def replace_list( b.refs.referenced_blocks.pop( b.refs.referenced_blocks.index(ref) ) - - if ( - not opt - and convert - and blk.is_object - and not all(x is None for x in dest_list) - ): - # GH#44498 avoid unwanted cast-back - nbs = [] - for res_blk in result: - converted = res_blk.convert() - if len(converted) > 1 or converted[0].dtype != res_blk.dtype: - warnings.warn( - # GH#54710 - "Downcasting behavior in `replace` is deprecated " - "and will be removed in a future version. To " - "retain the old behavior, explicitly call " - "`result.infer_objects(copy=False)`. " - "To opt-in to the future " - "behavior, set " - "`pd.set_option('future.no_silent_downcasting', True)`", - FutureWarning, - stacklevel=find_stack_level(), - ) - nbs.extend(converted) - result = nbs new_rb.extend(result) rb = new_rb return rb @@ -1399,7 +1244,7 @@ def putmask(self, mask, new) -> list[Block]: res_blocks.extend(rbs) return res_blocks - def where(self, other, cond, _downcast: str | bool = "infer") -> list[Block]: + def where(self, other, cond) -> list[Block]: """ evaluate the block; return result block(s) from the result @@ -1407,8 +1252,6 @@ def where(self, other, cond, _downcast: str | bool = "infer") -> list[Block]: ---------- other : a ndarray/object cond : np.ndarray[bool], SparseArray[bool], or BooleanArray - _downcast : str or None, default "infer" - Private because we only specify it when calling from fillna. Returns ------- @@ -1429,7 +1272,6 @@ def where(self, other, cond, _downcast: str | bool = "infer") -> list[Block]: icond, noop = validate_putmask(values, ~cond) if noop: - # GH-39595: Always return a copy; short-circuit up/downcasting return [self.copy(deep=False)] if other is lib.no_default: @@ -1449,13 +1291,9 @@ def where(self, other, cond, _downcast: str | bool = "infer") -> list[Block]: # no need to split columns block = self.coerce_to_target_dtype(other) - blocks = block.where(orig_other, cond) - return self._maybe_downcast(blocks, downcast=_downcast, caller="where") + return block.where(orig_other, cond) else: - # since _maybe_downcast would split blocks anyway, we - # can avoid some potential upcast/downcast by splitting - # on the front end. is_array = isinstance(other, (np.ndarray, ExtensionArray)) res_blocks = [] @@ -1467,7 +1305,7 @@ def where(self, other, cond, _downcast: str | bool = "infer") -> list[Block]: oth = other[:, i : i + 1] submask = cond[:, i : i + 1] - rbs = nb.where(oth, submask, _downcast=_downcast) + rbs = nb.where(oth, submask) res_blocks.extend(rbs) return res_blocks @@ -1515,7 +1353,6 @@ def fillna( value, limit: int | None = None, inplace: bool = False, - downcast=None, ) -> list[Block]: """ fillna on the block with the value. If we fail, then convert to @@ -1533,13 +1370,7 @@ def fillna( if noop: # we can't process the value, but nothing to do - if inplace: - return [self.copy(deep=False)] - else: - # GH#45423 consistent downcasting on no-ops. - nb = self.copy(deep=False) - nbs = nb._maybe_downcast([nb], downcast=downcast, caller="fillna") - return nbs + return [self.copy(deep=False)] if limit is not None: mask[mask.cumsum(self.ndim - 1) > limit] = False @@ -1547,19 +1378,8 @@ def fillna( if inplace: nbs = self.putmask(mask.T, value) else: - # without _downcast, we would break - # test_fillna_dtype_conversion_equiv_replace - nbs = self.where(value, ~mask.T, _downcast=False) - - # Note: blk._maybe_downcast vs self._maybe_downcast(nbs) - # makes a difference bc blk may have object dtype, which has - # different behavior in _maybe_downcast. - return extend_blocks( - [ - blk._maybe_downcast([blk], downcast=downcast, caller="fillna") - for blk in nbs - ] - ) + nbs = self.where(value, ~mask.T) + return extend_blocks(nbs) def pad_or_backfill( self, @@ -1569,7 +1389,6 @@ def pad_or_backfill( inplace: bool = False, limit: int | None = None, limit_area: Literal["inside", "outside"] | None = None, - downcast: Literal["infer"] | None = None, ) -> list[Block]: if not self._can_hold_na: # If there are no NAs, then interpolate is a no-op @@ -1592,9 +1411,7 @@ def pad_or_backfill( new_values = new_values.T data = extract_array(new_values, extract_numpy=True) - - nb = self.make_block_same_class(data, refs=refs) - return nb._maybe_downcast([nb], downcast, caller="fillna") + return [self.make_block_same_class(data, refs=refs)] @final def interpolate( @@ -1606,7 +1423,6 @@ def interpolate( limit: int | None = None, limit_direction: Literal["forward", "backward", "both"] = "forward", limit_area: Literal["inside", "outside"] | None = None, - downcast: Literal["infer"] | None = None, **kwargs, ) -> list[Block]: inplace = validate_bool_kwarg(inplace, "inplace") @@ -1640,9 +1456,7 @@ def interpolate( **kwargs, ) data = extract_array(new_values, extract_numpy=True) - - nb = self.make_block_same_class(data, refs=refs) - return nb._maybe_downcast([nb], downcast, caller="interpolate") + return [self.make_block_same_class(data, refs=refs)] @final def diff(self, n: int) -> list[Block]: @@ -1891,8 +1705,7 @@ def setitem(self, indexer, value): return self @final - def where(self, other, cond, _downcast: str | bool = "infer") -> list[Block]: - # _downcast private bc we only specify it when calling from fillna + def where(self, other, cond) -> list[Block]: arr = self.values.T cond = extract_bool_array(cond) @@ -1918,15 +1731,13 @@ def where(self, other, cond, _downcast: str | bool = "infer") -> list[Block]: if isinstance(self.dtype, IntervalDtype): # TestSetitemFloatIntervalWithIntIntervalValues blk = self.coerce_to_target_dtype(orig_other) - nbs = blk.where(orig_other, orig_cond) - return self._maybe_downcast(nbs, downcast=_downcast, caller="where") + return blk.where(orig_other, orig_cond) elif isinstance(self, NDArrayBackedExtensionBlock): # NB: not (yet) the same as # isinstance(values, NDArrayBackedExtensionArray) blk = self.coerce_to_target_dtype(orig_other) - nbs = blk.where(orig_other, orig_cond) - return self._maybe_downcast(nbs, downcast=_downcast, caller="where") + return blk.where(orig_other, orig_cond) else: raise @@ -2049,7 +1860,6 @@ def pad_or_backfill( inplace: bool = False, limit: int | None = None, limit_area: Literal["inside", "outside"] | None = None, - downcast: Literal["infer"] | None = None, ) -> list[Block]: values = self.values @@ -2090,7 +1900,6 @@ def fillna( value, limit: int | None = None, inplace: bool = False, - downcast=None, ) -> list[Block]: if isinstance(self.dtype, IntervalDtype): # Block.fillna handles coercion (test_fillna_interval) @@ -2098,7 +1907,6 @@ def fillna( value=value, limit=limit, inplace=inplace, - downcast=downcast, ) if self._can_hold_na and not self.values._hasna: refs = self.refs @@ -2127,8 +1935,7 @@ def fillna( stacklevel=find_stack_level(), ) - nb = self.make_block_same_class(new_values, refs=refs) - return nb._maybe_downcast([nb], downcast, caller="fillna") + return [self.make_block_same_class(new_values, refs=refs)] @cache_readonly def shape(self) -> Shape: diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py index d99a1f572ec2a..3cb7c72431613 100644 --- a/pandas/core/internals/managers.py +++ b/pandas/core/internals/managers.py @@ -457,7 +457,7 @@ def isna(self, func) -> Self: return self.apply("apply", func=func) @final - def fillna(self, value, limit: int | None, inplace: bool, downcast) -> Self: + def fillna(self, value, limit: int | None, inplace: bool) -> Self: if limit is not None: # Do this validation even if we go through one of the no-op paths limit = libalgos.validate_limit(None, limit=limit) @@ -467,7 +467,6 @@ def fillna(self, value, limit: int | None, inplace: bool, downcast) -> Self: value=value, limit=limit, inplace=inplace, - downcast=downcast, ) @final diff --git a/pandas/tests/apply/test_series_apply.py b/pandas/tests/apply/test_series_apply.py index cd1547620e208..e0153c97b8f29 100644 --- a/pandas/tests/apply/test_series_apply.py +++ b/pandas/tests/apply/test_series_apply.py @@ -305,7 +305,7 @@ def test_transform(string_series, by_row): @pytest.mark.parametrize("op", series_transform_kernels) def test_transform_partial_failure(op, request): # GH 35964 - if op in ("ffill", "bfill", "pad", "backfill", "shift"): + if op in ("ffill", "bfill", "shift"): request.applymarker( pytest.mark.xfail(reason=f"{op} is successful on any dtype") ) diff --git a/pandas/tests/arithmetic/test_timedelta64.py b/pandas/tests/arithmetic/test_timedelta64.py index 3e9508bd2f504..e47acd7d09dc0 100644 --- a/pandas/tests/arithmetic/test_timedelta64.py +++ b/pandas/tests/arithmetic/test_timedelta64.py @@ -2031,12 +2031,7 @@ def test_td64arr_div_numeric_array( if box_with_array is DataFrame: expected = [tdser.iloc[0, n] / vector[n] for n in range(len(vector))] expected = tm.box_expected(expected, xbox).astype(object) - # We specifically expect timedelta64("NaT") here, not pd.NA - msg = "The 'downcast' keyword in fillna" - with tm.assert_produces_warning(FutureWarning, match=msg): - expected[2] = expected[2].fillna( - np.timedelta64("NaT", "ns"), downcast=False - ) + expected[2] = expected[2].fillna(np.timedelta64("NaT", "ns")) else: expected = [tdser[n] / vector[n] for n in range(len(tdser))] expected = [ @@ -2118,9 +2113,7 @@ def test_td64arr_all_nat_div_object_dtype_numeric(self, box_with_array): if box_with_array is not Index: expected = tm.box_expected(expected, box_with_array).astype(object) if box_with_array in [Series, DataFrame]: - msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - expected = expected.fillna(tdnat, downcast=False) # GH#18463 + expected = expected.fillna(tdnat) # GH#18463 result = left / right tm.assert_equal(result, expected) diff --git a/pandas/tests/copy_view/test_interp_fillna.py b/pandas/tests/copy_view/test_interp_fillna.py index 733c6ddb9bd8a..e88896c9ec8c2 100644 --- a/pandas/tests/copy_view/test_interp_fillna.py +++ b/pandas/tests/copy_view/test_interp_fillna.py @@ -140,17 +140,6 @@ def test_interpolate_object_convert_no_op(): def test_interpolate_object_convert_copies(): - df = DataFrame({"a": Series([1, 2], dtype=object), "b": 1}) - arr_a = get_array(df, "a") - msg = "DataFrame.interpolate with method=pad is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - df.interpolate(method="pad", inplace=True) - - assert df._mgr._has_no_reference(0) - assert not np.shares_memory(arr_a, get_array(df, "a")) - - -def test_interpolate_downcast(): df = DataFrame({"a": [1, np.nan, 2.5], "b": 1}) arr_a = get_array(df, "a") msg = "DataFrame.interpolate with method=pad is deprecated" @@ -197,15 +186,12 @@ def test_fillna_dict(): tm.assert_frame_equal(df_orig, df) -@pytest.mark.parametrize("downcast", [None, False]) -def test_fillna_inplace(downcast): +def test_fillna_inplace(): df = DataFrame({"a": [1.5, np.nan], "b": 1}) arr_a = get_array(df, "a") arr_b = get_array(df, "b") - msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - df.fillna(5.5, inplace=True, downcast=downcast) + df.fillna(5.5, inplace=True) assert np.shares_memory(get_array(df, "a"), arr_a) assert np.shares_memory(get_array(df, "b"), arr_b) assert df._mgr._has_no_reference(0) diff --git a/pandas/tests/frame/indexing/test_where.py b/pandas/tests/frame/indexing/test_where.py index 954055acb6619..ebd4136f2e451 100644 --- a/pandas/tests/frame/indexing/test_where.py +++ b/pandas/tests/frame/indexing/test_where.py @@ -357,10 +357,9 @@ def test_where_bug_transposition(self): expected = a.copy() expected[~do_not_replace] = b + expected[[0, 1]] = expected[[0, 1]].astype("float64") - msg = "Downcasting behavior in Series and DataFrame methods 'where'" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = a.where(do_not_replace, b) + result = a.where(do_not_replace, b) tm.assert_frame_equal(result, expected) a = DataFrame({0: [4, 6], 1: [1, 0]}) @@ -369,9 +368,9 @@ def test_where_bug_transposition(self): expected = a.copy() expected[~do_not_replace] = b + expected[1] = expected[1].astype("float64") - with tm.assert_produces_warning(FutureWarning, match=msg): - result = a.where(do_not_replace, b) + result = a.where(do_not_replace, b) tm.assert_frame_equal(result, expected) def test_where_datetime(self): @@ -738,17 +737,10 @@ def test_where_interval_noop(self): def test_where_interval_fullop_downcast(self, frame_or_series): # GH#45768 obj = frame_or_series([pd.Interval(0, 0)] * 2) - other = frame_or_series([1.0, 2.0]) + other = frame_or_series([1.0, 2.0], dtype=object) + res = obj.where(~obj.notna(), other) + tm.assert_equal(res, other) - msg = "Downcasting behavior in Series and DataFrame methods 'where'" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = obj.where(~obj.notna(), other) - - # since all entries are being changed, we will downcast result - # from object to ints (not floats) - tm.assert_equal(res, other.astype(np.int64)) - - # unlike where, Block.putmask does not downcast with tm.assert_produces_warning( FutureWarning, match="Setting an item of incompatible dtype" ): @@ -783,14 +775,7 @@ def test_where_datetimelike_noop(self, dtype): res4 = df.mask(mask2, "foo") tm.assert_frame_equal(res4, df) - - # opposite case where we are replacing *all* values -> we downcast - # from object dtype # GH#45768 - msg = "Downcasting behavior in Series and DataFrame methods 'where'" - with tm.assert_produces_warning(FutureWarning, match=msg): - res5 = df.where(mask2, 4) expected = DataFrame(4, index=df.index, columns=df.columns) - tm.assert_frame_equal(res5, expected) # unlike where, Block.putmask does not downcast with tm.assert_produces_warning( @@ -991,16 +976,9 @@ def test_where_downcast_to_td64(): mask = np.array([False, False, False]) td = pd.Timedelta(days=1) - - msg = "Downcasting behavior in Series and DataFrame methods 'where'" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = ser.where(mask, td) expected = Series([td, td, td], dtype="m8[ns]") - tm.assert_series_equal(res, expected) - with pd.option_context("future.no_silent_downcasting", True): - with tm.assert_produces_warning(None, match=msg): - res2 = ser.where(mask, td) + res2 = ser.where(mask, td) expected2 = expected.astype(object) tm.assert_series_equal(res2, expected2) @@ -1036,13 +1014,6 @@ def test_where_dt64_2d(): mask = np.asarray(df.isna()).copy() mask[:, 1] = True - # setting all of one column, none of the other - expected = DataFrame({"A": other[:, 0], "B": dta[:, 1]}) - with tm.assert_produces_warning( - FutureWarning, match="Setting an item of incompatible dtype" - ): - _check_where_equivalences(df, mask, other, expected) - # setting part of one column, none of the other mask[1, 0] = True expected = DataFrame( diff --git a/pandas/tests/frame/methods/test_clip.py b/pandas/tests/frame/methods/test_clip.py index f783a388d7517..62a97271d208b 100644 --- a/pandas/tests/frame/methods/test_clip.py +++ b/pandas/tests/frame/methods/test_clip.py @@ -155,13 +155,13 @@ def test_clip_with_na_args(self, float_frame): # GH#19992 and adjusted in GH#40420 df = DataFrame({"col_0": [1, 2, 3], "col_1": [4, 5, 6], "col_2": [7, 8, 9]}) - msg = "Downcasting behavior in Series and DataFrame methods 'where'" - # TODO: avoid this warning here? seems like we should never be upcasting - # in the first place? - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.clip(lower=[4, 5, np.nan], axis=0) + result = df.clip(lower=[4, 5, np.nan], axis=0) expected = DataFrame( - {"col_0": [4, 5, 3], "col_1": [4, 5, 6], "col_2": [7, 8, 9]} + { + "col_0": Series([4, 5, 3], dtype="float"), + "col_1": [4, 5, 6], + "col_2": [7, 8, 9], + } ) tm.assert_frame_equal(result, expected) @@ -175,9 +175,10 @@ def test_clip_with_na_args(self, float_frame): data = {"col_0": [9, -3, 0, -1, 5], "col_1": [-2, -7, 6, 8, -5]} df = DataFrame(data) t = Series([2, -4, np.nan, 6, 3]) - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.clip(lower=t, axis=0) - expected = DataFrame({"col_0": [9, -3, 0, 6, 5], "col_1": [2, -4, 6, 8, 3]}) + result = df.clip(lower=t, axis=0) + expected = DataFrame( + {"col_0": [9, -3, 0, 6, 5], "col_1": [2, -4, 6, 8, 3]}, dtype="float" + ) tm.assert_frame_equal(result, expected) def test_clip_int_data_with_float_bound(self): diff --git a/pandas/tests/frame/methods/test_fillna.py b/pandas/tests/frame/methods/test_fillna.py index efb462416e132..ee660d8b03b40 100644 --- a/pandas/tests/frame/methods/test_fillna.py +++ b/pandas/tests/frame/methods/test_fillna.py @@ -278,57 +278,12 @@ def test_fillna_categorical_nan(self): df = DataFrame({"a": Categorical(idx)}) tm.assert_frame_equal(df.fillna(value=NaT), df) - def test_fillna_downcast(self): - # GH#15277 - # infer int64 from float64 - df = DataFrame({"a": [1.0, np.nan]}) - msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.fillna(0, downcast="infer") - expected = DataFrame({"a": [1, 0]}) - tm.assert_frame_equal(result, expected) - - # infer int64 from float64 when fillna value is a dict - df = DataFrame({"a": [1.0, np.nan]}) - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.fillna({"a": 0}, downcast="infer") - expected = DataFrame({"a": [1, 0]}) - tm.assert_frame_equal(result, expected) - - def test_fillna_downcast_false(self, frame_or_series): - # GH#45603 preserve object dtype with downcast=False + def test_fillna_no_downcast(self, frame_or_series): + # GH#45603 preserve object dtype obj = frame_or_series([1, 2, 3], dtype="object") - msg = "The 'downcast' keyword in fillna" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = obj.fillna("", downcast=False) + result = obj.fillna("") tm.assert_equal(result, obj) - def test_fillna_downcast_noop(self, frame_or_series): - # GH#45423 - # Two relevant paths: - # 1) not _can_hold_na (e.g. integer) - # 2) _can_hold_na + noop + not can_hold_element - - obj = frame_or_series([1, 2, 3], dtype=np.int64) - - msg = "The 'downcast' keyword in fillna" - with tm.assert_produces_warning(FutureWarning, match=msg): - # GH#40988 - res = obj.fillna("foo", downcast=np.dtype(np.int32)) - expected = obj.astype(np.int32) - tm.assert_equal(res, expected) - - obj2 = obj.astype(np.float64) - with tm.assert_produces_warning(FutureWarning, match=msg): - res2 = obj2.fillna("foo", downcast="infer") - expected2 = obj # get back int64 - tm.assert_equal(res2, expected2) - - with tm.assert_produces_warning(FutureWarning, match=msg): - # GH#40988 - res3 = obj2.fillna("foo", downcast=np.dtype(np.int32)) - tm.assert_equal(res3, expected) - @pytest.mark.parametrize("columns", [["A", "A", "B"], ["A", "A"]]) def test_fillna_dictlike_value_duplicate_colnames(self, columns): # GH#43476 @@ -346,20 +301,15 @@ def test_fillna_dtype_conversion(self, using_infer_string): result = df.dtypes expected = Series([np.dtype("object")] * 5, index=[1, 2, 3, 4, 5]) tm.assert_series_equal(result, expected) - - msg = "Downcasting object dtype arrays" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.fillna(1) - expected = DataFrame(1, index=["A", "B", "C"], columns=[1, 2, 3, 4, 5]) + result = df.fillna(1) + expected = DataFrame( + 1, index=["A", "B", "C"], columns=[1, 2, 3, 4, 5], dtype=object + ) tm.assert_frame_equal(result, expected) # empty block df = DataFrame(index=range(3), columns=["A", "B"], dtype="float64") - if using_infer_string: - with tm.assert_produces_warning(FutureWarning, match="Downcasting"): - result = df.fillna("nan") - else: - result = df.fillna("nan") + result = df.fillna("nan") expected = DataFrame("nan", index=range(3), columns=["A", "B"]) tm.assert_frame_equal(result, expected) @@ -647,16 +597,6 @@ def test_fill_corner(self, float_frame, float_string_frame): float_frame.reindex(columns=[]).fillna(value=0) - def test_fillna_downcast_dict(self): - # GH#40809 - df = DataFrame({"col1": [1, np.nan]}) - - msg = "The 'downcast' keyword in fillna" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.fillna({"col1": 2}, downcast={"col1": "int64"}) - expected = DataFrame({"col1": [1, 2]}) - tm.assert_frame_equal(result, expected) - def test_fillna_with_columns_and_limit(self): # GH40989 df = DataFrame( @@ -807,22 +747,12 @@ def test_fillna_nones_inplace(): [[None, None], [None, None]], columns=["A", "B"], ) - msg = "Downcasting object dtype arrays" - with tm.assert_produces_warning(FutureWarning, match=msg): - df.fillna(value={"A": 1, "B": 2}, inplace=True) + df.fillna(value={"A": 1, "B": 2}, inplace=True) - expected = DataFrame([[1, 2], [1, 2]], columns=["A", "B"]) + expected = DataFrame([[1, 2], [1, 2]], columns=["A", "B"], dtype=object) tm.assert_frame_equal(df, expected) -@pytest.mark.parametrize("func", ["pad", "backfill"]) -def test_pad_backfill_deprecated(func): - # GH#33396 - df = DataFrame({"a": [1, 2, 3]}) - with tm.assert_produces_warning(FutureWarning): - getattr(df, func)() - - @pytest.mark.parametrize( "data, expected_data, method, kwargs", ( diff --git a/pandas/tests/frame/methods/test_interpolate.py b/pandas/tests/frame/methods/test_interpolate.py index 483194a46ce56..73ba3545eaadb 100644 --- a/pandas/tests/frame/methods/test_interpolate.py +++ b/pandas/tests/frame/methods/test_interpolate.py @@ -3,7 +3,6 @@ from pandas._config import using_pyarrow_string_dtype -from pandas.errors import ChainedAssignmentError import pandas.util._test_decorators as td from pandas import ( @@ -167,33 +166,6 @@ def test_interp_combo(self): expected = Series([1.0, 2.0, 3.0, 4.0], name="A") tm.assert_series_equal(result, expected) - msg = "The 'downcast' keyword in Series.interpolate is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df["A"].interpolate(downcast="infer") - expected = Series([1, 2, 3, 4], name="A") - tm.assert_series_equal(result, expected) - - def test_inerpolate_invalid_downcast(self): - # GH#53103 - df = DataFrame( - { - "A": [1.0, 2.0, np.nan, 4.0], - "B": [1, 4, 9, np.nan], - "C": [1, 2, 3, 5], - "D": list("abcd"), - } - ) - - msg = "downcast must be either None or 'infer'" - msg2 = "The 'downcast' keyword in DataFrame.interpolate is deprecated" - msg3 = "The 'downcast' keyword in Series.interpolate is deprecated" - with pytest.raises(ValueError, match=msg): - with tm.assert_produces_warning(FutureWarning, match=msg2): - df.interpolate(downcast="int64") - with pytest.raises(ValueError, match=msg): - with tm.assert_produces_warning(FutureWarning, match=msg3): - df["A"].interpolate(downcast="int64") - def test_interp_nan_idx(self): df = DataFrame({"A": [1, 2, np.nan, 4], "B": [np.nan, 2, 3, 4]}) df = df.set_index("A") @@ -254,11 +226,6 @@ def test_interp_alt_scipy(self): expected.loc[5, "A"] = 6 tm.assert_frame_equal(result, expected) - msg = "The 'downcast' keyword in DataFrame.interpolate is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.interpolate(method="barycentric", downcast="infer") - tm.assert_frame_equal(result, expected.astype(np.int64)) - result = df.interpolate(method="krogh") expectedk = df.copy() expectedk["A"] = expected["A"] @@ -377,16 +344,6 @@ def test_interp_inplace(self): assert return_value is None tm.assert_frame_equal(result, expected) - result = df.copy() - msg = "The 'downcast' keyword in Series.interpolate is deprecated" - - with tm.assert_produces_warning( - (FutureWarning, ChainedAssignmentError), match=msg - ): - return_value = result["a"].interpolate(inplace=True, downcast="infer") - assert return_value is None - tm.assert_frame_equal(result, expected) - def test_interp_inplace_row(self): # GH 10395 result = DataFrame( @@ -415,15 +372,11 @@ def test_interp_ignore_all_good(self): "D": np.array([1.0, 2.0, 3.0, 4.0], dtype="float64"), } ) - - msg = "The 'downcast' keyword in DataFrame.interpolate is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.interpolate(downcast=None) + result = df.interpolate() tm.assert_frame_equal(result, expected) # all good - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df[["B", "D"]].interpolate(downcast=None) + result = df[["B", "D"]].interpolate() tm.assert_frame_equal(result, df[["B", "D"]]) def test_interp_time_inplace_axis(self): diff --git a/pandas/tests/frame/methods/test_quantile.py b/pandas/tests/frame/methods/test_quantile.py index 48d55b2954360..32ae4c0ff2f50 100644 --- a/pandas/tests/frame/methods/test_quantile.py +++ b/pandas/tests/frame/methods/test_quantile.py @@ -691,9 +691,7 @@ def test_quantile_empty_no_rows_dt64(self, interp_method): exp = exp.astype(object) if interpolation == "nearest": # GH#18463 TODO: would we prefer NaTs here? - msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - exp = exp.fillna(np.nan, downcast=False) + exp = exp.fillna(np.nan) tm.assert_series_equal(res, exp) # both dt64tz diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py index 8bfa98042eb07..6ca6cbad02d51 100644 --- a/pandas/tests/frame/methods/test_replace.py +++ b/pandas/tests/frame/methods/test_replace.py @@ -289,14 +289,8 @@ def test_regex_replace_dict_nested_non_first_character( # GH 25259 dtype = any_string_dtype df = DataFrame({"first": ["abc", "bca", "cab"]}, dtype=dtype) - if using_infer_string and any_string_dtype == "object": - with tm.assert_produces_warning(FutureWarning, match="Downcasting"): - result = df.replace({"a": "."}, regex=True) - expected = DataFrame({"first": [".bc", "bc.", "c.b"]}) - - else: - result = df.replace({"a": "."}, regex=True) - expected = DataFrame({"first": [".bc", "bc.", "c.b"]}, dtype=dtype) + result = df.replace({"a": "."}, regex=True) + expected = DataFrame({"first": [".bc", "bc.", "c.b"]}, dtype=dtype) tm.assert_frame_equal(result, expected) @pytest.mark.xfail( @@ -304,10 +298,10 @@ def test_regex_replace_dict_nested_non_first_character( ) def test_regex_replace_dict_nested_gh4115(self): df = DataFrame({"Type": ["Q", "T", "Q", "Q", "T"], "tmp": 2}) - expected = DataFrame({"Type": [0, 1, 0, 0, 1], "tmp": 2}) - msg = "Downcasting behavior in `replace`" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.replace({"Type": {"Q": 0, "T": 1}}) + expected = DataFrame( + {"Type": Series([0, 1, 0, 0, 1], dtype=df.Type.dtype), "tmp": 2} + ) + result = df.replace({"Type": {"Q": 0, "T": 1}}) tm.assert_frame_equal(result, expected) @pytest.mark.xfail( @@ -318,24 +312,21 @@ def test_regex_replace_list_to_scalar(self, mix_abc): expec = DataFrame( { "a": mix_abc["a"], - "b": np.array([np.nan] * 4), + "b": np.array([np.nan] * 4, dtype=object), "c": [np.nan, np.nan, np.nan, "d"], } ) - msg = "Downcasting behavior in `replace`" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = df.replace([r"\s*\.\s*", "a|b"], np.nan, regex=True) + + res = df.replace([r"\s*\.\s*", "a|b"], np.nan, regex=True) res2 = df.copy() res3 = df.copy() - with tm.assert_produces_warning(FutureWarning, match=msg): - return_value = res2.replace( - [r"\s*\.\s*", "a|b"], np.nan, regex=True, inplace=True - ) + return_value = res2.replace( + [r"\s*\.\s*", "a|b"], np.nan, regex=True, inplace=True + ) assert return_value is None - with tm.assert_produces_warning(FutureWarning, match=msg): - return_value = res3.replace( - regex=[r"\s*\.\s*", "a|b"], value=np.nan, inplace=True - ) + return_value = res3.replace( + regex=[r"\s*\.\s*", "a|b"], value=np.nan, inplace=True + ) assert return_value is None tm.assert_frame_equal(res, expec) tm.assert_frame_equal(res2, expec) @@ -452,19 +443,7 @@ def test_regex_replace_string_types( # GH-41333, GH-35977 dtype = any_string_dtype obj = frame_or_series(data, dtype=dtype) - if using_infer_string and any_string_dtype == "object": - if len(to_replace) > 1 and isinstance(obj, DataFrame): - request.node.add_marker( - pytest.mark.xfail( - reason="object input array that gets downcasted raises on " - "second pass" - ) - ) - with tm.assert_produces_warning(FutureWarning, match="Downcasting"): - result = obj.replace(to_replace, regex=True) - dtype = "string[pyarrow_numpy]" - else: - result = obj.replace(to_replace, regex=True) + result = obj.replace(to_replace, regex=True) expected = frame_or_series(expected, dtype=dtype) tm.assert_equal(result, expected) @@ -573,10 +552,8 @@ def test_replace_convert(self): # gh 3907 df = DataFrame([["foo", "bar", "bah"], ["bar", "foo", "bah"]]) m = {"foo": 1, "bar": 2, "bah": 3} - msg = "Downcasting behavior in `replace` " - with tm.assert_produces_warning(FutureWarning, match=msg): - rep = df.replace(m) - expec = Series([np.int64] * 3) + rep = df.replace(m) + expec = df.dtypes res = rep.dtypes tm.assert_series_equal(expec, res) @@ -661,11 +638,7 @@ def test_replace_mixed2(self, using_infer_string): "B": Series([0, "foo"], dtype="object"), } ) - if using_infer_string: - with tm.assert_produces_warning(FutureWarning, match="Downcasting"): - result = df.replace([1, 2], ["foo", "bar"]) - else: - result = df.replace([1, 2], ["foo", "bar"]) + result = df.replace([1, 2], ["foo", "bar"]) tm.assert_frame_equal(result, expected) def test_replace_mixed3(self): @@ -841,13 +814,6 @@ def test_replace_for_new_dtypes(self, datetime_frame): "bar", DataFrame({"dt": [datetime(3017, 12, 20)], "str": ["bar"]}), ), - # GH 36782 - ( - DataFrame({"dt": [datetime(2920, 10, 1)]}), - datetime(2920, 10, 1), - datetime(2020, 10, 1), - DataFrame({"dt": [datetime(2020, 10, 1)]}), - ), ( DataFrame( { @@ -898,12 +864,7 @@ def test_replace_for_new_dtypes(self, datetime_frame): ], ) def test_replace_dtypes(self, frame, to_replace, value, expected): - warn = None - if isinstance(to_replace, datetime) and to_replace.year == 2920: - warn = FutureWarning - msg = "Downcasting behavior in `replace` " - with tm.assert_produces_warning(warn, match=msg): - result = frame.replace(to_replace, value) + result = frame.replace(to_replace, value) tm.assert_frame_equal(result, expected) def test_replace_input_formats_listlike(self): @@ -997,10 +958,8 @@ def test_replace_dict_no_regex(self): "Strongly Agree": 5, "Strongly Disagree": 1, } - expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1}) - msg = "Downcasting behavior in `replace` " - with tm.assert_produces_warning(FutureWarning, match=msg): - result = answer.replace(weights) + expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1}, dtype=answer.dtype) + result = answer.replace(weights) tm.assert_series_equal(result, expected) @pytest.mark.xfail( @@ -1025,10 +984,8 @@ def test_replace_series_no_regex(self): "Strongly Disagree": 1, } ) - expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1}) - msg = "Downcasting behavior in `replace` " - with tm.assert_produces_warning(FutureWarning, match=msg): - result = answer.replace(weights) + expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1}, dtype=object) + result = answer.replace(weights) tm.assert_series_equal(result, expected) def test_replace_dict_tuple_list_ordering_remains_the_same(self): @@ -1126,80 +1083,6 @@ def test_replace_swapping_bug(self, using_infer_string): expect = DataFrame({"a": ["Y", "N", "Y"]}) tm.assert_frame_equal(res, expect) - @pytest.mark.xfail( - using_pyarrow_string_dtype(), reason="can't set float into string" - ) - def test_replace_period(self): - d = { - "fname": { - "out_augmented_AUG_2011.json": pd.Period(year=2011, month=8, freq="M"), - "out_augmented_JAN_2011.json": pd.Period(year=2011, month=1, freq="M"), - "out_augmented_MAY_2012.json": pd.Period(year=2012, month=5, freq="M"), - "out_augmented_SUBSIDY_WEEK.json": pd.Period( - year=2011, month=4, freq="M" - ), - "out_augmented_AUG_2012.json": pd.Period(year=2012, month=8, freq="M"), - "out_augmented_MAY_2011.json": pd.Period(year=2011, month=5, freq="M"), - "out_augmented_SEP_2013.json": pd.Period(year=2013, month=9, freq="M"), - } - } - - df = DataFrame( - [ - "out_augmented_AUG_2012.json", - "out_augmented_SEP_2013.json", - "out_augmented_SUBSIDY_WEEK.json", - "out_augmented_MAY_2012.json", - "out_augmented_MAY_2011.json", - "out_augmented_AUG_2011.json", - "out_augmented_JAN_2011.json", - ], - columns=["fname"], - ) - assert set(df.fname.values) == set(d["fname"].keys()) - - expected = DataFrame({"fname": [d["fname"][k] for k in df.fname.values]}) - assert expected.dtypes.iloc[0] == "Period[M]" - msg = "Downcasting behavior in `replace` " - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.replace(d) - tm.assert_frame_equal(result, expected) - - @pytest.mark.xfail( - using_pyarrow_string_dtype(), reason="can't set float into string" - ) - def test_replace_datetime(self): - d = { - "fname": { - "out_augmented_AUG_2011.json": Timestamp("2011-08"), - "out_augmented_JAN_2011.json": Timestamp("2011-01"), - "out_augmented_MAY_2012.json": Timestamp("2012-05"), - "out_augmented_SUBSIDY_WEEK.json": Timestamp("2011-04"), - "out_augmented_AUG_2012.json": Timestamp("2012-08"), - "out_augmented_MAY_2011.json": Timestamp("2011-05"), - "out_augmented_SEP_2013.json": Timestamp("2013-09"), - } - } - - df = DataFrame( - [ - "out_augmented_AUG_2012.json", - "out_augmented_SEP_2013.json", - "out_augmented_SUBSIDY_WEEK.json", - "out_augmented_MAY_2012.json", - "out_augmented_MAY_2011.json", - "out_augmented_AUG_2011.json", - "out_augmented_JAN_2011.json", - ], - columns=["fname"], - ) - assert set(df.fname.values) == set(d["fname"].keys()) - expected = DataFrame({"fname": [d["fname"][k] for k in df.fname.values]}) - msg = "Downcasting behavior in `replace` " - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.replace(d) - tm.assert_frame_equal(result, expected) - def test_replace_datetimetz(self): # GH 11326 # behaving poorly when presented with a datetime64[ns, tz] @@ -1409,10 +1292,8 @@ def test_replace_commutative(self, df, to_replace, exp): def test_replace_replacer_dtype(self, replacer): # GH26632 df = DataFrame(["a"]) - msg = "Downcasting behavior in `replace` " - with tm.assert_produces_warning(FutureWarning, match=msg): - result = df.replace({"a": replacer, "b": replacer}) - expected = DataFrame([replacer]) + result = df.replace({"a": replacer, "b": replacer}) + expected = DataFrame([replacer], dtype=object) tm.assert_frame_equal(result, expected) def test_replace_after_convert_dtypes(self): @@ -1566,12 +1447,10 @@ def test_replace_with_compiled_regex(self): expected = DataFrame(["z", "b", "c"]) tm.assert_frame_equal(result, expected) - def test_replace_intervals(self, using_infer_string): + def test_replace_intervals(self): # https://github.com/pandas-dev/pandas/issues/35931 df = DataFrame({"a": [pd.Interval(0, 1), pd.Interval(0, 1)]}) - warning = FutureWarning if using_infer_string else None - with tm.assert_produces_warning(warning, match="Downcasting"): - result = df.replace({"a": {pd.Interval(0, 1): "x"}}) + result = df.replace({"a": {pd.Interval(0, 1): "x"}}) expected = DataFrame({"a": ["x", "x"]}) tm.assert_frame_equal(result, expected) @@ -1679,16 +1558,13 @@ def test_regex_replace_scalar( def test_replace_regex_dtype_frame(self, regex): # GH-48644 df1 = DataFrame({"A": ["0"], "B": ["0"]}) - expected_df1 = DataFrame({"A": [1], "B": [1]}) - msg = "Downcasting behavior in `replace`" - with tm.assert_produces_warning(FutureWarning, match=msg): - result_df1 = df1.replace(to_replace="0", value=1, regex=regex) + expected_df1 = DataFrame({"A": [1], "B": [1]}, dtype=df1.dtypes.iloc[0]) + result_df1 = df1.replace(to_replace="0", value=1, regex=regex) tm.assert_frame_equal(result_df1, expected_df1) df2 = DataFrame({"A": ["0"], "B": ["1"]}) - expected_df2 = DataFrame({"A": [1], "B": ["1"]}) - with tm.assert_produces_warning(FutureWarning, match=msg): - result_df2 = df2.replace(to_replace="0", value=1, regex=regex) + expected_df2 = DataFrame({"A": [1], "B": ["1"]}, dtype=df2.dtypes.iloc[0]) + result_df2 = df2.replace(to_replace="0", value=1, regex=regex) tm.assert_frame_equal(result_df2, expected_df2) def test_replace_with_value_also_being_replaced(self): diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py index fc40fd5329118..3cf6d31390c2f 100644 --- a/pandas/tests/frame/test_arithmetic.py +++ b/pandas/tests/frame/test_arithmetic.py @@ -1239,9 +1239,8 @@ def test_operators_none_as_na(self, op): # since filling converts dtypes from object, changed expected to be # object - msg = "Downcasting object dtype arrays" - with tm.assert_produces_warning(FutureWarning, match=msg): - filled = df.fillna(np.nan) + + filled = df.fillna(np.nan) result = op(df, 3) expected = op(filled, 3).astype(object) expected[pd.isna(expected)] = np.nan @@ -1252,14 +1251,10 @@ def test_operators_none_as_na(self, op): expected[pd.isna(expected)] = np.nan tm.assert_frame_equal(result, expected) - msg = "Downcasting object dtype arrays" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = op(df, df.fillna(7)) + result = op(df, df.fillna(7)) tm.assert_frame_equal(result, expected) - msg = "Downcasting object dtype arrays" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = op(df.fillna(7), df) + result = op(df.fillna(7), df) tm.assert_frame_equal(result, expected) @pytest.mark.parametrize("op,res", [("__eq__", False), ("__ne__", True)]) diff --git a/pandas/tests/frame/test_logical_ops.py b/pandas/tests/frame/test_logical_ops.py index 16ca3a202f1e0..ad54cfaf9d927 100644 --- a/pandas/tests/frame/test_logical_ops.py +++ b/pandas/tests/frame/test_logical_ops.py @@ -157,7 +157,6 @@ def _check_unary_op(op): _check_unary_op(operator.inv) # TODO: belongs elsewhere - @pytest.mark.filterwarnings("ignore:Downcasting object dtype arrays:FutureWarning") def test_logical_with_nas(self): d = DataFrame({"a": [np.nan, False], "b": [True, True]}) @@ -171,10 +170,7 @@ def test_logical_with_nas(self): result = d["a"].fillna(False) | d["b"] expected = Series([True, True]) tm.assert_series_equal(result, expected) - - msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = d["a"].fillna(False, downcast=False) | d["b"] + result = d["a"].fillna(False) | d["b"] expected = Series([True, True]) tm.assert_series_equal(result, expected) diff --git a/pandas/tests/groupby/test_api.py b/pandas/tests/groupby/test_api.py index 24a02bb6b2b91..4b0f7890e1aa7 100644 --- a/pandas/tests/groupby/test_api.py +++ b/pandas/tests/groupby/test_api.py @@ -148,7 +148,7 @@ def test_all_methods_categorized(multiindex_dataframe_random_data): def test_frame_consistency(groupby_func): # GH#48028 if groupby_func in ("first", "last"): - msg = "first and last are entirely different between frame and groupby" + msg = "first and last don't exist for DataFrame anymore" pytest.skip(reason=msg) if groupby_func in ("cumcount", "ngroup"): @@ -181,8 +181,8 @@ def test_frame_consistency(groupby_func): exclude_result = {"engine", "engine_kwargs"} elif groupby_func in ("median", "prod", "sem"): exclude_expected = {"axis", "kwargs", "skipna"} - elif groupby_func in ("backfill", "bfill", "ffill", "pad"): - exclude_expected = {"downcast", "inplace", "axis", "limit_area"} + 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"} @@ -209,7 +209,8 @@ def test_frame_consistency(groupby_func): def test_series_consistency(request, groupby_func): # GH#48028 if groupby_func in ("first", "last"): - pytest.skip("first and last are entirely different between Series and groupby") + msg = "first and last don't exist for Series anymore" + pytest.skip(msg) if groupby_func in ("cumcount", "corrwith", "ngroup"): assert not hasattr(Series, groupby_func) @@ -237,8 +238,8 @@ def test_series_consistency(request, groupby_func): exclude_result = {"engine", "engine_kwargs"} elif groupby_func in ("median", "prod", "sem"): exclude_expected = {"axis", "kwargs", "skipna"} - elif groupby_func in ("backfill", "bfill", "ffill", "pad"): - exclude_expected = {"downcast", "inplace", "axis", "limit_area"} + 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"} diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py index 0bfde350c259b..1bb3539830900 100644 --- a/pandas/tests/groupby/transform/test_transform.py +++ b/pandas/tests/groupby/transform/test_transform.py @@ -734,12 +734,8 @@ def test_cython_transform_frame(request, op, args, targop, df_fix, gb_target): expected = expected.sort_index(axis=1) if op == "shift": - depr_msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=depr_msg): - expected["string_missing"] = expected["string_missing"].fillna( - np.nan, downcast=False - ) - expected["string"] = expected["string"].fillna(np.nan, downcast=False) + expected["string_missing"] = expected["string_missing"].fillna(np.nan) + expected["string"] = expected["string"].fillna(np.nan) result = gb[expected.columns].transform(op, *args).sort_index(axis=1) tm.assert_frame_equal(result, expected) @@ -807,9 +803,7 @@ def test_cython_transform_frame_column( expected = gb[c].apply(targop) expected.name = c if c in ["string_missing", "string"]: - depr_msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=depr_msg): - expected = expected.fillna(np.nan, downcast=False) + expected = expected.fillna(np.nan) res = gb[c].transform(op, *args) tm.assert_series_equal(expected, res) diff --git a/pandas/tests/indexing/test_coercion.py b/pandas/tests/indexing/test_coercion.py index 0e32399b131c3..d51a986a22f1e 100644 --- a/pandas/tests/indexing/test_coercion.py +++ b/pandas/tests/indexing/test_coercion.py @@ -860,18 +860,8 @@ def test_replace_series(self, how, to_key, from_key, replacer): exp = pd.Series(self.rep[to_key], index=index, name="yyy") assert exp.dtype == to_key - msg = "Downcasting behavior in `replace`" - warn = FutureWarning - if ( - exp.dtype == obj.dtype - or exp.dtype == object - or (exp.dtype.kind in "iufc" and obj.dtype.kind in "iufc") - ): - warn = None - with tm.assert_produces_warning(warn, match=msg): - result = obj.replace(replacer) - - tm.assert_series_equal(result, exp) + result = obj.replace(replacer) + tm.assert_series_equal(result, exp, check_dtype=False) @pytest.mark.parametrize( "to_key", @@ -894,12 +884,8 @@ def test_replace_series_datetime_tz( else: assert exp.dtype == to_key - msg = "Downcasting behavior in `replace`" - warn = FutureWarning if exp.dtype != object else None - with tm.assert_produces_warning(warn, match=msg): - result = obj.replace(replacer) - - tm.assert_series_equal(result, exp) + result = obj.replace(replacer) + tm.assert_series_equal(result, exp, check_dtype=False) @pytest.mark.parametrize( "to_key", @@ -917,23 +903,16 @@ def test_replace_series_datetime_datetime(self, how, to_key, from_key, replacer) assert obj.dtype == from_key exp = pd.Series(self.rep[to_key], index=index, name="yyy") - warn = FutureWarning if isinstance(obj.dtype, pd.DatetimeTZDtype) and isinstance( exp.dtype, pd.DatetimeTZDtype ): # with mismatched tzs, we retain the original dtype as of 2.0 exp = exp.astype(obj.dtype) - warn = None else: assert exp.dtype == to_key - if to_key == from_key: - warn = None - - msg = "Downcasting behavior in `replace`" - with tm.assert_produces_warning(warn, match=msg): - result = obj.replace(replacer) - tm.assert_series_equal(result, exp) + result = obj.replace(replacer) + tm.assert_series_equal(result, exp, check_dtype=False) @pytest.mark.xfail(reason="Test not implemented") def test_replace_series_period(self): diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py index 8eadbb9aac3c3..b9d97e7b75436 100644 --- a/pandas/tests/io/json/test_pandas.py +++ b/pandas/tests/io/json/test_pandas.py @@ -381,7 +381,7 @@ def test_frame_read_json_dtype_missing_value(self, dtype): # GH28501 Parse missing values using read_json with dtype=False # to NaN instead of None result = read_json(StringIO("[null]"), dtype=dtype) - expected = DataFrame([np.nan]) + expected = DataFrame([np.nan], dtype=object if not dtype else None) tm.assert_frame_equal(result, expected) @@ -1030,9 +1030,7 @@ def test_round_trip_exception(self, datapath): result = read_json(StringIO(s)) res = result.reindex(index=df.index, columns=df.columns) - msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = res.fillna(np.nan, downcast=False) + res = res.fillna(np.nan) tm.assert_frame_equal(res, df) @pytest.mark.network diff --git a/pandas/tests/series/indexing/test_where.py b/pandas/tests/series/indexing/test_where.py index dac01e49098d9..4979bcb42d7ab 100644 --- a/pandas/tests/series/indexing/test_where.py +++ b/pandas/tests/series/indexing/test_where.py @@ -386,34 +386,6 @@ def test_where_numeric_with_string(): assert w.dtype == "object" -@pytest.mark.parametrize("dtype", ["timedelta64[ns]", "datetime64[ns]"]) -def test_where_datetimelike_coerce(dtype): - ser = Series([1, 2], dtype=dtype) - expected = Series([10, 10]) - mask = np.array([False, False]) - - msg = "Downcasting behavior in Series and DataFrame methods 'where'" - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.where(mask, [10, 10]) - tm.assert_series_equal(rs, expected) - - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.where(mask, 10) - tm.assert_series_equal(rs, expected) - - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.where(mask, 10.0) - tm.assert_series_equal(rs, expected) - - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.where(mask, [10.0, 10.0]) - tm.assert_series_equal(rs, expected) - - rs = ser.where(mask, [10.0, np.nan]) - expected = Series([10, np.nan], dtype="object") - tm.assert_series_equal(rs, expected) - - def test_where_datetimetz(): # GH 15701 timestamps = ["2016-12-31 12:00:04+00:00", "2016-12-31 12:00:04.010000+00:00"] diff --git a/pandas/tests/series/methods/test_clip.py b/pandas/tests/series/methods/test_clip.py index 5bbf35f6e39bb..75b4050c18afe 100644 --- a/pandas/tests/series/methods/test_clip.py +++ b/pandas/tests/series/methods/test_clip.py @@ -69,15 +69,11 @@ def test_clip_with_na_args(self): tm.assert_series_equal(s.clip(upper=np.nan, lower=np.nan), Series([1, 2, 3])) # GH#19992 - msg = "Downcasting behavior in Series and DataFrame methods 'where'" - # TODO: avoid this warning here? seems like we should never be upcasting - # in the first place? - with tm.assert_produces_warning(FutureWarning, match=msg): - res = s.clip(lower=[0, 4, np.nan]) - tm.assert_series_equal(res, Series([1, 4, 3])) - with tm.assert_produces_warning(FutureWarning, match=msg): - res = s.clip(upper=[1, np.nan, 1]) - tm.assert_series_equal(res, Series([1, 2, 1])) + + res = s.clip(lower=[0, 4, np.nan]) + tm.assert_series_equal(res, Series([1, 4, 3.0])) + res = s.clip(upper=[1, np.nan, 1]) + tm.assert_series_equal(res, Series([1, 2, 1.0])) # GH#40420 s = Series([1, 2, 3]) diff --git a/pandas/tests/series/methods/test_fillna.py b/pandas/tests/series/methods/test_fillna.py index a70d9f39ff488..a458b31480375 100644 --- a/pandas/tests/series/methods/test_fillna.py +++ b/pandas/tests/series/methods/test_fillna.py @@ -175,71 +175,6 @@ def test_fillna_consistency(self): ser2[1] = "foo" tm.assert_series_equal(ser2, expected) - def test_fillna_downcast(self): - # GH#15277 - # infer int64 from float64 - ser = Series([1.0, np.nan]) - msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = ser.fillna(0, downcast="infer") - expected = Series([1, 0]) - tm.assert_series_equal(result, expected) - - # infer int64 from float64 when fillna value is a dict - ser = Series([1.0, np.nan]) - with tm.assert_produces_warning(FutureWarning, match=msg): - result = ser.fillna({1: 0}, downcast="infer") - expected = Series([1, 0]) - tm.assert_series_equal(result, expected) - - def test_fillna_downcast_infer_objects_to_numeric(self): - # GH#44241 if we have object-dtype, 'downcast="infer"' should - # _actually_ infer - - arr = np.arange(5).astype(object) - arr[3] = np.nan - - ser = Series(arr) - - msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = ser.fillna(3, downcast="infer") - expected = Series(np.arange(5), dtype=np.int64) - tm.assert_series_equal(res, expected) - - msg = "The 'downcast' keyword in ffill is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = ser.ffill(downcast="infer") - expected = Series([0, 1, 2, 2, 4], dtype=np.int64) - tm.assert_series_equal(res, expected) - - msg = "The 'downcast' keyword in bfill is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = ser.bfill(downcast="infer") - expected = Series([0, 1, 2, 4, 4], dtype=np.int64) - tm.assert_series_equal(res, expected) - - # with a non-round float present, we will downcast to float64 - ser[2] = 2.5 - - expected = Series([0, 1, 2.5, 3, 4], dtype=np.float64) - msg = "The 'downcast' keyword in fillna is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = ser.fillna(3, downcast="infer") - tm.assert_series_equal(res, expected) - - msg = "The 'downcast' keyword in ffill is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = ser.ffill(downcast="infer") - expected = Series([0, 1, 2.5, 2.5, 4], dtype=np.float64) - tm.assert_series_equal(res, expected) - - msg = "The 'downcast' keyword in bfill is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - res = ser.bfill(downcast="infer") - expected = Series([0, 1, 2.5, 4, 4], dtype=np.float64) - tm.assert_series_equal(res, expected) - def test_timedelta_fillna(self, frame_or_series, unit): # GH#3371 ser = Series( @@ -1072,13 +1007,6 @@ def test_fillna_parr(self): tm.assert_series_equal(filled, expected) - @pytest.mark.parametrize("func", ["pad", "backfill"]) - def test_pad_backfill_deprecated(self, func): - # GH#33396 - ser = Series([1, 2, 3]) - with tm.assert_produces_warning(FutureWarning): - getattr(ser, func)() - @pytest.mark.parametrize( "data, expected_data, method, kwargs", diff --git a/pandas/tests/series/methods/test_interpolate.py b/pandas/tests/series/methods/test_interpolate.py index 0f43c1bc72c45..db101d87a282f 100644 --- a/pandas/tests/series/methods/test_interpolate.py +++ b/pandas/tests/series/methods/test_interpolate.py @@ -288,26 +288,21 @@ def test_interp_scipy_basic(self): expected = Series([1.0, 3.0, 7.5, 12.0, 18.5, 25.0]) result = s.interpolate(method="slinear") tm.assert_series_equal(result, expected) - - msg = "The 'downcast' keyword in Series.interpolate is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = s.interpolate(method="slinear", downcast="infer") + result = s.interpolate(method="slinear") tm.assert_series_equal(result, expected) # nearest - expected = Series([1, 3, 3, 12, 12, 25]) + expected = Series([1, 3, 3, 12, 12, 25.0]) result = s.interpolate(method="nearest") tm.assert_series_equal(result, expected.astype("float")) - with tm.assert_produces_warning(FutureWarning, match=msg): - result = s.interpolate(method="nearest", downcast="infer") + result = s.interpolate(method="nearest") tm.assert_series_equal(result, expected) # zero - expected = Series([1, 3, 3, 12, 12, 25]) + expected = Series([1, 3, 3, 12, 12, 25.0]) result = s.interpolate(method="zero") tm.assert_series_equal(result, expected.astype("float")) - with tm.assert_produces_warning(FutureWarning, match=msg): - result = s.interpolate(method="zero", downcast="infer") + result = s.interpolate(method="zero") tm.assert_series_equal(result, expected) # quadratic # GH #15662. @@ -315,8 +310,7 @@ def test_interp_scipy_basic(self): result = s.interpolate(method="quadratic") tm.assert_series_equal(result, expected) - with tm.assert_produces_warning(FutureWarning, match=msg): - result = s.interpolate(method="quadratic", downcast="infer") + result = s.interpolate(method="quadratic") tm.assert_series_equal(result, expected) # cubic expected = Series([1.0, 3.0, 6.8, 12.0, 18.2, 25.0]) diff --git a/pandas/tests/series/methods/test_reindex.py b/pandas/tests/series/methods/test_reindex.py index 1959e71f60775..d049f446edb0c 100644 --- a/pandas/tests/series/methods/test_reindex.py +++ b/pandas/tests/series/methods/test_reindex.py @@ -135,15 +135,13 @@ def test_reindex_pad2(): # GH4604 s = Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"]) new_index = ["a", "g", "c", "f"] - expected = Series([1, 1, 3, 3], index=new_index) + expected = Series([1, 1, 3, 3.0], index=new_index) # this changes dtype because the ffill happens after result = s.reindex(new_index).ffill() - tm.assert_series_equal(result, expected.astype("float64")) + tm.assert_series_equal(result, expected) - msg = "The 'downcast' keyword in ffill is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = s.reindex(new_index).ffill(downcast="infer") + result = s.reindex(new_index).ffill() tm.assert_series_equal(result, expected) expected = Series([1, 5, 3, 5], index=new_index) @@ -155,20 +153,16 @@ def test_reindex_inference(): # inference of new dtype s = Series([True, False, False, True], index=list("abcd")) new_index = "agc" - msg = "Downcasting object dtype arrays on" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = s.reindex(list(new_index)).ffill() - expected = Series([True, True, False], index=list(new_index)) + result = s.reindex(list(new_index)).ffill() + expected = Series([True, True, False], index=list(new_index), dtype=object) tm.assert_series_equal(result, expected) def test_reindex_downcasting(): # GH4618 shifted series downcasting s = Series(False, index=range(5)) - msg = "Downcasting object dtype arrays on" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = s.shift(1).bfill() - expected = Series(False, index=range(5)) + result = s.shift(1).bfill() + expected = Series(False, index=range(5), dtype=object) tm.assert_series_equal(result, expected) diff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py index 5266bbf7741d7..d4ec09332ad97 100644 --- a/pandas/tests/series/methods/test_replace.py +++ b/pandas/tests/series/methods/test_replace.py @@ -78,9 +78,8 @@ def test_replace(self): ser[20:30] = "bar" # replace list with a single value - msg = "Downcasting behavior in `replace`" - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.replace([np.nan, "foo", "bar"], -1) + + rs = ser.replace([np.nan, "foo", "bar"], -1) assert (rs[:5] == -1).all() assert (rs[6:10] == -1).all() @@ -88,8 +87,7 @@ def test_replace(self): assert (pd.isna(ser[:5])).all() # replace with different values - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3}) + rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3}) assert (rs[:5] == -1).all() assert (rs[6:10] == -2).all() @@ -97,13 +95,11 @@ def test_replace(self): assert (pd.isna(ser[:5])).all() # replace with different values with 2 lists - with tm.assert_produces_warning(FutureWarning, match=msg): - rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3]) + rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3]) tm.assert_series_equal(rs, rs2) # replace inplace - with tm.assert_produces_warning(FutureWarning, match=msg): - return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True) + return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True) assert return_value is None assert (ser[:5] == -1).all() @@ -301,9 +297,7 @@ def test_replace2(self): ser[20:30] = "bar" # replace list with a single value - msg = "Downcasting behavior in `replace`" - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.replace([np.nan, "foo", "bar"], -1) + rs = ser.replace([np.nan, "foo", "bar"], -1) assert (rs[:5] == -1).all() assert (rs[6:10] == -1).all() @@ -311,8 +305,7 @@ def test_replace2(self): assert (pd.isna(ser[:5])).all() # replace with different values - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3}) + rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3}) assert (rs[:5] == -1).all() assert (rs[6:10] == -2).all() @@ -320,13 +313,11 @@ def test_replace2(self): assert (pd.isna(ser[:5])).all() # replace with different values with 2 lists - with tm.assert_produces_warning(FutureWarning, match=msg): - rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3]) + rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3]) tm.assert_series_equal(rs, rs2) # replace inplace - with tm.assert_produces_warning(FutureWarning, match=msg): - return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True) + return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True) assert return_value is None assert (ser[:5] == -1).all() assert (ser[6:10] == -1).all() @@ -385,10 +376,8 @@ def test_replace_unicode_with_number(self): def test_replace_mixed_types_with_string(self): # Testing mixed s = pd.Series([1, 2, 3, "4", 4, 5]) - msg = "Downcasting behavior in `replace`" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = s.replace([2, "4"], np.nan) - expected = pd.Series([1, np.nan, 3, np.nan, 4, 5]) + result = s.replace([2, "4"], np.nan) + expected = pd.Series([1, np.nan, 3, np.nan, 4, 5], dtype=object) tm.assert_series_equal(expected, result) @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="can't fill 0 in string") @@ -402,7 +391,6 @@ def test_replace_mixed_types_with_string(self): def test_replace_categorical(self, categorical, numeric): # GH 24971, GH#23305 ser = pd.Series(pd.Categorical(categorical, categories=["A", "B"])) - msg = "Downcasting behavior in `replace`" msg = "with CategoricalDtype is deprecated" with tm.assert_produces_warning(FutureWarning, match=msg): result = ser.replace({"A": 1, "B": 2}) @@ -411,7 +399,7 @@ def test_replace_categorical(self, categorical, numeric): # i.e. categories should be [1, 2] even if there are no "B"s present # GH#44940 expected = expected.cat.add_categories(2) - tm.assert_series_equal(expected, result) + tm.assert_series_equal(expected, result, check_categorical=False) @pytest.mark.parametrize( "data, data_exp", [(["a", "b", "c"], ["b", "b", "c"]), (["a"], ["b"])] @@ -736,10 +724,8 @@ def test_replace_nullable_numeric(self): def test_replace_regex_dtype_series(self, regex): # GH-48644 series = pd.Series(["0"]) - expected = pd.Series([1]) - msg = "Downcasting behavior in `replace`" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = series.replace(to_replace="0", value=1, regex=regex) + expected = pd.Series([1], dtype=object) + result = series.replace(to_replace="0", value=1, regex=regex) tm.assert_series_equal(result, expected) def test_replace_different_int_types(self, any_int_numpy_dtype): diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py index 691308633a796..910b4aae859fe 100644 --- a/pandas/tests/series/test_api.py +++ b/pandas/tests/series/test_api.py @@ -220,7 +220,6 @@ def test_series_datetimelike_attribute_access_invalid(self): ("count", False), ("median", True), ("std", True), - ("backfill", False), ("rank", True), ("pct_change", False), ("cummax", False), @@ -231,7 +230,6 @@ def test_series_datetimelike_attribute_access_invalid(self): ("cumprod", False), ("fillna", False), ("ffill", False), - ("pad", False), ("bfill", False), ("sample", False), ("tail", False), diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py index 03c113cf21854..00f48bf3b1d78 100644 --- a/pandas/tests/series/test_arithmetic.py +++ b/pandas/tests/series/test_arithmetic.py @@ -659,12 +659,10 @@ def test_comparison_operators_with_nas(self, comparison_op): result = comparison_op(ser, val) expected = comparison_op(ser.dropna(), val).reindex(ser.index) - msg = "Downcasting object dtype arrays" - with tm.assert_produces_warning(FutureWarning, match=msg): - if comparison_op is operator.ne: - expected = expected.fillna(True).astype(bool) - else: - expected = expected.fillna(False).astype(bool) + if comparison_op is operator.ne: + expected = expected.fillna(True).astype(bool) + else: + expected = expected.fillna(False).astype(bool) tm.assert_series_equal(result, expected)