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 |
|---|---|---|---|---|---|---|---|
ERR/DEPR: Fix quantile error message / remove percentile_width | diff --git a/doc/source/whatsnew/v0.17.0.txt b/doc/source/whatsnew/v0.17.0.txt
index 6b4bde588469e..f6ce0a0c4d975 100644
--- a/doc/source/whatsnew/v0.17.0.txt
+++ b/doc/source/whatsnew/v0.17.0.txt
@@ -654,6 +654,7 @@ Removal of prior version deprecations/changes
- Remove use of some deprecated numpy comparison operations, mainly in tests. (:issue:`10569`)
- Removal of ``na_last`` parameters from ``Series.order()`` and ``Series.sort()``, in favor of ``na_position``, xref (:issue:`5231`)
+- Remove of ``percentile_width`` from ``.describe()``, in favor of ``percentiles``. (:issue:`7088`)
.. _whatsnew_0170.performance:
@@ -678,6 +679,7 @@ Bug Fixes
- Bug in ``DataFrame.apply`` when function returns categorical series. (:issue:`9573`)
- Bug in ``to_datetime`` with invalid dates and formats supplied (:issue:`10154`)
- Bug in ``Index.drop_duplicates`` dropping name(s) (:issue:`10115`)
+- Bug in ``Series.quantile`` dropping name (:issue:`10881`)
- Bug in ``pd.Series`` when setting a value on an empty ``Series`` whose index has a frequency. (:issue:`10193`)
- Bug in ``pd.Series.interpolate`` with invalid ``order`` keyword values. (:issue:`10633`)
- Bug in ``DataFrame.plot`` raises ``ValueError`` when color name is specified by multiple characters (:issue:`10387`)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index da350a726c255..1f222f9f99cbe 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -4684,6 +4684,7 @@ def quantile(self, q=0.5, axis=0, numeric_only=True):
0.1 1.3 3.7
0.5 2.5 55.0
"""
+ self._check_percentile(q)
per = np.asarray(q) * 100
if not com.is_list_like(per):
@@ -4718,7 +4719,9 @@ def f(arr, per):
quantiles = [[f(vals, x) for x in per]
for (_, vals) in data.iteritems()]
- result = DataFrame(quantiles, index=data._info_axis, columns=q).T
+
+ result = self._constructor(quantiles, index=data._info_axis,
+ columns=q).T
if len(is_dt_col) > 0:
result[is_dt_col] = result[is_dt_col].applymap(lib.Timestamp)
if squeeze:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index ae4c09fba5469..bc49e9dd79e6a 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -2989,7 +2989,7 @@ def interpolate(self, method='linear', axis=0, limit=None, inplace=False,
* 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',
'barycentric', 'polynomial' is passed to
``scipy.interpolate.interp1d``. Both 'polynomial' and 'spline'
- require that you also specify an `order` (int),
+ require that you also specify an `order` (int),
e.g. df.interpolate(method='polynomial', order=4).
These use the actual numerical values of the index.
* 'krogh', 'piecewise_polynomial', 'spline', and 'pchip' are all
@@ -4096,11 +4096,6 @@ def abs(self):
Parameters
----------
- percentile_width : float, deprecated
- The ``percentile_width`` argument will be removed in a future
- version. Use ``percentiles`` instead.
- width of the desired uncertainty interval, default is 50,
- which corresponds to lower=25, upper=75
percentiles : array-like, optional
The percentiles to include in the output. Should all
be in the interval [0, 1]. By default `percentiles` is
@@ -4149,36 +4144,17 @@ def abs(self):
"""
@Appender(_shared_docs['describe'] % _shared_doc_kwargs)
- def describe(self, percentile_width=None, percentiles=None, include=None, exclude=None ):
+ def describe(self, percentiles=None, include=None, exclude=None ):
if self.ndim >= 3:
msg = "describe is not implemented on on Panel or PanelND objects."
raise NotImplementedError(msg)
- if percentile_width is not None and percentiles is not None:
- msg = "Cannot specify both 'percentile_width' and 'percentiles.'"
- raise ValueError(msg)
if percentiles is not None:
# get them all to be in [0, 1]
+ self._check_percentile(percentiles)
percentiles = np.asarray(percentiles)
- if (percentiles > 1).any():
- percentiles = percentiles / 100.0
- msg = ("percentiles should all be in the interval [0, 1]. "
- "Try {0} instead.")
- raise ValueError(msg.format(list(percentiles)))
else:
- # only warn if they change the default
- if percentile_width is not None:
- do_warn = True
- else:
- do_warn = False
- percentile_width = percentile_width or 50
- lb = .5 * (1. - percentile_width / 100.)
- ub = 1. - lb
- percentiles = np.array([lb, 0.5, ub])
- if do_warn:
- msg = ("The `percentile_width` keyword is deprecated. "
- "Use percentiles={0} instead".format(list(percentiles)))
- warnings.warn(msg, FutureWarning)
+ percentiles = np.array([0.25, 0.5, 0.75])
# median should always be included
if (percentiles != 0.5).all(): # median isn't included
@@ -4256,6 +4232,20 @@ def describe_1d(data, percentiles):
d = pd.concat(ldesc, join_axes=pd.Index([names]), axis=1)
return d
+ def _check_percentile(self, q):
+ """ Validate percentiles. Used by describe and quantile """
+
+ msg = ("percentiles should all be in the interval [0, 1]. "
+ "Try {0} instead.")
+ q = np.asarray(q)
+ if q.ndim == 0:
+ if not 0 <= q <= 1:
+ raise ValueError(msg.format(q / 100.0))
+ else:
+ if not all(0 <= qs <= 1 for qs in q):
+ raise ValueError(msg.format(q / 100.0))
+ return q
+
_shared_docs['pct_change'] = """
Percent change over given number of periods.
diff --git a/pandas/core/series.py b/pandas/core/series.py
index c788c15cdc398..8768d0e139e7b 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1266,11 +1266,12 @@ def quantile(self, q=0.5):
dtype: float64
"""
valid = self.dropna()
+ self._check_percentile(q)
def multi(values, qs):
if com.is_list_like(qs):
- return Series([_quantile(values, x*100)
- for x in qs], index=qs)
+ values = [_quantile(values, x*100) for x in qs]
+ return self._constructor(values, index=qs, name=self.name)
else:
return _quantile(values, qs*100)
diff --git a/pandas/tests/test_frame.py b/pandas/tests/test_frame.py
index c790c92280208..022594e296c2a 100644
--- a/pandas/tests/test_frame.py
+++ b/pandas/tests/test_frame.py
@@ -12837,6 +12837,12 @@ def test_quantile_datetime(self):
index=[0.5], columns=[0, 1])
assert_frame_equal(result, expected)
+ def test_quantile_invalid(self):
+ msg = 'percentiles should all be in the interval \\[0, 1\\]'
+ for invalid in [-1, 2, [0.5, -1], [0.5, 2]]:
+ with tm.assertRaisesRegexp(ValueError, msg):
+ self.tsframe.quantile(invalid)
+
def test_cumsum(self):
self.tsframe.ix[5:10, 0] = nan
self.tsframe.ix[10:15, 1] = nan
diff --git a/pandas/tests/test_generic.py b/pandas/tests/test_generic.py
index cfee33da5d913..7ed8799dd6ded 100644
--- a/pandas/tests/test_generic.py
+++ b/pandas/tests/test_generic.py
@@ -909,17 +909,6 @@ def test_describe(self):
_ = self.series.describe()
_ = self.ts.describe()
- def test_describe_percentiles(self):
- with tm.assert_produces_warning(FutureWarning):
- desc = self.series.describe(percentile_width=50)
- assert '75%' in desc.index
- assert '25%' in desc.index
-
- with tm.assert_produces_warning(FutureWarning):
- desc = self.series.describe(percentile_width=95)
- assert '97.5%' in desc.index
- assert '2.5%' in desc.index
-
def test_describe_objects(self):
s = Series(['a', 'b', 'b', np.nan, np.nan, np.nan, 'c', 'd', 'a', 'a'])
result = s.describe()
@@ -1181,27 +1170,19 @@ def test_describe(self):
desc = tm.makeMixedDataFrame().describe()
desc = tm.makeTimeDataFrame().describe()
- def test_describe_percentiles(self):
- with tm.assert_produces_warning(FutureWarning):
- desc = tm.makeDataFrame().describe(percentile_width=50)
- assert '75%' in desc.index
- assert '25%' in desc.index
-
- with tm.assert_produces_warning(FutureWarning):
- desc = tm.makeDataFrame().describe(percentile_width=95)
- assert '97.5%' in desc.index
- assert '2.5%' in desc.index
-
- def test_describe_quantiles_both(self):
- with tm.assertRaises(ValueError):
- tm.makeDataFrame().describe(percentile_width=50,
- percentiles=[25, 75])
-
def test_describe_percentiles_percent_or_raw(self):
+ msg = 'percentiles should all be in the interval \\[0, 1\\]'
+
df = tm.makeDataFrame()
- with tm.assertRaises(ValueError):
+ with tm.assertRaisesRegexp(ValueError, msg):
df.describe(percentiles=[10, 50, 100])
+ with tm.assertRaisesRegexp(ValueError, msg):
+ df.describe(percentiles=[2])
+
+ with tm.assertRaisesRegexp(ValueError, msg):
+ df.describe(percentiles=[-2])
+
def test_describe_percentiles_equivalence(self):
df = tm.makeDataFrame()
d1 = df.describe()
@@ -1213,16 +1194,29 @@ def test_describe_percentiles_insert_median(self):
d1 = df.describe(percentiles=[.25, .75])
d2 = df.describe(percentiles=[.25, .5, .75])
assert_frame_equal(d1, d2)
+ self.assertTrue('25%' in d1.index)
+ self.assertTrue('75%' in d2.index)
# none above
d1 = df.describe(percentiles=[.25, .45])
d2 = df.describe(percentiles=[.25, .45, .5])
assert_frame_equal(d1, d2)
+ self.assertTrue('25%' in d1.index)
+ self.assertTrue('45%' in d2.index)
# none below
d1 = df.describe(percentiles=[.75, 1])
d2 = df.describe(percentiles=[.5, .75, 1])
assert_frame_equal(d1, d2)
+ self.assertTrue('75%' in d1.index)
+ self.assertTrue('100%' in d2.index)
+
+ # edge
+ d1 = df.describe(percentiles=[0, 1])
+ d2 = df.describe(percentiles=[0, .5, 1])
+ assert_frame_equal(d1, d2)
+ self.assertTrue('0%' in d1.index)
+ self.assertTrue('100%' in d2.index)
def test_describe_no_numeric(self):
df = DataFrame({'A': ['foo', 'foo', 'bar'] * 8,
diff --git a/pandas/tests/test_series.py b/pandas/tests/test_series.py
index 4cf52b75fb7fe..3567c98e71bce 100644
--- a/pandas/tests/test_series.py
+++ b/pandas/tests/test_series.py
@@ -2854,6 +2854,11 @@ def test_quantile(self):
result = Series([np.timedelta64('NaT')]).sum()
self.assertTrue(result is pd.NaT)
+ msg = 'percentiles should all be in the interval \\[0, 1\\]'
+ for invalid in [-1, 2, [0.5, -1], [0.5, 2]]:
+ with tm.assertRaisesRegexp(ValueError, msg):
+ self.ts.quantile(invalid)
+
def test_quantile_multi(self):
from numpy import percentile
@@ -2861,14 +2866,20 @@ def test_quantile_multi(self):
result = self.ts.quantile(qs)
expected = pd.Series([percentile(self.ts.valid(), 10),
percentile(self.ts.valid(), 90)],
- index=qs)
+ index=qs, name=self.ts.name)
assert_series_equal(result, expected)
dts = self.ts.index.to_series()
+ dts.name = 'xxx'
result = dts.quantile((.2, .2))
- assert_series_equal(result, Series([Timestamp('2000-01-10 19:12:00'),
- Timestamp('2000-01-10 19:12:00')],
- index=[.2, .2]))
+ expected = Series([Timestamp('2000-01-10 19:12:00'),
+ Timestamp('2000-01-10 19:12:00')],
+ index=[.2, .2], name='xxx')
+ assert_series_equal(result, expected)
+
+ result = self.ts.quantile([])
+ expected = pd.Series([], name=self.ts.name)
+ assert_series_equal(result, expected)
def test_append(self):
appendedSeries = self.series.append(self.objSeries)
| Currently, error is raised from `numpy` and incorrect for `pandas`
```
s = pd.Series([1, 2, 3])
s.quantile(2)
# File ".../numpy/lib/function_base.py", line 3078, in _percentile
# raise ValueError("Percentiles must be in the range [0,100]")
# ValueError: Percentiles must be in the range [0,100]
```
`describe` using `percentiles` option outputs better error message, but not check lower limit.
```
# OK
s.describe(percentiles=[2])
# Traceback (most recent call last):
# File "pandas/core/generic.py", line 4167, in describe
# raise ValueError(msg.format(list(percentiles)))
# ValueError: percentiles should all be in the interval [0, 1]. Try [0.02] instead.
# NG
s.describe(percentiles=[-2])
# File ".../numpy/lib/function_base.py", line 3078, in _percentile
# raise ValueError("Percentiles must be in the range [0,100]")
# ValueError: Percentiles must be in the range [0,100]
```
This PR fix both error messages. Also, remove deprecated `percentile_width` option in `describe`.
| https://api.github.com/repos/pandas-dev/pandas/pulls/10881 | 2015-08-21T23:32:35Z | 2015-08-23T13:28:33Z | 2015-08-23T13:28:33Z | 2015-08-23T21:31:56Z |
BUG: DataFrame.plot may raise IndexError / show unnessesary minor ticklabels | diff --git a/doc/source/whatsnew/v0.17.0.txt b/doc/source/whatsnew/v0.17.0.txt
index 9f2ec43cb2ae3..95209ceb5f559 100644
--- a/doc/source/whatsnew/v0.17.0.txt
+++ b/doc/source/whatsnew/v0.17.0.txt
@@ -824,3 +824,5 @@ Bug Fixes
- Bug in ``DataFrame.where`` when handling Series slicing (:issue:`10218`, :issue:`9558`)
- Bug where ``pd.read_gbq`` throws ``ValueError`` when Bigquery returns zero rows (:issue:`10273`)
- Bug in ``to_json`` which was causing segmentation fault when serializing 0-rank ndarray (:issue:`9576`)
+- Bug in plotting functions may raise ``IndexError`` when plotted on ``GridSpec`` (:issue:`10819`)
+- Bug in plot result may show unnecessary minor ticklabels (:issue:`10657`)
diff --git a/pandas/tests/test_graphics.py b/pandas/tests/test_graphics.py
index 1907cbd78da1d..71fd85bde1235 100644
--- a/pandas/tests/test_graphics.py
+++ b/pandas/tests/test_graphics.py
@@ -3210,6 +3210,7 @@ def _check_errorbar_color(containers, expected, has_err='has_xerr'):
self._check_has_errorbars(ax, xerr=0, yerr=1)
_check_errorbar_color(ax.containers, 'green', has_err='has_yerr')
+ @slow
def test_sharex_and_ax(self):
# https://github.com/pydata/pandas/issues/9737
# using gridspec, the axis in fig.get_axis() are sorted differently than pandas expected
@@ -3218,68 +3219,96 @@ def test_sharex_and_ax(self):
plt.close('all')
gs, axes = _generate_4_axes_via_gridspec()
- df = DataFrame({"a":[1,2,3,4,5,6], "b":[1,2,3,4,5,6]})
+ df = DataFrame({"a": [1, 2, 3, 4, 5, 6],
+ "b": [1, 2, 3, 4, 5, 6],
+ "c": [1, 2, 3, 4, 5, 6],
+ "d": [1, 2, 3, 4, 5, 6]})
+
+ def _check(axes):
+ for ax in axes:
+ self.assertEqual(len(ax.lines), 1)
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ for ax in [axes[0], axes[2]]:
+ self._check_visible(ax.get_xticklabels(), visible=False)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=False)
+ for ax in [axes[1], axes[3]]:
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
for ax in axes:
df.plot(x="a", y="b", title="title", ax=ax, sharex=True)
-
gs.tight_layout(plt.gcf())
- for ax in plt.gcf().get_axes():
- for label in ax.get_xticklabels():
- self.assertEqual(label.get_visible(), ax.is_last_row(),
- "x ticklabel has wrong visiblity")
- self.assertEqual(ax.xaxis.get_label().get_visible(), ax.is_last_row(),
- "x label has wrong visiblity")
+ _check(axes)
+ tm.close()
+
+ gs, axes = _generate_4_axes_via_gridspec()
+ with tm.assert_produces_warning(UserWarning):
+ axes = df.plot(subplots=True, ax=axes, sharex=True)
+ _check(axes)
+ tm.close()
- plt.close('all')
gs, axes = _generate_4_axes_via_gridspec()
# without sharex, no labels should be touched!
for ax in axes:
df.plot(x="a", y="b", title="title", ax=ax)
gs.tight_layout(plt.gcf())
- for ax in plt.gcf().get_axes():
- for label in ax.get_xticklabels():
- self.assertTrue(label.get_visible(), "x ticklabel is invisible but shouldn't")
- self.assertTrue(ax.xaxis.get_label().get_visible(),
- "x label is invisible but shouldn't")
-
+ for ax in axes:
+ self.assertEqual(len(ax.lines), 1)
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+ tm.close()
+ @slow
def test_sharey_and_ax(self):
# https://github.com/pydata/pandas/issues/9737
# using gridspec, the axis in fig.get_axis() are sorted differently than pandas expected
# them, so make sure that only the right ones are removed
import matplotlib.pyplot as plt
- plt.close('all')
gs, axes = _generate_4_axes_via_gridspec()
- df = DataFrame({"a":[1,2,3,4,5,6], "b":[1,2,3,4,5,6]})
+ df = DataFrame({"a": [1, 2, 3, 4, 5, 6],
+ "b": [1, 2, 3, 4, 5, 6],
+ "c": [1, 2, 3, 4, 5, 6],
+ "d": [1, 2, 3, 4, 5, 6]})
+
+ def _check(axes):
+ for ax in axes:
+ self.assertEqual(len(ax.lines), 1)
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+ for ax in [axes[0], axes[1]]:
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ for ax in [axes[2], axes[3]]:
+ self._check_visible(ax.get_yticklabels(), visible=False)
for ax in axes:
df.plot(x="a", y="b", title="title", ax=ax, sharey=True)
-
gs.tight_layout(plt.gcf())
- for ax in plt.gcf().get_axes():
- for label in ax.get_yticklabels():
- self.assertEqual(label.get_visible(), ax.is_first_col(),
- "y ticklabel has wrong visiblity")
- self.assertEqual(ax.yaxis.get_label().get_visible(), ax.is_first_col(),
- "y label has wrong visiblity")
+ _check(axes)
+ tm.close()
- plt.close('all')
gs, axes = _generate_4_axes_via_gridspec()
+ with tm.assert_produces_warning(UserWarning):
+ axes = df.plot(subplots=True, ax=axes, sharey=True)
+
+ gs.tight_layout(plt.gcf())
+ _check(axes)
+ tm.close()
+ gs, axes = _generate_4_axes_via_gridspec()
# without sharex, no labels should be touched!
for ax in axes:
df.plot(x="a", y="b", title="title", ax=ax)
gs.tight_layout(plt.gcf())
- for ax in plt.gcf().get_axes():
- for label in ax.get_yticklabels():
- self.assertTrue(label.get_visible(), "y ticklabel is invisible but shouldn't")
- self.assertTrue(ax.yaxis.get_label().get_visible(),
- "y label is invisible but shouldn't")
+ for ax in axes:
+ self.assertEqual(len(ax.lines), 1)
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
def test_memory_leak(self):
""" Check that every plot type gets properly collected. """
@@ -3311,6 +3340,172 @@ def test_memory_leak(self):
# need to actually access something to get an error
results[key].lines
+ @slow
+ def test_df_subplots_patterns_minorticks(self):
+ # GH 10657
+ import matplotlib.pyplot as plt
+
+ df = DataFrame(np.random.randn(10, 2),
+ index=date_range('1/1/2000', periods=10),
+ columns=list('AB'))
+
+ # shared subplots
+ fig, axes = plt.subplots(2, 1, sharex=True)
+ axes = df.plot(subplots=True, ax=axes)
+ for ax in axes:
+ self.assertEqual(len(ax.lines), 1)
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ # xaxis of 1st ax must be hidden
+ self._check_visible(axes[0].get_xticklabels(), visible=False)
+ self._check_visible(axes[0].get_xticklabels(minor=True), visible=False)
+ self._check_visible(axes[1].get_xticklabels(), visible=True)
+ self._check_visible(axes[1].get_xticklabels(minor=True), visible=True)
+ tm.close()
+
+ fig, axes = plt.subplots(2, 1)
+ with tm.assert_produces_warning(UserWarning):
+ axes = df.plot(subplots=True, ax=axes, sharex=True)
+ for ax in axes:
+ self.assertEqual(len(ax.lines), 1)
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ # xaxis of 1st ax must be hidden
+ self._check_visible(axes[0].get_xticklabels(), visible=False)
+ self._check_visible(axes[0].get_xticklabels(minor=True), visible=False)
+ self._check_visible(axes[1].get_xticklabels(), visible=True)
+ self._check_visible(axes[1].get_xticklabels(minor=True), visible=True)
+ tm.close()
+
+ # not shared
+ fig, axes = plt.subplots(2, 1)
+ axes = df.plot(subplots=True, ax=axes)
+ for ax in axes:
+ self.assertEqual(len(ax.lines), 1)
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+ tm.close()
+
+ @slow
+ def test_df_gridspec_patterns(self):
+ # GH 10819
+ import matplotlib.pyplot as plt
+ import matplotlib.gridspec as gridspec
+
+ ts = Series(np.random.randn(10),
+ index=date_range('1/1/2000', periods=10))
+
+ df = DataFrame(np.random.randn(10, 2), index=ts.index,
+ columns=list('AB'))
+
+ def _get_vertical_grid():
+ gs = gridspec.GridSpec(3, 1)
+ fig = plt.figure()
+ ax1 = fig.add_subplot(gs[:2, :])
+ ax2 = fig.add_subplot(gs[2, :])
+ return ax1, ax2
+
+ def _get_horizontal_grid():
+ gs = gridspec.GridSpec(1, 3)
+ fig = plt.figure()
+ ax1 = fig.add_subplot(gs[:, :2])
+ ax2 = fig.add_subplot(gs[:, 2])
+ return ax1, ax2
+
+ for ax1, ax2 in [_get_vertical_grid(), _get_horizontal_grid()]:
+ ax1 = ts.plot(ax=ax1)
+ self.assertEqual(len(ax1.lines), 1)
+ ax2 = df.plot(ax=ax2)
+ self.assertEqual(len(ax2.lines), 2)
+ for ax in [ax1, ax2]:
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+ tm.close()
+
+ # subplots=True
+ for ax1, ax2 in [_get_vertical_grid(), _get_horizontal_grid()]:
+ axes = df.plot(subplots=True, ax=[ax1, ax2])
+ self.assertEqual(len(ax1.lines), 1)
+ self.assertEqual(len(ax2.lines), 1)
+ for ax in axes:
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+ tm.close()
+
+ # vertical / subplots / sharex=True / sharey=True
+ ax1, ax2 = _get_vertical_grid()
+ with tm.assert_produces_warning(UserWarning):
+ axes = df.plot(subplots=True, ax=[ax1, ax2],
+ sharex=True, sharey=True)
+ self.assertEqual(len(axes[0].lines), 1)
+ self.assertEqual(len(axes[1].lines), 1)
+ for ax in [ax1, ax2]:
+ # yaxis are visible because there is only one column
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ # xaxis of axes0 (top) are hidden
+ self._check_visible(axes[0].get_xticklabels(), visible=False)
+ self._check_visible(axes[0].get_xticklabels(minor=True), visible=False)
+ self._check_visible(axes[1].get_xticklabels(), visible=True)
+ self._check_visible(axes[1].get_xticklabels(minor=True), visible=True)
+ tm.close()
+
+ # horizontal / subplots / sharex=True / sharey=True
+ ax1, ax2 = _get_horizontal_grid()
+ with tm.assert_produces_warning(UserWarning):
+ axes = df.plot(subplots=True, ax=[ax1, ax2],
+ sharex=True, sharey=True)
+ self.assertEqual(len(axes[0].lines), 1)
+ self.assertEqual(len(axes[1].lines), 1)
+ self._check_visible(axes[0].get_yticklabels(), visible=True)
+ # yaxis of axes1 (right) are hidden
+ self._check_visible(axes[1].get_yticklabels(), visible=False)
+ for ax in [ax1, ax2]:
+ # xaxis are visible because there is only one column
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+ tm.close()
+
+ # boxed
+ def _get_boxed_grid():
+ gs = gridspec.GridSpec(3,3)
+ fig = plt.figure()
+ ax1 = fig.add_subplot(gs[:2, :2])
+ ax2 = fig.add_subplot(gs[:2, 2])
+ ax3 = fig.add_subplot(gs[2, :2])
+ ax4 = fig.add_subplot(gs[2, 2])
+ return ax1, ax2, ax3, ax4
+
+ axes = _get_boxed_grid()
+ df = DataFrame(np.random.randn(10, 4),
+ index=ts.index, columns=list('ABCD'))
+ axes = df.plot(subplots=True, ax=axes)
+ for ax in axes:
+ self.assertEqual(len(ax.lines), 1)
+ # axis are visible because these are not shared
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+ tm.close()
+
+ # subplots / sharex=True / sharey=True
+ axes = _get_boxed_grid()
+ with tm.assert_produces_warning(UserWarning):
+ axes = df.plot(subplots=True, ax=axes, sharex=True, sharey=True)
+ for ax in axes:
+ self.assertEqual(len(ax.lines), 1)
+ for ax in [axes[0], axes[2]]: # left column
+ self._check_visible(ax.get_yticklabels(), visible=True)
+ for ax in [axes[1], axes[3]]: # right column
+ self._check_visible(ax.get_yticklabels(), visible=False)
+ for ax in [axes[0], axes[1]]: # top row
+ self._check_visible(ax.get_xticklabels(), visible=False)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=False)
+ for ax in [axes[2], axes[3]]: # bottom row
+ self._check_visible(ax.get_xticklabels(), visible=True)
+ self._check_visible(ax.get_xticklabels(minor=True), visible=True)
+ tm.close()
+
@slow
def test_df_grid_settings(self):
# Make sure plot defaults to rcParams['axes.grid'] setting, GH 9792
diff --git a/pandas/tools/plotting.py b/pandas/tools/plotting.py
index 1f799c23c5396..041c747286c51 100644
--- a/pandas/tools/plotting.py
+++ b/pandas/tools/plotting.py
@@ -3278,63 +3278,64 @@ def _subplots(naxes=None, sharex=False, sharey=False, squeeze=True,
return fig, axes
-def _remove_xlabels_from_axis(ax):
- for label in ax.get_xticklabels():
- label.set_visible(False)
+
+def _remove_labels_from_axis(axis):
+ for t in axis.get_majorticklabels():
+ t.set_visible(False)
+
try:
# set_visible will not be effective if
# minor axis has NullLocator and NullFormattor (default)
import matplotlib.ticker as ticker
-
- if isinstance(ax.xaxis.get_minor_locator(), ticker.NullLocator):
- ax.xaxis.set_minor_locator(ticker.AutoLocator())
- if isinstance(ax.xaxis.get_minor_formatter(), ticker.NullFormatter):
- ax.xaxis.set_minor_formatter(ticker.FormatStrFormatter(''))
- for label in ax.get_xticklabels(minor=True):
- label.set_visible(False)
+ if isinstance(axis.get_minor_locator(), ticker.NullLocator):
+ axis.set_minor_locator(ticker.AutoLocator())
+ if isinstance(axis.get_minor_formatter(), ticker.NullFormatter):
+ axis.set_minor_formatter(ticker.FormatStrFormatter(''))
+ for t in axis.get_minorticklabels():
+ t.set_visible(False)
except Exception: # pragma no cover
- pass
- ax.xaxis.get_label().set_visible(False)
+ raise
+ axis.get_label().set_visible(False)
-def _remove_ylables_from_axis(ax):
- for label in ax.get_yticklabels():
- label.set_visible(False)
- try:
- import matplotlib.ticker as ticker
- if isinstance(ax.yaxis.get_minor_locator(), ticker.NullLocator):
- ax.yaxis.set_minor_locator(ticker.AutoLocator())
- if isinstance(ax.yaxis.get_minor_formatter(), ticker.NullFormatter):
- ax.yaxis.set_minor_formatter(ticker.FormatStrFormatter(''))
- for label in ax.get_yticklabels(minor=True):
- label.set_visible(False)
- except Exception: # pragma no cover
- pass
- ax.yaxis.get_label().set_visible(False)
def _handle_shared_axes(axarr, nplots, naxes, nrows, ncols, sharex, sharey):
if nplots > 1:
- # first find out the ax layout, so that we can correctly handle 'gaps"
- layout = np.zeros((nrows+1,ncols+1), dtype=np.bool)
- for ax in axarr:
- layout[ax.rowNum, ax.colNum] = ax.get_visible()
-
- if sharex and nrows > 1:
- for ax in axarr:
- # only the last row of subplots should get x labels -> all other off
- # layout handles the case that the subplot is the last in the column,
- # because below is no subplot/gap.
- if not layout[ax.rowNum+1, ax.colNum]:
- continue
- _remove_xlabels_from_axis(ax)
- if sharey and ncols > 1:
+ if nrows > 1:
+ try:
+ # first find out the ax layout,
+ # so that we can correctly handle 'gaps"
+ layout = np.zeros((nrows+1,ncols+1), dtype=np.bool)
+ for ax in axarr:
+ layout[ax.rowNum, ax.colNum] = ax.get_visible()
+
+ for ax in axarr:
+ # only the last row of subplots should get x labels -> all
+ # other off layout handles the case that the subplot is
+ # the last in the column, because below is no subplot/gap.
+ if not layout[ax.rowNum+1, ax.colNum]:
+ continue
+ if sharex or len(ax.get_shared_x_axes().get_siblings(ax)) > 1:
+ _remove_labels_from_axis(ax.xaxis)
+
+ except IndexError:
+ # if gridspec is used, ax.rowNum and ax.colNum may different
+ # from layout shape. in this case, use last_row logic
+ for ax in axarr:
+ if ax.is_last_row():
+ continue
+ if sharex or len(ax.get_shared_x_axes().get_siblings(ax)) > 1:
+ _remove_labels_from_axis(ax.xaxis)
+
+ if ncols > 1:
for ax in axarr:
# only the first column should get y labels -> set all other to off
# as we only have labels in teh first column and we always have a subplot there,
# we can skip the layout test
if ax.is_first_col():
continue
- _remove_ylables_from_axis(ax)
+ if sharey or len(ax.get_shared_y_axes().get_siblings(ax)) > 1:
+ _remove_labels_from_axis(ax.yaxis)
| Closes #10657. Closes #10819. Both are related to the logic how `pandas` detects axes layout. Use current logic as much to support cases like #7457, and added error handing logic for gridspec.
Following is an example notebook how the fix works.
- https://gist.github.com/sinhrks/2d29e2e8ef26f2757e92
CC @TomAugspurger @JanSchulz @heelancd @williamsmj
| https://api.github.com/repos/pandas-dev/pandas/pulls/10879 | 2015-08-21T15:54:55Z | 2015-09-01T12:06:24Z | 2015-09-01T12:06:24Z | 2015-09-01T12:16:17Z |
BUG: GH10747 where 'timestamp' is not inferred to be datetime column | diff --git a/doc/source/io.rst b/doc/source/io.rst
index 2f2c4c7566413..70e7154493ccf 100644
--- a/doc/source/io.rst
+++ b/doc/source/io.rst
@@ -1484,7 +1484,13 @@ be set to ``False`` if you need to preserve string-like numbers (e.g. '1', '2')
.. note::
- Large integer values may be converted to dates if ``convert_dates=True`` and the data and / or column labels appear 'date-like'. The exact threshold depends on the ``date_unit`` specified.
+ Large integer values may be converted to dates if ``convert_dates=True`` and the data and / or column labels appear 'date-like'. The exact threshold depends on the ``date_unit`` specified. 'date-like' means that the column label meets one of the following criteria:
+
+ * it ends with ``'_at'``
+ * it ends with ``'_time'``
+ * it begins with ``'timestamp'``
+ * it is ``'modified'``
+ * it is ``'date'``
.. warning::
diff --git a/pandas/io/json.py b/pandas/io/json.py
index 81a916e058b3d..d6310d81ab87f 100644
--- a/pandas/io/json.py
+++ b/pandas/io/json.py
@@ -150,7 +150,18 @@ def read_json(path_or_buf=None, orient=None, typ='frame', dtype=True,
Try to convert the axes to the proper dtypes.
convert_dates : boolean, default True
List of columns to parse for dates; If True, then try to parse
- datelike columns default is True
+ datelike columns default is True; a column label is datelike if
+
+ * it ends with ``'_at'``,
+
+ * it ends with ``'_time'``,
+
+ * it begins with ``'timestamp'``,
+
+ * it is ``'modified'``, or
+
+ * it is ``'date'``
+
keep_default_dates : boolean, default True.
If parsing dates, then parse the default datelike columns
numpy : boolean, default False
@@ -543,11 +554,13 @@ def is_ok(col):
if not isinstance(col, compat.string_types):
return False
- if (col.endswith('_at') or
- col.endswith('_time') or
- col.lower() == 'modified' or
- col.lower() == 'date' or
- col.lower() == 'datetime'):
+ col_lower = col.lower()
+ if (col_lower.endswith('_at') or
+ col_lower.endswith('_time') or
+ col_lower == 'modified' or
+ col_lower == 'date' or
+ col_lower == 'datetime' or
+ col_lower.startswith('timestamp')):
return True
return False
diff --git a/pandas/io/tests/test_json/test_pandas.py b/pandas/io/tests/test_json/test_pandas.py
index c577286ceca9a..40cdc8fe8478c 100644
--- a/pandas/io/tests/test_json/test_pandas.py
+++ b/pandas/io/tests/test_json/test_pandas.py
@@ -1,13 +1,12 @@
# pylint: disable-msg=W0612,E1101
from pandas.compat import range, lrange, StringIO, OrderedDict
-from pandas import compat
import os
import numpy as np
-from pandas import Series, DataFrame, DatetimeIndex, Timestamp, CategoricalIndex
+from pandas import (Series, DataFrame, DatetimeIndex, Timestamp, CategoricalIndex,
+ read_json, compat)
from datetime import timedelta
import pandas as pd
-read_json = pd.read_json
from pandas.util.testing import (assert_almost_equal, assert_frame_equal,
assert_series_equal, network,
@@ -574,6 +573,16 @@ def test_convert_dates(self):
result = read_json(json, typ='series')
assert_series_equal(result, ts)
+ def test_convert_dates_infer(self):
+ #GH10747
+ infer_words = ['trade_time', 'date', 'datetime', 'sold_at',
+ 'modified', 'timestamp', 'timestamps']
+ for infer_word in infer_words:
+ data = [{'id': 1, infer_word: 1036713600000}, {'id': 2}]
+ expected = DataFrame([[1, Timestamp('2002-11-08')], [2, pd.NaT]], columns=['id', infer_word])
+ result = read_json(pd.json.dumps(data))[['id', infer_word]]
+ assert_frame_equal(result, expected)
+
def test_date_format_frame(self):
df = self.tsframe.copy()
| addresses second point of #10747
| https://api.github.com/repos/pandas-dev/pandas/pulls/10876 | 2015-08-21T08:33:29Z | 2015-08-24T11:36:30Z | 2015-08-24T11:36:30Z | 2015-08-24T11:36:30Z |
PERF: uses bincount instead of hash table in categorical value counts | diff --git a/asv_bench/benchmarks/categoricals.py b/asv_bench/benchmarks/categoricals.py
index 34caef221a340..80b277336df7a 100644
--- a/asv_bench/benchmarks/categoricals.py
+++ b/asv_bench/benchmarks/categoricals.py
@@ -8,4 +8,20 @@ def setup(self):
self.s = pd.Series((list('aabbcd') * 1000000)).astype('category')
def time_concat_categorical(self):
- concat([self.s, self.s])
\ No newline at end of file
+ concat([self.s, self.s])
+
+
+class categorical_value_counts(object):
+ goal_time = 1
+
+ def setup(self):
+ n = 500000
+ np.random.seed(2718281)
+ arr = ['s%04d' % i for i in np.random.randint(0, n // 10, size=n)]
+ self.ts = Series(arr).astype('category')
+
+ def time_value_counts(self):
+ self.ts.value_counts(dropna=False)
+
+ def time_value_counts_dropna(self):
+ self.ts.value_counts(dropna=True)
diff --git a/doc/source/whatsnew/v0.17.0.txt b/doc/source/whatsnew/v0.17.0.txt
index 6b4bde588469e..5df49b1457a7e 100644
--- a/doc/source/whatsnew/v0.17.0.txt
+++ b/doc/source/whatsnew/v0.17.0.txt
@@ -660,6 +660,7 @@ Removal of prior version deprecations/changes
Performance Improvements
~~~~~~~~~~~~~~~~~~~~~~~~
- Added vbench benchmarks for alternative ExcelWriter engines and reading Excel files (:issue:`7171`)
+- Performance improvements in ``Categorical.value_counts`` (:issue:`10804`)
- 4x improvement in ``timedelta`` string parsing (:issue:`6755`, :issue:`10426`)
- 8x improvement in ``timedelta64`` and ``datetime64`` ops (:issue:`6755`)
diff --git a/pandas/core/categorical.py b/pandas/core/categorical.py
index ba2c9314322c3..78c9d264c43a5 100644
--- a/pandas/core/categorical.py
+++ b/pandas/core/categorical.py
@@ -1025,25 +1025,28 @@ def value_counts(self, dropna=True):
-------
counts : Series
"""
- import pandas.hashtable as htable
+ from numpy import bincount
+ from pandas.core.common import isnull
from pandas.core.series import Series
from pandas.core.index import CategoricalIndex
- cat = self.dropna() if dropna else self
- keys, counts = htable.value_count_scalar64(com._ensure_int64(cat._codes), dropna)
- result = Series(counts, index=keys)
+ obj = self.remove_categories([np.nan]) \
+ if dropna and isnull(self.categories).any() else self
+
+ code, cat = obj._codes, obj.categories
+ ncat, mask = len(cat), 0 <= code
+ ix, clean = np.arange(ncat), mask.all()
- ix = np.arange(len(cat.categories), dtype='int64')
- if not dropna and -1 in keys:
+ if dropna or clean:
+ count = bincount(code if clean else code[mask], minlength=ncat)
+ else:
+ count = bincount(np.where(mask, code, ncat))
ix = np.append(ix, -1)
- result = result.reindex(ix, fill_value=0)
- index = (np.append(cat.categories, np.nan)
- if not dropna and -1 in keys
- else cat.categories)
- result.index = CategoricalIndex(index, self.categories, self.ordered)
+ ix = Categorical(ix, categories=cat,
+ ordered=obj.ordered, fastpath=True)
- return result
+ return Series(count, index=CategoricalIndex(ix))
def get_values(self):
""" Return the values.
| closes https://github.com/pydata/pandas/issues/10804
``` ipython
In [1]: np.random.seed(2718281)
In [2]: n = 500000
In [3]: u = int(0.1*n)
In [4]: arr = ["s%04d" % i for i in np.random.randint(0, u, size=n)]
In [5]: ts = pd.Series(arr).astype('category')
In [6]: %timeit ts.value_counts()
10 loops, best of 3: 82.7 ms per loop
```
on branch:
``` ipython
In [6]: %timeit ts.value_counts()
10 loops, best of 3: 31.3 ms per loop
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/10874 | 2015-08-21T00:40:06Z | 2015-08-22T20:03:01Z | 2015-08-22T20:03:01Z | 2015-08-22T20:28:02Z |
DOC: update ipython sphinxext for IPython 4.0 | diff --git a/doc/sphinxext/ipython_sphinxext/ipython_directive.py b/doc/sphinxext/ipython_sphinxext/ipython_directive.py
index 3f9be95609874..ad7ada8e4eea3 100644
--- a/doc/sphinxext/ipython_sphinxext/ipython_directive.py
+++ b/doc/sphinxext/ipython_sphinxext/ipython_directive.py
@@ -127,7 +127,11 @@
from sphinx.util.compat import Directive
# Our own
-from IPython import Config, InteractiveShell
+try:
+ from traitlets.config import Config
+except ImportError:
+ from IPython import Config
+from IPython import InteractiveShell
from IPython.core.profiledir import ProfileDir
from IPython.utils import io
from IPython.utils.py3compat import PY3
| https://api.github.com/repos/pandas-dev/pandas/pulls/10868 | 2015-08-20T20:55:58Z | 2015-08-23T10:35:40Z | 2015-08-23T10:35:40Z | 2015-09-07T17:51:10Z | |
DEPR: iterkv change Deprecation to FutureWarning | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 1656d52c35eeb..610c5a0da2cff 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -701,7 +701,7 @@ def iterkv(self, *args, **kwargs):
"iteritems alias used to get around 2to3. Deprecated"
warnings.warn("iterkv is deprecated and will be removed in a future "
"release, use ``iteritems`` instead.",
- DeprecationWarning)
+ FutureWarning)
return self.iteritems(*args, **kwargs)
def __len__(self):
@@ -2004,13 +2004,13 @@ def sample(self, n=None, frac=None, replace=False, weights=None, random_state=No
Sample with or without replacement. Default = False.
weights : str or ndarray-like, optional
Default 'None' results in equal probability weighting.
- If passed a Series, will align with target object on index. Index
+ If passed a Series, will align with target object on index. Index
values in weights not found in sampled object will be ignored and
- index values in sampled object not in weights will be assigned
- weights of zero.
+ index values in sampled object not in weights will be assigned
+ weights of zero.
If called on a DataFrame, will accept the name of a column
when axis = 0.
- Unless weights are a Series, weights must be same length as axis
+ Unless weights are a Series, weights must be same length as axis
being sampled.
If weights do not sum to 1, they will be normalized to sum to 1.
Missing values in the weights column will be treated as zero.
@@ -2040,8 +2040,8 @@ def sample(self, n=None, frac=None, replace=False, weights=None, random_state=No
if weights is not None:
# If a series, align with frame
- if isinstance(weights, pd.Series):
- weights = weights.reindex(self.axes[axis])
+ if isinstance(weights, pd.Series):
+ weights = weights.reindex(self.axes[axis])
# Strings acceptable if a dataframe and axis = 0
if isinstance(weights, string_types):
diff --git a/pandas/tests/test_frame.py b/pandas/tests/test_frame.py
index 465f1da05ebde..d6e825d8fd000 100644
--- a/pandas/tests/test_frame.py
+++ b/pandas/tests/test_frame.py
@@ -14188,7 +14188,7 @@ def test_take(self):
assert_frame_equal(result, expected)
def test_iterkv_deprecation(self):
- with tm.assert_produces_warning(DeprecationWarning):
+ with tm.assert_produces_warning(FutureWarning):
self.mixed_float.iterkv()
def test_iterkv_names(self):
| So this is visible to the users (already long time deprecated in the docs)
| https://api.github.com/repos/pandas-dev/pandas/pulls/10867 | 2015-08-20T20:18:52Z | 2015-08-21T07:31:13Z | 2015-08-21T07:31:13Z | 2015-08-21T07:31:13Z |
ENH: Period pickle | diff --git a/doc/source/whatsnew/v0.17.0.txt b/doc/source/whatsnew/v0.17.0.txt
index 039772f68ee85..0c3af5c4bd64f 100644
--- a/doc/source/whatsnew/v0.17.0.txt
+++ b/doc/source/whatsnew/v0.17.0.txt
@@ -198,6 +198,8 @@ Other enhancements
``tolerance`` is also exposed by the lower level ``Index.get_indexer`` and ``Index.get_loc`` methods.
+- Support pickling of ``Period`` objects (:issue:`10439`)
+
.. _whatsnew_0170.api:
.. _whatsnew_0170.api_breaking:
diff --git a/pandas/io/tests/data/legacy_msgpack/0.16.2/0.16.2_x86_64_darwin_2.7.10.msgpack b/pandas/io/tests/data/legacy_msgpack/0.16.2/0.16.2_x86_64_darwin_2.7.10.msgpack
index 6bf1b9b9afaaa..000879f4cb2c2 100644
Binary files a/pandas/io/tests/data/legacy_msgpack/0.16.2/0.16.2_x86_64_darwin_2.7.10.msgpack and b/pandas/io/tests/data/legacy_msgpack/0.16.2/0.16.2_x86_64_darwin_2.7.10.msgpack differ
diff --git a/pandas/io/tests/data/legacy_pickle/0.16.2/0.16.2_x86_64_darwin_2.7.10.pickle b/pandas/io/tests/data/legacy_pickle/0.16.2/0.16.2_x86_64_darwin_2.7.10.pickle
index 60101c2f1e95e..d45936baa1e00 100644
Binary files a/pandas/io/tests/data/legacy_pickle/0.16.2/0.16.2_x86_64_darwin_2.7.10.pickle and b/pandas/io/tests/data/legacy_pickle/0.16.2/0.16.2_x86_64_darwin_2.7.10.pickle differ
diff --git a/pandas/io/tests/generate_legacy_storage_files.py b/pandas/io/tests/generate_legacy_storage_files.py
index e7cc89fcc0b61..86c5a9e0d7f19 100644
--- a/pandas/io/tests/generate_legacy_storage_files.py
+++ b/pandas/io/tests/generate_legacy_storage_files.py
@@ -4,7 +4,8 @@
from pandas import (Series, TimeSeries, DataFrame, Panel,
SparseSeries, SparseTimeSeries, SparseDataFrame, SparsePanel,
Index, MultiIndex, PeriodIndex, bdate_range, to_msgpack,
- date_range, period_range, bdate_range, Timestamp, Categorical)
+ date_range, period_range, bdate_range, Timestamp, Categorical,
+ Period)
import os
import sys
import numpy as np
@@ -63,6 +64,10 @@ def create_data():
'E': [0., 1, Timestamp('20100101'), 'foo', 2.]
}
+ scalars = dict(timestamp=Timestamp('20130101'))
+ if LooseVersion(pandas.__version__) >= '0.17.0':
+ scalars['period'] = Period('2012','M')
+
index = dict(int=Index(np.arange(10)),
date=date_range('20130101', periods=10),
period=period_range('2013-01-01', freq='M', periods=10))
@@ -79,6 +84,8 @@ def create_data():
names=['one', 'two'])),
dup=Series(np.arange(5).astype(np.float64), index=['A', 'B', 'C', 'D', 'A']),
cat=Series(Categorical(['foo', 'bar', 'baz'])))
+ if LooseVersion(pandas.__version__) >= '0.17.0':
+ series['period'] = Series([Period('2000Q1')] * 5)
mixed_dup_df = DataFrame(data)
mixed_dup_df.columns = list("ABCDA")
@@ -107,6 +114,7 @@ def create_data():
frame=frame,
panel=panel,
index=index,
+ scalars=scalars,
mi=mi,
sp_series=dict(float=_create_sp_series(),
ts=_create_sp_tsseries()),
diff --git a/pandas/io/tests/test_pickle.py b/pandas/io/tests/test_pickle.py
index e691fac215002..8f2079722c00e 100644
--- a/pandas/io/tests/test_pickle.py
+++ b/pandas/io/tests/test_pickle.py
@@ -48,7 +48,7 @@ def compare_element(self, typ, result, expected):
comparator = getattr(test_sparse,"assert_%s_equal" % typ)
comparator(result,expected,exact_indices=False)
else:
- comparator = getattr(tm,"assert_%s_equal" % typ)
+ comparator = getattr(tm,"assert_%s_equal" % typ,tm.assert_almost_equal)
comparator(result,expected)
def compare(self, vf):
diff --git a/pandas/src/period.pyx b/pandas/src/period.pyx
index b4a4930e09d68..619d1a87a71e0 100644
--- a/pandas/src/period.pyx
+++ b/pandas/src/period.pyx
@@ -969,6 +969,14 @@ cdef class Period(object):
value = ("%s" % formatted)
return value
+ def __setstate__(self, state):
+ self.freq=state[1]
+ self.ordinal=state[2]
+
+ def __reduce__(self):
+ object_state = None, self.freq, self.ordinal
+ return (Period, object_state)
+
def strftime(self, fmt):
"""
Returns the string representation of the :class:`Period`, depending
diff --git a/pandas/tseries/tests/test_period.py b/pandas/tseries/tests/test_period.py
index b9757c9e1b5d7..eb5c6759bfa45 100644
--- a/pandas/tseries/tests/test_period.py
+++ b/pandas/tseries/tests/test_period.py
@@ -2471,7 +2471,6 @@ def test_append_concat(self):
def test_pickle_freq(self):
# GH2891
- import pickle
prng = period_range('1/1/2011', '1/1/2012', freq='M')
new_prng = self.round_trip_pickle(prng)
self.assertEqual(new_prng.freq,'M')
@@ -2536,6 +2535,12 @@ def test_searchsorted(self):
ValueError, 'Different period frequency: H',
lambda: pidx.searchsorted(pd.Period('2014-01-01', freq='H')))
+ def test_round_trip(self):
+
+ p = Period('2000Q1')
+ new_p = self.round_trip_pickle(p)
+ self.assertEqual(new_p, p)
+
def _permute(obj):
return obj.take(np.random.permutation(len(obj)))
| closes #10439
closes #10441
| https://api.github.com/repos/pandas-dev/pandas/pulls/10866 | 2015-08-20T16:23:48Z | 2015-08-20T17:32:21Z | 2015-08-20T17:32:21Z | 2015-08-20T17:32:21Z |
removes categories & ordered from CategoricalIndex attributes | diff --git a/pandas/core/index.py b/pandas/core/index.py
index 135195d90ffdb..7b5a6b199bc1b 100644
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -2910,7 +2910,7 @@ class CategoricalIndex(Index, PandasDelegate):
_typ = 'categoricalindex'
_engine_type = _index.Int64Engine
- _attributes = ['name','categories','ordered']
+ _attributes = ['name']
def __new__(cls, data=None, categories=None, ordered=None, dtype=None, copy=False, name=None, fastpath=False, **kwargs):
| `categories` and `ordered` are properties not attributes ([index.py#L3085-L3091](https://github.com/pydata/pandas/blob/3e35c842f37265ac7339908869d4cc7bdef784d9/pandas/core/index.py#L3085-L3091)). The side effect is that the categories are rehashed too often:
on master:
``` ipython
In [1]: from pandas.core.index import CategoricalIndex
In [2]: np.random.seed(2718281)
In [3]: n = 100000
In [4]: val = map('{:->4}'.format, np.random.randint(0, 10000, n))
In [5]: idx = CategoricalIndex(list(val))
In [6]: %timeit idx[::-1]
100 loops, best of 3: 14.1 ms per loop
In [7]: %timeit idx[idx.argsort()]
10 loops, best of 3: 22 ms per loop
In [8]: cProfile.run("idx[::-1]", sort=1)
174 function calls (171 primitive calls) in 0.025 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.014 0.014 0.014 0.014 {method 'lookup' of 'pandas.hashtable.PyObjectHashTable' objects}
1 0.004 0.004 0.004 0.004 {pandas.algos.take_1d_object_object}
1 0.003 0.003 0.003 0.003 {method 'map_locations' of 'pandas.hashtable.PyObjectHashTable' objects}
```
on branch:
``` ipython
In [6]: %timeit idx[::-1]
The slowest run took 6.78 times longer than the fastest. This could mean that an intermediate result is being cached
10000 loops, best of 3: 29 µs per loop
In [7]: %timeit idx[idx.argsort()]
100 loops, best of 3: 9.38 ms per loop
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/10858 | 2015-08-20T00:10:29Z | 2015-08-20T12:48:09Z | 2015-08-20T12:48:09Z | 2015-08-20T23:32:06Z |
ENH: #8325 Add ability to create tables using the gbq module. | diff --git a/ci/requirements-2.7.pip b/ci/requirements-2.7.pip
index cf8e6b8b3d3a6..ff1978a8d45ed 100644
--- a/ci/requirements-2.7.pip
+++ b/ci/requirements-2.7.pip
@@ -1 +1,3 @@
blosc
+httplib2
+google-api-python-client == 1.2
diff --git a/ci/requirements-2.7.txt b/ci/requirements-2.7.txt
index 951c8798bef15..d6a1e2d362330 100644
--- a/ci/requirements-2.7.txt
+++ b/ci/requirements-2.7.txt
@@ -20,6 +20,4 @@ patsy
pymysql=0.6.3
html5lib=1.0b2
beautiful-soup=4.2.1
-httplib2=0.8
python-gflags=2.0
-google-api-python-client=1.2
diff --git a/ci/requirements-2.7_SLOW.txt b/ci/requirements-2.7_SLOW.txt
index 19686ccb56922..1a56434c62f86 100644
--- a/ci/requirements-2.7_SLOW.txt
+++ b/ci/requirements-2.7_SLOW.txt
@@ -20,6 +20,4 @@ psycopg2
pymysql
html5lib
beautiful-soup
-httplib2
python-gflags
-google-api-python-client
diff --git a/ci/requirements-3.4.pip b/ci/requirements-3.4.pip
index cf8e6b8b3d3a6..47a049aac7632 100644
--- a/ci/requirements-3.4.pip
+++ b/ci/requirements-3.4.pip
@@ -1 +1,3 @@
blosc
+httplib2
+google-api-python-client
diff --git a/doc/source/api.rst b/doc/source/api.rst
index 915727817bb7b..01634d7c02481 100644
--- a/doc/source/api.rst
+++ b/doc/source/api.rst
@@ -110,6 +110,10 @@ Google BigQuery
read_gbq
to_gbq
+ generate_bq_schema
+ create_table
+ delete_table
+ table_exists
.. currentmodule:: pandas
diff --git a/doc/source/io.rst b/doc/source/io.rst
index f95fdd502d306..5ad9af310225d 100644
--- a/doc/source/io.rst
+++ b/doc/source/io.rst
@@ -3951,14 +3951,35 @@ The :mod:`pandas.io.gbq` module provides a wrapper for Google's BigQuery
analytics web service to simplify retrieving results from BigQuery tables
using SQL-like queries. Result sets are parsed into a pandas
DataFrame with a shape and data types derived from the source table.
-Additionally, DataFrames can be appended to existing BigQuery tables if
-the destination table is the same shape as the DataFrame.
+Additionally, DataFrames can be inserted into new BigQuery tables or appended
+to existing tables.
-For specifics on the service itself, see `here <https://developers.google.com/bigquery/>`__
+.. warning::
+
+ To use this module, you will need a valid BigQuery account. Refer to the
+ `BigQuery Documentation <https://developers.google.com/bigquery/>`__ for details on the service itself.
+
+The key functions are:
-As an example, suppose you want to load all data from an existing BigQuery
-table : `test_dataset.test_table` into a DataFrame using the :func:`~pandas.io.read_gbq`
-function.
+.. currentmodule:: pandas.io.gbq
+
+.. autosummary::
+ :toctree: generated/
+
+ read_gbq
+ to_gbq
+ generate_bq_schema
+ create_table
+ delete_table
+ table_exists
+
+.. currentmodule:: pandas
+
+Querying
+''''''''
+
+Suppose you want to load all data from an existing BigQuery table : `test_dataset.test_table`
+into a DataFrame using the :func:`~pandas.io.gbq.read_gbq` function.
.. code-block:: python
@@ -3966,14 +3987,14 @@ function.
# Can be found in the Google web console
projectid = "xxxxxxxx"
- data_frame = pd.read_gbq('SELECT * FROM test_dataset.test_table', project_id = projectid)
+ data_frame = pd.read_gbq('SELECT * FROM test_dataset.test_table', projectid)
You will then be authenticated to the specified BigQuery account
via Google's Oauth2 mechanism. In general, this is as simple as following the
prompts in a browser window which will be opened for you. Should the browser not
be available, or fail to launch, a code will be provided to complete the process
manually. Additional information on the authentication mechanism can be found
-`here <https://developers.google.com/accounts/docs/OAuth2#clientside/>`__
+`here <https://developers.google.com/accounts/docs/OAuth2#clientside/>`__.
You can define which column from BigQuery to use as an index in the
destination DataFrame as well as a preferred column order as follows:
@@ -3982,56 +4003,167 @@ destination DataFrame as well as a preferred column order as follows:
data_frame = pd.read_gbq('SELECT * FROM test_dataset.test_table',
index_col='index_column_name',
- col_order=['col1', 'col2', 'col3'], project_id = projectid)
-
-Finally, you can append data to a BigQuery table from a pandas DataFrame
-using the :func:`~pandas.io.to_gbq` function. This function uses the
-Google streaming API which requires that your destination table exists in
-BigQuery. Given the BigQuery table already exists, your DataFrame should
-match the destination table in column order, structure, and data types.
-DataFrame indexes are not supported. By default, rows are streamed to
-BigQuery in chunks of 10,000 rows, but you can pass other chuck values
-via the ``chunksize`` argument. You can also see the progess of your
-post via the ``verbose`` flag which defaults to ``True``. The http
-response code of Google BigQuery can be successful (200) even if the
-append failed. For this reason, if there is a failure to append to the
-table, the complete error response from BigQuery is returned which
-can be quite long given it provides a status for each row. You may want
-to start with smaller chunks to test that the size and types of your
-dataframe match your destination table to make debugging simpler.
+ col_order=['col1', 'col2', 'col3'], projectid)
+
+.. note::
+
+ You can find your project id in the `BigQuery management console <https://code.google.com/apis/console/b/0/?noredirect>`__.
+
+
+.. note::
+
+ You can toggle the verbose output via the ``verbose`` flag which defaults to ``True``.
+
+Writing DataFrames
+''''''''''''''''''
+
+Assume we want to write a DataFrame ``df`` into a BigQuery table using :func:`~pandas.DataFrame.to_gbq`.
+
+.. ipython:: python
+
+ df = pd.DataFrame({'my_string': list('abc'),
+ 'my_int64': list(range(1, 4)),
+ 'my_float64': np.arange(4.0, 7.0),
+ 'my_bool1': [True, False, True],
+ 'my_bool2': [False, True, False],
+ 'my_dates': pd.date_range('now', periods=3)})
+
+ df
+ df.dtypes
.. code-block:: python
- df = pandas.DataFrame({'string_col_name' : ['hello'],
- 'integer_col_name' : [1],
- 'boolean_col_name' : [True]})
- df.to_gbq('my_dataset.my_table', project_id = projectid)
+ df.to_gbq('my_dataset.my_table', projectid)
+
+.. note::
+
+ If the destination table does not exist, a new table will be created. The
+ destination dataset id must already exist in order for a new table to be created.
+
+The ``if_exists`` argument can be used to dictate whether to ``'fail'``, ``'replace'``
+or ``'append'`` if the destination table already exists. The default value is ``'fail'``.
+
+For example, assume that ``if_exists`` is set to ``'fail'``. The following snippet will raise
+a ``TableCreationError`` if the destination table already exists.
+
+.. code-block:: python
-The BigQuery SQL query language has some oddities, see `here <https://developers.google.com/bigquery/query-reference>`__
+ df.to_gbq('my_dataset.my_table', projectid, if_exists='fail')
-While BigQuery uses SQL-like syntax, it has some important differences
-from traditional databases both in functionality, API limitations (size and
-quantity of queries or uploads), and how Google charges for use of the service.
-You should refer to Google documentation often as the service seems to
-be changing and evolving. BiqQuery is best for analyzing large sets of
-data quickly, but it is not a direct replacement for a transactional database.
+.. note::
-You can access the management console to determine project id's by:
-<https://code.google.com/apis/console/b/0/?noredirect>
+ If the ``if_exists`` argument is set to ``'append'``, the destination dataframe will
+ be written to the table using the defined table schema and column types. The
+ dataframe must match the destination table in column order, structure, and
+ data types.
+ If the ``if_exists`` argument is set to ``'replace'``, and the existing table has a
+ different schema, a delay of 2 minutes will be forced to ensure that the new schema
+ has propagated in the Google environment. See
+ `Google BigQuery issue 191 <https://code.google.com/p/google-bigquery/issues/detail?id=191>`__.
-As of 0.15.2, the gbq module has a function ``generate_bq_schema`` which
-will produce the dictionary representation of the schema.
+Writing large DataFrames can result in errors due to size limitations being exceeded.
+This can be avoided by setting the ``chunksize`` argument when calling :func:`~pandas.DataFrame.to_gbq`.
+For example, the following writes ``df`` to a BigQuery table in batches of 10000 rows at a time:
.. code-block:: python
- df = pandas.DataFrame({'A': [1.0]})
- gbq.generate_bq_schema(df, default_type='STRING')
+ df.to_gbq('my_dataset.my_table', projectid, chunksize=10000)
-.. warning::
+You can also see the progress of your post via the ``verbose`` flag which defaults to ``True``.
+For example:
+
+.. code-block:: python
+
+ In [8]: df.to_gbq('my_dataset.my_table', projectid, chunksize=10000, verbose=True)
+
+ Streaming Insert is 10% Complete
+ Streaming Insert is 20% Complete
+ Streaming Insert is 30% Complete
+ Streaming Insert is 40% Complete
+ Streaming Insert is 50% Complete
+ Streaming Insert is 60% Complete
+ Streaming Insert is 70% Complete
+ Streaming Insert is 80% Complete
+ Streaming Insert is 90% Complete
+ Streaming Insert is 100% Complete
+
+.. note::
+
+ If an error occurs while streaming data to BigQuery, see
+ `Troubleshooting BigQuery Errors <https://cloud.google.com/bigquery/troubleshooting-errors>`__.
+
+.. note::
+
+ The BigQuery SQL query language has some oddities, see the
+ `BigQuery Query Reference Documentation <https://developers.google.com/bigquery/query-reference>`__.
+
+.. note::
+
+ While BigQuery uses SQL-like syntax, it has some important differences from traditional
+ databases both in functionality, API limitations (size and quantity of queries or uploads),
+ and how Google charges for use of the service. You should refer to `Google BigQuery documentation <https://developers.google.com/bigquery/>`__
+ often as the service seems to be changing and evolving. BiqQuery is best for analyzing large
+ sets of data quickly, but it is not a direct replacement for a transactional database.
+
+
+Creating BigQuery Tables
+''''''''''''''''''''''''
+
+As of 0.17.0, the gbq module has a function :func:`~pandas.io.gbq.create_table` which allows users
+to create a table in BigQuery. The only requirement is that the dataset must already exist.
+The schema may be generated from a pandas DataFrame using the :func:`~pandas.io.gbq.generate_bq_schema` function below.
+
+For example:
+
+.. code-block:: python
+
+ gbq.create_table('my_dataset.my_table', schema, projectid)
+
+As of 0.15.2, the gbq module has a function :func:`~pandas.io.gbq.generate_bq_schema` which will
+produce the dictionary representation schema of the specified pandas DataFrame.
+
+.. code-block:: python
+
+ In [10]: gbq.generate_bq_schema(df, default_type='STRING')
+
+ Out[10]: {'fields': [{'name': 'my_bool1', 'type': 'BOOLEAN'},
+ {'name': 'my_bool2', 'type': 'BOOLEAN'},
+ {'name': 'my_dates', 'type': 'TIMESTAMP'},
+ {'name': 'my_float64', 'type': 'FLOAT'},
+ {'name': 'my_int64', 'type': 'INTEGER'},
+ {'name': 'my_string', 'type': 'STRING'}]}
+
+Deleting BigQuery Tables
+''''''''''''''''''''''''
+
+As of 0.17.0, the gbq module has a function :func:`~pandas.io.gbq.delete_table` which allows users to delete a table
+in Google BigQuery.
+
+For example:
+
+.. code-block:: python
+
+ gbq.delete_table('my_dataset.my_table', projectid)
+
+The following function can be used to check whether a table exists prior to calling ``table_exists``:
+
+:func:`~pandas.io.gbq.table_exists`.
+
+The return value will be of type boolean.
+
+For example:
+
+.. code-block:: python
+
+ In [12]: gbq.table_exists('my_dataset.my_table', projectid)
+ Out[12]: True
+
+.. note::
- To use this module, you will need a valid BigQuery account. See
- <https://cloud.google.com/products/big-query> for details on the
- service.
+ If you delete and re-create a BigQuery table with the same name, but different table schema,
+ you must wait 2 minutes before streaming data into the table. As a workaround, consider creating
+ the new table with a different name. Refer to
+ `Google BigQuery issue 191 <https://code.google.com/p/google-bigquery/issues/detail?id=191>`__.
.. _io.stata:
diff --git a/doc/source/whatsnew/v0.17.0.txt b/doc/source/whatsnew/v0.17.0.txt
index 3b3bf8cffe41b..0a2407ed7b16e 100644
--- a/doc/source/whatsnew/v0.17.0.txt
+++ b/doc/source/whatsnew/v0.17.0.txt
@@ -319,6 +319,15 @@ has been changed to make this keyword unnecessary - the change is shown below.
Excel files saved in version 0.16.2 or prior that had index names will still able to be read in,
but the ``has_index_names`` argument must specified to ``True``.
+.. _whatsnew_0170.gbq:
+
+Google BigQuery Enhancements
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Added ability to automatically create a table using the :func:`pandas.io.gbq.to_gbq` function if destination table does not exist. (:issue:`8325`).
+- Added ability to replace an existing table and schema when calling the :func:`pandas.io.gbq.to_gbq` function via the ``if_exists`` argument. See the :ref:`docs <io.bigquery>` for more details (:issue:`8325`).
+- Added the following functions to the gbq module: :func:`pandas.io.gbq.table_exists`, :func:`pandas.io.gbq.create_table`, and :func:`pandas.io.gbq.delete_table`. See the :ref:`docs <io.bigquery>` for more details (:issue:`8325`).
+- ``InvalidColumnOrder`` and ``InvalidPageToken`` in the gbq module will raise ``ValueError`` instead of ``IOError``.
+
.. _whatsnew_0170.enhancements.other:
Other enhancements
@@ -1137,3 +1146,4 @@ Bug Fixes
- Bug in ``DatetimeIndex`` cannot infer negative freq (:issue:`11018`)
- Remove use of some deprecated numpy comparison operations, mainly in tests. (:issue:`10569`)
- Bug in ``Index`` dtype may not applied properly (:issue:`11017`)
+- Bug in ``io.gbq`` when testing for minimum google api client version (:issue:`10652`)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 77b8c4cf35aad..e58bd1f2fa0ff 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -811,20 +811,12 @@ def to_dict(self, orient='dict'):
else:
raise ValueError("orient '%s' not understood" % orient)
- def to_gbq(self, destination_table, project_id=None, chunksize=10000,
- verbose=True, reauth=False):
+ def to_gbq(self, destination_table, project_id, chunksize=10000,
+ verbose=True, reauth=False, if_exists='fail'):
"""Write a DataFrame to a Google BigQuery table.
THIS IS AN EXPERIMENTAL LIBRARY
- If the table exists, the dataframe will be written to the table using
- the defined table schema and column types. For simplicity, this method
- uses the Google BigQuery streaming API. The to_gbq method chunks data
- into a default chunk size of 10,000. Failures return the complete error
- response which can be quite long depending on the size of the insert.
- There are several important limitations of the Google streaming API
- which are `here <https://developers.google.com/bigquery/streaming-data-into-bigquery>`__
-
Parameters
----------
dataframe : DataFrame
@@ -840,13 +832,18 @@ def to_gbq(self, destination_table, project_id=None, chunksize=10000,
reauth : boolean (default False)
Force Google BigQuery to reauthenticate the user. This is useful
if multiple accounts are used.
+ if_exists : {'fail', 'replace', 'append'}, default 'fail'
+ 'fail': If table exists, do nothing.
+ 'replace': If table exists, drop it, recreate it, and insert data.
+ 'append': If table exists, insert data. Create if does not exist.
+ .. versionadded:: 0.17.0
"""
from pandas.io import gbq
return gbq.to_gbq(self, destination_table, project_id=project_id,
chunksize=chunksize, verbose=verbose,
- reauth=reauth)
+ reauth=reauth, if_exists=if_exists)
@classmethod
def from_records(cls, data, index=None, exclude=None, columns=None,
diff --git a/pandas/io/gbq.py b/pandas/io/gbq.py
index 1dff195e4b54f..37e7cb944814a 100644
--- a/pandas/io/gbq.py
+++ b/pandas/io/gbq.py
@@ -7,7 +7,7 @@
import numpy as np
-from distutils.version import LooseVersion
+from distutils.version import StrictVersion
from pandas import compat
from pandas.core.api import DataFrame
from pandas.tools.merge import concat
@@ -26,76 +26,101 @@ def _check_google_client_version():
_GOOGLE_API_CLIENT_VERSION = pkg_resources.get_distribution('google-api-python-client').version
- if LooseVersion(_GOOGLE_API_CLIENT_VERSION) < '1.2.0':
+ if StrictVersion(_GOOGLE_API_CLIENT_VERSION) < StrictVersion('1.2.0'):
raise ImportError("pandas requires google-api-python-client >= 1.2.0 for Google "
"BigQuery support, current version " + _GOOGLE_API_CLIENT_VERSION)
logger = logging.getLogger('pandas.io.gbq')
logger.setLevel(logging.ERROR)
-class InvalidPageToken(PandasError, IOError):
+
+class AccessDenied(PandasError, ValueError):
"""
- Raised when Google BigQuery fails to return,
- or returns a duplicate page token.
+ Raised when invalid credentials are provided, or tokens have expired.
"""
pass
-class InvalidQueryException(PandasError, IOError):
+
+class GenericGBQException(PandasError, ValueError):
"""
- Raised when a malformed query is given to read_gbq.
+ Raised when an unrecognized Google API Error occurs.
"""
pass
-class AccessDeniedException(PandasError, IOError):
+
+class InvalidColumnOrder(PandasError, ValueError):
"""
- Raised when invalid credentials are provided, or tokens have expired.
+ Raised when the provided column order for output
+ results DataFrame does not match the schema
+ returned by BigQuery.
"""
pass
-class NotFoundException(PandasError, IOError):
+
+class InvalidPageToken(PandasError, ValueError):
"""
- Raised when the project_id/table provided in the query could not be found.
+ Raised when Google BigQuery fails to return,
+ or returns a duplicate page token.
"""
pass
-class TermsOfServiceNotAcceptedException(PandasError, IOError):
+
+
+class InvalidSchema(PandasError, ValueError):
"""
- Raised when the terms of service were not accepted or have been unaccepted.
+ Raised when the provided DataFrame does
+ not match the schema of the destination
+ table in BigQuery.
"""
pass
-class UnknownGBQException(PandasError, IOError):
+
+class NotFoundException(PandasError, ValueError):
"""
- Raised when an unrecognized Google API Error occurs.
+ Raised when the project_id, table or dataset provided in the query could not be found.
"""
pass
-class InvalidColumnOrder(PandasError, IOError):
+class StreamingInsertError(PandasError, ValueError):
"""
- Raised when the provided column order for output
- results DataFrame does not match the schema
- returned by BigQuery.
+ Raised when BigQuery reports a streaming insert error.
+ For more information see `Streaming Data Into BigQuery <https://cloud.google.com/bigquery/streaming-data-into-bigquery>`__
+ """
+
+
+class TableCreationError(PandasError, ValueError):
+ """
+ Raised when the create table method fails
"""
pass
+
class GbqConnector(object):
def __init__(self, project_id, reauth=False):
+ self.test_google_api_imports()
+ self.project_id = project_id
+ self.reauth = reauth
+ self.credentials = self.get_credentials()
+ self.service = self.get_service(self.credentials)
- self.project_id = project_id
- self.reauth = reauth
- self.credentials = self.get_credentials()
- self.service = self.get_service(self.credentials)
-
- def get_credentials(self):
+ def test_google_api_imports(self):
try:
+ import httplib2
+ from apiclient.discovery import build
+ from apiclient.errors import HttpError
+ from oauth2client.client import AccessTokenRefreshError
from oauth2client.client import OAuth2WebServerFlow
from oauth2client.file import Storage
from oauth2client.tools import run_flow, argparser
+ except ImportError as e:
+ raise ImportError("Missing module required for Google BigQuery support: {0}".format(str(e)))
- except ImportError:
- raise ImportError('Could not import Google API Client.')
+ def get_credentials(self):
+ from oauth2client.client import OAuth2WebServerFlow
+ from oauth2client.file import Storage
+ from oauth2client.tools import run_flow, argparser
_check_google_client_version()
@@ -113,17 +138,8 @@ def get_credentials(self):
return credentials
def get_service(self, credentials):
- try:
- import httplib2
-
- except ImportError:
- raise ImportError("pandas requires httplib2 for Google BigQuery support")
-
- try:
- from apiclient.discovery import build
-
- except ImportError:
- raise ImportError('Could not import Google API Client.')
+ import httplib2
+ from apiclient.discovery import build
_check_google_client_version()
@@ -133,13 +149,41 @@ def get_service(self, credentials):
return bigquery_service
- def run_query(self, query):
- try:
- from apiclient.errors import HttpError
- from oauth2client.client import AccessTokenRefreshError
+ def process_http_error(self, ex):
+ # See `BigQuery Troubleshooting Errors <https://cloud.google.com/bigquery/troubleshooting-errors>`__
+
+ status = json.loads(ex.content)['error']
+ errors = status.get('errors', None)
- except ImportError:
- raise ImportError('Could not import Google API Client.')
+ if errors:
+ for error in errors:
+ reason = error['reason']
+ message = error['message']
+
+ raise GenericGBQException("Reason: {0}, Message: {1}".format(reason, message))
+
+ raise GenericGBQException(errors)
+
+ def process_insert_errors(self, insert_errors, verbose):
+ for insert_error in insert_errors:
+ row = insert_error['index']
+ errors = insert_error.get('errors', None)
+ for error in errors:
+ reason = error['reason']
+ message = error['message']
+ error_message = 'Error at Row: {0}, Reason: {1}, Message: {2}'.format(row, reason, message)
+
+ # Report all error messages if verbose is set
+ if verbose:
+ print(error_message)
+ else:
+ raise StreamingInsertError(error_message + '\nEnable verbose logging to see all errors')
+
+ raise StreamingInsertError
+
+ def run_query(self, query, verbose=True):
+ from apiclient.errors import HttpError
+ from oauth2client.client import AccessTokenRefreshError
_check_google_client_version()
@@ -148,122 +192,201 @@ def run_query(self, query):
'configuration': {
'query': {
'query': query
- #'allowLargeResults', 'createDisposition', 'preserveNulls', destinationTable, useQueryCache
+ # 'allowLargeResults', 'createDisposition', 'preserveNulls', destinationTable, useQueryCache
}
}
}
try:
- query_reply = job_collection.insert(projectId=self.project_id,
- body=job_data).execute()
- status = query_reply['status']
+ query_reply = job_collection.insert(projectId=self.project_id, body=job_data).execute()
except AccessTokenRefreshError:
- raise AccessDeniedException("The credentials have been revoked or expired, please re-run"
- "the application to re-authorize")
+ raise AccessDenied("The credentials have been revoked or expired, please re-run the application "
+ "to re-authorize")
except HttpError as ex:
- status = json.loads(ex.content)['error']
-
-
- errors = status.get('errors', None)
-
- if errors:
- reasons = [error['reason'] for error in errors]
- if 'accessDenied' in reasons:
- raise AccessDeniedException
- if 'invalidQuery' in reasons:
- raise InvalidQueryException
- if 'notFound' in reasons:
- raise NotFoundException
- if 'termsOfServiceNotAccepted' in reasons:
- raise TermsOfServiceNotAcceptedException
- else:
- raise UnknownGBQException(errors)
+ self.process_http_error(ex)
job_reference = query_reply['jobReference']
- while(not query_reply.get('jobComplete', False)):
- print('Job not yet complete...')
- query_reply = job_collection.getQueryResults(
- projectId=job_reference['projectId'],
- jobId=job_reference['jobId']).execute()
+ while not query_reply.get('jobComplete', False):
+ if verbose:
+ print('Waiting for job to complete...')
+ try:
+ query_reply = job_collection.getQueryResults(projectId=job_reference['projectId'],
+ jobId=job_reference['jobId']).execute()
+ except HttpError as ex:
+ self.process_http_error(ex)
total_rows = int(query_reply['totalRows'])
result_pages = list()
seen_page_tokens = list()
current_row = 0
- #Only read schema on first page
+ # Only read schema on first page
schema = query_reply['schema']
# Loop through each page of data
- while('rows' in query_reply and current_row < total_rows):
+ while 'rows' in query_reply and current_row < total_rows:
page = query_reply['rows']
result_pages.append(page)
current_row += len(page)
page_token = query_reply.get('pageToken', None)
if not page_token and current_row < total_rows:
- raise InvalidPageToken("Required pageToken was missing. Recieved {0} of {1} rows".format(current_row,total_rows))
+ raise InvalidPageToken("Required pageToken was missing. Recieved {0} of {1} rows".format(current_row, total_rows))
elif page_token in seen_page_tokens:
raise InvalidPageToken("A duplicate pageToken was returned")
seen_page_tokens.append(page_token)
- query_reply = job_collection.getQueryResults(
- projectId = job_reference['projectId'],
- jobId = job_reference['jobId'],
- pageToken = page_token).execute()
- if (current_row < total_rows):
+ try:
+ query_reply = job_collection.getQueryResults(
+ projectId=job_reference['projectId'],
+ jobId=job_reference['jobId'],
+ pageToken=page_token).execute()
+ except HttpError as ex:
+ self.process_http_error(ex)
+
+ if current_row < total_rows:
raise InvalidPageToken()
return schema, result_pages
def load_data(self, dataframe, dataset_id, table_id, chunksize, verbose):
+ from apiclient.errors import HttpError
+
job_id = uuid.uuid4().hex
rows = []
remaining_rows = len(dataframe)
if verbose:
total_rows = remaining_rows
- sys.stdout.write("\n\n")
- sys.stdout.flush()
+ print("\n\n")
for index, row in dataframe.reset_index(drop=True).iterrows():
row_dict = dict()
- row_dict['json'] = json.loads(row.to_json(force_ascii = False,
- date_unit = 's',
- date_format = 'iso'))
+ row_dict['json'] = json.loads(row.to_json(force_ascii=False,
+ date_unit='s',
+ date_format='iso'))
row_dict['insertId'] = job_id + str(index)
rows.append(row_dict)
remaining_rows -= 1
if (len(rows) % chunksize == 0) or (remaining_rows == 0):
if verbose:
- sys.stdout.write("\rStreaming Insert is {0}% Complete".format(((total_rows - remaining_rows) * 100) / total_rows))
- sys.stdout.flush()
+ print("\rStreaming Insert is {0}% Complete".format(((total_rows - remaining_rows) * 100) / total_rows))
body = {'rows': rows}
- response = self.service.tabledata().insertAll(
- projectId = self.project_id,
- datasetId = dataset_id,
- tableId = table_id,
- body = body).execute()
- if 'insertErrors' in response:
- raise UnknownGBQException(response)
-
- sleep(1) # Maintains the inserts "per second" rate per API
+
+ try:
+ response = self.service.tabledata().insertAll(
+ projectId = self.project_id,
+ datasetId = dataset_id,
+ tableId = table_id,
+ body = body).execute()
+ except HttpError as ex:
+ self.process_http_error(ex)
+
+ # For streaming inserts, even if you receive a success HTTP response code, you'll need to check the
+ # insertErrors property of the response to determine if the row insertions were successful, because
+ # it's possible that BigQuery was only partially successful at inserting the rows.
+ # See the `Success HTTP Response Codes <https://cloud.google.com/bigquery/streaming-data-into-bigquery#troubleshooting>`__
+ # section
+
+ insert_errors = response.get('insertErrors', None)
+ if insert_errors:
+ self.process_insert_errors(insert_errors, verbose)
+
+ sleep(1) # Maintains the inserts "per second" rate per API
rows = []
if verbose:
- sys.stdout.write("\n")
- sys.stdout.flush()
+ print("\n")
+
+ def table_exists(self, dataset_id, table_id):
+ from apiclient.errors import HttpError
+
+ try:
+ self.service.tables().get(
+ projectId=self.project_id,
+ datasetId=dataset_id,
+ tableId=table_id).execute()
+ return True
+ except HttpError as ex:
+ if ex.resp.status == 404:
+ return False
+ else:
+ self.process_http_error(ex)
+
+ def verify_schema(self, dataset_id, table_id, schema):
+ from apiclient.errors import HttpError
+
+ try:
+ return (self.service.tables().get(
+ projectId=self.project_id,
+ datasetId=dataset_id,
+ tableId=table_id
+ ).execute()['schema']) == schema
+
+ except HttpError as ex:
+ self.process_http_error(ex)
+
+ def create_table(self, dataset_id, table_id, schema):
+ from apiclient.errors import HttpError
+
+ body = {
+ 'schema': schema,
+ 'tableReference': {
+ 'tableId': table_id,
+ 'projectId': self.project_id,
+ 'datasetId': dataset_id
+ }
+ }
+
+ try:
+ self.service.tables().insert(
+ projectId=self.project_id,
+ datasetId=dataset_id,
+ body=body
+ ).execute()
+ except HttpError as ex:
+ self.process_http_error(ex)
+
+ def delete_table(self, dataset_id, table_id):
+ from apiclient.errors import HttpError
+
+ try:
+ self.service.tables().delete(
+ datasetId=dataset_id,
+ projectId=self.project_id,
+ tableId=table_id
+ ).execute()
+
+ except HttpError as ex:
+ self.process_http_error(ex)
+
+ def delete_and_recreate_table(self, dataset_id, table_id, table_schema, verbose):
+ delay = 0
+
+ # Changes to table schema may take up to 2 minutes as of May 2015
+ # See `Issue 191 <https://code.google.com/p/google-bigquery/issues/detail?id=191>`__
+ # Compare previous schema with new schema to determine if there should be a 120 second delay
+
+ if not self.verify_schema(dataset_id, table_id, table_schema):
+ if verbose:
+ print('The existing table has a different schema. Please wait 2 minutes. See Google BigQuery issue #191')
+ delay = 120
+
+ self.delete_table(dataset_id, table_id)
+ self.create_table(dataset_id, table_id, table_schema)
+
+ sleep(delay)
+
def _parse_data(schema, rows):
# see: http://pandas.pydata.org/pandas-docs/dev/missing_data.html#missing-data-casting-rules-and-indexing
dtype_map = {'INTEGER': np.dtype(float),
'FLOAT': np.dtype(float),
- 'TIMESTAMP': 'M8[ns]'} # This seems to be buggy without
- # nanosecond indicator
+ 'TIMESTAMP': 'M8[ns]'} # This seems to be buggy without nanosecond indicator
fields = schema['fields']
col_types = [field['type'] for field in fields]
@@ -281,6 +404,7 @@ def _parse_data(schema, rows):
return DataFrame(page_array, columns=col_names)
+
def _parse_entry(field_value, field_type):
if field_value is None or field_value == 'null':
return None
@@ -294,7 +418,7 @@ def _parse_entry(field_value, field_type):
return field_value
-def read_gbq(query, project_id=None, index_col=None, col_order=None, reauth=False):
+def read_gbq(query, project_id=None, index_col=None, col_order=None, reauth=False, verbose=True):
"""Load data from Google BigQuery.
THIS IS AN EXPERIMENTAL LIBRARY
@@ -319,6 +443,8 @@ def read_gbq(query, project_id=None, index_col=None, col_order=None, reauth=Fals
reauth : boolean (default False)
Force Google BigQuery to reauthenticate the user. This is useful
if multiple accounts are used.
+ verbose : boolean (default True)
+ Verbose output
Returns
-------
@@ -327,12 +453,11 @@ def read_gbq(query, project_id=None, index_col=None, col_order=None, reauth=Fals
"""
-
if not project_id:
raise TypeError("Missing required parameter: project_id")
- connector = GbqConnector(project_id, reauth = reauth)
- schema, pages = connector.run_query(query)
+ connector = GbqConnector(project_id, reauth=reauth)
+ schema, pages = connector.run_query(query, verbose=verbose)
dataframe_list = []
while len(pages) > 0:
page = pages.pop()
@@ -346,7 +471,7 @@ def read_gbq(query, project_id=None, index_col=None, col_order=None, reauth=Fals
# Reindex the DataFrame on the provided column
if index_col is not None:
if index_col in final_df.columns:
- final_df.set_index(index_col, inplace = True)
+ final_df.set_index(index_col, inplace=True)
else:
raise InvalidColumnOrder(
'Index column "{0}" does not exist in DataFrame.'
@@ -368,21 +493,13 @@ def read_gbq(query, project_id=None, index_col=None, col_order=None, reauth=Fals
final_df._data = final_df._data.downcast(dtypes='infer')
return final_df
-def to_gbq(dataframe, destination_table, project_id=None, chunksize=10000,
- verbose=True, reauth=False):
+
+def to_gbq(dataframe, destination_table, project_id, chunksize=10000,
+ verbose=True, reauth=False, if_exists='fail'):
"""Write a DataFrame to a Google BigQuery table.
THIS IS AN EXPERIMENTAL LIBRARY
- If the table exists, the dataframe will be written to the table using
- the defined table schema and column types. For simplicity, this method
- uses the Google BigQuery streaming API. The to_gbq method chunks data
- into a default chunk size of 10,000. Failures return the complete error
- response which can be quite long depending on the size of the insert.
- There are several important limitations of the Google streaming API
- which are detailed at:
- https://developers.google.com/bigquery/streaming-data-into-bigquery.
-
Parameters
----------
dataframe : DataFrame
@@ -398,22 +515,41 @@ def to_gbq(dataframe, destination_table, project_id=None, chunksize=10000,
reauth : boolean (default False)
Force Google BigQuery to reauthenticate the user. This is useful
if multiple accounts are used.
-
+ if_exists : {'fail', 'replace', 'append'}, default 'fail'
+ 'fail': If table exists, do nothing.
+ 'replace': If table exists, drop it, recreate it, and insert data.
+ 'append': If table exists, insert data. Create if does not exist.
"""
- if not project_id:
- raise TypeError("Missing required parameter: project_id")
+ if if_exists not in ('fail', 'replace', 'append'):
+ raise ValueError("'{0}' is not valid for if_exists".format(if_exists))
- if not '.' in destination_table:
+ if '.' not in destination_table:
raise NotFoundException("Invalid Table Name. Should be of the form 'datasetId.tableId' ")
- connector = GbqConnector(project_id, reauth = reauth)
- dataset_id, table_id = destination_table.rsplit('.',1)
+ connector = GbqConnector(project_id, reauth=reauth)
+ dataset_id, table_id = destination_table.rsplit('.', 1)
+
+ table_schema = generate_bq_schema(dataframe)
+
+ # If table exists, check if_exists parameter
+ if connector.table_exists(dataset_id, table_id):
+ if if_exists == 'fail':
+ raise TableCreationError("Could not create the table because it already exists. "
+ "Change the if_exists parameter to append or replace data.")
+ elif if_exists == 'replace':
+ connector.delete_and_recreate_table(dataset_id, table_id, table_schema, verbose)
+ elif if_exists == 'append':
+ if not connector.verify_schema(dataset_id, table_id, table_schema):
+ raise InvalidSchema("The schema of the destination table does not match")
+ else:
+ connector.create_table(dataset_id, table_id, table_schema)
connector.load_data(dataframe, dataset_id, table_id, chunksize, verbose)
+
def generate_bq_schema(df, default_type='STRING'):
- """ Given a passed df, generate the associated big query schema.
+ """ Given a passed df, generate the associated Google BigQuery schema.
Parameters
----------
@@ -439,3 +575,76 @@ def generate_bq_schema(df, default_type='STRING'):
'type': type_mapping.get(dtype.kind, default_type)})
return {'fields': fields}
+
+
+def table_exists(table, project_id):
+ """ Check if a table exists in Google BigQuery given a table and project id
+
+ .. versionadded:: 0.17.0
+
+ Parameters
+ ----------
+ table : str
+ Name of table to be verified, in the form 'dataset.tablename'
+ project_id : str
+ Google BigQuery Account project ID.
+
+ Returns
+ -------
+ boolean
+ true if table exists, otherwise false
+ """
+
+ if '.' not in table:
+ raise NotFoundException("Invalid Table Name. Should be of the form 'datasetId.tableId' ")
+
+ connector = GbqConnector(project_id)
+ dataset_id, table_id = table.rsplit('.', 1)
+
+ return connector.table_exists(dataset_id, table_id)
+
+
+def create_table(table, schema, project_id):
+ """ Create a table in Google BigQuery given a table, schema and project id
+
+ .. versionadded:: 0.17.0
+
+ Parameters
+ ----------
+ table : str
+ Name of table to be written, in the form 'dataset.tablename'
+ schema : str
+ Use the generate_bq_schema to generate your table schema from a dataframe.
+ project_id : str
+ Google BigQuery Account project ID.
+ """
+
+ if table_exists(table, project_id):
+ raise TableCreationError("The table could not be created because it already exists")
+
+ connector = GbqConnector(project_id)
+ dataset_id, table_id = table.rsplit('.', 1)
+
+ return connector.create_table(dataset_id, table_id, schema)
+
+
+def delete_table(table, project_id):
+ """ Delete a table in Google BigQuery given a table and project id
+
+ .. versionadded:: 0.17.0
+
+ Parameters
+ ----------
+ table : str
+ Name of table to be written, in the form 'dataset.tablename'
+ project_id : str
+ Google BigQuery Account project ID.
+ """
+
+ if not table_exists(table, project_id):
+ raise NotFoundException("Table does not exist")
+
+ connector = GbqConnector(project_id)
+ dataset_id, table_id = table.rsplit('.', 1)
+
+ return connector.delete_table(dataset_id, table_id)
diff --git a/pandas/io/tests/test_gbq.py b/pandas/io/tests/test_gbq.py
index f04eeb03f790e..990050b8ac544 100644
--- a/pandas/io/tests/test_gbq.py
+++ b/pandas/io/tests/test_gbq.py
@@ -1,5 +1,5 @@
import ast
-import datetime
+from datetime import datetime
import json
import nose
import os
@@ -12,7 +12,7 @@
import numpy as np
-from distutils.version import LooseVersion
+from distutils.version import StrictVersion
from pandas import compat
from pandas import NaT
@@ -31,13 +31,15 @@
_HTTPLIB2_INSTALLED = False
_SETUPTOOLS_INSTALLED = False
+
def missing_bq():
try:
- subprocess.call('bq')
+ subprocess.call(['bq', 'ls'])
return False
except OSError:
return True
+
def _test_imports():
if not compat.PY3:
@@ -63,7 +65,7 @@ def _test_imports():
_GOOGLE_API_CLIENT_INSTALLED=True
_GOOGLE_API_CLIENT_VERSION = pkg_resources.get_distribution('google-api-python-client').version
- if LooseVersion(_GOOGLE_API_CLIENT_VERSION) >= '1.2.0':
+ if StrictVersion(_GOOGLE_API_CLIENT_VERSION) >= StrictVersion('1.2.0'):
_GOOGLE_API_CLIENT_VALID_VERSION = True
except ImportError:
@@ -75,7 +77,6 @@ def _test_imports():
_HTTPLIB2_INSTALLED = True
except ImportError:
_HTTPLIB2_INSTALLED = False
-
if compat.PY3:
raise NotImplementedError("Google's libraries do not support Python 3 yet")
@@ -93,12 +94,24 @@ def _test_imports():
if not _HTTPLIB2_INSTALLED:
raise ImportError("pandas requires httplib2 for Google BigQuery support")
+
def test_requirements():
try:
_test_imports()
except (ImportError, NotImplementedError) as import_exception:
raise nose.SkipTest(import_exception)
+
+def make_mixed_dataframe_v2(test_size):
+ # create df to test for all BQ datatypes except RECORD
+ bools = np.random.randint(2, size=(1,test_size)).astype(bool)
+ flts = np.random.randn(1, test_size)
+ ints = np.random.randint(1, 10, size=(1,test_size))
+ strs = np.random.randint(1, 10, size=(1,test_size)).astype(str)
+ times = [datetime.now(pytz.timezone('US/Arizona')) for t in xrange(test_size)]
+ return DataFrame({'bools': bools[0], 'flts': flts[0], 'ints': ints[0], 'strs': strs[0], 'times': times[0]}, index=range(test_size))
+
+
class TestGBQConnectorIntegration(tm.TestCase):
def setUp(self):
test_requirements()
@@ -128,6 +141,7 @@ def test_should_be_able_to_get_results_from_query(self):
schema, pages = self.sut.run_query('SELECT 1')
self.assertTrue(pages is not None)
+
class TestReadGBQUnitTests(tm.TestCase):
def setUp(self):
test_requirements()
@@ -165,90 +179,116 @@ def test_read_gbq_with_no_project_id_given_should_fail(self):
gbq.read_gbq('SELECT "1" as NUMBER_1')
def test_that_parse_data_works_properly(self):
- test_schema = {'fields': [{'mode': 'NULLABLE',
- 'name': 'VALID_STRING',
- 'type': 'STRING'}]}
+ test_schema = {'fields': [{'mode': 'NULLABLE', 'name': 'VALID_STRING', 'type': 'STRING'}]}
test_page = [{'f': [{'v': 'PI'}]}]
test_output = gbq._parse_data(test_schema, test_page)
- correct_output = DataFrame({'VALID_STRING' : ['PI']})
+ correct_output = DataFrame({'VALID_STRING': ['PI']})
tm.assert_frame_equal(test_output, correct_output)
+
class TestReadGBQIntegration(tm.TestCase):
- def setUp(self):
+ @classmethod
+ def setUpClass(cls):
+ # - GLOBAL CLASS FIXTURES -
+ # put here any instruction you want to execute only *ONCE* *BEFORE* executing *ALL* tests
+ # described below.
+
test_requirements()
if not PROJECT_ID:
raise nose.SkipTest("Cannot run integration tests without a project id")
+ if missing_bq():
+ raise nose.SkipTest("Cannot run read_gbq tests without bq command line client")
+
+ subprocess.call(['bq', 'mk', PROJECT_ID + ':pydata_pandas_bq_testing'])
+
+ def setUp(self):
+ # - PER-TEST FIXTURES -
+ # put here any instruction you want to be run *BEFORE* *EVERY* test is executed.
+ pass
+
+ @classmethod
+ def tearDownClass(cls):
+ # - GLOBAL CLASS FIXTURES -
+ # put here any instruction you want to execute only *ONCE* *AFTER* executing all tests.
+ subprocess.call(['bq', 'rm', '-f', PROJECT_ID + ':pydata_pandas_bq_testing'])
+
+ def tearDown(self):
+ # - PER-TEST FIXTURES -
+ # put here any instructions you want to be run *AFTER* *EVERY* test is executed.
+ if gbq.table_exists('pydata_pandas_bq_testing.new_test', PROJECT_ID):
+ subprocess.call(['bq', 'rm', '-f', PROJECT_ID + ':pydata_pandas_bq_testing.new_test'])
+
def test_should_properly_handle_valid_strings(self):
query = 'SELECT "PI" as VALID_STRING'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'VALID_STRING' : ['PI']}))
+ tm.assert_frame_equal(df, DataFrame({'VALID_STRING': ['PI']}))
def test_should_properly_handle_empty_strings(self):
query = 'SELECT "" as EMPTY_STRING'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'EMPTY_STRING' : [""]}))
+ tm.assert_frame_equal(df, DataFrame({'EMPTY_STRING': [""]}))
def test_should_properly_handle_null_strings(self):
query = 'SELECT STRING(NULL) as NULL_STRING'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'NULL_STRING' : [None]}))
+ tm.assert_frame_equal(df, DataFrame({'NULL_STRING': [None]}))
def test_should_properly_handle_valid_integers(self):
query = 'SELECT INTEGER(3) as VALID_INTEGER'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'VALID_INTEGER' : [3]}))
+ tm.assert_frame_equal(df, DataFrame({'VALID_INTEGER': [3]}))
def test_should_properly_handle_null_integers(self):
query = 'SELECT INTEGER(NULL) as NULL_INTEGER'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'NULL_INTEGER' : [np.nan]}))
+ tm.assert_frame_equal(df, DataFrame({'NULL_INTEGER': [np.nan]}))
def test_should_properly_handle_valid_floats(self):
query = 'SELECT PI() as VALID_FLOAT'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'VALID_FLOAT' : [3.141592653589793]}))
+ tm.assert_frame_equal(df, DataFrame({'VALID_FLOAT': [3.141592653589793]}))
def test_should_properly_handle_null_floats(self):
query = 'SELECT FLOAT(NULL) as NULL_FLOAT'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'NULL_FLOAT' : [np.nan]}))
+ tm.assert_frame_equal(df, DataFrame({'NULL_FLOAT': [np.nan]}))
def test_should_properly_handle_timestamp_unix_epoch(self):
query = 'SELECT TIMESTAMP("1970-01-01 00:00:00") as UNIX_EPOCH'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'UNIX_EPOCH' : [np.datetime64('1970-01-01T00:00:00.000000Z')]}))
+ tm.assert_frame_equal(df, DataFrame({'UNIX_EPOCH': [np.datetime64('1970-01-01T00:00:00.000000Z')]}))
def test_should_properly_handle_arbitrary_timestamp(self):
query = 'SELECT TIMESTAMP("2004-09-15 05:00:00") as VALID_TIMESTAMP'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'VALID_TIMESTAMP' : [np.datetime64('2004-09-15T05:00:00.000000Z')]}))
+ tm.assert_frame_equal(df, DataFrame({'VALID_TIMESTAMP': [np.datetime64('2004-09-15T05:00:00.000000Z')]}))
def test_should_properly_handle_null_timestamp(self):
query = 'SELECT TIMESTAMP(NULL) as NULL_TIMESTAMP'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'NULL_TIMESTAMP' :[NaT]}))
+ tm.assert_frame_equal(df, DataFrame({'NULL_TIMESTAMP': [NaT]}))
def test_should_properly_handle_true_boolean(self):
query = 'SELECT BOOLEAN(TRUE) as TRUE_BOOLEAN'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'TRUE_BOOLEAN' : [True]}))
+ tm.assert_frame_equal(df, DataFrame({'TRUE_BOOLEAN': [True]}))
def test_should_properly_handle_false_boolean(self):
query = 'SELECT BOOLEAN(FALSE) as FALSE_BOOLEAN'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'FALSE_BOOLEAN' : [False]}))
+ tm.assert_frame_equal(df, DataFrame({'FALSE_BOOLEAN': [False]}))
def test_should_properly_handle_null_boolean(self):
query = 'SELECT BOOLEAN(NULL) as NULL_BOOLEAN'
df = gbq.read_gbq(query, project_id=PROJECT_ID)
- tm.assert_frame_equal(df, DataFrame({'NULL_BOOLEAN' : [None]}))
+ tm.assert_frame_equal(df, DataFrame({'NULL_BOOLEAN': [None]}))
def test_unicode_string_conversion_and_normalization(self):
correct_test_datatype = DataFrame(
- {'UNICODE_STRING' : [u("\xe9\xfc")]}
+ {'UNICODE_STRING': [u("\xe9\xfc")]}
)
query = 'SELECT "\xc3\xa9\xc3\xbc" as UNICODE_STRING'
@@ -259,35 +299,35 @@ def test_unicode_string_conversion_and_normalization(self):
def test_index_column(self):
query = "SELECT 'a' as STRING_1, 'b' as STRING_2"
result_frame = gbq.read_gbq(query, project_id=PROJECT_ID, index_col="STRING_1")
- correct_frame = DataFrame({'STRING_1' : ['a'], 'STRING_2' : ['b']}).set_index("STRING_1")
+ correct_frame = DataFrame({'STRING_1': ['a'], 'STRING_2': ['b']}).set_index("STRING_1")
tm.assert_equal(result_frame.index.name, correct_frame.index.name)
def test_column_order(self):
query = "SELECT 'a' as STRING_1, 'b' as STRING_2, 'c' as STRING_3"
col_order = ['STRING_3', 'STRING_1', 'STRING_2']
result_frame = gbq.read_gbq(query, project_id=PROJECT_ID, col_order=col_order)
- correct_frame = DataFrame({'STRING_1' : ['a'], 'STRING_2' : ['b'], 'STRING_3' : ['c']})[col_order]
+ correct_frame = DataFrame({'STRING_1': ['a'], 'STRING_2': ['b'], 'STRING_3': ['c']})[col_order]
tm.assert_frame_equal(result_frame, correct_frame)
def test_column_order_plus_index(self):
query = "SELECT 'a' as STRING_1, 'b' as STRING_2, 'c' as STRING_3"
col_order = ['STRING_3', 'STRING_2']
result_frame = gbq.read_gbq(query, project_id=PROJECT_ID, index_col='STRING_1', col_order=col_order)
- correct_frame = DataFrame({'STRING_1' : ['a'], 'STRING_2' : ['b'], 'STRING_3' : ['c']})
+ correct_frame = DataFrame({'STRING_1': ['a'], 'STRING_2': ['b'], 'STRING_3': ['c']})
correct_frame.set_index('STRING_1', inplace=True)
correct_frame = correct_frame[col_order]
tm.assert_frame_equal(result_frame, correct_frame)
def test_malformed_query(self):
- with tm.assertRaises(gbq.InvalidQueryException):
+ with tm.assertRaises(gbq.GenericGBQException):
gbq.read_gbq("SELCET * FORM [publicdata:samples.shakespeare]", project_id=PROJECT_ID)
def test_bad_project_id(self):
- with tm.assertRaises(gbq.NotFoundException):
+ with tm.assertRaises(gbq.GenericGBQException):
gbq.read_gbq("SELECT 1", project_id='001')
def test_bad_table_name(self):
- with tm.assertRaises(gbq.NotFoundException):
+ with tm.assertRaises(gbq.GenericGBQException):
gbq.read_gbq("SELECT * FROM [publicdata:samples.nope]", project_id=PROJECT_ID)
def test_download_dataset_larger_than_200k_rows(self):
@@ -304,52 +344,128 @@ def test_zero_rows(self):
class TestToGBQIntegration(tm.TestCase):
- # This class requires bq.py to be installed for setup/teardown.
- # It will also need to be preconfigured with a default dataset,
- # so, be sure to `bq init` in terminal before running.
+ # Changes to BigQuery table schema may take up to 2 minutes as of May 2015
+ # As a workaround to this issue, each test should use a unique table name.
+ # Make sure to modify the for loop range in the tearDownClass when a new test is added
+ # See `Issue 191 <https://code.google.com/p/google-bigquery/issues/detail?id=191>`__
+
+ @classmethod
+ def setUpClass(cls):
+ # - GLOBAL CLASS FIXTURES -
+ # put here any instruction you want to execute only *ONCE* *BEFORE* executing *ALL* tests
+ # described below.
- def setUp(self):
test_requirements()
if not PROJECT_ID:
raise nose.SkipTest("Cannot run integration tests without a project id")
+
if missing_bq():
raise nose.SkipTest("Cannot run to_gbq tests without bq command line client")
+ subprocess.call(['bq', 'mk', PROJECT_ID + ':pydata_pandas_bq_testing'])
+
+ def setUp(self):
+ # - PER-TEST FIXTURES -
+ # put here any instruction you want to be run *BEFORE* *EVERY* test is executed.
+ pass
+
@classmethod
- def setUpClass(cls):
- if PROJECT_ID and not missing_bq():
- subprocess.call(['bq','mk','pydata_pandas_bq_testing'])
- subprocess.call(['bq','mk','pydata_pandas_bq_testing.new_test','bools:BOOLEAN,flts:FLOAT,ints:INTEGER,strs:STRING,times:TIMESTAMP'])
+ def tearDownClass(cls):
+ # - GLOBAL CLASS FIXTURES -
+ # put here any instruction you want to execute only *ONCE* *AFTER* executing all tests.
+
+ for i in range(1, 8):
+ if gbq.table_exists('pydata_pandas_bq_testing.new_test' + str(i), PROJECT_ID):
+ subprocess.call(['bq', 'rm', '-f', PROJECT_ID + ':pydata_pandas_bq_testing.new_test' + str(i)])
+
+ subprocess.call(['bq', 'rm', '-f', PROJECT_ID + ':pydata_pandas_bq_testing'])
+
+ def tearDown(self):
+ # - PER-TEST FIXTURES -
+ # put here any instructions you want to be run *AFTER* *EVERY* test is executed.
+ pass
def test_upload_data(self):
+ table_name = 'new_test1'
+
test_size = 1000001
- #create df to test for all BQ datatypes except RECORD
- bools = np.random.randint(2, size=(1,test_size)).astype(bool)
- flts = np.random.randn(1,test_size)
- ints = np.random.randint(1,10, size=(1,test_size))
- strs = np.random.randint(1,10, size=(1,test_size)).astype(str)
- times = [datetime.datetime.now(pytz.timezone('US/Arizona')) for t in xrange(test_size)]
- df = DataFrame({'bools':bools[0], 'flts':flts[0], 'ints':ints[0], 'strs':strs[0], 'times':times[0]}, index=range(test_size))
- gbq.to_gbq(df,"pydata_pandas_bq_testing.new_test", project_id=PROJECT_ID, chunksize=10000)
- sleep(60) # <- Curses Google!!!
-
- result = gbq.read_gbq("SELECT COUNT(*) as NUM_ROWS FROM pydata_pandas_bq_testing.new_test", project_id=PROJECT_ID)
+ df = make_mixed_dataframe_v2(test_size)
+
+ gbq.to_gbq(df, "pydata_pandas_bq_testing." + table_name, PROJECT_ID, chunksize=10000)
+
+ sleep(60) # <- Curses Google!!!
+
+ result = gbq.read_gbq("SELECT COUNT(*) as NUM_ROWS FROM pydata_pandas_bq_testing." + table_name, project_id=PROJECT_ID)
self.assertEqual(result['NUM_ROWS'][0], test_size)
+ def test_upload_data_if_table_exists_fail(self):
+ table_name = 'new_test2'
+
+ test_size = 10
+ df = make_mixed_dataframe_v2(test_size)
+
+ gbq.create_table('pydata_pandas_bq_testing.' + table_name, gbq.generate_bq_schema(df), PROJECT_ID)
+
+ # Test the default value of if_exists is 'fail'
+ with tm.assertRaises(gbq.TableCreationError):
+ gbq.to_gbq(df, "pydata_pandas_bq_testing." + table_name, PROJECT_ID)
+
+ # Test the if_exists parameter with value 'fail'
+ with tm.assertRaises(gbq.TableCreationError):
+ gbq.to_gbq(df, "pydata_pandas_bq_testing." + table_name, PROJECT_ID, if_exists='fail')
+
+ def test_upload_data_if_table_exists_append(self):
+ table_name = 'new_test3'
+
+ test_size = 10
+ df = make_mixed_dataframe_v2(test_size)
+ df_different_schema = tm.makeMixedDataFrame()
+
+ # Initialize table with sample data
+ gbq.to_gbq(df, "pydata_pandas_bq_testing." + table_name, PROJECT_ID, chunksize=10000)
+
+ # Test the if_exists parameter with value 'append'
+ gbq.to_gbq(df, "pydata_pandas_bq_testing." + table_name, PROJECT_ID, if_exists='append')
+
+ sleep(60) # <- Curses Google!!!
+
+ result = gbq.read_gbq("SELECT COUNT(*) as NUM_ROWS FROM pydata_pandas_bq_testing." + table_name, project_id=PROJECT_ID)
+ self.assertEqual(result['NUM_ROWS'][0], test_size * 2)
+
+ # Try inserting with a different schema, confirm failure
+ with tm.assertRaises(gbq.InvalidSchema):
+ gbq.to_gbq(df_different_schema, "pydata_pandas_bq_testing." + table_name, PROJECT_ID, if_exists='append')
+
+ def test_upload_data_if_table_exists_replace(self):
+ table_name = 'new_test4'
+
+ test_size = 10
+ df = make_mixed_dataframe_v2(test_size)
+ df_different_schema = tm.makeMixedDataFrame()
+
+ # Initialize table with sample data
+ gbq.to_gbq(df, "pydata_pandas_bq_testing." + table_name, PROJECT_ID, chunksize=10000)
+
+ # Test the if_exists parameter with the value 'replace'.
+ gbq.to_gbq(df_different_schema, "pydata_pandas_bq_testing." + table_name, PROJECT_ID, if_exists='replace')
+
+ sleep(60) # <- Curses Google!!!
+
+ result = gbq.read_gbq("SELECT COUNT(*) as NUM_ROWS FROM pydata_pandas_bq_testing." + table_name, project_id=PROJECT_ID)
+ self.assertEqual(result['NUM_ROWS'][0], 5)
+
def test_google_upload_errors_should_raise_exception(self):
- test_timestamp = datetime.datetime.now(pytz.timezone('US/Arizona'))
- bad_df = DataFrame( {'bools': [False, False],
- 'flts': [0.0,1.0],
- 'ints': [0,'1'],
- 'strs': ['a', 1],
- 'times': [test_timestamp, test_timestamp]
- }, index=range(2))
- with tm.assertRaises(gbq.UnknownGBQException):
- gbq.to_gbq(bad_df, 'pydata_pandas_bq_testing.new_test', project_id = PROJECT_ID)
+ table_name = 'new_test5'
- def test_generate_bq_schema(self):
+ test_timestamp = datetime.now(pytz.timezone('US/Arizona'))
+ bad_df = DataFrame({'bools': [False, False], 'flts': [0.0, 1.0], 'ints': [0, '1'], 'strs': ['a', 1],
+ 'times': [test_timestamp, test_timestamp]}, index=range(2))
+
+ with tm.assertRaises(gbq.StreamingInsertError):
+ gbq.to_gbq(bad_df, 'pydata_pandas_bq_testing.' + table_name, PROJECT_ID, verbose=True)
+ def test_generate_bq_schema(self):
df = tm.makeMixedDataFrame()
schema = gbq.generate_bq_schema(df)
@@ -360,13 +476,41 @@ def test_generate_bq_schema(self):
self.assertEqual(schema, test_schema)
- @classmethod
- def tearDownClass(cls):
- if PROJECT_ID and not missing_bq():
- subprocess.call(['bq','rm','-f','pydata_pandas_bq_testing.new_test'])
- subprocess.call(['bq','rm','-f','pydata_pandas_bq_testing'])
+ def test_create_bq_table(self):
+ table_name = 'new_test6'
+
+ test_schema = {'fields': [{'name': 'A', 'type': 'FLOAT'}, {'name': 'B', 'type': 'FLOAT'},
+ {'name': 'C', 'type': 'STRING'}, {'name': 'D', 'type': 'TIMESTAMP'}]}
+
+ gbq.create_table('pydata_pandas_bq_testing.' + table_name, test_schema, PROJECT_ID)
+
+ self.assertTrue(gbq.table_exists('pydata_pandas_bq_testing.' + table_name, PROJECT_ID), 'Expected table to exist')
+
+ def test_table_does_not_exist(self):
+ table_name = 'new_test7'
+ self.assertTrue(not gbq.table_exists('pydata_pandas_bq_testing.' + table_name, PROJECT_ID),
+ 'Expected table not to exist')
+
+ def test_delete_bq_table(self):
+ table_name = 'new_test8'
+
+ test_schema = {'fields': [{'name': 'A', 'type': 'FLOAT'}, {'name': 'B', 'type': 'FLOAT'},
+ {'name': 'C', 'type': 'STRING'}, {'name': 'D', 'type': 'TIMESTAMP'}]}
+
+ gbq.create_table('pydata_pandas_bq_testing.' + table_name, test_schema, PROJECT_ID)
+
+ gbq.delete_table('pydata_pandas_bq_testing.' + table_name, PROJECT_ID)
+
+ self.assertTrue(not gbq.table_exists('pydata_pandas_bq_testing.' + table_name, PROJECT_ID),
+ 'Expected table not to exist')
+
+ def test_upload_data_dataset_not_found(self):
+ test_size = 10
+ df = make_mixed_dataframe_v2(test_size)
+
+ with tm.assertRaises(gbq.GenericGBQException):
+ gbq.create_table('pydata_pandas_bq_testing2.new_test', gbq.generate_bq_schema(df), PROJECT_ID)
if __name__ == '__main__':
nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
exit=False)
-
| closes #8325
closes #10652
- Added ability to automatically create a table using the gbq.to_gbq function if destination table does not exist
- Added `gbq.gbq_table_exists()` function to the gbq module
- Added `gbq.create_gbq_table()` function to the gbq module
| https://api.github.com/repos/pandas-dev/pandas/pulls/10857 | 2015-08-19T21:29:11Z | 2015-09-13T20:20:52Z | 2015-09-13T20:20:52Z | 2015-09-14T03:28:03Z |
DOC: fix Panel4D docstring | diff --git a/pandas/core/panel4d.py b/pandas/core/panel4d.py
index 3d480464388c8..7fafbd0eaa2b5 100644
--- a/pandas/core/panel4d.py
+++ b/pandas/core/panel4d.py
@@ -12,7 +12,9 @@
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2,
ns=dict(__doc__="""
- Represents a 4 dimensional structured
+ Panel4D is a 4-Dimensional named container very much like a Panel, but
+ having 4 named dimensions. It is intended as a test bed for more
+ N-Dimensional named containers.
Parameters
----------
| Just took this from https://github.com/pydata/pandas/blob/master/doc/source/dsintro.rst#panel4d-experimental
| https://api.github.com/repos/pandas-dev/pandas/pulls/10854 | 2015-08-19T08:55:31Z | 2015-08-19T09:21:38Z | 2015-08-19T09:21:38Z | 2015-08-19T09:47:11Z |
TST: GH10837 remove test_ujson.py reliance on dict iteration order | diff --git a/pandas/io/tests/test_json/test_ujson.py b/pandas/io/tests/test_json/test_ujson.py
index 43e1c5c89dd5e..af0a1da830c83 100644
--- a/pandas/io/tests/test_json/test_ujson.py
+++ b/pandas/io/tests/test_json/test_ujson.py
@@ -1131,22 +1131,20 @@ def testArrayNumpyLabelled(self):
self.assertTrue(output[1] is None)
self.assertTrue((np.array([u('a')]) == output[2]).all())
- # py3 is non-determinstic on the ordering......
- if not compat.PY3:
- input = [{'a': 42, 'b':31}, {'a': 24, 'c': 99}, {'a': 2.4, 'b': 78}]
- output = ujson.loads(ujson.dumps(input), numpy=True, labelled=True)
- expectedvals = np.array([42, 31, 24, 99, 2.4, 78], dtype=int).reshape((3,2))
- self.assertTrue((expectedvals == output[0]).all())
- self.assertTrue(output[1] is None)
- self.assertTrue((np.array([u('a'), 'b']) == output[2]).all())
-
-
- input = {1: {'a': 42, 'b':31}, 2: {'a': 24, 'c': 99}, 3: {'a': 2.4, 'b': 78}}
- output = ujson.loads(ujson.dumps(input), numpy=True, labelled=True)
- expectedvals = np.array([42, 31, 24, 99, 2.4, 78], dtype=int).reshape((3,2))
- self.assertTrue((expectedvals == output[0]).all())
- self.assertTrue((np.array(['1','2','3']) == output[1]).all())
- self.assertTrue((np.array(['a', 'b']) == output[2]).all())
+ # Write out the dump explicitly so there is no dependency on iteration order GH10837
+ input_dumps = '[{"a": 42, "b":31}, {"a": 24, "c": 99}, {"a": 2.4, "b": 78}]'
+ output = ujson.loads(input_dumps, numpy=True, labelled=True)
+ expectedvals = np.array([42, 31, 24, 99, 2.4, 78], dtype=int).reshape((3, 2))
+ self.assertTrue((expectedvals == output[0]).all())
+ self.assertTrue(output[1] is None)
+ self.assertTrue((np.array([u('a'), 'b']) == output[2]).all())
+
+ input_dumps = '{"1": {"a": 42, "b":31}, "2": {"a": 24, "c": 99}, "3": {"a": 2.4, "b": 78}}'
+ output = ujson.loads(input_dumps, numpy=True, labelled=True)
+ expectedvals = np.array([42, 31, 24, 99, 2.4, 78], dtype=int).reshape((3, 2))
+ self.assertTrue((expectedvals == output[0]).all())
+ self.assertTrue((np.array(['1', '2', '3']) == output[1]).all())
+ self.assertTrue((np.array(['a', 'b']) == output[2]).all())
class PandasJSONTests(TestCase):
| closes #10837
| https://api.github.com/repos/pandas-dev/pandas/pulls/10853 | 2015-08-19T03:59:44Z | 2015-08-19T10:53:27Z | 2015-08-19T10:53:27Z | 2015-08-19T10:53:32Z |
DOC: Excel formatting and searchsorted cookbook examples | diff --git a/doc/source/cookbook.rst b/doc/source/cookbook.rst
index 49ff987ca3549..9e7b9ad0b7582 100644
--- a/doc/source/cookbook.rst
+++ b/doc/source/cookbook.rst
@@ -834,6 +834,9 @@ ignore_index is needed in pandas < v0.13, and depending on df construction
`Join with a criteria based on the values
<http://stackoverflow.com/questions/15581829/how-to-perform-an-inner-or-outer-join-of-dataframes-with-pandas-on-non-simplisti>`__
+`Using searchsorted to merge based on values inside a range
+<http://stackoverflow.com/questions/25125626/pandas-merge-with-logic/2512764>`__
+
.. _cookbook.plotting:
Plotting
@@ -988,8 +991,14 @@ The :ref:`Excel <io.excel>` docs
`Reading from a filelike handle
<http://stackoverflow.com/questions/15588713/sheets-of-excel-workbook-from-a-url-into-a-pandas-dataframe>`__
+`Modifying formatting in XlsxWriter output
+<http://pbpython.com/improve-pandas-excel-output.html>`__
+
.. _cookbook.html:
+HTML
+****
+
`Reading HTML tables from a server that cannot handle the default request
header <http://stackoverflow.com/a/18939272/564538>`__
| Also added the missing `HTML` header for the one link in that section.
| https://api.github.com/repos/pandas-dev/pandas/pulls/10852 | 2015-08-19T02:55:45Z | 2015-08-19T09:12:07Z | 2015-08-19T09:12:07Z | 2015-09-07T17:15:03Z |
BUG: Error while saving DataFrame with TimedeltaIndex to .csv #10833 | diff --git a/doc/source/whatsnew/v0.17.0.txt b/doc/source/whatsnew/v0.17.0.txt
index 1079ec52338b9..e41fe592a57ae 100644
--- a/doc/source/whatsnew/v0.17.0.txt
+++ b/doc/source/whatsnew/v0.17.0.txt
@@ -678,3 +678,4 @@ Bug Fixes
- Bug in ``iloc`` allowing memory outside bounds of a Series to be accessed with negative integers (:issue:`10779`)
- Bug in ``read_msgpack`` where encoding is not respected (:issue:`10580`)
- Bug preventing access to the first index when using ``iloc`` with a list containing the appropriate negative integer (:issue:`10547`, :issue:`10779`)
+- Bug in ``TimedeltaIndex`` formatter causing error while trying to save ``DataFrame`` with ``TimedeltaIndex`` using ``to_csv`` (:issue:`10833`)
diff --git a/pandas/core/format.py b/pandas/core/format.py
index 4ec4375349764..52f3c17ebdd26 100644
--- a/pandas/core/format.py
+++ b/pandas/core/format.py
@@ -2174,7 +2174,7 @@ def __init__(self, values, nat_rep='NaT', box=False, **kwargs):
def _format_strings(self):
formatter = self.formatter or _get_format_timedelta64(self.values, nat_rep=self.nat_rep,
box=self.box)
- fmt_values = [formatter(x) for x in self.values]
+ fmt_values = np.array([formatter(x) for x in self.values])
return fmt_values
diff --git a/pandas/tests/test_frame.py b/pandas/tests/test_frame.py
index a3a57929ad931..68d6ecf33e619 100644
--- a/pandas/tests/test_frame.py
+++ b/pandas/tests/test_frame.py
@@ -6308,7 +6308,6 @@ def test_to_csv_from_csv(self):
header=['AA', 'X'])
with ensure_clean(pname) as path:
- import pandas as pd
df1 = DataFrame(np.random.randn(3, 1))
df2 = DataFrame(np.random.randn(3, 1))
@@ -6320,6 +6319,22 @@ def test_to_csv_from_csv(self):
xp.columns = lmap(int,xp.columns)
assert_frame_equal(xp,rs)
+ with ensure_clean() as path:
+ # GH 10833 (TimedeltaIndex formatting)
+ dt = pd.Timedelta(seconds=1)
+ df = pd.DataFrame({'dt_data': [i*dt for i in range(3)]},
+ index=pd.Index([i*dt for i in range(3)],
+ name='dt_index'))
+ df.to_csv(path)
+
+ result = pd.read_csv(path, index_col='dt_index')
+ result.index = pd.to_timedelta(result.index)
+ # TODO: remove renaming when GH 10875 is solved
+ result.index = result.index.rename('dt_index')
+ result['dt_data'] = pd.to_timedelta(result['dt_data'])
+
+ assert_frame_equal(df, result, check_index_type=True)
+
def test_to_csv_cols_reordering(self):
# GH3454
import pandas as pd
| Fix in accordance with https://github.com/pydata/pandas/issues/10833
| https://api.github.com/repos/pandas-dev/pandas/pulls/10845 | 2015-08-18T19:55:42Z | 2015-08-21T14:09:48Z | 2015-08-21T14:09:48Z | 2015-08-21T14:10:00Z |
DOC: Fix for #10823, updating min_periods docstring | diff --git a/pandas/stats/ols.py b/pandas/stats/ols.py
index e1951135914e9..d1d74442d8961 100644
--- a/pandas/stats/ols.py
+++ b/pandas/stats/ols.py
@@ -614,7 +614,8 @@ class MovingOLS(OLS):
size of window (for rolling/expanding OLS)
min_periods : int
Threshold of non-null data points to require.
- If None, defaults to size of window.
+ If None, defaults to size of window for window_type='rolling' and 1
+ otherwise
intercept : bool
True if you want an intercept.
nw_lags : None or int
| closes #10823
| https://api.github.com/repos/pandas-dev/pandas/pulls/10841 | 2015-08-18T02:15:46Z | 2015-08-18T10:47:43Z | 2015-08-18T10:47:43Z | 2015-08-18T10:47:48Z |
PERF: value_counts_float64 #10821 | diff --git a/doc/source/whatsnew/v0.17.0.txt b/doc/source/whatsnew/v0.17.0.txt
index 7e69a8044a305..8ae2aa1659077 100644
--- a/doc/source/whatsnew/v0.17.0.txt
+++ b/doc/source/whatsnew/v0.17.0.txt
@@ -585,7 +585,7 @@ Performance Improvements
- Improved performance of ``Series.isin`` for datetimelike/integer Series (:issue:`10287`)
- 20x improvement in ``concat`` of Categoricals when categories are identical (:issue:`10587`)
- Improved performance of ``to_datetime`` when specified format string is ISO8601 (:issue:`10178`)
-
+- 2x improvement of ``Series.value_counts`` for float dtype (:issue:`10821`)
.. _whatsnew_0170.bug_fixes:
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index b0c7ff43bc7d8..0b11a2bae3973 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -232,7 +232,7 @@ def value_counts(values, sort=True, ascending=False, normalize=False,
values = PeriodIndex(values, name=name)
values = values.view(np.int64)
- keys, counts = htable.value_count_int64(values)
+ keys, counts = htable.value_count_scalar64(values, dropna)
if dropna:
from pandas.tslib import iNaT
@@ -244,7 +244,10 @@ def value_counts(values, sort=True, ascending=False, normalize=False,
elif com.is_integer_dtype(dtype):
values = com._ensure_int64(values)
- keys, counts = htable.value_count_int64(values)
+ keys, counts = htable.value_count_scalar64(values, dropna)
+ elif com.is_float_dtype(dtype):
+ values = com._ensure_float64(values)
+ keys, counts = htable.value_count_scalar64(values, dropna)
else:
values = com._ensure_object(values)
diff --git a/pandas/core/categorical.py b/pandas/core/categorical.py
index c9e30ea31dab8..b204cba997b98 100644
--- a/pandas/core/categorical.py
+++ b/pandas/core/categorical.py
@@ -1030,7 +1030,7 @@ def value_counts(self, dropna=True):
from pandas.core.index import CategoricalIndex
cat = self.dropna() if dropna else self
- keys, counts = htable.value_count_int64(com._ensure_int64(cat._codes))
+ keys, counts = htable.value_count_scalar64(com._ensure_int64(cat._codes), dropna)
result = Series(counts, index=keys)
ix = np.arange(len(cat.categories), dtype='int64')
diff --git a/pandas/hashtable.pyx b/pandas/hashtable.pyx
index 7dbd1b45c938f..dfa7930ada62f 100644
--- a/pandas/hashtable.pyx
+++ b/pandas/hashtable.pyx
@@ -866,51 +866,90 @@ cdef class Int64Factorizer:
self.count = len(self.uniques)
return labels
-
+ctypedef fused kh_scalar64:
+ kh_int64_t
+ kh_float64_t
@cython.boundscheck(False)
-cdef build_count_table_int64(int64_t[:] values, kh_int64_t *table):
+cdef build_count_table_scalar64(sixty_four_bit_scalar[:] values,
+ kh_scalar64 *table, bint dropna):
cdef:
khiter_t k
Py_ssize_t i, n = len(values)
- int64_t val
+ sixty_four_bit_scalar val
int ret = 0
- with nogil:
- kh_resize_int64(table, n)
+ if sixty_four_bit_scalar is float64_t and kh_scalar64 is kh_float64_t:
+ with nogil:
+ kh_resize_float64(table, n)
+
+ for i in range(n):
+ val = values[i]
+ if val == val or not dropna:
+ k = kh_get_float64(table, val)
+ if k != table.n_buckets:
+ table.vals[k] += 1
+ else:
+ k = kh_put_float64(table, val, &ret)
+ table.vals[k] = 1
+ elif sixty_four_bit_scalar is int64_t and kh_scalar64 is kh_int64_t:
+ with nogil:
+ kh_resize_int64(table, n)
+
+ for i in range(n):
+ val = values[i]
+ k = kh_get_int64(table, val)
+ if k != table.n_buckets:
+ table.vals[k] += 1
+ else:
+ k = kh_put_int64(table, val, &ret)
+ table.vals[k] = 1
+ else:
+ raise ValueError("Table type must match scalar type.")
- for i in range(n):
- val = values[i]
- k = kh_get_int64(table, val)
- if k != table.n_buckets:
- table.vals[k] += 1
- else:
- k = kh_put_int64(table, val, &ret)
- table.vals[k] = 1
@cython.boundscheck(False)
-cpdef value_count_int64(int64_t[:] values):
+cpdef value_count_scalar64(sixty_four_bit_scalar[:] values, bint dropna):
cdef:
Py_ssize_t i
- kh_int64_t *table
- int64_t[:] result_keys, result_counts
+ kh_float64_t *ftable
+ kh_int64_t *itable
+ sixty_four_bit_scalar[:] result_keys
+ int64_t[:] result_counts
int k
- table = kh_init_int64()
- build_count_table_int64(values, table)
-
i = 0
- result_keys = np.empty(table.n_occupied, dtype=np.int64)
- result_counts = np.zeros(table.n_occupied, dtype=np.int64)
- with nogil:
- for k in range(table.n_buckets):
- if kh_exist_int64(table, k):
- result_keys[i] = table.keys[k]
- result_counts[i] = table.vals[k]
- i += 1
- kh_destroy_int64(table)
+ if sixty_four_bit_scalar is float64_t:
+ ftable = kh_init_float64()
+ build_count_table_scalar64(values, ftable, dropna)
+
+ result_keys = np.empty(ftable.n_occupied, dtype=np.float64)
+ result_counts = np.zeros(ftable.n_occupied, dtype=np.int64)
+
+ with nogil:
+ for k in range(ftable.n_buckets):
+ if kh_exist_float64(ftable, k):
+ result_keys[i] = ftable.keys[k]
+ result_counts[i] = ftable.vals[k]
+ i += 1
+ kh_destroy_float64(ftable)
+
+ elif sixty_four_bit_scalar is int64_t:
+ itable = kh_init_int64()
+ build_count_table_scalar64(values, itable, dropna)
+
+ result_keys = np.empty(itable.n_occupied, dtype=np.int64)
+ result_counts = np.zeros(itable.n_occupied, dtype=np.int64)
+
+ with nogil:
+ for k in range(itable.n_buckets):
+ if kh_exist_int64(itable, k):
+ result_keys[i] = itable.keys[k]
+ result_counts[i] = itable.vals[k]
+ i += 1
+ kh_destroy_int64(itable)
return np.asarray(result_keys), np.asarray(result_counts)
@@ -1002,7 +1041,7 @@ def mode_int64(int64_t[:] values):
table = kh_init_int64()
- build_count_table_int64(values, table)
+ build_count_table_scalar64(values, table, 0)
modes = np.empty(table.n_buckets, dtype=np.int64)
diff --git a/vb_suite/groupby.py b/vb_suite/groupby.py
index 73f5f19d6a626..bceb78c26e6ac 100644
--- a/vb_suite/groupby.py
+++ b/vb_suite/groupby.py
@@ -194,6 +194,15 @@ def f():
series_value_counts_strings = Benchmark('s.value_counts()', setup,
start_date=datetime(2011, 10, 21))
+#value_counts on float dtype
+
+setup = common_setup + """
+s = Series(np.random.randint(0, 1000, size=100000)).astype(float)
+"""
+
+series_value_counts_float64 = Benchmark('s.value_counts()', setup,
+ start_date=datetime(2015, 8, 17))
+
#----------------------------------------------------------------------
# pivot_table
| Adresses #10821 - I get a doubling of performance for `value_counts` for a `Series` with a float dtype. Couldn't think of any new tests needed not covered by existing [here](https://github.com/pydata/pandas/blob/master/pandas/tests/test_algos.py#L416)
```
In [1]: f = np.hstack([np.hstack(np.linspace(0,1,1000) for _ in range(1000)), np.array([np.nan] * 1000)])
...: i = range(1000) * 1001
...: df = pd.DataFrame({'f':f, 'i':i})
```
### master
```
In [2]: %timeit df['i'].value_counts()
10 loops, best of 3: 21.1 ms per loop
In [3]: %timeit df['f'].value_counts()
10 loops, best of 3: 114 ms per loop
```
### pr
```
In [3]: %timeit df['i'].value_counts()
10 loops, best of 3: 21 ms per loop
In [2]: %timeit df['f'].value_counts()
10 loops, best of 3: 56 ms per loop
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/10840 | 2015-08-18T02:13:15Z | 2015-08-18T23:37:09Z | 2015-08-18T23:37:09Z | 2015-08-19T00:53:03Z |
BUG: Panel setitem with a multiindex #10360 (partial) | diff --git a/doc/source/whatsnew/v0.17.0.txt b/doc/source/whatsnew/v0.17.0.txt
index 7e69a8044a305..3e611d00a8757 100644
--- a/doc/source/whatsnew/v0.17.0.txt
+++ b/doc/source/whatsnew/v0.17.0.txt
@@ -606,7 +606,7 @@ Bug Fixes
- Bug in ``offsets.generate_range`` where ``start`` and ``end`` have finer precision than ``offset`` (:issue:`9907`)
- Bug in ``pd.rolling_*`` where ``Series.name`` would be lost in the output (:issue:`10565`)
- Bug in ``stack`` when index or columns are not unique. (:issue:`10417`)
-
+- Bug in setting a Panel when an axis has a multi-index (:issue:`10360`)
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 8a8ee00f234fa..b8ee831cdc12c 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -201,6 +201,7 @@ def _setitem_with_indexer(self, indexer, value):
# also has the side effect of consolidating in-place
from pandas import Panel, DataFrame, Series
+ info_axis = self.obj._info_axis_number
# maybe partial set
take_split_path = self.obj._is_mixed_type
@@ -213,6 +214,16 @@ def _setitem_with_indexer(self, indexer, value):
val = list(value.values()) if isinstance(value,dict) else value
take_split_path = not blk._can_hold_element(val)
+ if isinstance(indexer, tuple) and len(indexer) == len(self.obj.axes):
+
+ for i, ax in zip(indexer, self.obj.axes):
+
+ # if we have any multi-indexes that have non-trivial slices (not null slices)
+ # then we must take the split path, xref GH 10360
+ if isinstance(ax, MultiIndex) and not (is_integer(i) or is_null_slice(i)):
+ take_split_path = True
+ break
+
if isinstance(indexer, tuple):
nindexer = []
for i, idx in enumerate(indexer):
@@ -328,14 +339,8 @@ def _setitem_with_indexer(self, indexer, value):
return self.obj.__setitem__(indexer, value)
# set
- info_axis = self.obj._info_axis_number
item_labels = self.obj._get_axis(info_axis)
- # if we have a complicated setup, take the split path
- if (isinstance(indexer, tuple) and
- any([isinstance(ax, MultiIndex) for ax in self.obj.axes])):
- take_split_path = True
-
# align and set the values
if take_split_path:
diff --git a/pandas/tests/test_indexing.py b/pandas/tests/test_indexing.py
index 2c0bfcd9b905d..ee16b44f173ec 100644
--- a/pandas/tests/test_indexing.py
+++ b/pandas/tests/test_indexing.py
@@ -411,7 +411,7 @@ def test_iloc_exceeds_bounds(self):
df.iloc[30]
self.assertRaises(IndexError, lambda : df.iloc[-30])
- # GH10779
+ # GH10779
# single positive/negative indexer exceeding Series bounds should raise an IndexError
with tm.assertRaisesRegexp(IndexError, 'single positional indexer is out-of-bounds'):
s.iloc[30]
@@ -2652,6 +2652,44 @@ def test_panel_setitem(self):
tm.assert_panel_equal(p, expected)
+ def test_panel_setitem_with_multiindex(self):
+
+ # 10360
+ # failing with a multi-index
+ arr = np.array([[[1,2,3],[0,0,0]],[[0,0,0],[0,0,0]]],dtype=np.float64)
+
+ # reg index
+ axes = dict(items=['A', 'B'], major_axis=[0, 1], minor_axis=['X', 'Y' ,'Z'])
+ p1 = Panel(0., **axes)
+ p1.iloc[0, 0, :] = [1, 2, 3]
+ expected = Panel(arr, **axes)
+ tm.assert_panel_equal(p1, expected)
+
+ # multi-indexes
+ axes['items'] = pd.MultiIndex.from_tuples([('A','a'), ('B','b')])
+ p2 = Panel(0., **axes)
+ p2.iloc[0, 0, :] = [1, 2, 3]
+ expected = Panel(arr, **axes)
+ tm.assert_panel_equal(p2, expected)
+
+ axes['major_axis']=pd.MultiIndex.from_tuples([('A',1),('A',2)])
+ p3 = Panel(0., **axes)
+ p3.iloc[0, 0, :] = [1, 2, 3]
+ expected = Panel(arr, **axes)
+ tm.assert_panel_equal(p3, expected)
+
+ axes['minor_axis']=pd.MultiIndex.from_product([['X'],range(3)])
+ p4 = Panel(0., **axes)
+ p4.iloc[0, 0, :] = [1, 2, 3]
+ expected = Panel(arr, **axes)
+ tm.assert_panel_equal(p4, expected)
+
+ arr = np.array([[[1,0,0],[2,0,0]],[[0,0,0],[0,0,0]]],dtype=np.float64)
+ p5 = Panel(0., **axes)
+ p5.iloc[0, :, 0] = [1, 2]
+ expected = Panel(arr, **axes)
+ tm.assert_panel_equal(p5, expected)
+
def test_panel_assignment(self):
# GH3777
| partial on #10360
| https://api.github.com/repos/pandas-dev/pandas/pulls/10838 | 2015-08-18T00:03:35Z | 2015-08-18T10:44:03Z | 2015-08-18T10:44:03Z | 2019-08-10T19:45:05Z |
skipped failing test on non-engish locales | diff --git a/pandas/tseries/tests/test_timeseries.py b/pandas/tseries/tests/test_timeseries.py
index 0bb385b756eb8..e02973136863d 100644
--- a/pandas/tseries/tests/test_timeseries.py
+++ b/pandas/tseries/tests/test_timeseries.py
@@ -4325,6 +4325,8 @@ def test_to_datetime_format_time(self):
self.assertEqual(to_datetime(s, format=format), dt)
def test_to_datetime_with_non_exact(self):
+ # GH 10834
+ _skip_if_has_locale()
# 8904
# exact kw
| Should fix https://github.com/pydata/pandas/issues/10834
| https://api.github.com/repos/pandas-dev/pandas/pulls/10836 | 2015-08-17T17:36:22Z | 2015-08-17T20:50:10Z | 2015-08-17T20:50:10Z | 2015-08-17T20:50:15Z |
Minor fix to error messages ('See the the caveats in the documentatio… | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 2ced2aafe2f1c..2fc288de438b3 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -1300,7 +1300,7 @@ def _check_setitem_copy(self, stacklevel=4, t='setting', force=False):
t = ("\n"
"A value is trying to be set on a copy of a slice from a "
"DataFrame\n\n"
- "See the the caveats in the documentation: "
+ "See the caveats in the documentation: "
"http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy")
else:
@@ -1308,7 +1308,7 @@ def _check_setitem_copy(self, stacklevel=4, t='setting', force=False):
"A value is trying to be set on a copy of a slice from a "
"DataFrame.\n"
"Try using .loc[row_indexer,col_indexer] = value instead\n\n"
- "See the the caveats in the documentation: "
+ "See the caveats in the documentation: "
"http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy")
if value == 'raise':
| …n...')
| https://api.github.com/repos/pandas-dev/pandas/pulls/10829 | 2015-08-16T08:37:18Z | 2015-08-16T09:54:59Z | 2015-08-16T09:54:59Z | 2015-08-16T10:46:38Z |
Backport PR #54838 on branch 2.1.x (Don't expose EA.pad_or_backfill to users + switch to DeprecationWarning) | diff --git a/doc/source/reference/extensions.rst b/doc/source/reference/extensions.rst
index eb2529716b55e..e177e2b1d87d5 100644
--- a/doc/source/reference/extensions.rst
+++ b/doc/source/reference/extensions.rst
@@ -39,6 +39,7 @@ objects.
api.extensions.ExtensionArray._from_sequence
api.extensions.ExtensionArray._from_sequence_of_strings
api.extensions.ExtensionArray._hash_pandas_object
+ api.extensions.ExtensionArray._pad_or_backfill
api.extensions.ExtensionArray._reduce
api.extensions.ExtensionArray._values_for_argsort
api.extensions.ExtensionArray._values_for_factorize
@@ -54,7 +55,6 @@ objects.
api.extensions.ExtensionArray.interpolate
api.extensions.ExtensionArray.isin
api.extensions.ExtensionArray.isna
- api.extensions.ExtensionArray.pad_or_backfill
api.extensions.ExtensionArray.ravel
api.extensions.ExtensionArray.repeat
api.extensions.ExtensionArray.searchsorted
diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 7aea1fa99f655..cec61915f342e 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -583,7 +583,7 @@ Other Deprecations
- Deprecated positional indexing on :class:`Series` with :meth:`Series.__getitem__` and :meth:`Series.__setitem__`, in a future version ``ser[item]`` will *always* interpret ``item`` as a label, not a position (:issue:`50617`)
- Deprecated replacing builtin and NumPy functions in ``.agg``, ``.apply``, and ``.transform``; use the corresponding string alias (e.g. ``"sum"`` for ``sum`` or ``np.sum``) instead (:issue:`53425`)
- Deprecated strings ``T``, ``t``, ``L`` and ``l`` denoting units in :func:`to_timedelta` (:issue:`52536`)
-- Deprecated the "method" and "limit" keywords in ``.ExtensionArray.fillna``, implement and use ``pad_or_backfill`` instead (:issue:`53621`)
+- Deprecated the "method" and "limit" keywords in ``.ExtensionArray.fillna``, implement ``_pad_or_backfill`` instead (:issue:`53621`)
- Deprecated the ``method`` and ``limit`` keywords in :meth:`DataFrame.replace` and :meth:`Series.replace` (:issue:`33302`)
- Deprecated the ``method`` and ``limit`` keywords on :meth:`Series.fillna`, :meth:`DataFrame.fillna`, :meth:`.SeriesGroupBy.fillna`, :meth:`.DataFrameGroupBy.fillna`, and :meth:`.Resampler.fillna`, use ``obj.bfill()`` or ``obj.ffill()`` instead (:issue:`53394`)
- Deprecated the behavior of :meth:`Series.__getitem__`, :meth:`Series.__setitem__`, :meth:`DataFrame.__getitem__`, :meth:`DataFrame.__setitem__` with an integer slice on objects with a floating-dtype index, in a future version this will be treated as *positional* indexing (:issue:`49612`)
diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index 359e0161e763c..6d21f4a1ac8a2 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -296,13 +296,8 @@ def _fill_mask_inplace(
func = missing.get_fill_func(method, ndim=self.ndim)
func(self._ndarray.T, limit=limit, mask=mask.T)
- def pad_or_backfill(
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
) -> Self:
mask = self.isna()
if mask.any():
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 70c59e94f6d27..19443e2069270 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -924,19 +924,14 @@ def dropna(self) -> Self:
"""
return type(self)(pc.drop_null(self._pa_array))
- def pad_or_backfill(
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | 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 not None and limit_area is not None:
+ if limit is None:
method = missing.clean_fill_method(method)
try:
if method == "pad":
@@ -952,9 +947,7 @@ 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, limit_area=limit_area, copy=copy
- )
+ return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
@doc(ExtensionArray.fillna)
def fillna(
@@ -974,7 +967,7 @@ def fillna(
return super().fillna(value=value, method=method, limit=limit, copy=copy)
if method is not None:
- return super().pad_or_backfill(method=method, limit=limit, copy=copy)
+ return super().fillna(method=method, limit=limit, copy=copy)
if isinstance(value, (np.ndarray, ExtensionArray)):
# Similar to check_value_size, but we do not mask here since we may
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 7babce46a3977..a21253db59323 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -132,7 +132,6 @@ class ExtensionArray:
interpolate
isin
isna
- pad_or_backfill
ravel
repeat
searchsorted
@@ -148,6 +147,7 @@ class ExtensionArray:
_from_sequence
_from_sequence_of_strings
_hash_pandas_object
+ _pad_or_backfill
_reduce
_values_for_argsort
_values_for_factorize
@@ -183,7 +183,7 @@ class ExtensionArray:
methods:
* fillna
- * pad_or_backfill
+ * _pad_or_backfill
* dropna
* unique
* factorize / _values_for_factorize
@@ -917,13 +917,8 @@ def interpolate(
f"{type(self).__name__} does not implement interpolate"
)
- def pad_or_backfill(
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
) -> Self:
"""
Pad or backfill values, used by Series/DataFrame ffill and bfill.
@@ -959,26 +954,26 @@ def pad_or_backfill(
Examples
--------
>>> arr = pd.array([np.nan, np.nan, 2, 3, np.nan, np.nan])
- >>> arr.pad_or_backfill(method="backfill", limit=1)
+ >>> arr._pad_or_backfill(method="backfill", limit=1)
<IntegerArray>
[<NA>, 2, 2, 3, <NA>, <NA>]
Length: 6, dtype: Int64
"""
# If a 3rd-party EA has implemented this functionality in fillna,
- # we warn that they need to implement pad_or_backfill instead.
+ # we warn that they need to implement _pad_or_backfill instead.
if (
type(self).fillna is not ExtensionArray.fillna
- and type(self).pad_or_backfill is ExtensionArray.pad_or_backfill
+ and type(self)._pad_or_backfill is ExtensionArray._pad_or_backfill
):
- # Check for pad_or_backfill here allows us to call
- # super().pad_or_backfill without getting this warning
+ # Check for _pad_or_backfill here allows us to call
+ # super()._pad_or_backfill without getting this warning
warnings.warn(
"ExtensionArray.fillna 'method' keyword is deprecated. "
- "In a future version. arr.pad_or_backfill will be called "
+ "In a future version. arr._pad_or_backfill will be called "
"instead. 3rd-party ExtensionArray authors need to implement "
- "pad_or_backfill.",
- FutureWarning,
+ "_pad_or_backfill.",
+ DeprecationWarning,
stacklevel=find_stack_level(),
)
return self.fillna(method=method, limit=limit)
@@ -1062,8 +1057,7 @@ def fillna(
if method is not None:
warnings.warn(
f"The 'method' keyword in {type(self).__name__}.fillna is "
- "deprecated and will be removed in a future version. "
- "Use pad_or_backfill instead.",
+ "deprecated and will be removed in a future version.",
FutureWarning,
stacklevel=find_stack_level(),
)
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 2fce6631afa9b..d0510ede5a366 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -890,19 +890,12 @@ def max(self, *, axis: AxisInt | None = None, skipna: bool = True) -> IntervalOr
indexer = obj.argsort()[-1]
return obj[indexer]
- def pad_or_backfill( # pylint: disable=useless-parent-delegation
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill( # pylint: disable=useless-parent-delegation
+ self, *, method: FillnaOptions, limit: int | 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, limit_area=limit_area, copy=copy
- )
+ return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
def fillna(
self, value=None, method=None, limit: int | None = None, copy: bool = True
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index bec875f2bbfa1..2cf28c28427ab 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -190,13 +190,8 @@ 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,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
) -> Self:
mask = self._mask
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index 99a3586871d10..efe0c0df45e00 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -240,7 +240,10 @@ def _values_for_factorize(self) -> tuple[np.ndarray, float | None]:
fv = np.nan
return self._ndarray, fv
- def pad_or_backfill(
+ # Base EA class (and all other EA classes) don't have limit_area keyword
+ # This can be removed here as well when the interpolate ffill/bfill method
+ # deprecation is enforced
+ def _pad_or_backfill(
self,
*,
method: FillnaOptions,
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 024cd6d4aad14..a2e4b595c42aa 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -791,20 +791,13 @@ def searchsorted(
m8arr = self._ndarray.view("M8[ns]")
return m8arr.searchsorted(npvalue, side=side, sorter=sorter)
- def pad_or_backfill(
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | 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, limit_area=limit_area, copy=copy
- )
+ result = dta._pad_or_backfill(method=method, limit=limit, copy=copy)
if copy:
return cast("Self", result.view(self.dtype))
else:
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index d32c98535d7cb..e38fa0a3bdae5 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -712,19 +712,12 @@ def isna(self):
mask[self.sp_index.indices] = isna(self.sp_values)
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,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill( # pylint: disable=useless-parent-delegation
+ self, *, method: FillnaOptions, limit: int | 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, limit_area=limit_area, copy=copy
- )
+ return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
def fillna(
self,
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index a33c5d9303421..c0b78e734b4b4 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1452,7 +1452,7 @@ def pad_or_backfill(
vals = cast(NumpyExtensionArray, self.array_values)
if axis == 1:
vals = vals.T
- new_values = vals.pad_or_backfill(
+ new_values = vals._pad_or_backfill(
method=method,
limit=limit,
limit_area=limit_area,
@@ -1955,9 +1955,9 @@ def 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(method=method, limit=limit).T
else:
- new_values = values.pad_or_backfill(method=method, limit=limit)
+ new_values = values._pad_or_backfill(method=method, limit=limit)
return [self.make_block_same_class(new_values)]
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 20530e37116f2..96aab94b24ddd 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -258,7 +258,7 @@ def test_fillna_method_doesnt_change_orig(self, method):
fill_value = arr[3] if method == "pad" else arr[5]
- result = arr.pad_or_backfill(method=method)
+ result = arr._pad_or_backfill(method=method)
assert result[4] == fill_value
# check that the original was not changed
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 8e38a8c741b8d..c2d68a79f32d4 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -497,7 +497,7 @@ def test_fillna_preserves_tz(self, method):
dtype=DatetimeTZDtype(tz="US/Central"),
)
- result = arr.pad_or_backfill(method=method)
+ result = arr._pad_or_backfill(method=method)
tm.assert_extension_array_equal(result, expected)
# assert that arr and dti were not modified in-place
@@ -510,12 +510,12 @@ def test_fillna_2d(self):
dta[0, 1] = pd.NaT
dta[1, 0] = pd.NaT
- res1 = dta.pad_or_backfill(method="pad")
+ res1 = dta._pad_or_backfill(method="pad")
expected1 = dta.copy()
expected1[1, 0] = dta[0, 0]
tm.assert_extension_array_equal(res1, expected1)
- res2 = dta.pad_or_backfill(method="backfill")
+ res2 = dta._pad_or_backfill(method="backfill")
expected2 = dta.copy()
expected2 = dta.copy()
expected2[1, 0] = dta[2, 0]
@@ -529,10 +529,10 @@ def test_fillna_2d(self):
assert not dta2._ndarray.flags["C_CONTIGUOUS"]
tm.assert_extension_array_equal(dta, dta2)
- res3 = dta2.pad_or_backfill(method="pad")
+ res3 = dta2._pad_or_backfill(method="pad")
tm.assert_extension_array_equal(res3, expected1)
- res4 = dta2.pad_or_backfill(method="backfill")
+ res4 = dta2._pad_or_backfill(method="backfill")
tm.assert_extension_array_equal(res4, expected2)
# test the DataFrame method while we're here
diff --git a/pandas/tests/extension/base/dim2.py b/pandas/tests/extension/base/dim2.py
index a0c24ee068e81..f1d787041d10b 100644
--- a/pandas/tests/extension/base/dim2.py
+++ b/pandas/tests/extension/base/dim2.py
@@ -160,9 +160,9 @@ def test_fillna_2d_method(self, data_missing, method):
assert arr[0].isna().all()
assert not arr[1].isna().any()
- result = arr.pad_or_backfill(method=method, limit=None)
+ result = arr._pad_or_backfill(method=method, limit=None)
- expected = data_missing.pad_or_backfill(method=method).repeat(2).reshape(2, 2)
+ expected = data_missing._pad_or_backfill(method=method).repeat(2).reshape(2, 2)
tm.assert_extension_array_equal(result, expected)
# Reverse so that backfill is not a no-op.
@@ -170,10 +170,10 @@ def test_fillna_2d_method(self, data_missing, method):
assert not arr2[0].isna().any()
assert arr2[1].isna().all()
- result2 = arr2.pad_or_backfill(method=method, limit=None)
+ result2 = arr2._pad_or_backfill(method=method, limit=None)
expected2 = (
- data_missing[::-1].pad_or_backfill(method=method).repeat(2).reshape(2, 2)
+ data_missing[::-1]._pad_or_backfill(method=method).repeat(2).reshape(2, 2)
)
tm.assert_extension_array_equal(result2, expected2)
diff --git a/pandas/tests/extension/base/missing.py b/pandas/tests/extension/base/missing.py
index 2a0bd0770dc07..40cc952d44200 100644
--- a/pandas/tests/extension/base/missing.py
+++ b/pandas/tests/extension/base/missing.py
@@ -94,7 +94,7 @@ def test_fillna_no_op_returns_copy(self, data):
assert result is not data
tm.assert_extension_array_equal(result, data)
- result = data.pad_or_backfill(method="backfill")
+ result = data._pad_or_backfill(method="backfill")
assert result is not data
tm.assert_extension_array_equal(result, data)
diff --git a/pandas/tests/extension/decimal/array.py b/pandas/tests/extension/decimal/array.py
index d2c3cb395ed44..9ce7ac309b6d3 100644
--- a/pandas/tests/extension/decimal/array.py
+++ b/pandas/tests/extension/decimal/array.py
@@ -285,7 +285,7 @@ def value_counts(self, dropna: bool = True):
return value_counts(self.to_numpy(), dropna=dropna)
# We override fillna here to simulate a 3rd party EA that has done so. This
- # lets us test the deprecation telling authors to implement pad_or_backfill
+ # lets us test the deprecation telling authors to implement _pad_or_backfill
# Simulate a 3rd-party EA that has not yet updated to include a "copy"
# keyword in its fillna method.
# error: Signature of "fillna" incompatible with supertype "ExtensionArray"
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index 17dfc4e801ca0..e61a2894b9aa7 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -140,26 +140,59 @@ def test_fillna_frame(self, data_missing):
def test_fillna_limit_pad(self, data_missing):
msg = "ExtensionArray.fillna 'method' keyword is deprecated"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ DeprecationWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
+ ):
+ super().test_fillna_limit_pad(data_missing)
+
+ msg = "The 'method' keyword in DecimalArray.fillna is deprecated"
+ with tm.assert_produces_warning(
+ FutureWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
):
super().test_fillna_limit_pad(data_missing)
def test_fillna_limit_backfill(self, data_missing):
- msg = "|".join(
- [
- "ExtensionArray.fillna added a 'copy' keyword",
- "Series.fillna with 'method' is deprecated",
- ]
- )
+ msg = "Series.fillna with 'method' is deprecated"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ FutureWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
):
super().test_fillna_limit_backfill(data_missing)
- def test_fillna_no_op_returns_copy(self, data):
msg = "ExtensionArray.fillna 'method' keyword is deprecated"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ DeprecationWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
+ ):
+ super().test_fillna_limit_backfill(data_missing)
+
+ msg = "The 'method' keyword in DecimalArray.fillna is deprecated"
+ with tm.assert_produces_warning(
+ FutureWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
+ ):
+ super().test_fillna_limit_backfill(data_missing)
+
+ def test_fillna_no_op_returns_copy(self, data):
+ msg = "|".join(
+ [
+ "ExtensionArray.fillna 'method' keyword is deprecated",
+ "The 'method' keyword in DecimalArray.fillna is deprecated",
+ ]
+ )
+ with tm.assert_produces_warning(
+ (FutureWarning, DeprecationWarning), match=msg, check_stacklevel=False
):
super().test_fillna_no_op_returns_copy(data)
@@ -171,9 +204,14 @@ def test_fillna_series(self, data_missing):
super().test_fillna_series(data_missing)
def test_fillna_series_method(self, data_missing, fillna_method):
- msg = "ExtensionArray.fillna 'method' keyword is deprecated"
+ msg = "|".join(
+ [
+ "ExtensionArray.fillna 'method' keyword is deprecated",
+ "The 'method' keyword in DecimalArray.fillna is deprecated",
+ ]
+ )
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ (FutureWarning, DeprecationWarning), match=msg, check_stacklevel=False
):
super().test_fillna_series_method(data_missing, fillna_method)
| Backport PR #54838: Don't expose EA.pad_or_backfill to users + switch to DeprecationWarning | https://api.github.com/repos/pandas-dev/pandas/pulls/54851 | 2023-08-29T15:52:31Z | 2023-08-29T17:54:12Z | 2023-08-29T17:54:12Z | 2023-08-29T17:54:12Z |
DOC: Add date for v2.1.0 | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 7aea1fa99f655..9ecdcc1bfe597 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -1,6 +1,6 @@
.. _whatsnew_210:
-What's new in 2.1.0 (Aug 11, 2023)
+What's new in 2.1.0 (Aug 30, 2023)
--------------------------------------
These are the changes in pandas 2.1.0. See :ref:`release` for a full changelog
@@ -890,3 +890,5 @@ Other
Contributors
~~~~~~~~~~~~
+
+.. contributors:: v2.0.3..v2.1.0|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/54850 | 2023-08-29T15:20:49Z | 2023-08-29T20:30:10Z | 2023-08-29T20:30:10Z | 2023-08-29T20:39:44Z |
Backport PR #54818 on branch 2.1.x (DEP: Deprecate passing fill_value and freq to shift) | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 7aea1fa99f655..ebb31733fe370 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -591,6 +591,7 @@ Other Deprecations
- Deprecated values ``"pad"``, ``"ffill"``, ``"bfill"``, ``"backfill"`` for :meth:`Series.interpolate` and :meth:`DataFrame.interpolate`, use ``obj.ffill()`` or ``obj.bfill()`` instead (:issue:`53581`)
- Deprecated the behavior of :meth:`Index.argmax`, :meth:`Index.argmin`, :meth:`Series.argmax`, :meth:`Series.argmin` with either all-NAs and ``skipna=True`` or any-NAs and ``skipna=False`` returning -1; in a future version this will raise ``ValueError`` (:issue:`33941`, :issue:`33942`)
- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_sql` except ``name`` and ``con`` (:issue:`54229`)
+- Deprecated silently ignoring ``fill_value`` when passing both ``freq`` and ``fill_value`` to :meth:`DataFrame.shift`, :meth:`Series.shift` and :meth:`.DataFrameGroupBy.shift`; in a future version this will raise ``ValueError`` (:issue:`53832`)
.. ---------------------------------------------------------------------------
.. _whatsnew_210.performance:
@@ -875,7 +876,6 @@ Other
- Bug in :meth:`.DataFrameGroupBy.first`, :meth:`.DataFrameGroupBy.last`, :meth:`.SeriesGroupBy.first`, and :meth:`.SeriesGroupBy.last` where an empty group would return ``np.nan`` instead of the corresponding :class:`.ExtensionArray` NA value (:issue:`39098`)
- Bug in :meth:`DataFrame.pivot_table` with casting the mean of ints back to an int (:issue:`16676`)
- Bug in :meth:`DataFrame.reindex` with a ``fill_value`` that should be inferred with a :class:`ExtensionDtype` incorrectly inferring ``object`` dtype (:issue:`52586`)
-- Bug in :meth:`DataFrame.shift` and :meth:`Series.shift` and :meth:`.DataFrameGroupBy.shift` when passing both ``freq`` and ``fill_value`` silently ignoring ``fill_value`` instead of raising ``ValueError`` (:issue:`53832`)
- Bug in :meth:`DataFrame.shift` with ``axis=1`` on a :class:`DataFrame` with a single :class:`ExtensionDtype` column giving incorrect results (:issue:`53832`)
- Bug in :meth:`Index.sort_values` when a ``key`` is passed (:issue:`52764`)
- Bug in :meth:`Series.align`, :meth:`DataFrame.align`, :meth:`Series.reindex`, :meth:`DataFrame.reindex`, :meth:`Series.interpolate`, :meth:`DataFrame.interpolate`, incorrectly failing to raise with method="asfreq" (:issue:`53620`)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index cdd0545f0a3ec..471db115da8df 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5617,10 +5617,14 @@ def shift(
) -> DataFrame:
if freq is not None and fill_value is not lib.no_default:
# GH#53832
- raise ValueError(
- "Cannot pass both 'freq' and 'fill_value' to "
- f"{type(self).__name__}.shift"
+ warnings.warn(
+ "Passing a 'freq' together with a 'fill_value' silently ignores "
+ "the fill_value and is deprecated. This will raise in a future "
+ "version.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
)
+ fill_value = lib.no_default
axis = self._get_axis_number(axis)
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index fce9b35aa5c49..f6bf51f65049a 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -10802,10 +10802,14 @@ def shift(
if freq is not None and fill_value is not lib.no_default:
# GH#53832
- raise ValueError(
- "Cannot pass both 'freq' and 'fill_value' to "
- f"{type(self).__name__}.shift"
+ warnings.warn(
+ "Passing a 'freq' together with a 'fill_value' silently ignores "
+ "the fill_value and is deprecated. This will raise in a future "
+ "version.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
)
+ fill_value = lib.no_default
if periods == 0:
return self.copy(deep=None)
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
index 808f0cff2485c..1e88152137b1f 100644
--- a/pandas/tests/frame/methods/test_shift.py
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -32,19 +32,23 @@ def test_shift_axis1_with_valid_fill_value_one_array(self):
expected2 = DataFrame([12345] * 5, dtype="Float64")
tm.assert_frame_equal(res2, expected2)
- def test_shift_disallow_freq_and_fill_value(self, frame_or_series):
+ def test_shift_deprecate_freq_and_fill_value(self, frame_or_series):
# Can't pass both!
obj = frame_or_series(
np.random.default_rng(2).standard_normal(5),
index=date_range("1/1/2000", periods=5, freq="H"),
)
- msg = "Cannot pass both 'freq' and 'fill_value' to (Series|DataFrame).shift"
- with pytest.raises(ValueError, match=msg):
+ msg = (
+ "Passing a 'freq' together with a 'fill_value' silently ignores the "
+ "fill_value"
+ )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
obj.shift(1, fill_value=1, freq="H")
if frame_or_series is DataFrame:
- with pytest.raises(ValueError, match=msg):
+ obj.columns = date_range("1/1/2000", periods=1, freq="H")
+ with tm.assert_produces_warning(FutureWarning, match=msg):
obj.shift(1, axis=1, fill_value=1, freq="H")
@pytest.mark.parametrize(
@@ -716,8 +720,11 @@ def test_shift_with_iterable_freq_and_fill_value(self):
df.shift(1, freq="H"),
)
- msg = r"Cannot pass both 'freq' and 'fill_value' to.*"
- with pytest.raises(ValueError, match=msg):
+ msg = (
+ "Passing a 'freq' together with a 'fill_value' silently ignores the "
+ "fill_value"
+ )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
df.shift([1, 2], fill_value=1, freq="H")
def test_shift_with_iterable_check_other_arguments(self):
diff --git a/pandas/tests/groupby/test_groupby_shift_diff.py b/pandas/tests/groupby/test_groupby_shift_diff.py
index 495f3fcd359c7..bb4b9aa866ac9 100644
--- a/pandas/tests/groupby/test_groupby_shift_diff.py
+++ b/pandas/tests/groupby/test_groupby_shift_diff.py
@@ -166,12 +166,14 @@ def test_shift_periods_freq():
tm.assert_frame_equal(result, expected)
-def test_shift_disallow_freq_and_fill_value():
+def test_shift_deprecate_freq_and_fill_value():
# GH 53832
data = {"a": [1, 2, 3, 4, 5, 6], "b": [0, 0, 0, 1, 1, 1]}
df = DataFrame(data, index=date_range(start="20100101", periods=6))
- msg = "Cannot pass both 'freq' and 'fill_value' to (Series|DataFrame).shift"
- with pytest.raises(ValueError, match=msg):
+ msg = (
+ "Passing a 'freq' together with a 'fill_value' silently ignores the fill_value"
+ )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
df.groupby(df.index).shift(periods=-2, freq="D", fill_value="1")
@@ -238,12 +240,15 @@ def test_group_shift_with_multiple_periods_and_fill_value():
tm.assert_frame_equal(shifted_df, expected_df)
-def test_group_shift_with_multiple_periods_and_both_fill_and_freq_fails():
+def test_group_shift_with_multiple_periods_and_both_fill_and_freq_deprecated():
# GH#44424
df = DataFrame(
{"a": [1, 2, 3, 4, 5], "b": [True, True, False, False, True]},
index=date_range("1/1/2000", periods=5, freq="H"),
)
- msg = r"Cannot pass both 'freq' and 'fill_value' to.*"
- with pytest.raises(ValueError, match=msg):
+ msg = (
+ "Passing a 'freq' together with a 'fill_value' silently ignores the "
+ "fill_value"
+ )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
df.groupby("b")[["a"]].shift([1, 2], fill_value=1, freq="H")
| Backport PR #54818: DEP: Deprecate passing fill_value and freq to shift | https://api.github.com/repos/pandas-dev/pandas/pulls/54849 | 2023-08-29T14:44:11Z | 2023-08-29T17:49:53Z | 2023-08-29T17:49:53Z | 2023-08-29T17:49:53Z |
DEPR: remove use of `nan_as_null` from callers of `__dataframe__` | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 3a4e8fdd91362..3424b990a746c 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -893,8 +893,8 @@ def __dataframe__(
Parameters
----------
nan_as_null : bool, default False
- Whether to tell the DataFrame to overwrite null values in the data
- with ``NaN`` (or ``NaT``).
+ `nan_as_null` is DEPRECATED and has no effect. Please avoid using
+ it; it will be removed in a future release.
allow_copy : bool, default True
Whether to allow memory copying when exporting. If set to False
it would cause non-zero-copy exports to fail.
@@ -909,9 +909,6 @@ def __dataframe__(
Details on the interchange protocol:
https://data-apis.org/dataframe-protocol/latest/index.html
- `nan_as_null` currently has no effect; once support for nullable extension
- dtypes is added, this value should be propagated to columns.
-
Examples
--------
>>> df_not_necessarily_pandas = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
@@ -931,7 +928,7 @@ def __dataframe__(
from pandas.core.interchange.dataframe import PandasDataFrameXchg
- return PandasDataFrameXchg(self, nan_as_null, allow_copy)
+ return PandasDataFrameXchg(self, allow_copy=allow_copy)
def __dataframe_consortium_standard__(
self, *, api_version: str | None = None
diff --git a/pandas/core/interchange/dataframe.py b/pandas/core/interchange/dataframe.py
index 0ddceb6b8139b..3413f7281de78 100644
--- a/pandas/core/interchange/dataframe.py
+++ b/pandas/core/interchange/dataframe.py
@@ -27,25 +27,20 @@ class PandasDataFrameXchg(DataFrameXchg):
attributes defined on this class.
"""
- def __init__(
- self, df: DataFrame, nan_as_null: bool = False, allow_copy: bool = True
- ) -> None:
+ 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
- # ``nan_as_null`` is a keyword intended for the consumer to tell the
- # producer to overwrite null values in the data with ``NaN`` (or ``NaT``).
- # This currently has no effect; once support for nullable extension
- # dtypes is added, this value should be propagated to columns.
- self._nan_as_null = nan_as_null
self._allow_copy = allow_copy
def __dataframe__(
self, nan_as_null: bool = False, allow_copy: bool = True
) -> PandasDataFrameXchg:
- return PandasDataFrameXchg(self._df, nan_as_null, allow_copy)
+ # `nan_as_null` can be removed here once it's removed from
+ # Dataframe.__dataframe__
+ return PandasDataFrameXchg(self._df, allow_copy)
@property
def metadata(self) -> dict[str, Index]:
@@ -84,7 +79,7 @@ def select_columns(self, indices: Sequence[int]) -> PandasDataFrameXchg:
indices = list(indices)
return PandasDataFrameXchg(
- self._df.iloc[:, indices], self._nan_as_null, self._allow_copy
+ self._df.iloc[:, indices], allow_copy=self._allow_copy
)
def select_columns_by_name(self, names: list[str]) -> PandasDataFrameXchg: # type: ignore[override] # noqa: E501
@@ -93,9 +88,7 @@ def select_columns_by_name(self, names: list[str]) -> PandasDataFrameXchg: # ty
if not isinstance(names, list):
names = list(names)
- return PandasDataFrameXchg(
- self._df.loc[:, names], self._nan_as_null, self._allow_copy
- )
+ return PandasDataFrameXchg(self._df.loc[:, names], allow_copy=self._allow_copy)
def get_chunks(self, n_chunks: int | None = None) -> Iterable[PandasDataFrameXchg]:
"""
@@ -109,8 +102,7 @@ def get_chunks(self, n_chunks: int | None = None) -> Iterable[PandasDataFrameXch
for start in range(0, step * n_chunks, step):
yield PandasDataFrameXchg(
self._df.iloc[start : start + step, :],
- self._nan_as_null,
- self._allow_copy,
+ allow_copy=self._allow_copy,
)
else:
yield self
| No one was using it yet and it seemed easier to clean it up from libraries than to ask everyone to add support for it - see https://github.com/data-apis/dataframe-api/issues/125. | https://api.github.com/repos/pandas-dev/pandas/pulls/54846 | 2023-08-29T12:53:10Z | 2023-11-17T17:02:57Z | 2023-11-17T17:02:57Z | 2023-11-17T17:02:57Z |
BUG: ArrowExtensionArray.to_numpy avoid object dtype when na_value provided | diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index e815b8292b0cc..4d887ecd1510f 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -29,12 +29,12 @@
from pandas.util._decorators import doc
from pandas.util._validators import validate_fillna_kwargs
+from pandas.core.dtypes.cast import can_hold_element
from pandas.core.dtypes.common import (
is_array_like,
is_bool_dtype,
is_integer,
is_list_like,
- is_object_dtype,
is_scalar,
)
from pandas.core.dtypes.dtypes import DatetimeTZDtype
@@ -1240,46 +1240,50 @@ def to_numpy(
) -> np.ndarray:
if dtype is not None:
dtype = np.dtype(dtype)
- elif self._hasna:
- dtype = np.dtype(object)
if na_value is lib.no_default:
na_value = self.dtype.na_value
pa_type = self._pa_array.type
+ if not self._hasna or isna(na_value) or pa.types.is_null(pa_type):
+ data = self
+ else:
+ data = self.fillna(na_value)
+ copy = False
+
if pa.types.is_timestamp(pa_type) or pa.types.is_duration(pa_type):
- result = self._maybe_convert_datelike_array()
+ result = data._maybe_convert_datelike_array()
if dtype is None or dtype.kind == "O":
result = result.to_numpy(dtype=object, na_value=na_value)
else:
result = result.to_numpy(dtype=dtype)
- return result
elif pa.types.is_time(pa_type) or pa.types.is_date(pa_type):
# convert to list of python datetime.time objects before
# wrapping in ndarray
- result = np.array(list(self), dtype=dtype)
- elif is_object_dtype(dtype) and self._hasna:
- result = np.empty(len(self), dtype=object)
- mask = ~self.isna()
- result[mask] = np.asarray(self[mask]._pa_array)
- elif pa.types.is_null(self._pa_array.type):
- fill_value = None if isna(na_value) else na_value
- return np.full(len(self), fill_value=fill_value, dtype=dtype)
- elif self._hasna:
- data = self.fillna(na_value)
+ result = np.array(list(data), dtype=dtype)
+ if data._hasna:
+ result[data.isna()] = na_value
+ elif pa.types.is_null(pa_type):
+ 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):
result = data._pa_array.to_numpy()
- if dtype is not None:
- result = result.astype(dtype, copy=False)
- return result
- else:
- result = self._pa_array.to_numpy()
if dtype is not None:
result = result.astype(dtype, copy=False)
if copy:
result = result.copy()
- return result
- if self._hasna:
- result[self.isna()] = na_value
+ else:
+ if dtype is None:
+ empty = pa.array([], type=pa_type).to_numpy(zero_copy_only=False)
+ if can_hold_element(empty, na_value):
+ dtype = empty.dtype
+ else:
+ dtype = np.object_
+ result = np.empty(len(data), dtype=dtype)
+ mask = data.isna()
+ result[mask] = na_value
+ result[~mask] = data[~mask]._pa_array.to_numpy()
return result
def unique(self) -> Self:
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
index 24d8e43708b91..89cc31ec5ecc8 100644
--- a/pandas/tests/arrays/string_/test_string.py
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -377,8 +377,16 @@ def test_astype_int(dtype):
tm.assert_numpy_array_equal(result, expected)
arr = pd.array(["1", pd.NA, "3"], dtype=dtype)
- msg = r"int\(\) argument must be a string, a bytes-like object or a( real)? number"
- with pytest.raises(TypeError, match=msg):
+ if dtype.storage == "pyarrow_numpy":
+ err = ValueError
+ msg = "cannot convert float NaN to integer"
+ else:
+ err = TypeError
+ msg = (
+ r"int\(\) argument must be a string, a bytes-like "
+ r"object or a( real)? number"
+ )
+ with pytest.raises(err, match=msg):
arr.astype("int64")
diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
index 13d80329f4d51..5f1b16a44b8e9 100644
--- a/pandas/tests/extension/test_arrow.py
+++ b/pandas/tests/extension/test_arrow.py
@@ -1595,6 +1595,19 @@ def test_to_numpy_null_array_no_dtype():
tm.assert_numpy_array_equal(result, expected)
+def test_to_numpy_without_dtype():
+ # GH 54808
+ arr = pd.array([True, pd.NA], dtype="boolean[pyarrow]")
+ result = arr.to_numpy(na_value=False)
+ expected = np.array([True, False], dtype=np.bool_)
+ tm.assert_numpy_array_equal(result, expected)
+
+ arr = pd.array([1.0, pd.NA], dtype="float32[pyarrow]")
+ result = arr.to_numpy(na_value=0.0)
+ expected = np.array([1.0, 0.0], dtype=np.float32)
+ tm.assert_numpy_array_equal(result, expected)
+
+
def test_setitem_null_slice(data):
# GH50248
orig = data.copy()
| - [x] closes #54808
- [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.
| https://api.github.com/repos/pandas-dev/pandas/pulls/54843 | 2023-08-29T11:24:18Z | 2023-09-01T16:55:50Z | 2023-09-01T16:55:50Z | 2023-09-06T00:53:47Z |
DOC: Added missing git instruction to docs on how to update environment | diff --git a/doc/source/development/contributing.rst b/doc/source/development/contributing.rst
index 247f5cb0cb62d..82af8122a6bbd 100644
--- a/doc/source/development/contributing.rst
+++ b/doc/source/development/contributing.rst
@@ -311,6 +311,7 @@ If using :ref:`mamba <contributing.mamba>`, run:
.. code-block:: shell
git checkout main
+ git fetch upstream
git merge upstream/main
mamba activate pandas-dev
mamba env update -f environment.yml --prune
@@ -320,6 +321,7 @@ If using :ref:`pip <contributing.pip>` , do:
.. code-block:: shell
git checkout main
+ git fetch upstream
git merge upstream/main
# activate the virtual environment based on your platform
python -m pip install --upgrade -r requirements-dev.txt
| - [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
I think a `git fetch` instruction is missing from [Updating the development environment](https://pandas.pydata.org/docs/dev/development/contributing.html#updating-the-development-environment)
| https://api.github.com/repos/pandas-dev/pandas/pulls/54841 | 2023-08-29T09:33:42Z | 2023-08-29T10:54:56Z | 2023-08-29T10:54:56Z | 2023-08-29T10:54:57Z |
Backport PR #54794 on branch 2.1.x (Infer string storage based on infer_string option) | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 8f2667d69a322..7aea1fa99f655 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -39,11 +39,15 @@ We are collecting feedback on this decision `here <https://github.com/pandas-dev
Avoid NumPy object dtype for strings by default
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Previously, all strings were stored in columns with NumPy object dtype.
+Previously, all strings were stored in columns with NumPy object dtype by default.
This release introduces an option ``future.infer_string`` that infers all
strings as PyArrow backed strings with dtype ``"string[pyarrow_numpy]"`` instead.
This is a new string dtype implementation that follows NumPy semantics in comparison
operations and will return ``np.nan`` as the missing value indicator.
+Setting the option will also infer the dtype ``"string"`` as a :class:`StringDtype` with
+storage set to ``"pyarrow_numpy"``, ignoring the value behind the option
+``mode.string_storage``.
+
This option only works if PyArrow is installed. PyArrow backed strings have a
significantly reduced memory footprint and provide a big performance improvement
compared to NumPy object (:issue:`54430`).
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 3af63c781d499..84a85b9e56aff 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -112,7 +112,11 @@ def na_value(self) -> libmissing.NAType | float: # type: ignore[override]
def __init__(self, storage=None) -> None:
if storage is None:
- storage = get_option("mode.string_storage")
+ infer_string = get_option("future.infer_string")
+ if infer_string:
+ storage = "pyarrow_numpy"
+ else:
+ storage = get_option("mode.string_storage")
if storage not in {"python", "pyarrow", "pyarrow_numpy"}:
raise ValueError(
f"Storage must be 'python' or 'pyarrow'. Got {storage} instead."
diff --git a/pandas/core/config_init.py b/pandas/core/config_init.py
index 745689ab1fcc8..765b24fbc7868 100644
--- a/pandas/core/config_init.py
+++ b/pandas/core/config_init.py
@@ -492,7 +492,8 @@ def use_inf_as_na_cb(key) -> None:
string_storage_doc = """
: string
- The default storage for StringDtype.
+ The default storage for StringDtype. This option is ignored if
+ ``future.infer_string`` is set to True.
"""
with cf.config_prefix("mode"):
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index ef734e9664844..2c3fdf627788a 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -2115,6 +2115,14 @@ def test_series_string_inference_array_string_dtype(self):
ser = Series(np.array(["a", "b"]))
tm.assert_series_equal(ser, expected)
+ def test_series_string_inference_storage_definition(self):
+ # GH#54793
+ pytest.importorskip("pyarrow")
+ expected = Series(["a", "b"], dtype="string[pyarrow_numpy]")
+ with pd.option_context("future.infer_string", True):
+ result = Series(["a", "b"], dtype="string")
+ tm.assert_series_equal(result, expected)
+
class TestSeriesConstructorIndexCoercion:
def test_series_constructor_datetimelike_index_coercion(self):
| Backport PR #54794: Infer string storage based on infer_string option | https://api.github.com/repos/pandas-dev/pandas/pulls/54839 | 2023-08-29T08:37:25Z | 2023-08-29T11:14:20Z | 2023-08-29T11:14:20Z | 2023-08-29T11:14:20Z |
Don't expose EA.pad_or_backfill to users + switch to DeprecationWarning | diff --git a/doc/source/reference/extensions.rst b/doc/source/reference/extensions.rst
index eb2529716b55e..e177e2b1d87d5 100644
--- a/doc/source/reference/extensions.rst
+++ b/doc/source/reference/extensions.rst
@@ -39,6 +39,7 @@ objects.
api.extensions.ExtensionArray._from_sequence
api.extensions.ExtensionArray._from_sequence_of_strings
api.extensions.ExtensionArray._hash_pandas_object
+ api.extensions.ExtensionArray._pad_or_backfill
api.extensions.ExtensionArray._reduce
api.extensions.ExtensionArray._values_for_argsort
api.extensions.ExtensionArray._values_for_factorize
@@ -54,7 +55,6 @@ objects.
api.extensions.ExtensionArray.interpolate
api.extensions.ExtensionArray.isin
api.extensions.ExtensionArray.isna
- api.extensions.ExtensionArray.pad_or_backfill
api.extensions.ExtensionArray.ravel
api.extensions.ExtensionArray.repeat
api.extensions.ExtensionArray.searchsorted
diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 8f2667d69a322..84b50ac98a759 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -579,7 +579,7 @@ Other Deprecations
- Deprecated positional indexing on :class:`Series` with :meth:`Series.__getitem__` and :meth:`Series.__setitem__`, in a future version ``ser[item]`` will *always* interpret ``item`` as a label, not a position (:issue:`50617`)
- Deprecated replacing builtin and NumPy functions in ``.agg``, ``.apply``, and ``.transform``; use the corresponding string alias (e.g. ``"sum"`` for ``sum`` or ``np.sum``) instead (:issue:`53425`)
- Deprecated strings ``T``, ``t``, ``L`` and ``l`` denoting units in :func:`to_timedelta` (:issue:`52536`)
-- Deprecated the "method" and "limit" keywords in ``.ExtensionArray.fillna``, implement and use ``pad_or_backfill`` instead (:issue:`53621`)
+- Deprecated the "method" and "limit" keywords in ``.ExtensionArray.fillna``, implement ``_pad_or_backfill`` instead (:issue:`53621`)
- Deprecated the ``method`` and ``limit`` keywords in :meth:`DataFrame.replace` and :meth:`Series.replace` (:issue:`33302`)
- Deprecated the ``method`` and ``limit`` keywords on :meth:`Series.fillna`, :meth:`DataFrame.fillna`, :meth:`.SeriesGroupBy.fillna`, :meth:`.DataFrameGroupBy.fillna`, and :meth:`.Resampler.fillna`, use ``obj.bfill()`` or ``obj.ffill()`` instead (:issue:`53394`)
- Deprecated the behavior of :meth:`Series.__getitem__`, :meth:`Series.__setitem__`, :meth:`DataFrame.__getitem__`, :meth:`DataFrame.__setitem__` with an integer slice on objects with a floating-dtype index, in a future version this will be treated as *positional* indexing (:issue:`49612`)
diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index 359e0161e763c..6d21f4a1ac8a2 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -296,13 +296,8 @@ def _fill_mask_inplace(
func = missing.get_fill_func(method, ndim=self.ndim)
func(self._ndarray.T, limit=limit, mask=mask.T)
- def pad_or_backfill(
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
) -> Self:
mask = self.isna()
if mask.any():
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 70c59e94f6d27..19443e2069270 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -924,19 +924,14 @@ def dropna(self) -> Self:
"""
return type(self)(pc.drop_null(self._pa_array))
- def pad_or_backfill(
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | 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 not None and limit_area is not None:
+ if limit is None:
method = missing.clean_fill_method(method)
try:
if method == "pad":
@@ -952,9 +947,7 @@ 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, limit_area=limit_area, copy=copy
- )
+ return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
@doc(ExtensionArray.fillna)
def fillna(
@@ -974,7 +967,7 @@ def fillna(
return super().fillna(value=value, method=method, limit=limit, copy=copy)
if method is not None:
- return super().pad_or_backfill(method=method, limit=limit, copy=copy)
+ return super().fillna(method=method, limit=limit, copy=copy)
if isinstance(value, (np.ndarray, ExtensionArray)):
# Similar to check_value_size, but we do not mask here since we may
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 3827b5b5d40b2..f3bb7323c7d5f 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -132,7 +132,6 @@ class ExtensionArray:
interpolate
isin
isna
- pad_or_backfill
ravel
repeat
searchsorted
@@ -148,6 +147,7 @@ class ExtensionArray:
_from_sequence
_from_sequence_of_strings
_hash_pandas_object
+ _pad_or_backfill
_reduce
_values_for_argsort
_values_for_factorize
@@ -183,7 +183,7 @@ class ExtensionArray:
methods:
* fillna
- * pad_or_backfill
+ * _pad_or_backfill
* dropna
* unique
* factorize / _values_for_factorize
@@ -918,13 +918,8 @@ def interpolate(
f"{type(self).__name__} does not implement interpolate"
)
- def pad_or_backfill(
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
) -> Self:
"""
Pad or backfill values, used by Series/DataFrame ffill and bfill.
@@ -960,26 +955,26 @@ def pad_or_backfill(
Examples
--------
>>> arr = pd.array([np.nan, np.nan, 2, 3, np.nan, np.nan])
- >>> arr.pad_or_backfill(method="backfill", limit=1)
+ >>> arr._pad_or_backfill(method="backfill", limit=1)
<IntegerArray>
[<NA>, 2, 2, 3, <NA>, <NA>]
Length: 6, dtype: Int64
"""
# If a 3rd-party EA has implemented this functionality in fillna,
- # we warn that they need to implement pad_or_backfill instead.
+ # we warn that they need to implement _pad_or_backfill instead.
if (
type(self).fillna is not ExtensionArray.fillna
- and type(self).pad_or_backfill is ExtensionArray.pad_or_backfill
+ and type(self)._pad_or_backfill is ExtensionArray._pad_or_backfill
):
- # Check for pad_or_backfill here allows us to call
- # super().pad_or_backfill without getting this warning
+ # Check for _pad_or_backfill here allows us to call
+ # super()._pad_or_backfill without getting this warning
warnings.warn(
"ExtensionArray.fillna 'method' keyword is deprecated. "
- "In a future version. arr.pad_or_backfill will be called "
+ "In a future version. arr._pad_or_backfill will be called "
"instead. 3rd-party ExtensionArray authors need to implement "
- "pad_or_backfill.",
- FutureWarning,
+ "_pad_or_backfill.",
+ DeprecationWarning,
stacklevel=find_stack_level(),
)
return self.fillna(method=method, limit=limit)
@@ -1063,8 +1058,7 @@ def fillna(
if method is not None:
warnings.warn(
f"The 'method' keyword in {type(self).__name__}.fillna is "
- "deprecated and will be removed in a future version. "
- "Use pad_or_backfill instead.",
+ "deprecated and will be removed in a future version.",
FutureWarning,
stacklevel=find_stack_level(),
)
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 6875ab434a5f8..73d4f6f38f102 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -890,19 +890,12 @@ def max(self, *, axis: AxisInt | None = None, skipna: bool = True) -> IntervalOr
indexer = obj.argsort()[-1]
return obj[indexer]
- def pad_or_backfill( # pylint: disable=useless-parent-delegation
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill( # pylint: disable=useless-parent-delegation
+ self, *, method: FillnaOptions, limit: int | 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, limit_area=limit_area, copy=copy
- )
+ return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
def fillna(
self, value=None, method=None, limit: int | None = None, copy: bool = True
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index bec875f2bbfa1..2cf28c28427ab 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -190,13 +190,8 @@ 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,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
) -> Self:
mask = self._mask
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index 99a3586871d10..efe0c0df45e00 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -240,7 +240,10 @@ def _values_for_factorize(self) -> tuple[np.ndarray, float | None]:
fv = np.nan
return self._ndarray, fv
- def pad_or_backfill(
+ # Base EA class (and all other EA classes) don't have limit_area keyword
+ # This can be removed here as well when the interpolate ffill/bfill method
+ # deprecation is enforced
+ def _pad_or_backfill(
self,
*,
method: FillnaOptions,
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 024cd6d4aad14..a2e4b595c42aa 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -791,20 +791,13 @@ def searchsorted(
m8arr = self._ndarray.view("M8[ns]")
return m8arr.searchsorted(npvalue, side=side, sorter=sorter)
- def pad_or_backfill(
- self,
- *,
- method: FillnaOptions,
- limit: int | None = None,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill(
+ self, *, method: FillnaOptions, limit: int | 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, limit_area=limit_area, copy=copy
- )
+ result = dta._pad_or_backfill(method=method, limit=limit, copy=copy)
if copy:
return cast("Self", result.view(self.dtype))
else:
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index d32c98535d7cb..e38fa0a3bdae5 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -712,19 +712,12 @@ def isna(self):
mask[self.sp_index.indices] = isna(self.sp_values)
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,
- limit_area: Literal["inside", "outside"] | None = None,
- copy: bool = True,
+ def _pad_or_backfill( # pylint: disable=useless-parent-delegation
+ self, *, method: FillnaOptions, limit: int | 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, limit_area=limit_area, copy=copy
- )
+ return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
def fillna(
self,
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 3b27f7e2eb80c..43f4f527afc3a 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1451,7 +1451,7 @@ def pad_or_backfill(
vals = cast(NumpyExtensionArray, self.array_values)
if axis == 1:
vals = vals.T
- new_values = vals.pad_or_backfill(
+ new_values = vals._pad_or_backfill(
method=method,
limit=limit,
limit_area=limit_area,
@@ -1948,9 +1948,9 @@ def 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(method=method, limit=limit).T
else:
- new_values = values.pad_or_backfill(method=method, limit=limit)
+ new_values = values._pad_or_backfill(method=method, limit=limit)
return [self.make_block_same_class(new_values)]
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 20530e37116f2..96aab94b24ddd 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -258,7 +258,7 @@ def test_fillna_method_doesnt_change_orig(self, method):
fill_value = arr[3] if method == "pad" else arr[5]
- result = arr.pad_or_backfill(method=method)
+ result = arr._pad_or_backfill(method=method)
assert result[4] == fill_value
# check that the original was not changed
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 8e38a8c741b8d..c2d68a79f32d4 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -497,7 +497,7 @@ def test_fillna_preserves_tz(self, method):
dtype=DatetimeTZDtype(tz="US/Central"),
)
- result = arr.pad_or_backfill(method=method)
+ result = arr._pad_or_backfill(method=method)
tm.assert_extension_array_equal(result, expected)
# assert that arr and dti were not modified in-place
@@ -510,12 +510,12 @@ def test_fillna_2d(self):
dta[0, 1] = pd.NaT
dta[1, 0] = pd.NaT
- res1 = dta.pad_or_backfill(method="pad")
+ res1 = dta._pad_or_backfill(method="pad")
expected1 = dta.copy()
expected1[1, 0] = dta[0, 0]
tm.assert_extension_array_equal(res1, expected1)
- res2 = dta.pad_or_backfill(method="backfill")
+ res2 = dta._pad_or_backfill(method="backfill")
expected2 = dta.copy()
expected2 = dta.copy()
expected2[1, 0] = dta[2, 0]
@@ -529,10 +529,10 @@ def test_fillna_2d(self):
assert not dta2._ndarray.flags["C_CONTIGUOUS"]
tm.assert_extension_array_equal(dta, dta2)
- res3 = dta2.pad_or_backfill(method="pad")
+ res3 = dta2._pad_or_backfill(method="pad")
tm.assert_extension_array_equal(res3, expected1)
- res4 = dta2.pad_or_backfill(method="backfill")
+ res4 = dta2._pad_or_backfill(method="backfill")
tm.assert_extension_array_equal(res4, expected2)
# test the DataFrame method while we're here
diff --git a/pandas/tests/extension/base/dim2.py b/pandas/tests/extension/base/dim2.py
index a0c24ee068e81..f1d787041d10b 100644
--- a/pandas/tests/extension/base/dim2.py
+++ b/pandas/tests/extension/base/dim2.py
@@ -160,9 +160,9 @@ def test_fillna_2d_method(self, data_missing, method):
assert arr[0].isna().all()
assert not arr[1].isna().any()
- result = arr.pad_or_backfill(method=method, limit=None)
+ result = arr._pad_or_backfill(method=method, limit=None)
- expected = data_missing.pad_or_backfill(method=method).repeat(2).reshape(2, 2)
+ expected = data_missing._pad_or_backfill(method=method).repeat(2).reshape(2, 2)
tm.assert_extension_array_equal(result, expected)
# Reverse so that backfill is not a no-op.
@@ -170,10 +170,10 @@ def test_fillna_2d_method(self, data_missing, method):
assert not arr2[0].isna().any()
assert arr2[1].isna().all()
- result2 = arr2.pad_or_backfill(method=method, limit=None)
+ result2 = arr2._pad_or_backfill(method=method, limit=None)
expected2 = (
- data_missing[::-1].pad_or_backfill(method=method).repeat(2).reshape(2, 2)
+ data_missing[::-1]._pad_or_backfill(method=method).repeat(2).reshape(2, 2)
)
tm.assert_extension_array_equal(result2, expected2)
diff --git a/pandas/tests/extension/base/missing.py b/pandas/tests/extension/base/missing.py
index 2a0bd0770dc07..40cc952d44200 100644
--- a/pandas/tests/extension/base/missing.py
+++ b/pandas/tests/extension/base/missing.py
@@ -94,7 +94,7 @@ def test_fillna_no_op_returns_copy(self, data):
assert result is not data
tm.assert_extension_array_equal(result, data)
- result = data.pad_or_backfill(method="backfill")
+ result = data._pad_or_backfill(method="backfill")
assert result is not data
tm.assert_extension_array_equal(result, data)
diff --git a/pandas/tests/extension/decimal/array.py b/pandas/tests/extension/decimal/array.py
index d2c3cb395ed44..9ce7ac309b6d3 100644
--- a/pandas/tests/extension/decimal/array.py
+++ b/pandas/tests/extension/decimal/array.py
@@ -285,7 +285,7 @@ def value_counts(self, dropna: bool = True):
return value_counts(self.to_numpy(), dropna=dropna)
# We override fillna here to simulate a 3rd party EA that has done so. This
- # lets us test the deprecation telling authors to implement pad_or_backfill
+ # lets us test the deprecation telling authors to implement _pad_or_backfill
# Simulate a 3rd-party EA that has not yet updated to include a "copy"
# keyword in its fillna method.
# error: Signature of "fillna" incompatible with supertype "ExtensionArray"
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index acc82ecd9301a..8dbd1c4c511d0 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -140,26 +140,59 @@ def test_fillna_frame(self, data_missing):
def test_fillna_limit_pad(self, data_missing):
msg = "ExtensionArray.fillna 'method' keyword is deprecated"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ DeprecationWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
+ ):
+ super().test_fillna_limit_pad(data_missing)
+
+ msg = "The 'method' keyword in DecimalArray.fillna is deprecated"
+ with tm.assert_produces_warning(
+ FutureWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
):
super().test_fillna_limit_pad(data_missing)
def test_fillna_limit_backfill(self, data_missing):
- msg = "|".join(
- [
- "ExtensionArray.fillna added a 'copy' keyword",
- "Series.fillna with 'method' is deprecated",
- ]
- )
+ msg = "Series.fillna with 'method' is deprecated"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ FutureWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
):
super().test_fillna_limit_backfill(data_missing)
- def test_fillna_no_op_returns_copy(self, data):
msg = "ExtensionArray.fillna 'method' keyword is deprecated"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ DeprecationWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
+ ):
+ super().test_fillna_limit_backfill(data_missing)
+
+ msg = "The 'method' keyword in DecimalArray.fillna is deprecated"
+ with tm.assert_produces_warning(
+ FutureWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
+ ):
+ super().test_fillna_limit_backfill(data_missing)
+
+ def test_fillna_no_op_returns_copy(self, data):
+ msg = "|".join(
+ [
+ "ExtensionArray.fillna 'method' keyword is deprecated",
+ "The 'method' keyword in DecimalArray.fillna is deprecated",
+ ]
+ )
+ with tm.assert_produces_warning(
+ (FutureWarning, DeprecationWarning), match=msg, check_stacklevel=False
):
super().test_fillna_no_op_returns_copy(data)
@@ -171,9 +204,14 @@ def test_fillna_series(self, data_missing):
super().test_fillna_series(data_missing)
def test_fillna_series_method(self, data_missing, fillna_method):
- msg = "ExtensionArray.fillna 'method' keyword is deprecated"
+ msg = "|".join(
+ [
+ "ExtensionArray.fillna 'method' keyword is deprecated",
+ "The 'method' keyword in DecimalArray.fillna is deprecated",
+ ]
+ )
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ (FutureWarning, DeprecationWarning), match=msg, check_stacklevel=False
):
super().test_fillna_series_method(data_missing, fillna_method)
| Closes #54831
This does:
- Rename `ExtensionArray.pad_or_backfill` to `ExtensionArray._pad_or_backfill` (added underscore -> this is only a method that needs to be implemented by developers (EA authors), and not be called by or visible to users)
- Changed the warning in `_pad_or_backfill` for when the EA still only has `fillna` with method to a DeprecationWarning, since this is targetting EA authors, we can avoid that initially users see the warning
- Removed `limit_area` keyword from `ExtensionArray._pad_or_backfill` signature, since it is unused (for all EAs except for numy dtypes). Removing it now because otherwise removing it later can give compatibility problems with third party EAs (and then it would need to be deprecated)
- Fixed a bug in the Arrow array implementation | https://api.github.com/repos/pandas-dev/pandas/pulls/54838 | 2023-08-29T08:28:39Z | 2023-08-29T15:52:21Z | 2023-08-29T15:52:21Z | 2023-08-30T13:26:34Z |
TST: added test for missing categories for `value_counts` | diff --git a/pandas/tests/frame/methods/test_value_counts.py b/pandas/tests/frame/methods/test_value_counts.py
index c05a929360478..f30db91f82b60 100644
--- a/pandas/tests/frame/methods/test_value_counts.py
+++ b/pandas/tests/frame/methods/test_value_counts.py
@@ -189,3 +189,17 @@ def test_value_counts_categorical_future_warning():
name="count",
)
tm.assert_series_equal(result, expected)
+
+
+def test_value_counts_with_missing_category():
+ # GH-54836
+ df = pd.DataFrame({"a": pd.Categorical([1, 2, 4], categories=[1, 2, 3, 4])})
+ result = df.value_counts()
+ expected = pd.Series(
+ [1, 1, 1, 0],
+ index=pd.MultiIndex.from_arrays(
+ [pd.CategoricalIndex([1, 2, 4, 3], categories=[1, 2, 3, 4], name="a")]
+ ),
+ name="count",
+ )
+ tm.assert_series_equal(result, expected)
| - [x] closes #54836
- [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). | https://api.github.com/repos/pandas-dev/pandas/pulls/54837 | 2023-08-29T06:55:12Z | 2023-08-31T20:58:07Z | 2023-08-31T20:58:07Z | 2023-09-01T04:33:56Z |
PERF: lexsort_indexer (MultiIndex / multi-column sorting) | diff --git a/asv_bench/benchmarks/frame_methods.py b/asv_bench/benchmarks/frame_methods.py
index 96fe90ce08c5f..8e0bffd7b8ece 100644
--- a/asv_bench/benchmarks/frame_methods.py
+++ b/asv_bench/benchmarks/frame_methods.py
@@ -693,20 +693,24 @@ def time_frame_sort_values(self, ascending):
self.df.sort_values(by="A", ascending=ascending)
-class SortIndexByColumns:
+class SortMultiKey:
def setup(self):
N = 10000
K = 10
- self.df = DataFrame(
+ self.df_by_columns = DataFrame(
{
"key1": tm.makeStringIndex(N).values.repeat(K),
"key2": tm.makeStringIndex(N).values.repeat(K),
"value": np.random.randn(N * K),
}
)
+ self.df_by_index = self.df_by_columns.set_index(["key1", "key2"])
+
+ def time_sort_values(self):
+ self.df_by_columns.sort_values(by=["key1", "key2"])
- def time_frame_sort_values_by_columns(self):
- self.df.sort_values(by=["key1", "key2"])
+ def time_sort_index(self):
+ self.df_by_index.sort_index()
class Quantile:
diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index e49436c4ed549..621c9159a5fe8 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -157,6 +157,7 @@ Deprecations
Performance improvements
~~~~~~~~~~~~~~~~~~~~~~~~
+- Performance improvement in :meth:`DataFrame.sort_index` and :meth:`Series.sort_index` when indexed by a :class:`MultiIndex` (:issue:`54835`)
- Performance improvement when indexing with more than 4 keys (:issue:`54550`)
-
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index ae0ab66dd5f3e..bcb1392b5e7a7 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -2208,17 +2208,9 @@ def append(self, other):
def argsort(
self, *args, na_position: str = "last", **kwargs
) -> npt.NDArray[np.intp]:
- if len(args) == 0 and len(kwargs) == 0:
- # lexsort is significantly faster than self._values.argsort()
- target = self._sort_levels_monotonic(raise_if_incomparable=True)
- return lexsort_indexer(
- # error: Argument 1 to "lexsort_indexer" has incompatible type
- # "List[Categorical]"; expected "Union[List[Union[ExtensionArray,
- # ndarray[Any, Any]]], List[Series]]"
- target._get_codes_for_sorting(), # type: ignore[arg-type]
- na_position=na_position,
- )
- return self._values.argsort(*args, **kwargs)
+ target = self._sort_levels_monotonic(raise_if_incomparable=True)
+ keys = [lev.codes for lev in target._get_codes_for_sorting()]
+ return lexsort_indexer(keys, na_position=na_position, codes_given=True)
@Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
def repeat(self, repeats: int, axis=None) -> MultiIndex:
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
index bc6e29c3c7fbf..485644339414f 100644
--- a/pandas/core/sorting.py
+++ b/pandas/core/sorting.py
@@ -99,8 +99,9 @@ def get_indexer_indexer(
na_position=na_position,
)
elif isinstance(target, ABCMultiIndex):
+ codes = [lev.codes for lev in target._get_codes_for_sorting()]
indexer = lexsort_indexer(
- target.codes, orders=ascending, na_position=na_position, codes_given=True
+ codes, orders=ascending, na_position=na_position, codes_given=True
)
else:
# Check monotonic-ness before sort an index (GH 11080)
@@ -298,22 +299,8 @@ def decons_obs_group_ids(
return [lab[indexer].astype(np.intp, subok=False, copy=True) for lab in labels]
-def indexer_from_factorized(
- labels, shape: Shape, compress: bool = True
-) -> npt.NDArray[np.intp]:
- ids = get_group_index(labels, shape, sort=True, xnull=False)
-
- if not compress:
- ngroups = (ids.size and ids.max()) + 1
- else:
- ids, obs = compress_group_index(ids, sort=True)
- ngroups = len(obs)
-
- return get_group_index_sorter(ids, ngroups)
-
-
def lexsort_indexer(
- keys: list[ArrayLike] | list[Series],
+ keys: Sequence[ArrayLike | Index | Series],
orders=None,
na_position: str = "last",
key: Callable | None = None,
@@ -324,9 +311,9 @@ def lexsort_indexer(
Parameters
----------
- keys : list[ArrayLike] | list[Series]
- Sequence of ndarrays to be sorted by the indexer
- list[Series] is only if key is not None.
+ keys : Sequence[ArrayLike | Index | Series]
+ Sequence of arrays to be sorted by the indexer
+ Sequence[Series] is only if key is not None.
orders : bool or list of booleans, optional
Determines the sorting order for each element in keys. If a list,
it must be the same length as keys. This determines whether the
@@ -346,83 +333,38 @@ def lexsort_indexer(
"""
from pandas.core.arrays import Categorical
- labels = []
- shape = []
+ if na_position not in ["last", "first"]:
+ raise ValueError(f"invalid na_position: {na_position}")
+
if isinstance(orders, bool):
orders = [orders] * len(keys)
elif orders is None:
orders = [True] * len(keys)
- # error: Incompatible types in assignment (expression has type
- # "List[Union[ExtensionArray, ndarray[Any, Any], Index, Series]]", variable
- # has type "Union[List[Union[ExtensionArray, ndarray[Any, Any]]], List[Series]]")
- keys = [ensure_key_mapped(k, key) for k in keys] # type: ignore[assignment]
+ labels = []
for k, order in zip(keys, orders):
- if na_position not in ["last", "first"]:
- raise ValueError(f"invalid na_position: {na_position}")
-
+ k = ensure_key_mapped(k, key)
if codes_given:
- mask = k == -1
- codes = k.copy()
- n = len(codes)
- mask_n = n
- # error: Item "ExtensionArray" of "Union[Any, ExtensionArray,
- # ndarray[Any, Any]]" has no attribute "any"
- if mask.any(): # type: ignore[union-attr]
- n -= 1
-
+ codes = cast(np.ndarray, k)
+ n = codes.max() + 1 if len(codes) else 0
else:
cat = Categorical(k, ordered=True)
+ codes = cat.codes
n = len(cat.categories)
- codes = cat.codes.copy()
- mask = cat.codes == -1
- if mask.any():
- mask_n = n + 1
- else:
- mask_n = n
-
- if order: # ascending
- if na_position == "last":
- # error: Argument 1 to "where" has incompatible type "Union[Any,
- # ExtensionArray, ndarray[Any, Any]]"; expected
- # "Union[_SupportsArray[dtype[Any]],
- # _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float,
- # complex, str, bytes, _NestedSequence[Union[bool, int, float,
- # complex, str, bytes]]]"
- codes = np.where(mask, n, codes) # type: ignore[arg-type]
- elif na_position == "first":
- # error: Incompatible types in assignment (expression has type
- # "Union[Any, int, ndarray[Any, dtype[signedinteger[Any]]]]",
- # variable has type "Union[Series, ExtensionArray, ndarray[Any, Any]]")
- # error: Unsupported operand types for + ("ExtensionArray" and "int")
- codes += 1 # type: ignore[operator,assignment]
- else: # not order means descending
- if na_position == "last":
- # error: Unsupported operand types for - ("int" and "ExtensionArray")
- # error: Argument 1 to "where" has incompatible type "Union[Any,
- # ExtensionArray, ndarray[Any, Any]]"; expected
- # "Union[_SupportsArray[dtype[Any]],
- # _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float,
- # complex, str, bytes, _NestedSequence[Union[bool, int, float,
- # complex, str, bytes]]]"
- codes = np.where(
- mask, n, n - codes - 1 # type: ignore[operator,arg-type]
- )
- elif na_position == "first":
- # error: Unsupported operand types for - ("int" and "ExtensionArray")
- # error: Argument 1 to "where" has incompatible type "Union[Any,
- # ExtensionArray, ndarray[Any, Any]]"; expected
- # "Union[_SupportsArray[dtype[Any]],
- # _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float,
- # complex, str, bytes, _NestedSequence[Union[bool, int, float,
- # complex, str, bytes]]]"
- codes = np.where(mask, 0, n - codes) # type: ignore[operator,arg-type]
-
- shape.append(mask_n)
+
+ mask = codes == -1
+
+ if na_position == "last" and mask.any():
+ codes = np.where(mask, n, codes)
+
+ # not order means descending
+ if not order:
+ codes = np.where(mask, codes, n - codes - 1)
+
labels.append(codes)
- return indexer_from_factorized(labels, tuple(shape))
+ return np.lexsort(labels[::-1])
def nargsort(
| - [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/v2.2.0.rst` file if fixing a bug or adding a new feature.
Improves performance for `MultiIndex` and multi-column sorting.
frame_methods.SortMultiKey:
```
before after ratio
- 51.1±0.7ms 45.0±0.5ms 0.88 frame_methods.SortMultiKey.time_sort_values
- 11.6±1ms 6.38±0.3ms 0.55 frame_methods.SortMultiKey.time_sort_index
```
multiindex_object.SetOperations:
```
before after ratio
- 29.4±2ms 19.5±0.2ms 0.66 multiindex_object.SetOperations.time_operation('monotonic', 'ea_int', 'intersection', None)
- 42.4±2ms 26.8±2ms 0.63 multiindex_object.SetOperations.time_operation('non_monotonic', 'int', 'intersection', None)
- 30.8±1ms 19.4±2ms 0.63 multiindex_object.SetOperations.time_operation('non_monotonic', 'int', 'union', None)
- 32.4±2ms 20.2±2ms 0.63 multiindex_object.SetOperations.time_operation('non_monotonic', 'ea_int', 'union', None)
- 30.5±1ms 18.7±0.4ms 0.61 multiindex_object.SetOperations.time_operation('monotonic', 'int', 'intersection', None)
- 34.8±4ms 19.4±2ms 0.56 multiindex_object.SetOperations.time_operation('non_monotonic', 'datetime', 'union', None)
- 25.4±3ms 14.1±0.7ms 0.56 multiindex_object.SetOperations.time_operation('monotonic', 'datetime', 'union', None)
- 33.7±1ms 17.2±1ms 0.51 multiindex_object.SetOperations.time_operation('non_monotonic', 'string', 'union', None)
- 35.2±3ms 16.5±0.8ms 0.47 multiindex_object.SetOperations.time_operation('monotonic', 'string', 'union', None)
- 41.3±1ms 18.4±2ms 0.45 multiindex_object.SetOperations.time_operation('non_monotonic', 'string', 'intersection', None)
- 40.8±2ms 18.1±0.6ms 0.44 multiindex_object.SetOperations.time_operation('non_monotonic', 'datetime', 'intersection', None)
- 48.6±4ms 19.8±2ms 0.41 multiindex_object.SetOperations.time_operation('non_monotonic', 'ea_int', 'intersection', None)
- 45.1±5ms 17.9±2ms 0.40 multiindex_object.SetOperations.time_operation('monotonic', 'string', 'intersection', None)
```
multiindex_object.Difference:
```
before after ratio
- 6.55±0.5ms 3.88±0.2ms 0.59 multiindex_object.Difference.time_difference('string')
- 5.42±0.7ms 3.10±0.3ms 0.57 multiindex_object.Difference.time_difference('ea_int')
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/54835 | 2023-08-29T02:12:34Z | 2023-08-30T17:02:18Z | 2023-08-30T17:02:18Z | 2023-09-06T00:53:58Z |
ENH: add `ExtensionArray._explode` method; adjust pyarrow extension for use of new interface | diff --git a/doc/source/reference/extensions.rst b/doc/source/reference/extensions.rst
index e177e2b1d87d5..83f830bb11198 100644
--- a/doc/source/reference/extensions.rst
+++ b/doc/source/reference/extensions.rst
@@ -34,6 +34,7 @@ objects.
api.extensions.ExtensionArray._accumulate
api.extensions.ExtensionArray._concat_same_type
+ api.extensions.ExtensionArray._explode
api.extensions.ExtensionArray._formatter
api.extensions.ExtensionArray._from_factorized
api.extensions.ExtensionArray._from_sequence
diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 55a3419e95703..0fc4afc95a2ce 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -73,6 +73,7 @@ enhancement2
Other enhancements
^^^^^^^^^^^^^^^^^^
+- :meth:`ExtensionArray._explode` interface method added to allow extension type implementations of the ``explode`` method (:issue:`54833`)
- DataFrame.apply now allows the usage of numba (via ``engine="numba"``) to JIT compile the passed function, allowing for potential speedups (:issue:`54666`)
-
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index a329c37c77449..e67b7035822cc 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -1609,6 +1609,10 @@ def _explode(self):
"""
See Series.explode.__doc__.
"""
+ # child class explode method supports only list types; return
+ # default implementation for non list types.
+ if not pa.types.is_list(self.dtype.pyarrow_dtype):
+ return super()._explode()
values = self
counts = pa.compute.list_value_length(values._pa_array)
counts = counts.fill_null(1).to_numpy()
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index f3bb7323c7d5f..933944dbd4632 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -142,6 +142,7 @@ class ExtensionArray:
view
_accumulate
_concat_same_type
+ _explode
_formatter
_from_factorized
_from_sequence
@@ -1924,6 +1925,41 @@ def _hash_pandas_object(
values, encoding=encoding, hash_key=hash_key, categorize=categorize
)
+ def _explode(self) -> tuple[Self, npt.NDArray[np.uint64]]:
+ """
+ Transform each element of list-like to a row.
+
+ For arrays that do not contain list-like elements the default
+ implementation of this method just returns a copy and an array
+ of ones (unchanged index).
+
+ Returns
+ -------
+ ExtensionArray
+ Array with the exploded values.
+ np.ndarray[uint64]
+ The original lengths of each list-like for determining the
+ resulting index.
+
+ See Also
+ --------
+ Series.explode : The method on the ``Series`` object that this
+ extension array method is meant to support.
+
+ Examples
+ --------
+ >>> import pyarrow as pa
+ >>> a = pd.array([[1, 2, 3], [4], [5, 6]],
+ ... dtype=pd.ArrowDtype(pa.list_(pa.int64())))
+ >>> a._explode()
+ (<ArrowExtensionArray>
+ [1, 2, 3, 4, 5, 6]
+ Length: 6, dtype: int64[pyarrow], array([3, 1, 2], dtype=int32))
+ """
+ values = self.copy()
+ counts = np.ones(shape=(len(self),), dtype=np.uint64)
+ return values, counts
+
def tolist(self) -> list:
"""
Return a list of the values.
diff --git a/pandas/core/series.py b/pandas/core/series.py
index e0e27581ef7e2..78ec1554198df 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -76,10 +76,7 @@
pandas_dtype,
validate_all_hashable,
)
-from pandas.core.dtypes.dtypes import (
- ArrowDtype,
- ExtensionDtype,
-)
+from pandas.core.dtypes.dtypes import ExtensionDtype
from pandas.core.dtypes.generic import ABCDataFrame
from pandas.core.dtypes.inference import is_hashable
from pandas.core.dtypes.missing import (
@@ -4390,7 +4387,7 @@ def explode(self, ignore_index: bool = False) -> Series:
3 4
dtype: object
"""
- if isinstance(self.dtype, ArrowDtype) and self.dtype.type == list:
+ if isinstance(self.dtype, ExtensionDtype):
values, counts = self._values._explode()
elif len(self) and is_object_dtype(self.dtype):
values, counts = reshape.explode(np.asarray(self._values))
diff --git a/pandas/tests/series/methods/test_explode.py b/pandas/tests/series/methods/test_explode.py
index c8a9eb6f89fde..5a0188585ef30 100644
--- a/pandas/tests/series/methods/test_explode.py
+++ b/pandas/tests/series/methods/test_explode.py
@@ -163,3 +163,13 @@ def test_explode_pyarrow_list_type(ignore_index):
dtype=pd.ArrowDtype(pa.int64()),
)
tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("ignore_index", [True, False])
+def test_explode_pyarrow_non_list_type(ignore_index):
+ pa = pytest.importorskip("pyarrow")
+ data = [1, 2, 3]
+ ser = pd.Series(data, dtype=pd.ArrowDtype(pa.int64()))
+ result = ser.explode(ignore_index=ignore_index)
+ expected = pd.Series([1, 2, 3], dtype="int64[pyarrow]", index=[0, 1, 2])
+ tm.assert_series_equal(result, expected)
| - [x] closes #54833
- [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/54834 | 2023-08-29T01:28:31Z | 2023-09-18T21:37:33Z | 2023-09-18T21:37:33Z | 2023-09-19T00:37:36Z |
ENH: allow EADtype to specify _supports_2d | diff --git a/pandas/core/dtypes/base.py b/pandas/core/dtypes/base.py
index a055afe6ec0ae..6567ca7155b0d 100644
--- a/pandas/core/dtypes/base.py
+++ b/pandas/core/dtypes/base.py
@@ -418,6 +418,33 @@ def index_class(self) -> type_t[Index]:
return Index
+ @property
+ def _supports_2d(self) -> bool:
+ """
+ Do ExtensionArrays with this dtype support 2D arrays?
+
+ Historically ExtensionArrays were limited to 1D. By returning True here,
+ authors can indicate that their arrays support 2D instances. This can
+ improve performance in some cases, particularly operations with `axis=1`.
+
+ Arrays that support 2D values should:
+
+ - implement Array.reshape
+ - subclass the Dim2CompatTests in tests.extension.base
+ - _concat_same_type should support `axis` keyword
+ - _reduce and reductions should support `axis` keyword
+ """
+ return False
+
+ @property
+ def _can_fast_transpose(self) -> bool:
+ """
+ Is transposing an array with this dtype zero-copy?
+
+ Only relevant for cases where _supports_2d is True.
+ """
+ return False
+
class StorageExtensionDtype(ExtensionDtype):
"""ExtensionDtype that may be backed by more than one implementation."""
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index 3db36fc50e343..63c59297f454a 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -1256,13 +1256,7 @@ def is_1d_only_ea_dtype(dtype: DtypeObj | None) -> bool:
"""
Analogue to is_extension_array_dtype but excluding DatetimeTZDtype.
"""
- # Note: if other EA dtypes are ever held in HybridBlock, exclude those
- # here too.
- # NB: need to check DatetimeTZDtype and not is_datetime64tz_dtype
- # to exclude ArrowTimestampUSDtype
- return isinstance(dtype, ExtensionDtype) and not isinstance(
- dtype, (DatetimeTZDtype, PeriodDtype)
- )
+ return isinstance(dtype, ExtensionDtype) and not dtype._supports_2d
def is_extension_array_dtype(arr_or_dtype) -> bool:
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index f43865465cb28..8ab002445633e 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -210,6 +210,8 @@ class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
base = np.dtype("O")
_metadata = ("categories", "ordered")
_cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
+ _supports_2d = False
+ _can_fast_transpose = False
def __init__(self, categories=None, ordered: Ordered = False) -> None:
self._finalize(categories, ordered, fastpath=False)
@@ -727,6 +729,8 @@ class DatetimeTZDtype(PandasExtensionDtype):
_metadata = ("unit", "tz")
_match = re.compile(r"(datetime64|M8)\[(?P<unit>.+), (?P<tz>.+)\]")
_cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
+ _supports_2d = True
+ _can_fast_transpose = True
@property
def na_value(self) -> NaTType:
@@ -970,6 +974,8 @@ class PeriodDtype(PeriodDtypeBase, PandasExtensionDtype):
_cache_dtypes: dict[BaseOffset, int] = {} # type: ignore[assignment]
__hash__ = PeriodDtypeBase.__hash__
_freq: BaseOffset
+ _supports_2d = True
+ _can_fast_transpose = True
def __new__(cls, freq):
"""
@@ -1432,6 +1438,8 @@ class NumpyEADtype(ExtensionDtype):
"""
_metadata = ("_dtype",)
+ _supports_2d = False
+ _can_fast_transpose = False
def __init__(self, dtype: npt.DTypeLike | NumpyEADtype | None) -> None:
if isinstance(dtype, NumpyEADtype):
diff --git a/pandas/tests/extension/base/__init__.py b/pandas/tests/extension/base/__init__.py
index 82b61722f5e96..6efaa95aef1b5 100644
--- a/pandas/tests/extension/base/__init__.py
+++ b/pandas/tests/extension/base/__init__.py
@@ -85,6 +85,7 @@ class ExtensionTests(
BaseReduceTests,
BaseReshapingTests,
BaseSetitemTests,
+ Dim2CompatTests,
):
pass
diff --git a/pandas/tests/extension/base/dim2.py b/pandas/tests/extension/base/dim2.py
index a0c24ee068e81..85b3dd2d2b267 100644
--- a/pandas/tests/extension/base/dim2.py
+++ b/pandas/tests/extension/base/dim2.py
@@ -20,6 +20,17 @@ class Dim2CompatTests:
# Note: these are ONLY for ExtensionArray subclasses that support 2D arrays.
# i.e. not for pyarrow-backed EAs.
+ @pytest.fixture(autouse=True)
+ def skip_if_doesnt_support_2d(self, dtype, request):
+ if not dtype._supports_2d:
+ node = request.node
+ # In cases where we are mixed in to ExtensionTests, we only want to
+ # skip tests that are defined in Dim2CompatTests
+ test_func = node._obj
+ if test_func.__qualname__.startswith("Dim2CompatTests"):
+ # TODO: is there a less hacky way of checking this?
+ pytest.skip("Test is only for EAs that support 2D.")
+
def test_transpose(self, data):
arr2d = data.repeat(2).reshape(-1, 2)
shape = arr2d.shape
| - [ ] 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.
The can_fast_transpose bit isn't used but is future-proofing for a time when we have e.g. pyarrow tables backing a 2D EA where transposing isn't cheap. If asked, I'll revert that bit until it is necessary. | https://api.github.com/repos/pandas-dev/pandas/pulls/54832 | 2023-08-28T23:12:17Z | 2023-09-01T00:18:31Z | 2023-09-01T00:18:31Z | 2023-09-01T01:18:27Z |
Backport PR #54823 on branch 2.1.x (REGR: clip raising for list-bound) | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index c34df3e0e865c..cdd0545f0a3ec 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7929,6 +7929,7 @@ def to_series(right):
)
elif isinstance(right, Series):
# axis=1 is default for DataFrame-with-Series op
+ axis = axis if axis is not None else 1
if not flex:
if not left.axes[axis].equals(right.index):
raise ValueError(
diff --git a/pandas/tests/frame/methods/test_clip.py b/pandas/tests/frame/methods/test_clip.py
index 9bd032a0aefc4..f7b221d84ab78 100644
--- a/pandas/tests/frame/methods/test_clip.py
+++ b/pandas/tests/frame/methods/test_clip.py
@@ -177,3 +177,14 @@ def test_clip_int_data_with_float_bound(self):
result = df.clip(lower=1.5)
expected = DataFrame({"a": [1.5, 2.0, 3.0]})
tm.assert_frame_equal(result, expected)
+
+ def test_clip_with_list_bound(self):
+ # GH#54817
+ df = DataFrame([1, 5])
+ expected = DataFrame([3, 5])
+ result = df.clip([3])
+ tm.assert_frame_equal(result, expected)
+
+ expected = DataFrame([1, 3])
+ result = df.clip(upper=[3])
+ tm.assert_frame_equal(result, expected)
| Backport PR #54823: REGR: clip raising for list-bound | https://api.github.com/repos/pandas-dev/pandas/pulls/54829 | 2023-08-28T21:01:48Z | 2023-08-28T22:39:49Z | 2023-08-28T22:39:49Z | 2023-08-28T22:39:49Z |
DOC: update information of parameter value_name of pandas.melt | diff --git a/pandas/core/shared_docs.py b/pandas/core/shared_docs.py
index 7579f816d0ace..1fc63dd503467 100644
--- a/pandas/core/shared_docs.py
+++ b/pandas/core/shared_docs.py
@@ -213,7 +213,7 @@
Name to use for the 'variable' column. If None it uses
``frame.columns.name`` or 'variable'.
value_name : scalar, default 'value'
- Name to use for the 'value' column.
+ Name to use for the 'value' column, can't be an existing column label.
col_level : int or str, optional
If columns are a MultiIndex then use this level to melt.
ignore_index : bool, default True
| - [x] closes #54715
- [x] *Pre-commit* and *python3 scripts/validate_docstrings.py pandas.melt* were executed with no mistakes
The update developed was to add the information of no repeating an already existing column name.
| https://api.github.com/repos/pandas-dev/pandas/pulls/54828 | 2023-08-28T20:58:24Z | 2023-08-30T16:47:04Z | 2023-08-30T16:47:04Z | 2023-09-22T22:03:19Z |
Backport PR #54820 on branch 2.1.x (REF: Dispatch ArrowExtensionArray.fillna methods to pad_or_backfill) | diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 528b085bd5236..70c59e94f6d27 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -40,7 +40,10 @@
from pandas.core.dtypes.dtypes import DatetimeTZDtype
from pandas.core.dtypes.missing import isna
-from pandas.core import roperator
+from pandas.core import (
+ missing,
+ roperator,
+)
from pandas.core.arraylike import OpsMixin
from pandas.core.arrays._arrow_string_mixins import ArrowStringArrayMixin
from pandas.core.arrays.base import (
@@ -933,6 +936,20 @@ def pad_or_backfill(
# TODO(CoW): Not necessary anymore when CoW is the default
return self.copy()
+ if limit is not None and limit_area is not None:
+ method = missing.clean_fill_method(method)
+ try:
+ if method == "pad":
+ return type(self)(pc.fill_null_forward(self._pa_array))
+ elif method == "backfill":
+ return type(self)(pc.fill_null_backward(self._pa_array))
+ except pa.ArrowNotImplementedError:
+ # ArrowNotImplementedError: Function 'coalesce' has no kernel
+ # matching input types (duration[ns], duration[ns])
+ # TODO: remove try/except wrapper if/when pyarrow implements
+ # a kernel for duration types.
+ pass
+
# TODO(3.0): after EA.fillna 'method' deprecation is enforced, we can remove
# this method entirely.
return super().pad_or_backfill(
@@ -953,9 +970,12 @@ def fillna(
# TODO(CoW): Not necessary anymore when CoW is the default
return self.copy()
- if limit is not None or method is not None:
+ if limit is not None:
return super().fillna(value=value, method=method, limit=limit, copy=copy)
+ if method is not None:
+ return super().pad_or_backfill(method=method, limit=limit, copy=copy)
+
if isinstance(value, (np.ndarray, ExtensionArray)):
# Similar to check_value_size, but we do not mask here since we may
# end up passing it to the super() method.
@@ -972,12 +992,7 @@ def fillna(
raise TypeError(msg) from err
try:
- if method is None:
- return type(self)(pc.fill_null(self._pa_array, fill_value=fill_value))
- elif method == "pad":
- return type(self)(pc.fill_null_forward(self._pa_array))
- elif method == "backfill":
- return type(self)(pc.fill_null_backward(self._pa_array))
+ return type(self)(pc.fill_null(self._pa_array, fill_value=fill_value))
except pa.ArrowNotImplementedError:
# ArrowNotImplementedError: Function 'coalesce' has no kernel
# matching input types (duration[ns], duration[ns])
| Backport PR #54820: REF: Dispatch ArrowExtensionArray.fillna methods to pad_or_backfill | https://api.github.com/repos/pandas-dev/pandas/pulls/54827 | 2023-08-28T19:56:59Z | 2023-08-28T22:29:33Z | 2023-08-28T22:29:33Z | 2023-08-28T22:29:33Z |
Infer large_string type as pyarrow_numpy strings | diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index cc3bc5900c4c2..769d04bbc02c7 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -448,6 +448,15 @@ def _str_rstrip(self, to_strip=None):
class ArrowStringArrayNumpySemantics(ArrowStringArray):
_storage = "pyarrow_numpy"
+ def __init__(self, values) -> None:
+ _chk_pyarrow_available()
+
+ if isinstance(values, (pa.Array, pa.ChunkedArray)) and pa.types.is_large_string(
+ values.type
+ ):
+ values = pc.cast(values, pa.string())
+ super().__init__(values)
+
@classmethod
def _result_converter(cls, values, na=None):
if not isna(na):
diff --git a/pandas/io/_util.py b/pandas/io/_util.py
index 915595833468d..3b2ae5daffdba 100644
--- a/pandas/io/_util.py
+++ b/pandas/io/_util.py
@@ -28,4 +28,7 @@ def _arrow_dtype_mapping() -> dict:
def arrow_string_types_mapper() -> Callable:
pa = import_optional_dependency("pyarrow")
- return {pa.string(): pd.StringDtype(storage="pyarrow_numpy")}.get
+ return {
+ pa.string(): pd.StringDtype(storage="pyarrow_numpy"),
+ pa.large_string(): pd.StringDtype(storage="pyarrow_numpy"),
+ }.get
diff --git a/pandas/tests/arrays/string_/test_string_arrow.py b/pandas/tests/arrays/string_/test_string_arrow.py
index 1ab628f186b47..09f9f788dc3e4 100644
--- a/pandas/tests/arrays/string_/test_string_arrow.py
+++ b/pandas/tests/arrays/string_/test_string_arrow.py
@@ -12,7 +12,10 @@
StringArray,
StringDtype,
)
-from pandas.core.arrays.string_arrow import ArrowStringArray
+from pandas.core.arrays.string_arrow import (
+ ArrowStringArray,
+ ArrowStringArrayNumpySemantics,
+)
skip_if_no_pyarrow = pytest.mark.skipif(
pa_version_under7p0,
@@ -166,6 +169,9 @@ def test_pyarrow_not_installed_raises():
with pytest.raises(ImportError, match=msg):
ArrowStringArray([])
+ with pytest.raises(ImportError, match=msg):
+ ArrowStringArrayNumpySemantics([])
+
with pytest.raises(ImportError, match=msg):
ArrowStringArray._from_sequence(["a", None, "b"])
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index 7c4176fa92361..d8c92c81699cf 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1139,6 +1139,25 @@ def test_roundtrip_decimal(self, tmp_path, pa):
expected = pd.DataFrame({"a": ["123"]}, dtype="string[python]")
tm.assert_frame_equal(result, expected)
+ def test_infer_string_large_string_type(self, tmp_path, pa):
+ # GH#54798
+ import pyarrow as pa
+ import pyarrow.parquet as pq
+
+ path = tmp_path / "large_string.p"
+
+ table = pa.table({"a": pa.array([None, "b", "c"], pa.large_string())})
+ pq.write_table(table, path)
+
+ with pd.option_context("future.infer_string", True):
+ result = read_parquet(path)
+ expected = pd.DataFrame(
+ data={"a": [None, "b", "c"]},
+ dtype="string[pyarrow_numpy]",
+ columns=pd.Index(["a"], dtype="string[pyarrow_numpy]"),
+ )
+ tm.assert_frame_equal(result, expected)
+
class TestParquetFastParquet(Base):
def test_basic(self, fp, df_full):
| - [ ] ref #54798 (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.
this covers the case where we don't overflow | https://api.github.com/repos/pandas-dev/pandas/pulls/54826 | 2023-08-28T19:20:47Z | 2023-09-02T18:15:52Z | 2023-09-02T18:15:52Z | 2023-09-02T18:15:55Z |
#50990 Increase to_dict('list') performance | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index bc66335d74f9b..3c9810598331e 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -157,9 +157,9 @@ Deprecations
Performance improvements
~~~~~~~~~~~~~~~~~~~~~~~~
-- Performance improvement in :meth:`DataFrame.sort_index` and :meth:`Series.sort_index` when indexed by a :class:`MultiIndex` (:issue:`54835`, :issue:`54883`)
+- Performance improvement in :func:`to_dict` on converting DataFrame to dictionary (:issue:`50990`)
+- Performance improvement in :meth:`DataFrame.sort_index` and :meth:`Series.sort_index` when indexed by a :class:`MultiIndex` (:issue:`54835`)
- Performance improvement when indexing with more than 4 keys (:issue:`54550`)
--
.. ---------------------------------------------------------------------------
.. _whatsnew_220.bug_fixes:
diff --git a/pandas/core/methods/to_dict.py b/pandas/core/methods/to_dict.py
index e89f641e17296..f4e0dcddcd34a 100644
--- a/pandas/core/methods/to_dict.py
+++ b/pandas/core/methods/to_dict.py
@@ -106,13 +106,13 @@ def to_dict(
return into_c((k, v.to_dict(into)) for k, v in df.items())
elif orient == "list":
- object_dtype_indices_as_set = set(box_native_indices)
+ object_dtype_indices_as_set: set[int] = set(box_native_indices)
return into_c(
(
k,
- list(map(maybe_box_native, v.tolist()))
+ list(map(maybe_box_native, v.to_numpy().tolist()))
if i in object_dtype_indices_as_set
- else v.tolist(),
+ else v.to_numpy().tolist(),
)
for i, (k, v) in enumerate(df.items())
)
diff --git a/pandas/tests/frame/methods/test_to_dict.py b/pandas/tests/frame/methods/test_to_dict.py
index 7bb9518f9b0f9..61f0ad30b4519 100644
--- a/pandas/tests/frame/methods/test_to_dict.py
+++ b/pandas/tests/frame/methods/test_to_dict.py
@@ -166,6 +166,21 @@ def test_to_dict_not_unique_warning(self):
with tm.assert_produces_warning(UserWarning):
df.to_dict()
+ @pytest.mark.filterwarnings("ignore::UserWarning")
+ @pytest.mark.parametrize(
+ "orient,expected",
+ [
+ ("list", {"A": [2, 5], "B": [3, 6]}),
+ ("dict", {"A": {0: 2, 1: 5}, "B": {0: 3, 1: 6}}),
+ ],
+ )
+ def test_to_dict_not_unique(self, orient, expected):
+ # GH#54824: This is to make sure that dataframes with non-unique column
+ # would have uniform behavior throughout different orients
+ df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["A", "A", "B"])
+ result = df.to_dict(orient)
+ assert result == expected
+
# orient - orient argument to to_dict function
# item_getter - function for extracting value from
# the resulting dict using column name and index
| - [x] closes #50990
- [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/v2.1.0.rst` file if fixing a bug or adding a new feature.
`25.8±2ms 1.61±0.4ms 0.06 frame_methods.ToDict.time_to_dict_datetimelike('list')` | https://api.github.com/repos/pandas-dev/pandas/pulls/54824 | 2023-08-28T19:07:00Z | 2023-09-01T16:55:06Z | 2023-09-01T16:55:06Z | 2023-09-01T16:55:13Z |
REGR: clip raising for list-bound | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 018059ce2784f..3a4e8fdd91362 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7948,6 +7948,7 @@ def to_series(right):
)
elif isinstance(right, Series):
# axis=1 is default for DataFrame-with-Series op
+ axis = axis if axis is not None else 1
if not flex:
if not left.axes[axis].equals(right.index):
raise ValueError(
diff --git a/pandas/tests/frame/methods/test_clip.py b/pandas/tests/frame/methods/test_clip.py
index 9bd032a0aefc4..f7b221d84ab78 100644
--- a/pandas/tests/frame/methods/test_clip.py
+++ b/pandas/tests/frame/methods/test_clip.py
@@ -177,3 +177,14 @@ def test_clip_int_data_with_float_bound(self):
result = df.clip(lower=1.5)
expected = DataFrame({"a": [1.5, 2.0, 3.0]})
tm.assert_frame_equal(result, expected)
+
+ def test_clip_with_list_bound(self):
+ # GH#54817
+ df = DataFrame([1, 5])
+ expected = DataFrame([3, 5])
+ result = df.clip([3])
+ tm.assert_frame_equal(result, expected)
+
+ expected = DataFrame([1, 3])
+ result = df.clip(upper=[3])
+ tm.assert_frame_equal(result, expected)
| - [ ] closes #54817 (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/54823 | 2023-08-28T19:05:29Z | 2023-08-28T21:01:39Z | 2023-08-28T21:01:39Z | 2023-08-28T21:01:42Z |
DOC: Removing repeated NA | diff --git a/doc/source/reference/arrays.rst b/doc/source/reference/arrays.rst
index 41ddbd048e6c5..fe65364896f54 100644
--- a/doc/source/reference/arrays.rst
+++ b/doc/source/reference/arrays.rst
@@ -134,11 +134,6 @@ is the missing value for datetime data.
Timestamp
-.. autosummary::
- :toctree: api/
-
- NaT
-
Properties
~~~~~~~~~~
.. autosummary::
@@ -257,11 +252,6 @@ is the missing value for timedelta data.
Timedelta
-.. autosummary::
- :toctree: api/
-
- NaT
-
Properties
~~~~~~~~~~
.. autosummary::
@@ -465,7 +455,6 @@ pandas provides this through :class:`arrays.IntegerArray`.
UInt16Dtype
UInt32Dtype
UInt64Dtype
- NA
.. _api.arrays.float_na:
@@ -484,7 +473,6 @@ Nullable float
Float32Dtype
Float64Dtype
- NA
.. _api.arrays.categorical:
@@ -621,7 +609,6 @@ with a bool :class:`numpy.ndarray`.
:template: autosummary/class_without_autosummary.rst
BooleanDtype
- NA
.. Dtype attributes which are manually listed in their docstrings: including
diff --git a/doc/source/reference/index.rst b/doc/source/reference/index.rst
index 6d3ce3d31f005..7da02f7958416 100644
--- a/doc/source/reference/index.rst
+++ b/doc/source/reference/index.rst
@@ -53,6 +53,7 @@ are mentioned in the documentation.
options
extensions
testing
+ missing_value
.. This is to prevent warnings in the doc build. We don't want to encourage
.. these methods.
diff --git a/doc/source/reference/missing_value.rst b/doc/source/reference/missing_value.rst
new file mode 100644
index 0000000000000..3bf22aef765d1
--- /dev/null
+++ b/doc/source/reference/missing_value.rst
@@ -0,0 +1,24 @@
+{{ header }}
+
+.. _api.missing_value:
+
+==============
+Missing values
+==============
+.. currentmodule:: pandas
+
+NA is the way to represent missing values for nullable dtypes (see below):
+
+.. autosummary::
+ :toctree: api/
+ :template: autosummary/class_without_autosummary.rst
+
+ NA
+
+NaT is the missing value for timedelta and datetime data (see below):
+
+.. autosummary::
+ :toctree: api/
+ :template: autosummary/class_without_autosummary.rst
+
+ NaT
| - [x] closes #53404 (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/54821 | 2023-08-28T17:54:29Z | 2023-09-29T16:34:43Z | 2023-09-29T16:34:43Z | 2023-09-29T16:34:44Z |
REF: Dispatch ArrowExtensionArray.fillna methods to pad_or_backfill | diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 528b085bd5236..70c59e94f6d27 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -40,7 +40,10 @@
from pandas.core.dtypes.dtypes import DatetimeTZDtype
from pandas.core.dtypes.missing import isna
-from pandas.core import roperator
+from pandas.core import (
+ missing,
+ roperator,
+)
from pandas.core.arraylike import OpsMixin
from pandas.core.arrays._arrow_string_mixins import ArrowStringArrayMixin
from pandas.core.arrays.base import (
@@ -933,6 +936,20 @@ def pad_or_backfill(
# TODO(CoW): Not necessary anymore when CoW is the default
return self.copy()
+ if limit is not None and limit_area is not None:
+ method = missing.clean_fill_method(method)
+ try:
+ if method == "pad":
+ return type(self)(pc.fill_null_forward(self._pa_array))
+ elif method == "backfill":
+ return type(self)(pc.fill_null_backward(self._pa_array))
+ except pa.ArrowNotImplementedError:
+ # ArrowNotImplementedError: Function 'coalesce' has no kernel
+ # matching input types (duration[ns], duration[ns])
+ # TODO: remove try/except wrapper if/when pyarrow implements
+ # a kernel for duration types.
+ pass
+
# TODO(3.0): after EA.fillna 'method' deprecation is enforced, we can remove
# this method entirely.
return super().pad_or_backfill(
@@ -953,9 +970,12 @@ def fillna(
# TODO(CoW): Not necessary anymore when CoW is the default
return self.copy()
- if limit is not None or method is not None:
+ if limit is not None:
return super().fillna(value=value, method=method, limit=limit, copy=copy)
+ if method is not None:
+ return super().pad_or_backfill(method=method, limit=limit, copy=copy)
+
if isinstance(value, (np.ndarray, ExtensionArray)):
# Similar to check_value_size, but we do not mask here since we may
# end up passing it to the super() method.
@@ -972,12 +992,7 @@ def fillna(
raise TypeError(msg) from err
try:
- if method is None:
- return type(self)(pc.fill_null(self._pa_array, fill_value=fill_value))
- elif method == "pad":
- return type(self)(pc.fill_null_forward(self._pa_array))
- elif method == "backfill":
- return type(self)(pc.fill_null_backward(self._pa_array))
+ return type(self)(pc.fill_null(self._pa_array, fill_value=fill_value))
except pa.ArrowNotImplementedError:
# ArrowNotImplementedError: Function 'coalesce' has no kernel
# matching input types (duration[ns], duration[ns])
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/54820 | 2023-08-28T17:38:02Z | 2023-08-28T19:56:52Z | 2023-08-28T19:56:52Z | 2023-08-28T20:08:26Z |
Backport PR #54801 on branch 2.1.x (BUG: repr aligning left for string dtype columns) | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 19a8500928ab7..8f2667d69a322 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -717,6 +717,7 @@ Conversion
Strings
^^^^^^^
- Bug in :meth:`Series.str` that did not raise a ``TypeError`` when iterated (:issue:`54173`)
+- Bug in ``repr`` for :class:`DataFrame`` with string-dtype columns (:issue:`54797`)
Interval
^^^^^^^^
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 0db0a3608a1f0..aa306da017d34 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1419,8 +1419,8 @@ def _format_with_header(self, header: list[str_t], na_rep: str_t) -> list[str_t]
values = self._values
- if is_object_dtype(values.dtype):
- values = cast(np.ndarray, values)
+ if is_object_dtype(values.dtype) or is_string_dtype(values.dtype):
+ values = np.asarray(values)
values = lib.maybe_convert_objects(values, safe=True)
result = [pprint_thing(x, escape_chars=("\t", "\r", "\n")) for x in values]
diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py
index 49375658abfee..64d516e484991 100644
--- a/pandas/tests/frame/test_repr_info.py
+++ b/pandas/tests/frame/test_repr_info.py
@@ -455,3 +455,14 @@ def test_masked_ea_with_formatter(self):
0 0.12 1.00
1 1.12 2.00"""
assert result == expected
+
+ def test_repr_ea_columns(self, any_string_dtype):
+ # GH#54797
+ pytest.importorskip("pyarrow")
+ df = DataFrame({"long_column_name": [1, 2, 3], "col2": [4, 5, 6]})
+ df.columns = df.columns.astype(any_string_dtype)
+ expected = """ long_column_name col2
+0 1 4
+1 2 5
+2 3 6"""
+ assert repr(df) == expected
| Backport PR #54801: BUG: repr aligning left for string dtype columns | https://api.github.com/repos/pandas-dev/pandas/pulls/54819 | 2023-08-28T17:35:23Z | 2023-08-28T19:36:41Z | 2023-08-28T19:36:41Z | 2023-08-28T19:36:41Z |
DEP: Deprecate passing fill_value and freq to shift | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 8f2667d69a322..e7fc83c35f56d 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -587,6 +587,7 @@ Other Deprecations
- Deprecated values ``"pad"``, ``"ffill"``, ``"bfill"``, ``"backfill"`` for :meth:`Series.interpolate` and :meth:`DataFrame.interpolate`, use ``obj.ffill()`` or ``obj.bfill()`` instead (:issue:`53581`)
- Deprecated the behavior of :meth:`Index.argmax`, :meth:`Index.argmin`, :meth:`Series.argmax`, :meth:`Series.argmin` with either all-NAs and ``skipna=True`` or any-NAs and ``skipna=False`` returning -1; in a future version this will raise ``ValueError`` (:issue:`33941`, :issue:`33942`)
- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_sql` except ``name`` and ``con`` (:issue:`54229`)
+- Deprecated silently ignoring ``fill_value`` when passing both ``freq`` and ``fill_value`` to :meth:`DataFrame.shift`, :meth:`Series.shift` and :meth:`.DataFrameGroupBy.shift`; in a future version this will raise ``ValueError`` (:issue:`53832`)
.. ---------------------------------------------------------------------------
.. _whatsnew_210.performance:
@@ -871,7 +872,6 @@ Other
- Bug in :meth:`.DataFrameGroupBy.first`, :meth:`.DataFrameGroupBy.last`, :meth:`.SeriesGroupBy.first`, and :meth:`.SeriesGroupBy.last` where an empty group would return ``np.nan`` instead of the corresponding :class:`.ExtensionArray` NA value (:issue:`39098`)
- Bug in :meth:`DataFrame.pivot_table` with casting the mean of ints back to an int (:issue:`16676`)
- Bug in :meth:`DataFrame.reindex` with a ``fill_value`` that should be inferred with a :class:`ExtensionDtype` incorrectly inferring ``object`` dtype (:issue:`52586`)
-- Bug in :meth:`DataFrame.shift` and :meth:`Series.shift` and :meth:`.DataFrameGroupBy.shift` when passing both ``freq`` and ``fill_value`` silently ignoring ``fill_value`` instead of raising ``ValueError`` (:issue:`53832`)
- Bug in :meth:`DataFrame.shift` with ``axis=1`` on a :class:`DataFrame` with a single :class:`ExtensionDtype` column giving incorrect results (:issue:`53832`)
- Bug in :meth:`Index.sort_values` when a ``key`` is passed (:issue:`52764`)
- Bug in :meth:`Series.align`, :meth:`DataFrame.align`, :meth:`Series.reindex`, :meth:`DataFrame.reindex`, :meth:`Series.interpolate`, :meth:`DataFrame.interpolate`, incorrectly failing to raise with method="asfreq" (:issue:`53620`)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 018059ce2784f..997e13e3f0503 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5636,10 +5636,14 @@ def shift(
) -> DataFrame:
if freq is not None and fill_value is not lib.no_default:
# GH#53832
- raise ValueError(
- "Cannot pass both 'freq' and 'fill_value' to "
- f"{type(self).__name__}.shift"
+ warnings.warn(
+ "Passing a 'freq' together with a 'fill_value' silently ignores "
+ "the fill_value and is deprecated. This will raise in a future "
+ "version.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
)
+ fill_value = lib.no_default
axis = self._get_axis_number(axis)
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index b87772594cfbf..d6ee8ad2cd347 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -10822,10 +10822,14 @@ def shift(
if freq is not None and fill_value is not lib.no_default:
# GH#53832
- raise ValueError(
- "Cannot pass both 'freq' and 'fill_value' to "
- f"{type(self).__name__}.shift"
+ warnings.warn(
+ "Passing a 'freq' together with a 'fill_value' silently ignores "
+ "the fill_value and is deprecated. This will raise in a future "
+ "version.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
)
+ fill_value = lib.no_default
if periods == 0:
return self.copy(deep=None)
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
index 808f0cff2485c..1e88152137b1f 100644
--- a/pandas/tests/frame/methods/test_shift.py
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -32,19 +32,23 @@ def test_shift_axis1_with_valid_fill_value_one_array(self):
expected2 = DataFrame([12345] * 5, dtype="Float64")
tm.assert_frame_equal(res2, expected2)
- def test_shift_disallow_freq_and_fill_value(self, frame_or_series):
+ def test_shift_deprecate_freq_and_fill_value(self, frame_or_series):
# Can't pass both!
obj = frame_or_series(
np.random.default_rng(2).standard_normal(5),
index=date_range("1/1/2000", periods=5, freq="H"),
)
- msg = "Cannot pass both 'freq' and 'fill_value' to (Series|DataFrame).shift"
- with pytest.raises(ValueError, match=msg):
+ msg = (
+ "Passing a 'freq' together with a 'fill_value' silently ignores the "
+ "fill_value"
+ )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
obj.shift(1, fill_value=1, freq="H")
if frame_or_series is DataFrame:
- with pytest.raises(ValueError, match=msg):
+ obj.columns = date_range("1/1/2000", periods=1, freq="H")
+ with tm.assert_produces_warning(FutureWarning, match=msg):
obj.shift(1, axis=1, fill_value=1, freq="H")
@pytest.mark.parametrize(
@@ -716,8 +720,11 @@ def test_shift_with_iterable_freq_and_fill_value(self):
df.shift(1, freq="H"),
)
- msg = r"Cannot pass both 'freq' and 'fill_value' to.*"
- with pytest.raises(ValueError, match=msg):
+ msg = (
+ "Passing a 'freq' together with a 'fill_value' silently ignores the "
+ "fill_value"
+ )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
df.shift([1, 2], fill_value=1, freq="H")
def test_shift_with_iterable_check_other_arguments(self):
diff --git a/pandas/tests/groupby/test_groupby_shift_diff.py b/pandas/tests/groupby/test_groupby_shift_diff.py
index 495f3fcd359c7..bb4b9aa866ac9 100644
--- a/pandas/tests/groupby/test_groupby_shift_diff.py
+++ b/pandas/tests/groupby/test_groupby_shift_diff.py
@@ -166,12 +166,14 @@ def test_shift_periods_freq():
tm.assert_frame_equal(result, expected)
-def test_shift_disallow_freq_and_fill_value():
+def test_shift_deprecate_freq_and_fill_value():
# GH 53832
data = {"a": [1, 2, 3, 4, 5, 6], "b": [0, 0, 0, 1, 1, 1]}
df = DataFrame(data, index=date_range(start="20100101", periods=6))
- msg = "Cannot pass both 'freq' and 'fill_value' to (Series|DataFrame).shift"
- with pytest.raises(ValueError, match=msg):
+ msg = (
+ "Passing a 'freq' together with a 'fill_value' silently ignores the fill_value"
+ )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
df.groupby(df.index).shift(periods=-2, freq="D", fill_value="1")
@@ -238,12 +240,15 @@ def test_group_shift_with_multiple_periods_and_fill_value():
tm.assert_frame_equal(shifted_df, expected_df)
-def test_group_shift_with_multiple_periods_and_both_fill_and_freq_fails():
+def test_group_shift_with_multiple_periods_and_both_fill_and_freq_deprecated():
# GH#44424
df = DataFrame(
{"a": [1, 2, 3, 4, 5], "b": [True, True, False, False, True]},
index=date_range("1/1/2000", periods=5, freq="H"),
)
- msg = r"Cannot pass both 'freq' and 'fill_value' to.*"
- with pytest.raises(ValueError, match=msg):
+ msg = (
+ "Passing a 'freq' together with a 'fill_value' silently ignores the "
+ "fill_value"
+ )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
df.groupby("b")[["a"]].shift([1, 2], fill_value=1, freq="H")
| - [ ] 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.
see #53832 | https://api.github.com/repos/pandas-dev/pandas/pulls/54818 | 2023-08-28T17:34:18Z | 2023-08-29T14:44:02Z | 2023-08-29T14:44:02Z | 2023-08-29T14:44:05Z |
Fix minor cython warning | diff --git a/pandas/_libs/writers.pyx b/pandas/_libs/writers.pyx
index bd5c0290b2879..48eedd1fd1af6 100644
--- a/pandas/_libs/writers.pyx
+++ b/pandas/_libs/writers.pyx
@@ -1,4 +1,5 @@
cimport cython
+from cython cimport Py_ssize_t
import numpy as np
from cpython cimport (
| Fixes
```
2023-08-26T19:21:26.6203637Z warning: /home/runner/work/pandas/pandas/pandas/_libs/writers.pyx:123:50: Unknown type declaration 'Py_ssize_t' in annotation, ignoring
2023-08-26T19:21:26.6253780Z warning: /home/runner/work/pandas/pandas/pandas/_libs/writers.pyx:123:50: Unknown type declaration 'Py_ssize_t' in annotation, ignoring
2023-08-26T19:21:26.6254699Z warning: /home/runner/work/pandas/pandas/pandas/_libs/writers.pyx:123:50: Unknown type declaration 'Py_ssize_t' in annotation, ignoring
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/54816 | 2023-08-28T16:10:42Z | 2023-08-28T19:35:34Z | 2023-08-28T19:35:34Z | 2023-08-28T19:35:37Z |
DOC: added docstring for `storage_options` in `read_html` | diff --git a/pandas/io/html.py b/pandas/io/html.py
index 8a73c786825e3..10701be4f7e0b 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -23,6 +23,7 @@
AbstractMethodError,
EmptyDataError,
)
+from pandas.util._decorators import doc
from pandas.util._exceptions import find_stack_level
from pandas.util._validators import check_dtype_backend
@@ -32,6 +33,7 @@
from pandas.core.indexes.base import Index
from pandas.core.indexes.multi import MultiIndex
from pandas.core.series import Series
+from pandas.core.shared_docs import _shared_docs
from pandas.io.common import (
file_exists,
@@ -363,13 +365,13 @@ def _parse_tfoot_tr(self, table):
"""
raise AbstractMethodError(self)
- def _parse_tables(self, doc, match, attrs):
+ def _parse_tables(self, document, match, attrs):
"""
Return all tables from the parsed DOM.
Parameters
----------
- doc : the DOM from which to parse the table element.
+ document : the DOM from which to parse the table element.
match : str or regular expression
The text to search for in the DOM tree.
@@ -594,9 +596,9 @@ def __init__(self, *args, **kwargs) -> None:
self._strainer = SoupStrainer("table")
- def _parse_tables(self, doc, match, attrs):
+ def _parse_tables(self, document, match, attrs):
element_name = self._strainer.name
- tables = doc.find_all(element_name, attrs=attrs)
+ tables = document.find_all(element_name, attrs=attrs)
if not tables:
raise ValueError("No tables found")
@@ -726,7 +728,7 @@ def _parse_td(self, row):
# <thead> or <tfoot> (see _parse_thead_tr).
return row.xpath("./td|./th")
- def _parse_tables(self, doc, match, kwargs):
+ def _parse_tables(self, document, match, kwargs):
pattern = match.pattern
# 1. check all descendants for the given pattern and only search tables
@@ -738,7 +740,7 @@ def _parse_tables(self, doc, match, kwargs):
if kwargs:
xpath_expr += _build_xpath_expr(kwargs)
- tables = doc.xpath(xpath_expr, namespaces=_re_namespace)
+ tables = document.xpath(xpath_expr, namespaces=_re_namespace)
tables = self._handle_hidden_tables(tables, "attrib")
if self.displayed_only:
@@ -1026,6 +1028,7 @@ def _parse(
return ret
+@doc(storage_options=_shared_docs["storage_options"])
def read_html(
io: FilePath | ReadBuffer[str],
*,
@@ -1096,13 +1099,13 @@ def read_html(
passed to lxml or Beautiful Soup. However, these attributes must be
valid HTML table attributes to work correctly. For example, ::
- attrs = {'id': 'table'}
+ attrs = {{'id': 'table'}}
is a valid attribute dictionary because the 'id' HTML tag attribute is
a valid HTML attribute for *any* HTML tag as per `this document
<https://html.spec.whatwg.org/multipage/dom.html#global-attributes>`__. ::
- attrs = {'asdf': 'table'}
+ attrs = {{'asdf': 'table'}}
is *not* a valid attribute dictionary because 'asdf' is not a valid
HTML attribute even if it is a valid XML attribute. Valid HTML 4.01
@@ -1144,13 +1147,13 @@ def read_html(
displayed_only : bool, default True
Whether elements with "display: none" should be parsed.
- extract_links : {None, "all", "header", "body", "footer"}
+ extract_links : {{None, "all", "header", "body", "footer"}}
Table elements in the specified section(s) with <a> tags will have their
href extracted.
.. versionadded:: 1.5.0
- dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
+ dtype_backend : {{'numpy_nullable', 'pyarrow'}}, default 'numpy_nullable'
Back-end data type applied to the resultant :class:`DataFrame`
(still experimental). Behaviour is as follows:
@@ -1161,6 +1164,10 @@ def read_html(
.. versionadded:: 2.0
+ {storage_options}
+
+ .. versionadded:: 2.1.0
+
Returns
-------
dfs
| - [x] closes #54772
- [ ] 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. | https://api.github.com/repos/pandas-dev/pandas/pulls/54815 | 2023-08-28T15:32:10Z | 2023-08-29T16:06:40Z | 2023-08-29T16:06:40Z | 2023-08-29T16:06:47Z |
Backport PR #54803 on branch 2.1.x (DOC: update docstrings for ffill and bfill (no longer aliases for fillna with method)) | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index b4281f6959997..fce9b35aa5c49 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -7079,6 +7079,8 @@ def fillna(
See Also
--------
+ ffill : Fill values by propagating the last valid observation to next valid.
+ bfill : Fill values by using the next valid observation to fill the gap.
interpolate : Fill NaN values using interpolation.
reindex : Conform object to new index.
asfreq : Convert TimeSeries to specified frequency.
@@ -7338,7 +7340,10 @@ def ffill(
...
@final
- @doc(klass=_shared_doc_kwargs["klass"])
+ @doc(
+ klass=_shared_doc_kwargs["klass"],
+ axes_single_arg=_shared_doc_kwargs["axes_single_arg"],
+ )
def ffill(
self,
*,
@@ -7350,6 +7355,27 @@ def ffill(
"""
Fill NA/NaN values by propagating the last valid observation to next valid.
+ Parameters
+ ----------
+ axis : {axes_single_arg}
+ Axis along which to fill missing values. For `Series`
+ this parameter is unused and defaults to 0.
+ inplace : bool, default False
+ If True, fill in-place. Note: this will modify any
+ other views on this object (e.g., a no-copy slice for a column in a
+ DataFrame).
+ limit : int, default None
+ If method is specified, this is the maximum number of consecutive
+ NaN values to forward/backward fill. In other words, if there is
+ a gap with more than this number of consecutive NaNs, it will only
+ 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).
+
Returns
-------
{klass} or None
@@ -7417,7 +7443,7 @@ def pad(
downcast: dict | None | lib.NoDefault = lib.no_default,
) -> Self | None:
"""
- Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.
+ Fill NA/NaN values by propagating the last valid observation to next valid.
.. deprecated:: 2.0
@@ -7474,7 +7500,10 @@ def bfill(
...
@final
- @doc(klass=_shared_doc_kwargs["klass"])
+ @doc(
+ klass=_shared_doc_kwargs["klass"],
+ axes_single_arg=_shared_doc_kwargs["axes_single_arg"],
+ )
def bfill(
self,
*,
@@ -7484,7 +7513,28 @@ def bfill(
downcast: dict | None | lib.NoDefault = lib.no_default,
) -> Self | None:
"""
- Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.
+ Fill NA/NaN values by using the next valid observation to fill the gap.
+
+ Parameters
+ ----------
+ axis : {axes_single_arg}
+ Axis along which to fill missing values. For `Series`
+ this parameter is unused and defaults to 0.
+ inplace : bool, default False
+ If True, fill in-place. Note: this will modify any
+ other views on this object (e.g., a no-copy slice for a column in a
+ DataFrame).
+ limit : int, default None
+ If method is specified, this is the maximum number of consecutive
+ NaN values to forward/backward fill. In other words, if there is
+ a gap with more than this number of consecutive NaNs, it will only
+ 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).
Returns
-------
@@ -7563,7 +7613,7 @@ def backfill(
downcast: dict | None | lib.NoDefault = lib.no_default,
) -> Self | None:
"""
- Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.
+ Fill NA/NaN values by using the next valid observation to fill the gap.
.. deprecated:: 2.0
| Backport PR #54803: DOC: update docstrings for ffill and bfill (no longer aliases for fillna with method) | https://api.github.com/repos/pandas-dev/pandas/pulls/54814 | 2023-08-28T15:25:51Z | 2023-08-28T17:26:21Z | 2023-08-28T17:26:21Z | 2023-08-28T17:26:21Z |
Backport PR #54778 on branch 2.1.x (REGR: Index.union loses python string dtype) | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 1f15a4ad84755..0db0a3608a1f0 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -5204,7 +5204,7 @@ def _from_join_target(self, result: np.ndarray) -> ArrayLike:
"""
if isinstance(self.values, BaseMaskedArray):
return type(self.values)(result, np.zeros(result.shape, dtype=np.bool_))
- elif isinstance(self.values, ArrowExtensionArray):
+ elif isinstance(self.values, (ArrowExtensionArray, StringArray)):
return type(self.values)._from_sequence(result)
return result
diff --git a/pandas/tests/indexes/test_setops.py b/pandas/tests/indexes/test_setops.py
index 2fd203dbc77ed..a64994efec85a 100644
--- a/pandas/tests/indexes/test_setops.py
+++ b/pandas/tests/indexes/test_setops.py
@@ -899,3 +899,10 @@ def test_union_ea_dtypes(self, any_numeric_ea_and_arrow_dtype):
result = idx.union(idx2)
expected = Index([1, 2, 3, 4, 5], dtype=any_numeric_ea_and_arrow_dtype)
tm.assert_index_equal(result, expected)
+
+ def test_union_string_array(self, any_string_dtype):
+ idx1 = Index(["a"], dtype=any_string_dtype)
+ idx2 = Index(["b"], dtype=any_string_dtype)
+ result = idx1.union(idx2)
+ expected = Index(["a", "b"], dtype=any_string_dtype)
+ tm.assert_index_equal(result, expected)
| Backport PR #54778: REGR: Index.union loses python string dtype | https://api.github.com/repos/pandas-dev/pandas/pulls/54813 | 2023-08-28T15:16:48Z | 2023-08-28T17:25:59Z | 2023-08-28T17:25:59Z | 2023-08-28T17:26:00Z |
Backport PR #54800 on branch 2.1.x (ExtensionArray.fillna: start with DeprecationWarning about added copy keyword) | diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 7e647426e9726..a33c5d9303421 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -2015,7 +2015,7 @@ def fillna(
"need to implement this keyword or an exception will be "
"raised. In the interim, the keyword is ignored by "
f"{type(self.values).__name__}.",
- FutureWarning,
+ DeprecationWarning,
stacklevel=find_stack_level(),
)
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index baa056550624f..17dfc4e801ca0 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -133,7 +133,7 @@ def test_arith_series_with_array(self, data, all_arithmetic_operators):
def test_fillna_frame(self, data_missing):
msg = "ExtensionArray.fillna added a 'copy' keyword"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ DeprecationWarning, match=msg, check_stacklevel=False
):
super().test_fillna_frame(data_missing)
@@ -166,7 +166,7 @@ def test_fillna_no_op_returns_copy(self, data):
def test_fillna_series(self, data_missing):
msg = "ExtensionArray.fillna added a 'copy' keyword"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ DeprecationWarning, match=msg, check_stacklevel=False
):
super().test_fillna_series(data_missing)
@@ -178,13 +178,13 @@ def test_fillna_series_method(self, data_missing, fillna_method):
super().test_fillna_series_method(data_missing, fillna_method)
def test_fillna_copy_frame(self, data_missing, using_copy_on_write):
- warn = FutureWarning if not using_copy_on_write else None
+ warn = DeprecationWarning if not using_copy_on_write else None
msg = "ExtensionArray.fillna added a 'copy' keyword"
with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
super().test_fillna_copy_frame(data_missing)
def test_fillna_copy_series(self, data_missing, using_copy_on_write):
- warn = FutureWarning if not using_copy_on_write else None
+ warn = DeprecationWarning if not using_copy_on_write else None
msg = "ExtensionArray.fillna added a 'copy' keyword"
with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
super().test_fillna_copy_series(data_missing)
| Backport PR #54800: ExtensionArray.fillna: start with DeprecationWarning about added copy keyword | https://api.github.com/repos/pandas-dev/pandas/pulls/54812 | 2023-08-28T15:10:43Z | 2023-08-28T17:25:37Z | 2023-08-28T17:25:37Z | 2023-08-28T17:25:37Z |
ERR: improve setitem error message for DatetimeArray | diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index c3b8d1c0e79e8..61946caa3c142 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -625,15 +625,19 @@ def _validation_error_message(self, value, allow_listlike: bool = False) -> str:
-------
str
"""
+ if hasattr(value, "dtype") and getattr(value, "ndim", 0) > 0:
+ msg_got = f"{value.dtype} array"
+ else:
+ msg_got = f"'{type(value).__name__}'"
if allow_listlike:
msg = (
f"value should be a '{self._scalar_type.__name__}', 'NaT', "
- f"or array of those. Got '{type(value).__name__}' instead."
+ f"or array of those. Got {msg_got} instead."
)
else:
msg = (
f"value should be a '{self._scalar_type.__name__}' or 'NaT'. "
- f"Got '{type(value).__name__}' instead."
+ f"Got {msg_got} instead."
)
return msg
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 20530e37116f2..bd03e0698d667 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -324,19 +324,12 @@ def test_searchsorted_castable_strings(self, arr1d, box, string_storage):
):
arr.searchsorted("foo")
- if string_storage == "python":
- arr_type = "StringArray"
- elif string_storage == "pyarrow":
- arr_type = "ArrowStringArray"
- else:
- arr_type = "ArrowStringArrayNumpySemantics"
-
with pd.option_context("string_storage", string_storage):
with pytest.raises(
TypeError,
match=re.escape(
f"value should be a '{arr1d._scalar_type.__name__}', 'NaT', "
- f"or array of those. Got '{arr_type}' instead."
+ "or array of those. Got string array instead."
),
):
arr.searchsorted([str(arr[1]), "baz"])
| This is a small detail, but currently we see this kind of error message:
```python
>>> ser = pd.Series(pd.arrays.DatetimeArray(np.arange(10, dtype="i8") * 24 * 3600 * 10**9))
>>> ser.searchsorted(["foo", "baz"])
TypeError: value should be a 'Timestamp', 'NaT', or array of those. Got 'StringArray' instead.
>>> ser.searchsorted(np.array([1, 2, 3]))
TypeError: value should be a 'Timestamp', 'NaT', or array of those. Got 'IntegerArray' instead.
>>> pd.options.mode.string_storage = "pyarrow_numpy"
>>> ser.searchsorted(["foo", "baz"])
TypeError: value should be a 'Timestamp', 'NaT', or array of those. Got 'ArrowStringArrayNumpySemantics' instead.
```
(and same error message is used for the array's `__setitem__`)
I personally don't like that the error message uses the array class names (those are not exactly private, but still not something users typically have to work with directly), and I think in general we should try to write our messages in a more generic, user-friendly way (what the user wants to know here is that they provided data of a wrong data type).
With this small PR, the above message become the following, respectively:
```
TypeError: value should be a 'Timestamp', 'NaT', or array of those. Got string array instead.
TypeError: value should be a 'Timestamp', 'NaT', or array of those. Got Int64 array instead.
TypeError: value should be a 'Timestamp', 'NaT', or array of those. Got string array instead.
```
(and as a bonus, the testing actually became easier) | https://api.github.com/repos/pandas-dev/pandas/pulls/54809 | 2023-08-28T13:38:57Z | 2023-08-29T16:08:19Z | 2023-08-29T16:08:19Z | 2023-08-29T16:08:25Z |
DOC: update docstrings for ffill and bfill (no longer aliases for fillna with method) | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 021725899a1bb..b87772594cfbf 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -7099,6 +7099,8 @@ def fillna(
See Also
--------
+ ffill : Fill values by propagating the last valid observation to next valid.
+ bfill : Fill values by using the next valid observation to fill the gap.
interpolate : Fill NaN values using interpolation.
reindex : Conform object to new index.
asfreq : Convert TimeSeries to specified frequency.
@@ -7358,7 +7360,10 @@ def ffill(
...
@final
- @doc(klass=_shared_doc_kwargs["klass"])
+ @doc(
+ klass=_shared_doc_kwargs["klass"],
+ axes_single_arg=_shared_doc_kwargs["axes_single_arg"],
+ )
def ffill(
self,
*,
@@ -7370,6 +7375,27 @@ def ffill(
"""
Fill NA/NaN values by propagating the last valid observation to next valid.
+ Parameters
+ ----------
+ axis : {axes_single_arg}
+ Axis along which to fill missing values. For `Series`
+ this parameter is unused and defaults to 0.
+ inplace : bool, default False
+ If True, fill in-place. Note: this will modify any
+ other views on this object (e.g., a no-copy slice for a column in a
+ DataFrame).
+ limit : int, default None
+ If method is specified, this is the maximum number of consecutive
+ NaN values to forward/backward fill. In other words, if there is
+ a gap with more than this number of consecutive NaNs, it will only
+ 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).
+
Returns
-------
{klass} or None
@@ -7437,7 +7463,7 @@ def pad(
downcast: dict | None | lib.NoDefault = lib.no_default,
) -> Self | None:
"""
- Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.
+ Fill NA/NaN values by propagating the last valid observation to next valid.
.. deprecated:: 2.0
@@ -7494,7 +7520,10 @@ def bfill(
...
@final
- @doc(klass=_shared_doc_kwargs["klass"])
+ @doc(
+ klass=_shared_doc_kwargs["klass"],
+ axes_single_arg=_shared_doc_kwargs["axes_single_arg"],
+ )
def bfill(
self,
*,
@@ -7504,7 +7533,28 @@ def bfill(
downcast: dict | None | lib.NoDefault = lib.no_default,
) -> Self | None:
"""
- Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.
+ Fill NA/NaN values by using the next valid observation to fill the gap.
+
+ Parameters
+ ----------
+ axis : {axes_single_arg}
+ Axis along which to fill missing values. For `Series`
+ this parameter is unused and defaults to 0.
+ inplace : bool, default False
+ If True, fill in-place. Note: this will modify any
+ other views on this object (e.g., a no-copy slice for a column in a
+ DataFrame).
+ limit : int, default None
+ If method is specified, this is the maximum number of consecutive
+ NaN values to forward/backward fill. In other words, if there is
+ a gap with more than this number of consecutive NaNs, it will only
+ 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).
Returns
-------
@@ -7583,7 +7633,7 @@ def backfill(
downcast: dict | None | lib.NoDefault = lib.no_default,
) -> Self | None:
"""
- Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.
+ Fill NA/NaN values by using the next valid observation to fill the gap.
.. deprecated:: 2.0
| Follow-up on https://github.com/pandas-dev/pandas/pull/54728 to do the same for `bfill`, and also updated both `ffill` and `bfill` to include the parameter section (now that only lived in fillna) | https://api.github.com/repos/pandas-dev/pandas/pulls/54803 | 2023-08-28T12:16:37Z | 2023-08-28T15:25:43Z | 2023-08-28T15:25:43Z | 2023-08-28T15:26:41Z |
Revert "MAINT: small simplification of meson.build following best practices" | diff --git a/meson.build b/meson.build
index e16f565d491fe..09a1494135af4 100644
--- a/meson.build
+++ b/meson.build
@@ -2,7 +2,7 @@
project(
'pandas',
'c', 'cpp', 'cython',
- version: run_command(['python3', 'generate_version.py', '--print'], check: true).stdout().strip(),
+ version: run_command(['python', 'generate_version.py', '--print'], check: true).stdout().strip(),
license: 'BSD-3',
meson_version: '>=1.0.1',
default_options: [
| Reverts pandas-dev/pandas#54737
cc @lithomas1 | https://api.github.com/repos/pandas-dev/pandas/pulls/54802 | 2023-08-28T12:13:49Z | 2023-08-28T17:36:01Z | 2023-08-28T17:36:01Z | 2023-08-28T17:36:07Z |
BUG: repr aligning left for string dtype columns | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 19a8500928ab7..8f2667d69a322 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -717,6 +717,7 @@ Conversion
Strings
^^^^^^^
- Bug in :meth:`Series.str` that did not raise a ``TypeError`` when iterated (:issue:`54173`)
+- Bug in ``repr`` for :class:`DataFrame`` with string-dtype columns (:issue:`54797`)
Interval
^^^^^^^^
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index a49db84450bb3..4e037cc3e8626 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1396,8 +1396,8 @@ def _format_with_header(self, header: list[str_t], na_rep: str_t) -> list[str_t]
values = self._values
- if is_object_dtype(values.dtype):
- values = cast(np.ndarray, values)
+ if is_object_dtype(values.dtype) or is_string_dtype(values.dtype):
+ values = np.asarray(values)
values = lib.maybe_convert_objects(values, safe=True)
result = [pprint_thing(x, escape_chars=("\t", "\r", "\n")) for x in values]
diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py
index 49375658abfee..64d516e484991 100644
--- a/pandas/tests/frame/test_repr_info.py
+++ b/pandas/tests/frame/test_repr_info.py
@@ -455,3 +455,14 @@ def test_masked_ea_with_formatter(self):
0 0.12 1.00
1 1.12 2.00"""
assert result == expected
+
+ def test_repr_ea_columns(self, any_string_dtype):
+ # GH#54797
+ pytest.importorskip("pyarrow")
+ df = DataFrame({"long_column_name": [1, 2, 3], "col2": [4, 5, 6]})
+ df.columns = df.columns.astype(any_string_dtype)
+ expected = """ long_column_name col2
+0 1 4
+1 2 5
+2 3 6"""
+ assert repr(df) == expected
| - [ ] closes #54797 (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.
cc @jorisvandenbossche this is a bit hacky, but changing format_array breaks index-related stuff. Don't feel comfortable to do this now, can be a follow up (we are casting to object anyway, so this does not impact performance) | https://api.github.com/repos/pandas-dev/pandas/pulls/54801 | 2023-08-28T12:09:21Z | 2023-08-28T17:35:15Z | 2023-08-28T17:35:15Z | 2023-08-28T17:35:18Z |
ExtensionArray.fillna: start with DeprecationWarning about added copy keyword | diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 12380752c198e..3b27f7e2eb80c 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -2008,7 +2008,7 @@ def fillna(
"need to implement this keyword or an exception will be "
"raised. In the interim, the keyword is ignored by "
f"{type(self.values).__name__}.",
- FutureWarning,
+ DeprecationWarning,
stacklevel=find_stack_level(),
)
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index 2f274354f0da0..acc82ecd9301a 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -133,7 +133,7 @@ def test_arith_series_with_array(self, data, all_arithmetic_operators):
def test_fillna_frame(self, data_missing):
msg = "ExtensionArray.fillna added a 'copy' keyword"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ DeprecationWarning, match=msg, check_stacklevel=False
):
super().test_fillna_frame(data_missing)
@@ -166,7 +166,7 @@ def test_fillna_no_op_returns_copy(self, data):
def test_fillna_series(self, data_missing):
msg = "ExtensionArray.fillna added a 'copy' keyword"
with tm.assert_produces_warning(
- FutureWarning, match=msg, check_stacklevel=False
+ DeprecationWarning, match=msg, check_stacklevel=False
):
super().test_fillna_series(data_missing)
@@ -178,13 +178,13 @@ def test_fillna_series_method(self, data_missing, fillna_method):
super().test_fillna_series_method(data_missing, fillna_method)
def test_fillna_copy_frame(self, data_missing, using_copy_on_write):
- warn = FutureWarning if not using_copy_on_write else None
+ warn = DeprecationWarning if not using_copy_on_write else None
msg = "ExtensionArray.fillna added a 'copy' keyword"
with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
super().test_fillna_copy_frame(data_missing)
def test_fillna_copy_series(self, data_missing, using_copy_on_write):
- warn = FutureWarning if not using_copy_on_write else None
+ warn = DeprecationWarning if not using_copy_on_write else None
msg = "ExtensionArray.fillna added a 'copy' keyword"
with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
super().test_fillna_copy_series(data_missing)
| Follow-up on https://github.com/pandas-dev/pandas/pull/53728, changing the FutureWarning to DeprecationWarning. This warning is targetting EA authors, not end users, and thus we should start with a DeprecationWarning. | https://api.github.com/repos/pandas-dev/pandas/pulls/54800 | 2023-08-28T11:57:56Z | 2023-08-28T15:10:35Z | 2023-08-28T15:10:35Z | 2023-08-28T15:10:38Z |
Backport PR #54737 on branch 2.1.x (MAINT: small simplification of meson.build following best practices) | diff --git a/meson.build b/meson.build
index a927b59abeaf9..09a1494135af4 100644
--- a/meson.build
+++ b/meson.build
@@ -6,9 +6,6 @@ project(
license: 'BSD-3',
meson_version: '>=1.0.1',
default_options: [
- # TODO: investigate, does meson try to compile against debug Python
- # when buildtype = debug, this seems to be causing problems on CI
- # where provided Python is not compiled in debug mode
'buildtype=release',
# TODO: Reactivate werror, some warnings on Windows
#'werror=true',
@@ -16,10 +13,8 @@ project(
]
)
-py_mod = import('python')
fs = import('fs')
-py = py_mod.find_installation('python')
-py_dep = py.dependency()
+py = import('python').find_installation()
tempita = files('generate_pxi.py')
versioneer = files('generate_version.py')
diff --git a/pandas/_libs/window/meson.build b/pandas/_libs/window/meson.build
index b83d8730f9447..85aa060a26406 100644
--- a/pandas/_libs/window/meson.build
+++ b/pandas/_libs/window/meson.build
@@ -3,7 +3,6 @@ py.extension_module(
['aggregations.pyx'],
cython_args: ['-X always_allow_keywords=true'],
include_directories: [inc_np, inc_pd],
- dependencies: [py_dep],
subdir: 'pandas/_libs/window',
override_options : ['cython_language=cpp'],
install: true
@@ -14,7 +13,6 @@ py.extension_module(
['indexers.pyx'],
cython_args: ['-X always_allow_keywords=true'],
include_directories: [inc_np, inc_pd],
- dependencies: [py_dep],
subdir: 'pandas/_libs/window',
install: true
)
| Backport PR #54737: MAINT: small simplification of meson.build following best practices | https://api.github.com/repos/pandas-dev/pandas/pulls/54799 | 2023-08-28T11:45:43Z | 2023-08-28T19:43:07Z | 2023-08-28T19:43:07Z | 2023-08-28T19:43:07Z |
Backport PR #54591 on branch 2.1.x (Implement any and all for pyarrow numpy strings) | diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index bc1d7cb52e196..87dd48b3569d8 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -554,3 +554,16 @@ def value_counts(self, dropna: bool = True):
return Series(
result._values.to_numpy(), index=result.index, name=result.name, copy=False
)
+
+ def _reduce(
+ self, name: str, *, skipna: bool = True, keepdims: bool = False, **kwargs
+ ):
+ if name in ["any", "all"]:
+ arr = pc.and_kleene(
+ pc.invert(pc.is_null(self._pa_array)), pc.not_equal(self._pa_array, "")
+ )
+ return ArrowExtensionArray(arr)._reduce(
+ name, skipna=skipna, keepdims=keepdims, **kwargs
+ )
+ else:
+ return super()._reduce(name, skipna=skipna, keepdims=keepdims, **kwargs)
diff --git a/pandas/tests/extension/base/reduce.py b/pandas/tests/extension/base/reduce.py
index a6532a6190467..43b2df4290eed 100644
--- a/pandas/tests/extension/base/reduce.py
+++ b/pandas/tests/extension/base/reduce.py
@@ -25,7 +25,7 @@ def check_reduce(self, s, op_name, skipna):
try:
alt = s.astype("float64")
- except TypeError:
+ except (TypeError, ValueError):
# e.g. Interval can't cast, so let's cast to object and do
# the reduction pointwise
alt = s.astype(object)
diff --git a/pandas/tests/extension/test_string.py b/pandas/tests/extension/test_string.py
index 069d53aeb248f..5176289994033 100644
--- a/pandas/tests/extension/test_string.py
+++ b/pandas/tests/extension/test_string.py
@@ -157,6 +157,12 @@ def test_fillna_no_op_returns_copy(self, data):
class TestReduce(base.BaseReduceTests):
+ def _supports_reduction(self, ser: pd.Series, op_name: str) -> bool:
+ return (
+ ser.dtype.storage == "pyarrow_numpy" # type: ignore[union-attr]
+ and op_name in ("any", "all")
+ )
+
@pytest.mark.parametrize("skipna", [True, False])
def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna):
op_name = all_numeric_reductions
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index 87892a81cef3d..021252500e814 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -1078,6 +1078,25 @@ def test_any_all_datetimelike(self):
assert df.any().all()
assert not df.all().any()
+ def test_any_all_pyarrow_string(self):
+ # GH#54591
+ pytest.importorskip("pyarrow")
+ ser = Series(["", "a"], dtype="string[pyarrow_numpy]")
+ assert ser.any()
+ assert not ser.all()
+
+ ser = Series([None, "a"], dtype="string[pyarrow_numpy]")
+ assert ser.any()
+ assert not ser.all()
+
+ ser = Series([None, ""], dtype="string[pyarrow_numpy]")
+ assert not ser.any()
+ assert not ser.all()
+
+ ser = Series(["a", "b"], dtype="string[pyarrow_numpy]")
+ assert ser.any()
+ assert ser.all()
+
def test_timedelta64_analytics(self):
# index min/max
dti = date_range("2012-1-1", periods=3, freq="D")
| #54591 | https://api.github.com/repos/pandas-dev/pandas/pulls/54796 | 2023-08-28T11:21:56Z | 2023-08-28T15:05:31Z | 2023-08-28T15:05:31Z | 2023-08-28T15:05:39Z |
Backport PR #54789 on branch 2.1.x (WARN: Remove non-actionable warning in value_counts) | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 56e1b82c992c3..c34df3e0e865c 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7260,7 +7260,7 @@ def value_counts(
subset = self.columns.tolist()
name = "proportion" if normalize else "count"
- counts = self.groupby(subset, dropna=dropna).grouper.size()
+ counts = self.groupby(subset, dropna=dropna, observed=False).grouper.size()
counts.name = name
if sort:
diff --git a/pandas/tests/frame/methods/test_value_counts.py b/pandas/tests/frame/methods/test_value_counts.py
index 355f05cd5156c..c05a929360478 100644
--- a/pandas/tests/frame/methods/test_value_counts.py
+++ b/pandas/tests/frame/methods/test_value_counts.py
@@ -175,3 +175,17 @@ def test_data_frame_value_counts_subset(nulls_fixture, columns):
)
tm.assert_series_equal(result, expected)
+
+
+def test_value_counts_categorical_future_warning():
+ # GH#54775
+ df = pd.DataFrame({"a": [1, 2, 3]}, dtype="category")
+ result = df.value_counts()
+ expected = pd.Series(
+ 1,
+ index=pd.MultiIndex.from_arrays(
+ [pd.Index([1, 2, 3], name="a", dtype="category")]
+ ),
+ name="count",
+ )
+ tm.assert_series_equal(result, expected)
| Backport PR #54789: WARN: Remove non-actionable warning in value_counts | https://api.github.com/repos/pandas-dev/pandas/pulls/54795 | 2023-08-28T10:35:06Z | 2023-08-28T12:30:58Z | 2023-08-28T12:30:58Z | 2023-08-28T12:30:58Z |
Infer string storage based on infer_string option | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 19a8500928ab7..7e5be1fdde71b 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -39,11 +39,15 @@ We are collecting feedback on this decision `here <https://github.com/pandas-dev
Avoid NumPy object dtype for strings by default
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Previously, all strings were stored in columns with NumPy object dtype.
+Previously, all strings were stored in columns with NumPy object dtype by default.
This release introduces an option ``future.infer_string`` that infers all
strings as PyArrow backed strings with dtype ``"string[pyarrow_numpy]"`` instead.
This is a new string dtype implementation that follows NumPy semantics in comparison
operations and will return ``np.nan`` as the missing value indicator.
+Setting the option will also infer the dtype ``"string"`` as a :class:`StringDtype` with
+storage set to ``"pyarrow_numpy"``, ignoring the value behind the option
+``mode.string_storage``.
+
This option only works if PyArrow is installed. PyArrow backed strings have a
significantly reduced memory footprint and provide a big performance improvement
compared to NumPy object (:issue:`54430`).
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 1eaae0807fee1..72ba95e5fa258 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -115,7 +115,11 @@ def na_value(self) -> libmissing.NAType | float: # type: ignore[override]
def __init__(self, storage=None) -> None:
if storage is None:
- storage = get_option("mode.string_storage")
+ infer_string = get_option("future.infer_string")
+ if infer_string:
+ storage = "pyarrow_numpy"
+ else:
+ storage = get_option("mode.string_storage")
if storage not in {"python", "pyarrow", "pyarrow_numpy"}:
raise ValueError(
f"Storage must be 'python' or 'pyarrow'. Got {storage} instead."
diff --git a/pandas/core/config_init.py b/pandas/core/config_init.py
index d425a378b8d5b..645ed81c16ed3 100644
--- a/pandas/core/config_init.py
+++ b/pandas/core/config_init.py
@@ -493,7 +493,8 @@ def use_inf_as_na_cb(key) -> None:
string_storage_doc = """
: string
- The default storage for StringDtype.
+ The default storage for StringDtype. This option is ignored if
+ ``future.infer_string`` is set to True.
"""
with cf.config_prefix("mode"):
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index ef734e9664844..2c3fdf627788a 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -2115,6 +2115,14 @@ def test_series_string_inference_array_string_dtype(self):
ser = Series(np.array(["a", "b"]))
tm.assert_series_equal(ser, expected)
+ def test_series_string_inference_storage_definition(self):
+ # GH#54793
+ pytest.importorskip("pyarrow")
+ expected = Series(["a", "b"], dtype="string[pyarrow_numpy]")
+ with pd.option_context("future.infer_string", True):
+ result = Series(["a", "b"], dtype="string")
+ tm.assert_series_equal(result, expected)
+
class TestSeriesConstructorIndexCoercion:
def test_series_constructor_datetimelike_index_coercion(self):
| - [x] closes #54793
- [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 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/54794 | 2023-08-28T10:32:36Z | 2023-08-29T08:36:21Z | 2023-08-29T08:36:21Z | 2023-08-29T22:07:57Z |
Backport PR #54527 on branch 2.1.x (BUG: Special-case setting nan into integer series) | diff --git a/pandas/_libs/lib.pyi b/pandas/_libs/lib.pyi
index 32641319a6b96..15bd5a7379105 100644
--- a/pandas/_libs/lib.pyi
+++ b/pandas/_libs/lib.pyi
@@ -195,6 +195,7 @@ def array_equivalent_object(
right: npt.NDArray[np.object_],
) -> bool: ...
def has_infs(arr: np.ndarray) -> bool: ... # const floating[:]
+def has_only_ints_or_nan(arr: np.ndarray) -> bool: ... # const floating[:]
def get_reverse_indexer(
indexer: np.ndarray, # const intp_t[:]
length: int,
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 859cb8e5ebead..0c0610f72044e 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -530,6 +530,22 @@ def has_infs(floating[:] arr) -> bool:
return ret
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def has_only_ints_or_nan(floating[:] arr) -> bool:
+ cdef:
+ floating val
+ intp_t i
+
+ for i in range(len(arr)):
+ val = arr[i]
+ if (val != val) or (val == <int64_t>val):
+ continue
+ else:
+ return False
+ return True
+
+
def maybe_indices_to_slice(ndarray[intp_t, ndim=1] indices, int max_len):
cdef:
Py_ssize_t i, n = len(indices)
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 6df90eece3cc8..7e647426e9726 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -18,6 +18,7 @@
from pandas._config import using_copy_on_write
from pandas._libs import (
+ NaT,
internals as libinternals,
lib,
writers,
@@ -60,7 +61,10 @@
from pandas.core.dtypes.common import (
ensure_platform_int,
is_1d_only_ea_dtype,
+ is_float_dtype,
+ is_integer_dtype,
is_list_like,
+ is_scalar,
is_string_dtype,
)
from pandas.core.dtypes.dtypes import (
@@ -454,6 +458,25 @@ def coerce_to_target_dtype(self, other, warn_on_upcast: bool = False) -> Block:
and will receive the same block
"""
new_dtype = find_result_type(self.values.dtype, other)
+
+ # In a future version of pandas, the default will be that
+ # setting `nan` into an integer series won't raise.
+ if (
+ is_scalar(other)
+ and is_integer_dtype(self.values.dtype)
+ and isna(other)
+ and other is not NaT
+ ):
+ warn_on_upcast = False
+ elif (
+ isinstance(other, np.ndarray)
+ and other.ndim == 1
+ and is_integer_dtype(self.values.dtype)
+ and is_float_dtype(other.dtype)
+ and lib.has_only_ints_or_nan(other)
+ ):
+ warn_on_upcast = False
+
if warn_on_upcast:
warnings.warn(
f"Setting an item of incompatible dtype is deprecated "
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index 288aa1af746b6..b324291bab31e 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -337,18 +337,12 @@ def test_setitem(self, float_frame, using_copy_on_write):
def test_setitem2(self):
# dtype changing GH4204
df = DataFrame([[0, 0]])
- with tm.assert_produces_warning(
- FutureWarning, match="Setting an item of incompatible dtype"
- ):
- df.iloc[0] = np.nan
+ df.iloc[0] = np.nan
expected = DataFrame([[np.nan, np.nan]])
tm.assert_frame_equal(df, expected)
df = DataFrame([[0, 0]])
- with tm.assert_produces_warning(
- FutureWarning, match="Setting an item of incompatible dtype"
- ):
- df.loc[0] = np.nan
+ df.loc[0] = np.nan
tm.assert_frame_equal(df, expected)
def test_setitem_boolean(self, float_frame):
@@ -1579,9 +1573,7 @@ def test_setitem(self, uint64_frame):
# With NaN: because uint64 has no NaN element,
# the column should be cast to object.
df2 = df.copy()
- with tm.assert_produces_warning(
- FutureWarning, match="Setting an item of incompatible dtype"
- ):
+ with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
df2.iloc[1, 1] = pd.NaT
df2.iloc[1, 2] = pd.NaT
result = df2["B"]
@@ -1901,19 +1893,19 @@ def test_setitem_dict_and_set_disallowed_multiindex(self, key):
class TestSetitemValidation:
# This is adapted from pandas/tests/arrays/masked/test_indexing.py
# but checks for warnings instead of errors.
- def _check_setitem_invalid(self, df, invalid, indexer):
+ def _check_setitem_invalid(self, df, invalid, indexer, warn):
msg = "Setting an item of incompatible dtype is deprecated"
msg = re.escape(msg)
orig_df = df.copy()
# iloc
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(warn, match=msg):
df.iloc[indexer, 0] = invalid
df = orig_df.copy()
# loc
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(warn, match=msg):
df.loc[indexer, "a"] = invalid
df = orig_df.copy()
@@ -1934,16 +1926,20 @@ def _check_setitem_invalid(self, df, invalid, indexer):
@pytest.mark.parametrize("indexer", _indexers)
def test_setitem_validation_scalar_bool(self, invalid, indexer):
df = DataFrame({"a": [True, False, False]}, dtype="bool")
- self._check_setitem_invalid(df, invalid, indexer)
+ self._check_setitem_invalid(df, invalid, indexer, FutureWarning)
@pytest.mark.parametrize("invalid", _invalid_scalars + [True, 1.5, np.float64(1.5)])
@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)
- self._check_setitem_invalid(df, invalid, indexer)
+ if isna(invalid) and invalid is not pd.NaT:
+ warn = None
+ else:
+ warn = FutureWarning
+ self._check_setitem_invalid(df, invalid, indexer, warn)
@pytest.mark.parametrize("invalid", _invalid_scalars + [True])
@pytest.mark.parametrize("indexer", _indexers)
def test_setitem_validation_scalar_float(self, invalid, float_numpy_dtype, indexer):
df = DataFrame({"a": [1, 2, None]}, dtype=float_numpy_dtype)
- self._check_setitem_invalid(df, invalid, indexer)
+ self._check_setitem_invalid(df, invalid, indexer, FutureWarning)
diff --git a/pandas/tests/indexing/test_indexing.py b/pandas/tests/indexing/test_indexing.py
index 224555399ff8f..54e204c43dadd 100644
--- a/pandas/tests/indexing/test_indexing.py
+++ b/pandas/tests/indexing/test_indexing.py
@@ -830,8 +830,7 @@ def test_coercion_with_loc(self, expected):
start_data, expected_result, warn = expected
start_dataframe = DataFrame({"foo": start_data})
- with tm.assert_produces_warning(warn, match="incompatible dtype"):
- start_dataframe.loc[0, ["foo"]] = None
+ start_dataframe.loc[0, ["foo"]] = None
expected_dataframe = DataFrame({"foo": expected_result})
tm.assert_frame_equal(start_dataframe, expected_dataframe)
@@ -841,8 +840,7 @@ def test_coercion_with_setitem_and_dataframe(self, expected):
start_data, expected_result, warn = expected
start_dataframe = DataFrame({"foo": start_data})
- with tm.assert_produces_warning(warn, match="incompatible dtype"):
- start_dataframe[start_dataframe["foo"] == start_dataframe["foo"][0]] = None
+ start_dataframe[start_dataframe["foo"] == start_dataframe["foo"][0]] = None
expected_dataframe = DataFrame({"foo": expected_result})
tm.assert_frame_equal(start_dataframe, expected_dataframe)
@@ -852,10 +850,7 @@ def test_none_coercion_loc_and_dataframe(self, expected):
start_data, expected_result, warn = expected
start_dataframe = DataFrame({"foo": start_data})
- with tm.assert_produces_warning(warn, match="incompatible dtype"):
- start_dataframe.loc[
- start_dataframe["foo"] == start_dataframe["foo"][0]
- ] = None
+ start_dataframe.loc[start_dataframe["foo"] == start_dataframe["foo"][0]] = None
expected_dataframe = DataFrame({"foo": expected_result})
tm.assert_frame_equal(start_dataframe, expected_dataframe)
@@ -869,10 +864,7 @@ def test_none_coercion_mixed_dtypes(self):
"d": ["a", "b", "c"],
}
)
- with tm.assert_produces_warning(
- FutureWarning, match="item of incompatible dtype"
- ):
- start_dataframe.iloc[0] = None
+ start_dataframe.iloc[0] = None
exp = DataFrame(
{
diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py
index 7b857a487db78..0fa28920d41bd 100644
--- a/pandas/tests/series/indexing/test_indexing.py
+++ b/pandas/tests/series/indexing/test_indexing.py
@@ -19,6 +19,7 @@
Timestamp,
concat,
date_range,
+ isna,
period_range,
timedelta_range,
)
@@ -456,25 +457,25 @@ def test_setitem_dict_and_set_disallowed_multiindex(self, key):
class TestSetitemValidation:
# This is adapted from pandas/tests/arrays/masked/test_indexing.py
# but checks for warnings instead of errors.
- def _check_setitem_invalid(self, ser, invalid, indexer):
+ def _check_setitem_invalid(self, ser, invalid, indexer, warn):
msg = "Setting an item of incompatible dtype is deprecated"
msg = re.escape(msg)
orig_ser = ser.copy()
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(warn, match=msg):
ser[indexer] = invalid
ser = orig_ser.copy()
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(warn, match=msg):
ser.iloc[indexer] = invalid
ser = orig_ser.copy()
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(warn, match=msg):
ser.loc[indexer] = invalid
ser = orig_ser.copy()
- with tm.assert_produces_warning(FutureWarning, match=msg):
+ with tm.assert_produces_warning(warn, match=msg):
ser[:] = invalid
_invalid_scalars = [
@@ -494,16 +495,20 @@ def _check_setitem_invalid(self, ser, invalid, indexer):
@pytest.mark.parametrize("indexer", _indexers)
def test_setitem_validation_scalar_bool(self, invalid, indexer):
ser = Series([True, False, False], dtype="bool")
- self._check_setitem_invalid(ser, invalid, indexer)
+ self._check_setitem_invalid(ser, invalid, indexer, FutureWarning)
@pytest.mark.parametrize("invalid", _invalid_scalars + [True, 1.5, np.float64(1.5)])
@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)
- self._check_setitem_invalid(ser, invalid, indexer)
+ if isna(invalid) and invalid is not NaT:
+ warn = None
+ else:
+ warn = FutureWarning
+ self._check_setitem_invalid(ser, invalid, indexer, warn)
@pytest.mark.parametrize("invalid", _invalid_scalars + [True])
@pytest.mark.parametrize("indexer", _indexers)
def test_setitem_validation_scalar_float(self, invalid, float_numpy_dtype, indexer):
ser = Series([1, 2, None], dtype=float_numpy_dtype)
- self._check_setitem_invalid(ser, invalid, indexer)
+ self._check_setitem_invalid(ser, invalid, indexer, FutureWarning)
diff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py
index bc596fb0a3abe..d42e884c1ac78 100644
--- a/pandas/tests/series/indexing/test_setitem.py
+++ b/pandas/tests/series/indexing/test_setitem.py
@@ -191,14 +191,11 @@ def test_setitem_series_object_dtype(self, indexer, ser_index):
expected = Series([Series([42], index=[ser_index]), 0], dtype="object")
tm.assert_series_equal(ser, expected)
- @pytest.mark.parametrize(
- "index, exp_value, warn", [(0, 42, None), (1, np.nan, FutureWarning)]
- )
- def test_setitem_series(self, index, exp_value, warn):
+ @pytest.mark.parametrize("index, exp_value", [(0, 42), (1, np.nan)])
+ def test_setitem_series(self, index, exp_value):
# GH#38303
ser = Series([0, 0])
- with tm.assert_produces_warning(warn, match="item of incompatible dtype"):
- ser.loc[0] = Series([42], index=[index])
+ ser.loc[0] = Series([42], index=[index])
expected = Series([exp_value, 0])
tm.assert_series_equal(ser, expected)
@@ -575,7 +572,7 @@ def test_setitem_keep_precision(self, any_numeric_ea_dtype):
[
(NA, NA, "Int64", "Int64", 1, None),
(NA, NA, "Int64", "Int64", 2, None),
- (NA, np.nan, "int64", "float64", 1, FutureWarning),
+ (NA, np.nan, "int64", "float64", 1, None),
(NA, np.nan, "int64", "float64", 2, None),
(NaT, NaT, "int64", "object", 1, FutureWarning),
(NaT, NaT, "int64", "object", 2, None),
@@ -583,7 +580,7 @@ def test_setitem_keep_precision(self, any_numeric_ea_dtype):
(np.nan, NA, "Int64", "Int64", 2, None),
(np.nan, NA, "Float64", "Float64", 1, None),
(np.nan, NA, "Float64", "Float64", 2, None),
- (np.nan, np.nan, "int64", "float64", 1, FutureWarning),
+ (np.nan, np.nan, "int64", "float64", 1, None),
(np.nan, np.nan, "int64", "float64", 2, None),
],
)
@@ -592,7 +589,7 @@ def test_setitem_enlarge_with_na(
):
# GH#32346
ser = Series([1, 2], dtype=dtype)
- with tm.assert_produces_warning(warn, match="item of incompatible dtype"):
+ with tm.assert_produces_warning(warn, match="incompatible dtype"):
ser[indexer] = na
expected_values = [1, target_na] if indexer == 1 else [1, 2, target_na]
expected = Series(expected_values, dtype=target_dtype)
@@ -884,7 +881,7 @@ def test_index_putmask(self, obj, key, expected, warn, val):
Series([2, 3, 4, 5, 6, 7, 8, 9, 10]),
Series([np.nan, 3, np.nan, 5, np.nan, 7, np.nan, 9, np.nan]),
slice(None, None, 2),
- FutureWarning,
+ None,
id="int_series_slice_key_step",
),
pytest.param(
@@ -899,7 +896,7 @@ def test_index_putmask(self, obj, key, expected, warn, val):
Series(np.arange(10)),
Series([np.nan, np.nan, np.nan, np.nan, np.nan, 5, 6, 7, 8, 9]),
slice(None, 5),
- FutureWarning,
+ None,
id="int_series_slice_key",
),
pytest.param(
@@ -907,7 +904,7 @@ def test_index_putmask(self, obj, key, expected, warn, val):
Series([1, 2, 3]),
Series([np.nan, 2, 3]),
0,
- FutureWarning,
+ None,
id="int_series_int_key",
),
pytest.param(
@@ -1134,7 +1131,7 @@ def warn(self):
"obj,expected,warn",
[
# For numeric series, we should coerce to NaN.
- (Series([1, 2, 3]), Series([np.nan, 2, 3]), FutureWarning),
+ (Series([1, 2, 3]), Series([np.nan, 2, 3]), None),
(Series([1.0, 2.0, 3.0]), Series([np.nan, 2.0, 3.0]), None),
# For datetime series, we should coerce to NaT.
(
@@ -1584,13 +1581,11 @@ def test_20643_comment():
expected = Series([np.nan, 1, 2], index=["a", "b", "c"])
ser = orig.copy()
- with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
- ser.iat[0] = None
+ ser.iat[0] = None
tm.assert_series_equal(ser, expected)
ser = orig.copy()
- with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
- ser.iloc[0] = None
+ ser.iloc[0] = None
tm.assert_series_equal(ser, expected)
diff --git a/pandas/tests/series/methods/test_convert_dtypes.py b/pandas/tests/series/methods/test_convert_dtypes.py
index 9cd0ce250b5df..d1c79d0f00365 100644
--- a/pandas/tests/series/methods/test_convert_dtypes.py
+++ b/pandas/tests/series/methods/test_convert_dtypes.py
@@ -206,17 +206,7 @@ def test_convert_dtypes(
# Test that it is a copy
copy = series.copy(deep=True)
- if result.notna().sum() > 0 and result.dtype in [
- "int8",
- "uint8",
- "int16",
- "uint16",
- "int32",
- "uint32",
- "int64",
- "uint64",
- "interval[int64, right]",
- ]:
+ if result.notna().sum() > 0 and result.dtype in ["interval[int64, right]"]:
with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
result[result.notna()] = np.nan
else:
| Backport PR #54527: BUG: Special-case setting nan into integer series | https://api.github.com/repos/pandas-dev/pandas/pulls/54791 | 2023-08-28T09:37:29Z | 2023-08-28T12:31:28Z | 2023-08-28T12:31:28Z | 2023-08-28T12:31:29Z |
WARN: Remove non-actionable warning in value_counts | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 53ab03696551e..018059ce2784f 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7279,7 +7279,7 @@ def value_counts(
subset = self.columns.tolist()
name = "proportion" if normalize else "count"
- counts = self.groupby(subset, dropna=dropna).grouper.size()
+ counts = self.groupby(subset, dropna=dropna, observed=False).grouper.size()
counts.name = name
if sort:
diff --git a/pandas/tests/frame/methods/test_value_counts.py b/pandas/tests/frame/methods/test_value_counts.py
index 355f05cd5156c..c05a929360478 100644
--- a/pandas/tests/frame/methods/test_value_counts.py
+++ b/pandas/tests/frame/methods/test_value_counts.py
@@ -175,3 +175,17 @@ def test_data_frame_value_counts_subset(nulls_fixture, columns):
)
tm.assert_series_equal(result, expected)
+
+
+def test_value_counts_categorical_future_warning():
+ # GH#54775
+ df = pd.DataFrame({"a": [1, 2, 3]}, dtype="category")
+ result = df.value_counts()
+ expected = pd.Series(
+ 1,
+ index=pd.MultiIndex.from_arrays(
+ [pd.Index([1, 2, 3], name="a", dtype="category")]
+ ),
+ name="count",
+ )
+ tm.assert_series_equal(result, expected)
| - [x] closes #54775 (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.
cc @rhshadrach maybe? | https://api.github.com/repos/pandas-dev/pandas/pulls/54789 | 2023-08-28T08:41:04Z | 2023-08-28T10:34:59Z | 2023-08-28T10:34:58Z | 2023-08-29T05:19:35Z |
TYP: simple return types | diff --git a/pandas/_testing/_io.py b/pandas/_testing/_io.py
index edbba9452b50a..95977edb600ad 100644
--- a/pandas/_testing/_io.py
+++ b/pandas/_testing/_io.py
@@ -118,7 +118,7 @@ def round_trip_localpath(writer, reader, path: str | None = None):
return obj
-def write_to_compressed(compression, path, data, dest: str = "test"):
+def write_to_compressed(compression, path, data, dest: str = "test") -> None:
"""
Write data to a compressed file.
diff --git a/pandas/arrays/__init__.py b/pandas/arrays/__init__.py
index 32e2afc0eef52..a11755275d00e 100644
--- a/pandas/arrays/__init__.py
+++ b/pandas/arrays/__init__.py
@@ -36,7 +36,7 @@
]
-def __getattr__(name: str):
+def __getattr__(name: str) -> type[NumpyExtensionArray]:
if name == "PandasArray":
# GH#53694
import warnings
diff --git a/pandas/compat/pickle_compat.py b/pandas/compat/pickle_compat.py
index 8282ec25c1d58..4f067d958b799 100644
--- a/pandas/compat/pickle_compat.py
+++ b/pandas/compat/pickle_compat.py
@@ -26,7 +26,7 @@
from collections.abc import Generator
-def load_reduce(self):
+def load_reduce(self) -> None:
stack = self.stack
args = stack.pop()
func = stack[-1]
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 10826f50d1fe1..ea59bbfd088a9 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -491,7 +491,7 @@ def box_with_array(request):
@pytest.fixture
-def dict_subclass():
+def dict_subclass() -> type[dict]:
"""
Fixture for a dictionary subclass.
"""
@@ -504,7 +504,7 @@ def __init__(self, *args, **kwargs) -> None:
@pytest.fixture
-def non_dict_mapping_subclass():
+def non_dict_mapping_subclass() -> type[abc.Mapping]:
"""
Fixture for a non-mapping dictionary subclass.
"""
diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index 6ab2f958b8730..4d6dd8f4fd577 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -54,9 +54,9 @@
if TYPE_CHECKING:
from collections.abc import (
+ Generator,
Hashable,
Iterable,
- Iterator,
Sequence,
)
@@ -253,7 +253,7 @@ def transform(self) -> DataFrame | Series:
return result
- def transform_dict_like(self, func):
+ def transform_dict_like(self, func) -> DataFrame:
"""
Compute transform in the case of a dict-like func
"""
@@ -315,7 +315,7 @@ def compute_list_like(
op_name: Literal["agg", "apply"],
selected_obj: Series | DataFrame,
kwargs: dict[str, Any],
- ) -> tuple[list[Hashable], list[Any]]:
+ ) -> tuple[list[Hashable] | Index, list[Any]]:
"""
Compute agg/apply results for like-like input.
@@ -330,7 +330,7 @@ def compute_list_like(
Returns
-------
- keys : list[hashable]
+ keys : list[Hashable] or Index
Index labels for result.
results : list
Data for result. When aggregating with a Series, this can contain any
@@ -370,12 +370,14 @@ def compute_list_like(
new_res = getattr(colg, op_name)(func, *args, **kwargs)
results.append(new_res)
indices.append(index)
- keys = selected_obj.columns.take(indices)
+ # error: Incompatible types in assignment (expression has type "Any |
+ # Index", variable has type "list[Any | Callable[..., Any] | str]")
+ keys = selected_obj.columns.take(indices) # type: ignore[assignment]
return keys, results
def wrap_results_list_like(
- self, keys: list[Hashable], results: list[Series | DataFrame]
+ self, keys: Iterable[Hashable], results: list[Series | DataFrame]
):
from pandas.core.reshape.concat import concat
@@ -772,7 +774,7 @@ def result_columns(self) -> Index:
@property
@abc.abstractmethod
- def series_generator(self) -> Iterator[Series]:
+ def series_generator(self) -> Generator[Series, None, None]:
pass
@abc.abstractmethod
@@ -1014,7 +1016,7 @@ class FrameRowApply(FrameApply):
axis: AxisInt = 0
@property
- def series_generator(self):
+ def series_generator(self) -> Generator[Series, None, None]:
return (self.obj._ixs(i, axis=1) for i in range(len(self.columns)))
@property
@@ -1075,7 +1077,7 @@ def apply_broadcast(self, target: DataFrame) -> DataFrame:
return result.T
@property
- def series_generator(self):
+ def series_generator(self) -> Generator[Series, None, None]:
values = self.values
values = ensure_wrapped_if_datetimelike(values)
assert len(values) > 0
diff --git a/pandas/core/arrays/arrow/extension_types.py b/pandas/core/arrays/arrow/extension_types.py
index 3249c1c829546..7814a77a1cdc5 100644
--- a/pandas/core/arrays/arrow/extension_types.py
+++ b/pandas/core/arrays/arrow/extension_types.py
@@ -48,7 +48,7 @@ def __ne__(self, other) -> bool:
def __hash__(self) -> int:
return hash((str(self), self.freq))
- def to_pandas_dtype(self):
+ def to_pandas_dtype(self) -> PeriodDtype:
return PeriodDtype(freq=self.freq)
@@ -105,7 +105,7 @@ def __ne__(self, other) -> bool:
def __hash__(self) -> int:
return hash((str(self), str(self.subtype), self.closed))
- def to_pandas_dtype(self):
+ def to_pandas_dtype(self) -> IntervalDtype:
return IntervalDtype(self.subtype.to_pandas_dtype(), self.closed)
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index dae0fb7782791..9f63d1f97c54f 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -2410,7 +2410,7 @@ def _mode(self, dropna: bool = True) -> Categorical:
# ------------------------------------------------------------------
# ExtensionArray Interface
- def unique(self):
+ def unique(self) -> Self:
"""
Return the ``Categorical`` which ``categories`` and ``codes`` are
unique.
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 73d4f6f38f102..58ade1ee935ec 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -110,7 +110,7 @@
)
-IntervalSideT = Union[TimeArrayLike, np.ndarray]
+IntervalSide = Union[TimeArrayLike, np.ndarray]
IntervalOrNA = Union[Interval, float]
_interval_shared_docs: dict[str, str] = {}
@@ -219,8 +219,8 @@ def ndim(self) -> Literal[1]:
return 1
# To make mypy recognize the fields
- _left: IntervalSideT
- _right: IntervalSideT
+ _left: IntervalSide
+ _right: IntervalSide
_dtype: IntervalDtype
# ---------------------------------------------------------------------
@@ -237,8 +237,8 @@ def __new__(
data = extract_array(data, extract_numpy=True)
if isinstance(data, cls):
- left: IntervalSideT = data._left
- right: IntervalSideT = data._right
+ left: IntervalSide = data._left
+ right: IntervalSide = data._right
closed = closed or data.closed
dtype = IntervalDtype(left.dtype, closed=closed)
else:
@@ -280,8 +280,8 @@ def __new__(
@classmethod
def _simple_new(
cls,
- left: IntervalSideT,
- right: IntervalSideT,
+ left: IntervalSide,
+ right: IntervalSide,
dtype: IntervalDtype,
) -> Self:
result = IntervalMixin.__new__(cls)
@@ -299,7 +299,7 @@ def _ensure_simple_new_inputs(
closed: IntervalClosedType | None = None,
copy: bool = False,
dtype: Dtype | None = None,
- ) -> tuple[IntervalSideT, IntervalSideT, IntervalDtype]:
+ ) -> tuple[IntervalSide, IntervalSide, IntervalDtype]:
"""Ensure correctness of input parameters for cls._simple_new."""
from pandas.core.indexes.base import ensure_index
@@ -1031,8 +1031,8 @@ def _concat_same_type(cls, to_concat: Sequence[IntervalArray]) -> Self:
raise ValueError("Intervals must all be closed on the same side.")
closed = closed_set.pop()
- left = np.concatenate([interval.left for interval in to_concat])
- right = np.concatenate([interval.right for interval in to_concat])
+ left: IntervalSide = np.concatenate([interval.left for interval in to_concat])
+ right: IntervalSide = np.concatenate([interval.right for interval in to_concat])
left, right, dtype = cls._ensure_simple_new_inputs(left, right, closed=closed)
@@ -1283,7 +1283,7 @@ def _format_space(self) -> str:
# Vectorized Interval Properties/Attributes
@property
- def left(self):
+ def left(self) -> Index:
"""
Return the left endpoints of each Interval in the IntervalArray as an Index.
@@ -1303,7 +1303,7 @@ def left(self):
return Index(self._left, copy=False)
@property
- def right(self):
+ def right(self) -> Index:
"""
Return the right endpoints of each Interval in the IntervalArray as an Index.
@@ -1855,11 +1855,17 @@ def isin(self, values) -> npt.NDArray[np.bool_]:
return isin(self.astype(object), values.astype(object))
@property
- def _combined(self) -> IntervalSideT:
- left = self.left._values.reshape(-1, 1)
- right = self.right._values.reshape(-1, 1)
+ def _combined(self) -> IntervalSide:
+ # error: Item "ExtensionArray" of "ExtensionArray | ndarray[Any, Any]"
+ # has no attribute "reshape" [union-attr]
+ left = self.left._values.reshape(-1, 1) # type: ignore[union-attr]
+ right = self.right._values.reshape(-1, 1) # type: ignore[union-attr]
if needs_i8_conversion(left.dtype):
- comb = left._concat_same_type([left, right], axis=1)
+ # error: Item "ndarray[Any, Any]" of "Any | ndarray[Any, Any]" has
+ # no attribute "_concat_same_type"
+ comb = left._concat_same_type( # type: ignore[union-attr]
+ [left, right], axis=1
+ )
else:
comb = np.concatenate([left, right], axis=1)
return comb
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index a2e4b595c42aa..eeede0ad9e6d2 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -948,7 +948,7 @@ def _check_timedeltalike_freq_compat(self, other):
return lib.item_from_zerodim(delta)
-def raise_on_incompatible(left, right):
+def raise_on_incompatible(left, right) -> IncompatibleFrequency:
"""
Helper function to render a consistent error message when raising
IncompatibleFrequency.
@@ -1089,7 +1089,7 @@ def validate_dtype_freq(dtype, freq: timedelta | str | None) -> BaseOffset:
def validate_dtype_freq(
- dtype, freq: BaseOffsetT | timedelta | str | None
+ dtype, freq: BaseOffsetT | BaseOffset | timedelta | str | None
) -> BaseOffsetT:
"""
If both a dtype and a freq are available, ensure they match. If only
@@ -1110,10 +1110,7 @@ def validate_dtype_freq(
IncompatibleFrequency : mismatch between dtype and freq
"""
if freq is not None:
- # error: Incompatible types in assignment (expression has type
- # "BaseOffset", variable has type "Union[BaseOffsetT, timedelta,
- # str, None]")
- freq = to_offset(freq) # type: ignore[assignment]
+ freq = to_offset(freq)
if dtype is not None:
dtype = pandas_dtype(dtype)
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index e38fa0a3bdae5..00cbe1286c195 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -702,7 +702,9 @@ def npoints(self) -> int:
"""
return self.sp_index.npoints
- def isna(self):
+ # error: Return type "SparseArray" of "isna" incompatible with return type
+ # "ndarray[Any, Any] | ExtensionArraySupportsAnyAll" in supertype "ExtensionArray"
+ def isna(self) -> Self: # type: ignore[override]
# If null fill value, we want SparseDtype[bool, true]
# to preserve the same memory usage.
dtype = SparseDtype(bool, self._null_fill_value)
@@ -1421,7 +1423,7 @@ def all(self, axis=None, *args, **kwargs):
return values.all()
- def any(self, axis: AxisInt = 0, *args, **kwargs):
+ def any(self, axis: AxisInt = 0, *args, **kwargs) -> bool:
"""
Tests whether at least one of elements evaluate True
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 72ba95e5fa258..c90127c0e9812 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -59,6 +59,7 @@
NumpySorter,
NumpyValueArrayLike,
Scalar,
+ Self,
npt,
type_t,
)
@@ -135,7 +136,7 @@ def type(self) -> type[str]:
return str
@classmethod
- def construct_from_string(cls, string):
+ def construct_from_string(cls, string) -> Self:
"""
Construct a StringDtype from a string.
diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index cc3bc5900c4c2..f438f75707265 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -53,6 +53,8 @@
npt,
)
+ from pandas import Series
+
ArrowStringScalarOrNAT = Union[str, libmissing.NAType]
@@ -547,7 +549,7 @@ def _cmp_method(self, other, op):
result = super()._cmp_method(other, op)
return result.to_numpy(np.bool_, na_value=False)
- def value_counts(self, dropna: bool = True):
+ def value_counts(self, dropna: bool = True) -> Series:
from pandas import Series
result = super().value_counts(dropna)
diff --git a/pandas/core/computation/expr.py b/pandas/core/computation/expr.py
index 2f94856702465..4770f403b1bdb 100644
--- a/pandas/core/computation/expr.py
+++ b/pandas/core/computation/expr.py
@@ -12,6 +12,7 @@
import tokenize
from typing import (
Callable,
+ ClassVar,
TypeVar,
)
@@ -349,8 +350,8 @@ class BaseExprVisitor(ast.NodeVisitor):
preparser : callable
"""
- const_type: type[Term] = Constant
- term_type = Term
+ const_type: ClassVar[type[Term]] = Constant
+ term_type: ClassVar[type[Term]] = Term
binary_ops = CMP_OPS_SYMS + BOOL_OPS_SYMS + ARITH_OPS_SYMS
binary_op_nodes = (
@@ -540,7 +541,7 @@ def visit_UnaryOp(self, node, **kwargs):
operand = self.visit(node.operand)
return op(operand)
- def visit_Name(self, node, **kwargs):
+ def visit_Name(self, node, **kwargs) -> Term:
return self.term_type(node.id, self.env, **kwargs)
# TODO(py314): deprecated since Python 3.8. Remove after Python 3.14 is min
@@ -555,11 +556,11 @@ def visit_Constant(self, node, **kwargs) -> Term:
return self.const_type(node.value, self.env)
# TODO(py314): deprecated since Python 3.8. Remove after Python 3.14 is min
- def visit_Str(self, node, **kwargs):
+ def visit_Str(self, node, **kwargs) -> Term:
name = self.env.add_tmp(node.s)
return self.term_type(name, self.env)
- def visit_List(self, node, **kwargs):
+ def visit_List(self, node, **kwargs) -> Term:
name = self.env.add_tmp([self.visit(e)(self.env) for e in node.elts])
return self.term_type(name, self.env)
@@ -569,7 +570,7 @@ def visit_Index(self, node, **kwargs):
"""df.index[4]"""
return self.visit(node.value)
- def visit_Subscript(self, node, **kwargs):
+ def visit_Subscript(self, node, **kwargs) -> Term:
from pandas import eval as pd_eval
value = self.visit(node.value)
@@ -589,7 +590,7 @@ def visit_Subscript(self, node, **kwargs):
name = self.env.add_tmp(v)
return self.term_type(name, env=self.env)
- def visit_Slice(self, node, **kwargs):
+ def visit_Slice(self, node, **kwargs) -> slice:
"""df.index[slice(4,6)]"""
lower = node.lower
if lower is not None:
diff --git a/pandas/core/computation/ops.py b/pandas/core/computation/ops.py
index 852bfae1cc79a..95ac20ba39edc 100644
--- a/pandas/core/computation/ops.py
+++ b/pandas/core/computation/ops.py
@@ -617,5 +617,5 @@ def __init__(self, name: str) -> None:
self.name = name
self.func = getattr(np, name)
- def __call__(self, *args):
+ def __call__(self, *args) -> MathCall:
return MathCall(self, args)
diff --git a/pandas/core/computation/pytables.py b/pandas/core/computation/pytables.py
index 77d8d79506258..138a3ee42f686 100644
--- a/pandas/core/computation/pytables.py
+++ b/pandas/core/computation/pytables.py
@@ -10,6 +10,7 @@
from typing import (
TYPE_CHECKING,
Any,
+ ClassVar,
)
import numpy as np
@@ -40,7 +41,10 @@
)
if TYPE_CHECKING:
- from pandas._typing import npt
+ from pandas._typing import (
+ Self,
+ npt,
+ )
class PyTablesScope(_scope.Scope):
@@ -283,7 +287,7 @@ def __repr__(self) -> str:
return "Filter: Not Initialized"
return pprint_thing(f"[Filter : [{self.filter[0]}] -> [{self.filter[1]}]")
- def invert(self):
+ def invert(self) -> Self:
"""invert the filter"""
if self.filter is not None:
self.filter = (
@@ -297,7 +301,8 @@ def format(self):
"""return the actual filter format"""
return [self.filter]
- def evaluate(self):
+ # error: Signature of "evaluate" incompatible with supertype "BinOp"
+ def evaluate(self) -> Self | None: # type: ignore[override]
if not self.is_valid:
raise ValueError(f"query term is not valid [{self}]")
@@ -336,7 +341,8 @@ class JointFilterBinOp(FilterBinOp):
def format(self):
raise NotImplementedError("unable to collapse Joint Filters")
- def evaluate(self):
+ # error: Signature of "evaluate" incompatible with supertype "BinOp"
+ def evaluate(self) -> Self: # type: ignore[override]
return self
@@ -357,7 +363,8 @@ def format(self):
"""return the actual ne format"""
return self.condition
- def evaluate(self):
+ # error: Signature of "evaluate" incompatible with supertype "BinOp"
+ def evaluate(self) -> Self | None: # type: ignore[override]
if not self.is_valid:
raise ValueError(f"query term is not valid [{self}]")
@@ -385,7 +392,8 @@ def evaluate(self):
class JointConditionBinOp(ConditionBinOp):
- def evaluate(self):
+ # error: Signature of "evaluate" incompatible with supertype "BinOp"
+ def evaluate(self) -> Self: # type: ignore[override]
self.condition = f"({self.lhs.condition} {self.op} {self.rhs.condition})"
return self
@@ -410,8 +418,8 @@ def prune(self, klass):
class PyTablesExprVisitor(BaseExprVisitor):
- const_type = Constant
- term_type = Term
+ const_type: ClassVar[type[ops.Term]] = Constant
+ term_type: ClassVar[type[Term]] = Term
def __init__(self, env, engine, parser, **kwargs) -> None:
super().__init__(env, engine, parser)
@@ -423,13 +431,15 @@ def __init__(self, env, engine, parser, **kwargs) -> None:
lambda node, bin_op=bin_op: partial(BinOp, bin_op, **kwargs),
)
- def visit_UnaryOp(self, node, **kwargs):
+ def visit_UnaryOp(self, node, **kwargs) -> ops.Term | UnaryOp | None:
if isinstance(node.op, (ast.Not, ast.Invert)):
return UnaryOp("~", self.visit(node.operand))
elif isinstance(node.op, ast.USub):
return self.const_type(-self.visit(node.operand).value, self.env)
elif isinstance(node.op, ast.UAdd):
raise NotImplementedError("Unary addition not supported")
+ # TODO: return None might never be reached
+ return None
def visit_Index(self, node, **kwargs):
return self.visit(node.value).value
@@ -440,7 +450,7 @@ def visit_Assign(self, node, **kwargs):
)
return self.visit(cmpr)
- def visit_Subscript(self, node, **kwargs):
+ def visit_Subscript(self, node, **kwargs) -> ops.Term:
# only allow simple subscripts
value = self.visit(node.value)
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index e3e38961a200b..66f00a7e9a805 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -77,6 +77,7 @@
DtypeObj,
IntervalClosedType,
Ordered,
+ Self,
npt,
type_t,
)
@@ -973,7 +974,7 @@ class PeriodDtype(PeriodDtypeBase, PandasExtensionDtype):
__hash__ = PeriodDtypeBase.__hash__
_freq: BaseOffset
- def __new__(cls, freq):
+ def __new__(cls, freq) -> PeriodDtype: # noqa: PYI034
"""
Parameters
----------
@@ -1004,11 +1005,11 @@ def __new__(cls, freq):
u._freq = freq
return u
- def __reduce__(self):
+ def __reduce__(self) -> tuple[type_t[Self], tuple[str_type]]:
return type(self), (self.name,)
@property
- def freq(self):
+ def freq(self) -> BaseOffset:
"""
The frequency object of this PeriodDtype.
@@ -1729,7 +1730,7 @@ def fill_value(self):
"""
return self._fill_value
- def _check_fill_value(self):
+ def _check_fill_value(self) -> None:
if not lib.is_scalar(self._fill_value):
raise ValueError(
f"fill_value must be a scalar. Got {self._fill_value} instead"
diff --git a/pandas/core/dtypes/inference.py b/pandas/core/dtypes/inference.py
index 9c04e57be36fc..f551716772f61 100644
--- a/pandas/core/dtypes/inference.py
+++ b/pandas/core/dtypes/inference.py
@@ -401,7 +401,7 @@ def is_sequence(obj) -> bool:
return False
-def is_dataclass(item):
+def is_dataclass(item) -> bool:
"""
Checks if the object is a data-class instance
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 282ecdcf31939..bd2a07afad688 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -12247,8 +12247,7 @@ def _to_dict_of_blocks(self, copy: bool = True):
"""
mgr = self._mgr
# convert to BlockManager if needed -> this way support ArrayManager as well
- mgr = mgr_to_mgr(mgr, "block")
- mgr = cast(BlockManager, mgr)
+ mgr = cast(BlockManager, mgr_to_mgr(mgr, "block"))
return {
k: self._constructor_from_mgr(v, axes=v.axes).__finalize__(self)
for k, v, in mgr.to_dict(copy=copy).items()
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 8bef167b747e2..dbabd04a87c36 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -721,8 +721,10 @@ def nunique(self, dropna: bool = True) -> Series | DataFrame:
return self._reindex_output(result, fill_value=0)
@doc(Series.describe)
- def describe(self, **kwargs):
- return super().describe(**kwargs)
+ def describe(self, percentiles=None, include=None, exclude=None) -> Series:
+ return super().describe(
+ percentiles=percentiles, include=include, exclude=exclude
+ )
def value_counts(
self,
@@ -770,6 +772,7 @@ def value_counts(
mask = ids != -1
ids, val = ids[mask], val[mask]
+ lab: Index | np.ndarray
if bins is None:
lab, lev = algorithms.factorize(val, sort=True)
llab = lambda lab, inc: lab[inc]
@@ -1152,7 +1155,7 @@ def alt(obj):
@property
@doc(Series.plot.__doc__)
- def plot(self):
+ def plot(self) -> GroupByPlot:
result = GroupByPlot(self)
return result
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 7f77c0c4826fb..11c97e30ab5cd 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -143,6 +143,7 @@ class providing the base-class of operations.
if TYPE_CHECKING:
from typing import Any
+ from pandas.core.resample import Resampler
from pandas.core.window import (
ExpandingGroupby,
ExponentialMovingWindowGroupby,
@@ -2094,7 +2095,7 @@ def _obj_1d_constructor(self) -> Callable:
@final
@Substitution(name="groupby")
@Substitution(see_also=_common_see_also)
- def any(self, skipna: bool = True):
+ def any(self, skipna: bool = True) -> NDFrameT:
"""
Return True if any value in the group is truthful, else False.
@@ -2150,7 +2151,7 @@ def any(self, skipna: bool = True):
@final
@Substitution(name="groupby")
@Substitution(see_also=_common_see_also)
- def all(self, skipna: bool = True):
+ def all(self, skipna: bool = True) -> NDFrameT:
"""
Return True if all values in the group are truthful, else False.
@@ -2399,7 +2400,7 @@ def mean(
return result.__finalize__(self.obj, method="groupby")
@final
- def median(self, numeric_only: bool = False):
+ def median(self, numeric_only: bool = False) -> NDFrameT:
"""
Compute median of groups, excluding missing values.
@@ -2828,7 +2829,7 @@ def _value_counts(
return result.__finalize__(self.obj, method="value_counts")
@final
- def sem(self, ddof: int = 1, numeric_only: bool = False):
+ def sem(self, ddof: int = 1, numeric_only: bool = False) -> NDFrameT:
"""
Compute standard error of the mean of groups, excluding missing values.
@@ -3119,7 +3120,7 @@ def sum(
2 30 72"""
),
)
- def prod(self, numeric_only: bool = False, min_count: int = 0):
+ def prod(self, numeric_only: bool = False, min_count: int = 0) -> NDFrameT:
return self._agg_general(
numeric_only=numeric_only, min_count=min_count, alias="prod", npfunc=np.prod
)
@@ -3261,7 +3262,7 @@ def max(
)
@final
- def first(self, numeric_only: bool = False, min_count: int = -1):
+ def first(self, numeric_only: bool = False, min_count: int = -1) -> NDFrameT:
"""
Compute the first non-null entry of each column.
@@ -3331,7 +3332,7 @@ def first(x: Series):
)
@final
- def last(self, numeric_only: bool = False, min_count: int = -1):
+ def last(self, numeric_only: bool = False, min_count: int = -1) -> NDFrameT:
"""
Compute the last non-null entry of each column.
@@ -3518,7 +3519,7 @@ def describe(
return result
@final
- def resample(self, rule, *args, **kwargs):
+ def resample(self, rule, *args, **kwargs) -> Resampler:
"""
Provide resampling when using a TimeGrouper.
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index add6c3ac4ec20..c51c17e04796a 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -289,12 +289,12 @@ def __init__(
self.dropna = dropna
self._grouper_deprecated = None
- self._indexer_deprecated = None
+ self._indexer_deprecated: npt.NDArray[np.intp] | None = None
self._obj_deprecated = None
self._gpr_index = None
self.binner = None
self._grouper = None
- self._indexer = None
+ self._indexer: npt.NDArray[np.intp] | None = None
def _get_grouper(
self, obj: NDFrameT, validate: bool = True
@@ -329,8 +329,8 @@ def _get_grouper(
@final
def _set_grouper(
- self, obj: NDFrame, sort: bool = False, *, gpr_index: Index | None = None
- ):
+ self, obj: NDFrameT, sort: bool = False, *, gpr_index: Index | None = None
+ ) -> tuple[NDFrameT, Index, npt.NDArray[np.intp] | None]:
"""
given an object and the specifications, setup the internal grouper
for this particular specification
@@ -350,8 +350,6 @@ def _set_grouper(
"""
assert obj is not None
- indexer = None
-
if self.key is not None and self.level is not None:
raise ValueError("The Grouper cannot specify both a key and a level!")
@@ -398,6 +396,7 @@ def _set_grouper(
raise ValueError(f"The level {level} is not valid")
# possibly sort
+ indexer: npt.NDArray[np.intp] | None = None
if (self.sort or sort) and not ax.is_monotonic_increasing:
# use stable sort to support first, last, nth
# TODO: why does putting na_position="first" fix datetimelike cases?
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 71525c8c1a223..607059e5183ec 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -77,7 +77,7 @@
from pandas.core.generic import NDFrame
-def check_result_array(obj, dtype):
+def check_result_array(obj, dtype) -> None:
# Our operation is supposed to be an aggregation/reduction. If
# it returns an ndarray, this likely means an invalid operation has
# been passed. See test_apply_without_aggregation, test_agg_must_agg
diff --git a/pandas/core/indexes/accessors.py b/pandas/core/indexes/accessors.py
index 5134c506b8c61..af8fa441f8b3f 100644
--- a/pandas/core/indexes/accessors.py
+++ b/pandas/core/indexes/accessors.py
@@ -227,7 +227,7 @@ def to_pydatetime(self):
)
return cast(ArrowExtensionArray, self._parent.array)._dt_to_pydatetime()
- def isocalendar(self):
+ def isocalendar(self) -> DataFrame:
from pandas import DataFrame
result = (
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index da16c3c54995a..6a397862712de 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1121,7 +1121,7 @@ def take(
allow_fill: bool = True,
fill_value=None,
**kwargs,
- ):
+ ) -> Self:
if kwargs:
nv.validate_take((), kwargs)
if is_scalar(indices):
@@ -1206,7 +1206,7 @@ def _maybe_disallow_fill(self, allow_fill: bool, fill_value, indices) -> bool:
"""
@Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
- def repeat(self, repeats, axis: None = None):
+ def repeat(self, repeats, axis: None = None) -> Self:
repeats = ensure_platform_int(repeats)
nv.validate_repeat((), {"axis": axis})
res_values = self._values.repeat(repeats)
@@ -3527,7 +3527,7 @@ def _intersection_via_get_indexer(
Returns
-------
- np.ndarray or ExtensionArray
+ np.ndarray or ExtensionArray or MultiIndex
The returned array will be unique.
"""
left_unique = self.unique()
@@ -3544,6 +3544,7 @@ def _intersection_via_get_indexer(
# unnecessary in the case with sort=None bc we will sort later
taker = np.sort(taker)
+ result: MultiIndex | ExtensionArray | np.ndarray
if isinstance(left_unique, ABCMultiIndex):
result = left_unique.take(taker)
else:
@@ -4445,7 +4446,7 @@ def _reindex_non_unique(
indexer, missing = self.get_indexer_non_unique(target)
check = indexer != -1
- new_labels = self.take(indexer[check])
+ new_labels: Index | np.ndarray = self.take(indexer[check])
new_indexer = None
if len(missing):
@@ -5005,7 +5006,7 @@ def _wrap_joined_index(
# expected "Self")
mask = lidx == -1
join_idx = self.take(lidx)
- right = other.take(ridx)
+ right = cast("MultiIndex", other.take(ridx))
join_index = join_idx.putmask(mask, right)._sort_levels_monotonic()
return join_index.set_names(name) # type: ignore[return-value]
else:
@@ -6990,7 +6991,7 @@ def infer_objects(self, copy: bool = True) -> Index:
result._references.add_index_reference(result)
return result
- def diff(self, periods: int = 1):
+ def diff(self, periods: int = 1) -> Self:
"""
Computes the difference between consecutive values in the Index object.
@@ -7018,7 +7019,7 @@ def diff(self, periods: int = 1):
"""
return self._constructor(self.to_series().diff(periods))
- def round(self, decimals: int = 0):
+ def round(self, decimals: int = 0) -> Self:
"""
Round each value in the Index to the given number of decimals.
diff --git a/pandas/core/indexes/frozen.py b/pandas/core/indexes/frozen.py
index 2d1d2a81a8a71..9d528d34e3684 100644
--- a/pandas/core/indexes/frozen.py
+++ b/pandas/core/indexes/frozen.py
@@ -8,12 +8,18 @@
"""
from __future__ import annotations
-from typing import NoReturn
+from typing import (
+ TYPE_CHECKING,
+ NoReturn,
+)
from pandas.core.base import PandasObject
from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+ from pandas._typing import Self
+
class FrozenList(PandasObject, list):
"""
@@ -72,7 +78,7 @@ def __getitem__(self, n):
return type(self)(super().__getitem__(n))
return super().__getitem__(n)
- def __radd__(self, other):
+ def __radd__(self, other) -> Self:
if isinstance(other, tuple):
other = list(other)
return type(self)(other + list(self))
@@ -84,7 +90,7 @@ def __eq__(self, other: object) -> bool:
__req__ = __eq__
- def __mul__(self, other):
+ def __mul__(self, other) -> Self:
return type(self)(super().__mul__(other))
__imul__ = __mul__
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index ae0ab66dd5f3e..86d198059ea95 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -1030,7 +1030,7 @@ def levshape(self) -> Shape:
# Codes Methods
@property
- def codes(self):
+ def codes(self) -> FrozenList:
return self._codes
def _set_codes(
@@ -1074,7 +1074,9 @@ def _set_codes(
self._reset_cache()
- def set_codes(self, codes, *, level=None, verify_integrity: bool = True):
+ def set_codes(
+ self, codes, *, level=None, verify_integrity: bool = True
+ ) -> MultiIndex:
"""
Set new codes on MultiIndex. Defaults to returning new index.
@@ -1199,7 +1201,7 @@ def copy( # type: ignore[override]
names=None,
deep: bool = False,
name=None,
- ):
+ ) -> Self:
"""
Make a copy of this object.
@@ -1262,7 +1264,7 @@ def __array__(self, dtype=None) -> np.ndarray:
"""the array interface, return my values"""
return self.values
- def view(self, cls=None):
+ def view(self, cls=None) -> Self:
"""this is defined as a copy with the same identity"""
result = self.copy()
result._id = self._id
@@ -1659,7 +1661,8 @@ def _get_level_values(self, level: int, unique: bool = False) -> Index:
filled = algos.take_nd(lev._values, level_codes, fill_value=lev._na_value)
return lev._shallow_copy(filled, name=name)
- def get_level_values(self, level):
+ # error: Signature of "get_level_values" incompatible with supertype "Index"
+ def get_level_values(self, level) -> Index: # type: ignore[override]
"""
Return vector of label values for requested level.
@@ -3304,7 +3307,7 @@ def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
raise KeyError(key)
return slice(start, end)
- def get_locs(self, seq):
+ def get_locs(self, seq) -> npt.NDArray[np.intp]:
"""
Get location for a sequence of labels.
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 9576997af6641..aeb7bb1813fef 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -407,7 +407,7 @@ def inferred_type(self) -> str:
# Indexing Methods
@doc(Index.get_loc)
- def get_loc(self, key):
+ def get_loc(self, key) -> int:
if is_integer(key) or (is_float(key) and key.is_integer()):
new_key = int(key)
try:
@@ -1107,14 +1107,16 @@ def _arith_method(self, other, op):
# test_arithmetic_explicit_conversions
return super()._arith_method(other, op)
- def take(
+ # error: Return type "Index" of "take" incompatible with return type
+ # "RangeIndex" in supertype "Index"
+ def take( # type: ignore[override]
self,
indices,
axis: Axis = 0,
allow_fill: bool = True,
fill_value=None,
**kwargs,
- ):
+ ) -> Index:
if kwargs:
nv.validate_take((), kwargs)
if is_scalar(indices):
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 97578e3f1668b..871e5817fdf0d 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -82,6 +82,7 @@
Axis,
AxisInt,
Self,
+ npt,
)
from pandas import (
@@ -1384,7 +1385,7 @@ def _getitem_axis(self, key, axis: AxisInt):
# nested tuple slicing
if is_nested_tuple(key, labels):
locs = labels.get_locs(key)
- indexer = [slice(None)] * self.ndim
+ indexer: list[slice | npt.NDArray[np.intp]] = [slice(None)] * self.ndim
indexer[axis] = locs
return self.obj.iloc[tuple(indexer)]
diff --git a/pandas/core/internals/array_manager.py b/pandas/core/internals/array_manager.py
index 14969425e75a7..b4e3fdb78b77b 100644
--- a/pandas/core/internals/array_manager.py
+++ b/pandas/core/internals/array_manager.py
@@ -1103,7 +1103,7 @@ def _verify_integrity(self) -> None:
def _normalize_axis(axis):
return axis
- def make_empty(self, axes=None) -> SingleArrayManager:
+ def make_empty(self, axes=None) -> Self:
"""Return an empty ArrayManager with index/array of length 0"""
if axes is None:
axes = [Index([], dtype=object)]
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 43f4f527afc3a..61aa8549a6790 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -2126,8 +2126,9 @@ def is_view(self) -> bool:
"""Extension arrays are never treated as views."""
return False
+ # error: Cannot override writeable attribute with read-only property
@cache_readonly
- def is_numeric(self):
+ def is_numeric(self) -> bool: # type: ignore[override]
return self.values.dtype._is_numeric
def _slice(
diff --git a/pandas/core/internals/construction.py b/pandas/core/internals/construction.py
index 5c8873d4324e0..aeadd75b22b33 100644
--- a/pandas/core/internals/construction.py
+++ b/pandas/core/internals/construction.py
@@ -193,7 +193,7 @@ def rec_array_to_mgr(
return mgr
-def mgr_to_mgr(mgr, typ: str, copy: bool = True):
+def mgr_to_mgr(mgr, typ: str, copy: bool = True) -> Manager:
"""
Convert to specific type of Manager. Does not copy if the type is already
correct. Does not guarantee a copy otherwise. `copy` keyword only controls
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index b315a318a9a0a..4cb7b610074ba 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -93,6 +93,8 @@
npt,
)
+ from pandas.api.extensions import ExtensionArray
+
class BaseBlockManager(DataManager):
"""
@@ -1046,7 +1048,7 @@ def iset(
value: ArrayLike,
inplace: bool = False,
refs: BlockValuesRefs | None = None,
- ):
+ ) -> None:
"""
Set new item in-place. Does not consolidate. Adds new Block if not
contained in the current set of items
@@ -1870,7 +1872,7 @@ def __getstate__(self):
# compatibility with 0.13.1.
return axes_array, block_values, block_items, extra_state
- def __setstate__(self, state):
+ def __setstate__(self, state) -> None:
def unpickle_block(values, mgr_locs, ndim: int) -> Block:
# TODO(EA2D): ndim would be unnecessary with 2D EAs
# older pickles may store e.g. DatetimeIndex instead of DatetimeArray
@@ -1959,7 +1961,7 @@ def internal_values(self):
"""The array that Series._values returns"""
return self._block.values
- def array_values(self):
+ def array_values(self) -> ExtensionArray:
"""The array that Series.array returns"""
return self._block.array_values
diff --git a/pandas/core/missing.py b/pandas/core/missing.py
index 58b0e2907b8ce..d275445983b6f 100644
--- a/pandas/core/missing.py
+++ b/pandas/core/missing.py
@@ -12,6 +12,7 @@
Any,
Literal,
cast,
+ overload,
)
import numpy as np
@@ -124,9 +125,33 @@ def mask_missing(arr: ArrayLike, values_to_mask) -> npt.NDArray[np.bool_]:
return mask
-def clean_fill_method(method: str, allow_nearest: bool = False):
+@overload
+def clean_fill_method(
+ method: Literal["ffill", "pad", "bfill", "backfill"],
+ *,
+ allow_nearest: Literal[False] = ...,
+) -> Literal["pad", "backfill"]:
+ ...
+
+
+@overload
+def clean_fill_method(
+ method: Literal["ffill", "pad", "bfill", "backfill", "nearest"],
+ *,
+ allow_nearest: Literal[True],
+) -> Literal["pad", "backfill", "nearest"]:
+ ...
+
+
+def clean_fill_method(
+ method: Literal["ffill", "pad", "bfill", "backfill", "nearest"],
+ *,
+ allow_nearest: bool = False,
+) -> Literal["pad", "backfill", "nearest"]:
if isinstance(method, str):
- method = method.lower()
+ # error: Incompatible types in assignment (expression has type "str", variable
+ # has type "Literal['ffill', 'pad', 'bfill', 'backfill', 'nearest']")
+ method = method.lower() # type: ignore[assignment]
if method == "ffill":
method = "pad"
elif method == "bfill":
@@ -252,7 +277,9 @@ def validate_limit_area(limit_area: str | None) -> Literal["inside", "outside"]
return limit_area # type: ignore[return-value]
-def infer_limit_direction(limit_direction, method):
+def infer_limit_direction(
+ limit_direction: Literal["backward", "forward", "both"] | None, method: str
+) -> Literal["backward", "forward", "both"]:
# Set `limit_direction` depending on `method`
if limit_direction is None:
if method in ("backfill", "bfill"):
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index e45cff0b0679f..5ff18d8a25e36 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -1676,6 +1676,8 @@ def _gotitem(self, key, ndim, subset=None):
class DatetimeIndexResampler(Resampler):
+ ax: DatetimeIndex
+
@property
def _resampler_for_grouping(self):
return DatetimeIndexResamplerGroupby
@@ -1807,7 +1809,11 @@ def _wrap_result(self, result):
return result
-class DatetimeIndexResamplerGroupby(_GroupByMixin, DatetimeIndexResampler):
+# error: Definition of "ax" in base class "_GroupByMixin" is incompatible
+# with definition in base class "DatetimeIndexResampler"
+class DatetimeIndexResamplerGroupby( # type: ignore[misc]
+ _GroupByMixin, DatetimeIndexResampler
+):
"""
Provides a resample of a groupby implementation
"""
@@ -1818,6 +1824,10 @@ def _resampler_cls(self):
class PeriodIndexResampler(DatetimeIndexResampler):
+ # error: Incompatible types in assignment (expression has type "PeriodIndex", base
+ # class "DatetimeIndexResampler" defined the type as "DatetimeIndex")
+ ax: PeriodIndex # type: ignore[assignment]
+
@property
def _resampler_for_grouping(self):
return PeriodIndexResamplerGroupby
@@ -1924,7 +1934,11 @@ def _upsample(self, method, limit: int | None = None, fill_value=None):
return self._wrap_result(new_obj)
-class PeriodIndexResamplerGroupby(_GroupByMixin, PeriodIndexResampler):
+# error: Definition of "ax" in base class "_GroupByMixin" is incompatible with
+# definition in base class "PeriodIndexResampler"
+class PeriodIndexResamplerGroupby( # type: ignore[misc]
+ _GroupByMixin, PeriodIndexResampler
+):
"""
Provides a resample of a groupby implementation.
"""
@@ -1935,6 +1949,10 @@ def _resampler_cls(self):
class TimedeltaIndexResampler(DatetimeIndexResampler):
+ # error: Incompatible types in assignment (expression has type "TimedeltaIndex",
+ # base class "DatetimeIndexResampler" defined the type as "DatetimeIndex")
+ ax: TimedeltaIndex # type: ignore[assignment]
+
@property
def _resampler_for_grouping(self):
return TimedeltaIndexResamplerGroupby
@@ -1952,7 +1970,11 @@ def _adjust_binner_for_upsample(self, binner):
return binner
-class TimedeltaIndexResamplerGroupby(_GroupByMixin, TimedeltaIndexResampler):
+# error: Definition of "ax" in base class "_GroupByMixin" is incompatible with
+# definition in base class "DatetimeIndexResampler"
+class TimedeltaIndexResamplerGroupby( # type: ignore[misc]
+ _GroupByMixin, TimedeltaIndexResampler
+):
"""
Provides a resample of a groupby implementation.
"""
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index ffa7199921298..1bc548de91f01 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -76,7 +76,7 @@ def concat(
axis: Literal[0, "index"] = ...,
join: str = ...,
ignore_index: bool = ...,
- keys=...,
+ keys: Iterable[Hashable] | None = ...,
levels=...,
names: list[HashableT] | None = ...,
verify_integrity: bool = ...,
@@ -93,7 +93,7 @@ def concat(
axis: Literal[0, "index"] = ...,
join: str = ...,
ignore_index: bool = ...,
- keys=...,
+ keys: Iterable[Hashable] | None = ...,
levels=...,
names: list[HashableT] | None = ...,
verify_integrity: bool = ...,
@@ -110,7 +110,7 @@ def concat(
axis: Literal[0, "index"] = ...,
join: str = ...,
ignore_index: bool = ...,
- keys=...,
+ keys: Iterable[Hashable] | None = ...,
levels=...,
names: list[HashableT] | None = ...,
verify_integrity: bool = ...,
@@ -127,7 +127,7 @@ def concat(
axis: Literal[1, "columns"],
join: str = ...,
ignore_index: bool = ...,
- keys=...,
+ keys: Iterable[Hashable] | None = ...,
levels=...,
names: list[HashableT] | None = ...,
verify_integrity: bool = ...,
@@ -144,7 +144,7 @@ def concat(
axis: Axis = ...,
join: str = ...,
ignore_index: bool = ...,
- keys=...,
+ keys: Iterable[Hashable] | None = ...,
levels=...,
names: list[HashableT] | None = ...,
verify_integrity: bool = ...,
@@ -160,7 +160,7 @@ def concat(
axis: Axis = 0,
join: str = "outer",
ignore_index: bool = False,
- keys=None,
+ keys: Iterable[Hashable] | None = None,
levels=None,
names: list[HashableT] | None = None,
verify_integrity: bool = False,
@@ -405,7 +405,7 @@ def __init__(
objs: Iterable[Series | DataFrame] | Mapping[HashableT, Series | DataFrame],
axis: Axis = 0,
join: str = "outer",
- keys=None,
+ keys: Iterable[Hashable] | None = None,
levels=None,
names: list[HashableT] | None = None,
ignore_index: bool = False,
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 13bc1008698b2..f3695fb87ea78 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -105,6 +105,7 @@
from pandas import DataFrame
from pandas.core import groupby
from pandas.core.arrays import DatetimeArray
+ from pandas.core.indexes.frozen import FrozenList
_factorizers = {
np.int64: libhashtable.Int64Factorizer,
@@ -1738,7 +1739,7 @@ def restore_dropped_levels_multijoin(
join_index: Index,
lindexer: npt.NDArray[np.intp],
rindexer: npt.NDArray[np.intp],
-) -> tuple[list[Index], npt.NDArray[np.intp], list[Hashable]]:
+) -> tuple[FrozenList, FrozenList, FrozenList]:
"""
*this is an internal non-public method*
@@ -1814,7 +1815,7 @@ def _convert_to_multiindex(index: Index) -> MultiIndex:
# error: Cannot determine type of "__add__"
join_levels = join_levels + [restore_levels] # type: ignore[has-type]
- join_codes = join_codes + [restore_codes]
+ join_codes = join_codes + [restore_codes] # type: ignore[has-type]
join_names = join_names + [dropped_level_name]
return join_levels, join_codes, join_names
diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index 71e3ea5b2588e..924b56f7a14d5 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -522,6 +522,7 @@ def pivot(
cols + columns_listlike, append=append # type: ignore[operator]
)
else:
+ index_list: list[Index] | list[Series]
if index is lib.no_default:
if isinstance(data.index, MultiIndex):
# GH 23955
diff --git a/pandas/core/series.py b/pandas/core/series.py
index a44f6bc01328d..9b5c8829fd5ff 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -4398,7 +4398,7 @@ def explode(self, ignore_index: bool = False) -> Series:
return result.reset_index(drop=True) if ignore_index else result
if ignore_index:
- index = default_index(len(values))
+ index: Index = default_index(len(values))
else:
index = self.index.repeat(counts)
diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py
index 124ca546c4583..71d6f9c58e2c2 100644
--- a/pandas/core/strings/accessor.py
+++ b/pandas/core/strings/accessor.py
@@ -372,7 +372,7 @@ def cons_row(x):
if expand:
result = list(result)
- out = MultiIndex.from_tuples(result, names=name)
+ out: Index = MultiIndex.from_tuples(result, names=name)
if out.nlevels == 1:
# We had all tuples of length-one, which are
# better represented as a regular Index.
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index fb0354ef9df6c..c0a27ecfec803 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -2823,7 +2823,7 @@ def read(
"cannot read on an abstract storer: subclasses should implement"
)
- def write(self, **kwargs):
+ def write(self, obj, **kwargs) -> None:
raise NotImplementedError(
"cannot write on an abstract storer: subclasses should implement"
)
@@ -2937,8 +2937,7 @@ def get_attrs(self) -> None:
for n in self.attributes:
setattr(self, n, _ensure_decoded(getattr(self.attrs, n, None)))
- # error: Signature of "write" incompatible with supertype "Fixed"
- def write(self, obj, **kwargs) -> None: # type: ignore[override]
+ def write(self, obj, **kwargs) -> None:
self.set_attrs()
def read_array(self, key: str, start: int | None = None, stop: int | None = None):
@@ -3226,8 +3225,7 @@ def read(
result = result.astype("string[pyarrow_numpy]")
return result
- # error: Signature of "write" incompatible with supertype "Fixed"
- def write(self, obj, **kwargs) -> None: # type: ignore[override]
+ def write(self, obj, **kwargs) -> None:
super().write(obj, **kwargs)
self.write_index("index", obj.index)
self.write_array("values", obj)
@@ -3303,8 +3301,7 @@ def read(
return DataFrame(columns=axes[0], index=axes[1])
- # error: Signature of "write" incompatible with supertype "Fixed"
- def write(self, obj, **kwargs) -> None: # type: ignore[override]
+ def write(self, obj, **kwargs) -> None:
super().write(obj, **kwargs)
# TODO(ArrayManager) HDFStore relies on accessing the blocks
@@ -4355,7 +4352,7 @@ def read(
"""
raise NotImplementedError("WORMTable needs to implement read")
- def write(self, **kwargs) -> None:
+ def write(self, obj, **kwargs) -> None:
"""
write in a format that we can search later on (but cannot append
to): write out the indices and the values using _write_array
@@ -4712,12 +4709,13 @@ def is_transposed(self) -> bool:
def get_object(cls, obj, transposed: bool):
return obj
- def write(self, obj, data_columns=None, **kwargs):
+ # error: Signature of "write" incompatible with supertype "Fixed"
+ def write(self, obj, data_columns=None, **kwargs) -> None: # type: ignore[override]
"""we are going to write this as a frame table"""
if not isinstance(obj, DataFrame):
name = obj.name or "values"
obj = obj.to_frame(name)
- return super().write(obj=obj, data_columns=obj.columns.tolist(), **kwargs)
+ super().write(obj=obj, data_columns=obj.columns.tolist(), **kwargs)
def read(
self,
@@ -4750,7 +4748,8 @@ class AppendableMultiSeriesTable(AppendableSeriesTable):
pandas_kind = "series_table"
table_type = "appendable_multiseries"
- def write(self, obj, **kwargs):
+ # error: Signature of "write" incompatible with supertype "Fixed"
+ def write(self, obj, **kwargs) -> None: # type: ignore[override]
"""we are going to write this as a frame table"""
name = obj.name or "values"
newobj, self.levels = self.validate_multiindex(obj)
@@ -4758,7 +4757,7 @@ def write(self, obj, **kwargs):
cols = list(self.levels)
cols.append(name)
newobj.columns = Index(cols)
- return super().write(obj=newobj, **kwargs)
+ super().write(obj=newobj, **kwargs)
class GenericTable(AppendableFrameTable):
@@ -4823,7 +4822,8 @@ def indexables(self):
return _indexables
- def write(self, **kwargs):
+ # error: Signature of "write" incompatible with supertype "AppendableTable"
+ def write(self, **kwargs) -> None: # type: ignore[override]
raise NotImplementedError("cannot write on an generic table")
@@ -4839,7 +4839,8 @@ class AppendableMultiFrameTable(AppendableFrameTable):
def table_type_short(self) -> str:
return "appendable_multi"
- def write(self, obj, data_columns=None, **kwargs):
+ # error: Signature of "write" incompatible with supertype "Fixed"
+ def write(self, obj, data_columns=None, **kwargs) -> None: # type: ignore[override]
if data_columns is None:
data_columns = []
elif data_columns is True:
@@ -4849,7 +4850,7 @@ def write(self, obj, data_columns=None, **kwargs):
for n in self.levels:
if n not in data_columns:
data_columns.insert(0, n)
- return super().write(obj=obj, data_columns=data_columns, **kwargs)
+ super().write(obj=obj, data_columns=data_columns, **kwargs)
def read(
self,
| "simple" meaning, non-unions and non-overload return types (at least in most cases).
xref #47521
edit: sorry for changes in many files - I grep'ed for missing return types inferred by pyright and then fixed the resulting type errors. | https://api.github.com/repos/pandas-dev/pandas/pulls/54786 | 2023-08-28T00:20:20Z | 2023-08-31T17:52:56Z | 2023-08-31T17:52:56Z | 2023-09-19T15:24:48Z |
Backport PR #54783 on branch 2.1.x (CI: Remove strict option) | diff --git a/.github/workflows/code-checks.yml b/.github/workflows/code-checks.yml
index 9daa1a67bc2c1..f87aef5385898 100644
--- a/.github/workflows/code-checks.yml
+++ b/.github/workflows/code-checks.yml
@@ -124,7 +124,7 @@ jobs:
run: |
cd asv_bench
asv machine --yes
- asv run --quick --dry-run --strict --durations=30 --python=same
+ asv run --quick --dry-run --durations=30 --python=same
build_docker_dev_environment:
name: Build Docker Dev Environment
| Backport PR #54783: CI: Remove strict option | https://api.github.com/repos/pandas-dev/pandas/pulls/54785 | 2023-08-27T23:38:00Z | 2023-08-28T05:01:15Z | 2023-08-28T05:01:15Z | 2023-08-28T05:01:16Z |
CI: Unpin Cython | diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index 6410f2edd6175..1445e5e822017 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -233,8 +233,8 @@ jobs:
run: |
/opt/python/cp311-cp311/bin/python -m venv ~/virtualenvs/pandas-dev
. ~/virtualenvs/pandas-dev/bin/activate
- python -m pip install --no-cache-dir -U pip wheel setuptools meson[ninja]==1.0.1 meson-python==0.13.1
- python -m pip install --no-cache-dir versioneer[toml] "cython<3.0.1" numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
+ python -m pip install --no-cache-dir -U pip wheel setuptools meson[ninja]==1.2.1 meson-python==0.13.1
+ python -m pip install --no-cache-dir versioneer[toml] cython numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
python -m pip install --no-cache-dir --no-build-isolation -e .
python -m pip list --no-cache-dir
export PANDAS_CI=1
@@ -271,8 +271,8 @@ jobs:
run: |
/opt/python/cp311-cp311/bin/python -m venv ~/virtualenvs/pandas-dev
. ~/virtualenvs/pandas-dev/bin/activate
- python -m pip install --no-cache-dir -U pip wheel setuptools meson-python==0.13.1 meson[ninja]==1.0.1
- python -m pip install --no-cache-dir versioneer[toml] "cython<3.0.1" numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
+ python -m pip install --no-cache-dir -U pip wheel setuptools meson-python==0.13.1 meson[ninja]==1.2.1
+ python -m pip install --no-cache-dir versioneer[toml] cython numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
python -m pip install --no-cache-dir --no-build-isolation -e .
python -m pip list --no-cache-dir
@@ -342,10 +342,10 @@ jobs:
- name: Build Environment
run: |
python --version
- python -m pip install --upgrade pip setuptools wheel meson[ninja]==1.0.1 meson-python==0.13.1
+ python -m pip install --upgrade pip setuptools wheel meson[ninja]==1.2.1 meson-python==0.13.1
python -m pip install --pre --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple numpy
python -m pip install versioneer[toml]
- python -m pip install python-dateutil pytz tzdata "cython<3.0.1" hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-cov pytest-asyncio>=0.17
+ python -m pip install python-dateutil pytz tzdata cython hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-cov pytest-asyncio>=0.17
python -m pip install -ve . --no-build-isolation --no-index
python -m pip list
diff --git a/ci/deps/actions-310.yaml b/ci/deps/actions-310.yaml
index 2190136220c6c..edd48604dbfda 100644
--- a/ci/deps/actions-310.yaml
+++ b/ci/deps/actions-310.yaml
@@ -6,8 +6,8 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33, <3.0.1
- - meson[ninja]=1.0.1
+ - cython>=0.29.33
+ - meson[ninja]=1.2.1
- meson-python=0.13.1
# test dependencies
diff --git a/ci/deps/actions-311-downstream_compat.yaml b/ci/deps/actions-311-downstream_compat.yaml
index cf85345cb0cc2..2fb6072314b1e 100644
--- a/ci/deps/actions-311-downstream_compat.yaml
+++ b/ci/deps/actions-311-downstream_compat.yaml
@@ -7,8 +7,8 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33, <3.0.1
- - meson[ninja]=1.0.1
+ - cython>=0.29.33
+ - meson[ninja]=1.2.1
- meson-python=0.13.1
# test dependencies
diff --git a/ci/deps/actions-311-numpydev.yaml b/ci/deps/actions-311-numpydev.yaml
index acf94fce5288b..7fd3a65ec91f8 100644
--- a/ci/deps/actions-311-numpydev.yaml
+++ b/ci/deps/actions-311-numpydev.yaml
@@ -6,8 +6,9 @@ dependencies:
# build dependencies
- versioneer[toml]
- - meson[ninja]=1.0.1
+ - meson[ninja]=1.2.1
- meson-python=0.13.1
+ - cython>=0.29.33
# test dependencies
- pytest>=7.3.2
@@ -25,7 +26,6 @@ dependencies:
- pip
- pip:
- - "cython<3.0.1"
- "--extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple"
- "--pre"
- "numpy"
diff --git a/ci/deps/actions-311-pyarrownightly.yaml b/ci/deps/actions-311-pyarrownightly.yaml
index e850f69f945c5..893341350f4ef 100644
--- a/ci/deps/actions-311-pyarrownightly.yaml
+++ b/ci/deps/actions-311-pyarrownightly.yaml
@@ -6,8 +6,8 @@ dependencies:
# build dependencies
- versioneer[toml]
- - meson[ninja]=1.0.1
- - cython>=0.29.33, <3.0.1
+ - meson[ninja]=1.2.1
+ - cython>=0.29.33
- meson-python=0.13.1
# test dependencies
diff --git a/ci/deps/actions-311.yaml b/ci/deps/actions-311.yaml
index 3c1630714a041..029312202bcaa 100644
--- a/ci/deps/actions-311.yaml
+++ b/ci/deps/actions-311.yaml
@@ -6,8 +6,8 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33, <3.0.1
- - meson[ninja]=1.0.1
+ - cython>=0.29.33
+ - meson[ninja]=1.2.1
- meson-python=0.13.1
# test dependencies
diff --git a/ci/deps/actions-39-minimum_versions.yaml b/ci/deps/actions-39-minimum_versions.yaml
index b1cea49e22d15..2a7312cefe619 100644
--- a/ci/deps/actions-39-minimum_versions.yaml
+++ b/ci/deps/actions-39-minimum_versions.yaml
@@ -8,8 +8,8 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33, <3.0.1
- - meson[ninja]=1.0.1
+ - cython>=0.29.33
+ - meson[ninja]=1.2.1
- meson-python=0.13.1
# test dependencies
diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index b8a119ece4b03..12893698b5534 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -6,8 +6,8 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33, <3.0.1
- - meson[ninja]=1.0.1
+ - cython>=0.29.33
+ - meson[ninja]=1.2.1
- meson-python=0.13.1
# test dependencies
diff --git a/ci/deps/actions-pypy-39.yaml b/ci/deps/actions-pypy-39.yaml
index 23c3706f43dad..4923c94ab08f3 100644
--- a/ci/deps/actions-pypy-39.yaml
+++ b/ci/deps/actions-pypy-39.yaml
@@ -9,8 +9,8 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33, <3.0.1
- - meson[ninja]=1.0.1
+ - cython>=0.29.33
+ - meson[ninja]=1.2.1
- meson-python=0.13.1
# test dependencies
diff --git a/ci/deps/circle-310-arm64.yaml b/ci/deps/circle-310-arm64.yaml
index 71686837451b4..a945dbfe2ca20 100644
--- a/ci/deps/circle-310-arm64.yaml
+++ b/ci/deps/circle-310-arm64.yaml
@@ -6,8 +6,8 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33, <3.0.1
- - meson[ninja]=1.0.1
+ - cython>=0.29.33
+ - meson[ninja]=1.2.1
- meson-python=0.13.1
# test dependencies
diff --git a/environment.yml b/environment.yml
index 1a9dffb55bca7..d194b11df7195 100644
--- a/environment.yml
+++ b/environment.yml
@@ -9,7 +9,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- cython=0.29.33
- - meson[ninja]=1.0.1
+ - meson[ninja]=1.2.1
- meson-python=0.13.1
# test dependencies
diff --git a/meson.build b/meson.build
index 09a1494135af4..ddaf642f974c9 100644
--- a/meson.build
+++ b/meson.build
@@ -4,7 +4,7 @@ project(
'c', 'cpp', 'cython',
version: run_command(['python', 'generate_version.py', '--print'], check: true).stdout().strip(),
license: 'BSD-3',
- meson_version: '>=1.0.1',
+ meson_version: '>=1.2.1',
default_options: [
'buildtype=release',
# TODO: Reactivate werror, some warnings on Windows
diff --git a/pyproject.toml b/pyproject.toml
index 74d6aaee286a9..ccb21a5f36ded 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,7 +3,7 @@
# See https://github.com/scipy/scipy/pull/12940 for the AIX issue.
requires = [
"meson-python==0.13.1",
- "meson==1.0.1",
+ "meson==1.2.1",
"wheel",
"Cython>=0.29.33,<3", # Note: sync with setup.py, environment.yml and asv.conf.json
# Note: numpy 1.25 has a backwards compatible C API by default
diff --git a/requirements-dev.txt b/requirements-dev.txt
index be02007a36333..0177016806b0e 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -4,7 +4,7 @@
pip
versioneer[toml]
cython==0.29.33
-meson[ninja]==1.0.1
+meson[ninja]==1.2.1
meson-python==0.13.1
pytest>=7.3.2
pytest-cov
| - [ ] closes #54756 (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/54784 | 2023-08-27T21:52:58Z | 2023-09-16T02:03:22Z | 2023-09-16T02:03:22Z | 2023-09-16T13:37:46Z |
CI: Remove strict option | diff --git a/.github/workflows/code-checks.yml b/.github/workflows/code-checks.yml
index 9daa1a67bc2c1..f87aef5385898 100644
--- a/.github/workflows/code-checks.yml
+++ b/.github/workflows/code-checks.yml
@@ -124,7 +124,7 @@ jobs:
run: |
cd asv_bench
asv machine --yes
- asv run --quick --dry-run --strict --durations=30 --python=same
+ asv run --quick --dry-run --durations=30 --python=same
build_docker_dev_environment:
name: Build Docker Dev Environment
| It is there by default in asv > 0.6.0
- [ ] 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/54783 | 2023-08-27T21:42:06Z | 2023-08-27T23:36:38Z | 2023-08-27T23:36:38Z | 2023-08-28T01:16:33Z |
Backport PR #54755 on branch 2.1.x (BUG: merge raising for ea int and numpy float) | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index f5758a079b1b5..19a8500928ab7 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -816,6 +816,7 @@ Reshaping
- Bug in :func:`merge_asof` raising ``KeyError`` for extension dtypes (:issue:`52904`)
- Bug in :func:`merge_asof` raising ``ValueError`` for data backed by read-only ndarrays (:issue:`53513`)
- Bug in :func:`merge_asof` with ``left_index=True`` or ``right_index=True`` with mismatched index dtypes giving incorrect results in some cases instead of raising ``MergeError`` (:issue:`53870`)
+- Bug in :func:`merge` when merging on integer ``ExtensionDtype`` and float NumPy dtype raising ``TypeError`` (:issue:`46178`)
- Bug in :meth:`DataFrame.agg` and :meth:`Series.agg` on non-unique columns would return incorrect type when dist-like argument passed in (:issue:`51099`)
- Bug in :meth:`DataFrame.combine_first` ignoring other's columns if ``other`` is empty (:issue:`53792`)
- Bug in :meth:`DataFrame.idxmin` and :meth:`DataFrame.idxmax`, where the axis dtype would be lost for empty frames (:issue:`53265`)
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index c2cb9d643ca87..d811c53909fde 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -53,6 +53,7 @@
ensure_object,
is_bool,
is_bool_dtype,
+ is_extension_array_dtype,
is_float_dtype,
is_integer,
is_integer_dtype,
@@ -1385,6 +1386,21 @@ def _maybe_coerce_merge_keys(self) -> None:
if lk.dtype.kind == rk.dtype.kind:
continue
+ if is_extension_array_dtype(lk.dtype) and not is_extension_array_dtype(
+ rk.dtype
+ ):
+ ct = find_common_type([lk.dtype, rk.dtype])
+ if is_extension_array_dtype(ct):
+ rk = ct.construct_array_type()._from_sequence(rk) # type: ignore[union-attr] # noqa: E501
+ else:
+ rk = rk.astype(ct) # type: ignore[arg-type]
+ elif is_extension_array_dtype(rk.dtype):
+ ct = find_common_type([lk.dtype, rk.dtype])
+ if is_extension_array_dtype(ct):
+ lk = ct.construct_array_type()._from_sequence(lk) # type: ignore[union-attr] # noqa: E501
+ else:
+ lk = lk.astype(ct) # type: ignore[arg-type]
+
# check whether ints and floats
if is_integer_dtype(rk.dtype) and is_float_dtype(lk.dtype):
# GH 47391 numpy > 1.24 will raise a RuntimeError for nan -> int
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 91510fae0a9b1..98db24530833b 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -2847,3 +2847,26 @@ def test_merge_multiindex_single_level():
result = df.merge(df2, left_on=["col"], right_index=True, how="left")
tm.assert_frame_equal(result, expected)
+
+
+def test_merge_ea_int_and_float_numpy():
+ # GH#46178
+ df1 = DataFrame([1.0, np.nan], dtype=pd.Int64Dtype())
+ df2 = DataFrame([1.5])
+ expected = DataFrame(columns=[0], dtype="Int64")
+
+ with tm.assert_produces_warning(UserWarning, match="You are merging"):
+ result = df1.merge(df2)
+ tm.assert_frame_equal(result, expected)
+
+ with tm.assert_produces_warning(UserWarning, match="You are merging"):
+ result = df2.merge(df1)
+ tm.assert_frame_equal(result, expected.astype("float64"))
+
+ df2 = DataFrame([1.0])
+ expected = DataFrame([1], columns=[0], dtype="Int64")
+ result = df1.merge(df2)
+ tm.assert_frame_equal(result, expected)
+
+ result = df2.merge(df1)
+ tm.assert_frame_equal(result, expected.astype("float64"))
| #54755 | https://api.github.com/repos/pandas-dev/pandas/pulls/54779 | 2023-08-27T14:58:24Z | 2023-08-27T21:45:15Z | 2023-08-27T21:45:15Z | 2023-09-01T11:17:08Z |
REGR: Index.union loses python string dtype | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index a49db84450bb3..4fa8eb0cce2a2 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -5194,7 +5194,7 @@ def _from_join_target(self, result: np.ndarray) -> ArrayLike:
"""
if isinstance(self.values, BaseMaskedArray):
return type(self.values)(result, np.zeros(result.shape, dtype=np.bool_))
- elif isinstance(self.values, ArrowExtensionArray):
+ elif isinstance(self.values, (ArrowExtensionArray, StringArray)):
return type(self.values)._from_sequence(result)
return result
diff --git a/pandas/tests/indexes/test_setops.py b/pandas/tests/indexes/test_setops.py
index 2fd203dbc77ed..a64994efec85a 100644
--- a/pandas/tests/indexes/test_setops.py
+++ b/pandas/tests/indexes/test_setops.py
@@ -899,3 +899,10 @@ def test_union_ea_dtypes(self, any_numeric_ea_and_arrow_dtype):
result = idx.union(idx2)
expected = Index([1, 2, 3, 4, 5], dtype=any_numeric_ea_and_arrow_dtype)
tm.assert_index_equal(result, expected)
+
+ def test_union_string_array(self, any_string_dtype):
+ idx1 = Index(["a"], dtype=any_string_dtype)
+ idx2 = Index(["b"], dtype=any_string_dtype)
+ result = idx1.union(idx2)
+ expected = Index(["a", "b"], dtype=any_string_dtype)
+ tm.assert_index_equal(result, expected)
| - [x] closes #54745 (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.
cc @mroeschke | https://api.github.com/repos/pandas-dev/pandas/pulls/54778 | 2023-08-27T14:49:11Z | 2023-08-28T15:16:40Z | 2023-08-28T15:16:40Z | 2023-08-28T15:17:39Z |
Backport PR #54768 on branch 2.1.x (Fix roundtripping with pyarrow schema) | diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index e3656b6ff4bcc..3af63c781d499 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -14,6 +14,7 @@
missing as libmissing,
)
from pandas._libs.arrays import NDArrayBacked
+from pandas._libs.lib import ensure_string_array
from pandas.compat import pa_version_under7p0
from pandas.compat.numpy import function as nv
from pandas.util._decorators import doc
@@ -221,7 +222,7 @@ def __from_arrow__(
arr = np.array([], dtype=object)
else:
arr = pyarrow.concat_arrays(chunks).to_numpy(zero_copy_only=False)
- arr = lib.convert_nans_to_NA(arr)
+ arr = ensure_string_array(arr, na_value=libmissing.NA)
# Bypass validation inside StringArray constructor, see GH#47781
new_string_array = StringArray.__new__(StringArray)
NDArrayBacked.__init__(
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index ccba44b7f8fe4..b2d6e958020be 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1,5 +1,6 @@
""" test parquet compat """
import datetime
+from decimal import Decimal
from io import BytesIO
import os
import pathlib
@@ -16,6 +17,7 @@
from pandas.compat.pyarrow import (
pa_version_under7p0,
pa_version_under8p0,
+ pa_version_under11p0,
pa_version_under13p0,
)
@@ -1111,6 +1113,18 @@ def test_string_inference(self, tmp_path, pa):
)
tm.assert_frame_equal(result, expected)
+ @pytest.mark.skipif(pa_version_under11p0, reason="not supported before 11.0")
+ def test_roundtrip_decimal(self, tmp_path, pa):
+ # GH#54768
+ import pyarrow as pa
+
+ path = tmp_path / "decimal.p"
+ df = pd.DataFrame({"a": [Decimal("123.00")]}, dtype="string[pyarrow]")
+ df.to_parquet(path, schema=pa.schema([("a", pa.decimal128(5))]))
+ result = read_parquet(path)
+ expected = pd.DataFrame({"a": ["123"]}, dtype="string[python]")
+ tm.assert_frame_equal(result, expected)
+
class TestParquetFastParquet(Base):
def test_basic(self, fp, df_full):
| Backport PR #54768: Fix roundtripping with pyarrow schema | https://api.github.com/repos/pandas-dev/pandas/pulls/54773 | 2023-08-26T19:07:36Z | 2023-08-27T05:45:08Z | 2023-08-27T05:45:08Z | 2023-08-27T05:45:08Z |
Fix roundtripping with pyarrow schema | diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 2394b9af2015e..1eaae0807fee1 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -15,6 +15,7 @@
missing as libmissing,
)
from pandas._libs.arrays import NDArrayBacked
+from pandas._libs.lib import ensure_string_array
from pandas.compat import pa_version_under7p0
from pandas.compat.numpy import function as nv
from pandas.util._decorators import doc
@@ -224,7 +225,7 @@ def __from_arrow__(
arr = np.array([], dtype=object)
else:
arr = pyarrow.concat_arrays(chunks).to_numpy(zero_copy_only=False)
- arr = lib.convert_nans_to_NA(arr)
+ arr = ensure_string_array(arr, na_value=libmissing.NA)
# Bypass validation inside StringArray constructor, see GH#47781
new_string_array = StringArray.__new__(StringArray)
NDArrayBacked.__init__(
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index 6ca71b9507322..7c4176fa92361 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1,5 +1,6 @@
""" test parquet compat """
import datetime
+from decimal import Decimal
from io import BytesIO
import os
import pathlib
@@ -16,6 +17,7 @@
from pandas.compat.pyarrow import (
pa_version_under7p0,
pa_version_under8p0,
+ pa_version_under11p0,
pa_version_under13p0,
)
@@ -1125,6 +1127,18 @@ def test_string_inference(self, tmp_path, pa):
)
tm.assert_frame_equal(result, expected)
+ @pytest.mark.skipif(pa_version_under11p0, reason="not supported before 11.0")
+ def test_roundtrip_decimal(self, tmp_path, pa):
+ # GH#54768
+ import pyarrow as pa
+
+ path = tmp_path / "decimal.p"
+ df = pd.DataFrame({"a": [Decimal("123.00")]}, dtype="string[pyarrow]")
+ df.to_parquet(path, schema=pa.schema([("a", pa.decimal128(5))]))
+ result = read_parquet(path)
+ expected = pd.DataFrame({"a": ["123"]}, dtype="string[python]")
+ tm.assert_frame_equal(result, expected)
+
class TestParquetFastParquet(Base):
def test_basic(self, fp, df_full):
| - [ ] 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.
that's a regression on main as well, it's currently returning NA
cc @mroeschke | https://api.github.com/repos/pandas-dev/pandas/pulls/54768 | 2023-08-26T11:02:11Z | 2023-08-26T19:07:28Z | 2023-08-26T19:07:28Z | 2023-08-28T15:25:26Z |
Backport PR #54585 on branch 2.1.x (Use NaN as na_value for new pyarrow_numpy StringDtype) | diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 1e285f90e9fea..e3656b6ff4bcc 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -98,10 +98,14 @@ class StringDtype(StorageExtensionDtype):
name = "string"
- #: StringDtype().na_value uses pandas.NA
+ #: StringDtype().na_value uses pandas.NA except the implementation that
+ # follows NumPy semantics, which uses nan.
@property
- def na_value(self) -> libmissing.NAType:
- return libmissing.NA
+ def na_value(self) -> libmissing.NAType | float: # type: ignore[override]
+ if self.storage == "pyarrow_numpy":
+ return np.nan
+ else:
+ return libmissing.NA
_metadata = ("storage",)
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
index e29a72e1a5338..68b2b01ddcaf3 100644
--- a/pandas/tests/arrays/string_/test_string.py
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -17,6 +17,13 @@
)
+def na_val(dtype):
+ if dtype.storage == "pyarrow_numpy":
+ return np.nan
+ else:
+ return pd.NA
+
+
@pytest.fixture
def dtype(string_storage):
"""Fixture giving StringDtype from parametrized 'string_storage'"""
@@ -31,26 +38,34 @@ def cls(dtype):
def test_repr(dtype):
df = pd.DataFrame({"A": pd.array(["a", pd.NA, "b"], dtype=dtype)})
- expected = " A\n0 a\n1 <NA>\n2 b"
+ if dtype.storage == "pyarrow_numpy":
+ expected = " A\n0 a\n1 NaN\n2 b"
+ else:
+ expected = " A\n0 a\n1 <NA>\n2 b"
assert repr(df) == expected
- expected = "0 a\n1 <NA>\n2 b\nName: A, dtype: string"
+ if dtype.storage == "pyarrow_numpy":
+ expected = "0 a\n1 NaN\n2 b\nName: A, dtype: string"
+ else:
+ expected = "0 a\n1 <NA>\n2 b\nName: A, dtype: string"
assert repr(df.A) == expected
if dtype.storage == "pyarrow":
arr_name = "ArrowStringArray"
+ expected = f"<{arr_name}>\n['a', <NA>, 'b']\nLength: 3, dtype: string"
elif dtype.storage == "pyarrow_numpy":
arr_name = "ArrowStringArrayNumpySemantics"
+ expected = f"<{arr_name}>\n['a', nan, 'b']\nLength: 3, dtype: string"
else:
arr_name = "StringArray"
- expected = f"<{arr_name}>\n['a', <NA>, 'b']\nLength: 3, dtype: string"
+ expected = f"<{arr_name}>\n['a', <NA>, 'b']\nLength: 3, dtype: string"
assert repr(df.A.array) == expected
def test_none_to_nan(cls):
a = cls._from_sequence(["a", None, "b"])
assert a[1] is not None
- assert a[1] is pd.NA
+ assert a[1] is na_val(a.dtype)
def test_setitem_validates(cls):
@@ -205,13 +220,9 @@ def test_comparison_methods_scalar(comparison_op, dtype):
other = "a"
result = getattr(a, op_name)(other)
if dtype.storage == "pyarrow_numpy":
- expected = np.array([getattr(item, op_name)(other) for item in a], dtype=object)
- expected = (
- pd.array(expected, dtype="boolean")
- .to_numpy(na_value=False)
- .astype(np.bool_)
- )
- tm.assert_numpy_array_equal(result, expected)
+ expected = np.array([getattr(item, op_name)(other) for item in a])
+ expected[1] = False
+ tm.assert_numpy_array_equal(result, expected.astype(np.bool_))
else:
expected_dtype = "boolean[pyarrow]" if dtype.storage == "pyarrow" else "boolean"
expected = np.array([getattr(item, op_name)(other) for item in a], dtype=object)
@@ -407,7 +418,7 @@ def test_min_max(method, skipna, dtype, request):
expected = "a" if method == "min" else "c"
assert result == expected
else:
- assert result is pd.NA
+ assert result is na_val(arr.dtype)
@pytest.mark.parametrize("method", ["min", "max"])
@@ -475,7 +486,7 @@ def test_arrow_roundtrip(dtype, string_storage2):
expected = df.astype(f"string[{string_storage2}]")
tm.assert_frame_equal(result, expected)
# ensure the missing value is represented by NA and not np.nan or None
- assert result.loc[2, "a"] is pd.NA
+ assert result.loc[2, "a"] is na_val(result["a"].dtype)
def test_arrow_load_from_zero_chunks(dtype, string_storage2):
@@ -573,7 +584,7 @@ def test_astype_from_float_dtype(float_dtype, dtype):
def test_to_numpy_returns_pdna_default(dtype):
arr = pd.array(["a", pd.NA, "b"], dtype=dtype)
result = np.array(arr)
- expected = np.array(["a", pd.NA, "b"], dtype=object)
+ expected = np.array(["a", na_val(dtype), "b"], dtype=object)
tm.assert_numpy_array_equal(result, expected)
@@ -613,7 +624,7 @@ def test_setitem_scalar_with_mask_validation(dtype):
mask = np.array([False, True, False])
ser[mask] = None
- assert ser.array[1] is pd.NA
+ assert ser.array[1] is na_val(ser.dtype)
# for other non-string we should also raise an error
ser = pd.Series(["a", "b", "c"], dtype=dtype)
diff --git a/pandas/tests/strings/__init__.py b/pandas/tests/strings/__init__.py
index bf119f2721ed4..01b49b5e5b633 100644
--- a/pandas/tests/strings/__init__.py
+++ b/pandas/tests/strings/__init__.py
@@ -1,4 +1,4 @@
-# Needed for new arrow string dtype
+import numpy as np
import pandas as pd
@@ -7,6 +7,9 @@
def _convert_na_value(ser, expected):
if ser.dtype != object:
- # GH#18463
- expected = expected.fillna(pd.NA)
+ if ser.dtype.storage == "pyarrow_numpy":
+ expected = expected.fillna(np.nan)
+ else:
+ # GH#18463
+ expected = expected.fillna(pd.NA)
return expected
diff --git a/pandas/tests/strings/test_split_partition.py b/pandas/tests/strings/test_split_partition.py
index 7fabe238d2b86..0a7d409773dd6 100644
--- a/pandas/tests/strings/test_split_partition.py
+++ b/pandas/tests/strings/test_split_partition.py
@@ -12,7 +12,10 @@
Series,
_testing as tm,
)
-from pandas.tests.strings import _convert_na_value
+from pandas.tests.strings import (
+ _convert_na_value,
+ object_pyarrow_numpy,
+)
@pytest.mark.parametrize("method", ["split", "rsplit"])
@@ -113,8 +116,8 @@ def test_split_object_mixed(expand, method):
def test_split_n(any_string_dtype, method, n):
s = Series(["a b", pd.NA, "b c"], dtype=any_string_dtype)
expected = Series([["a", "b"], pd.NA, ["b", "c"]])
-
result = getattr(s.str, method)(" ", n=n)
+ expected = _convert_na_value(s, expected)
tm.assert_series_equal(result, expected)
@@ -381,7 +384,7 @@ def test_split_nan_expand(any_string_dtype):
# check that these are actually np.nan/pd.NA and not None
# TODO see GH 18463
# tm.assert_frame_equal does not differentiate
- if any_string_dtype == "object":
+ if any_string_dtype in object_pyarrow_numpy:
assert all(np.isnan(x) for x in result.iloc[1])
else:
assert all(x is pd.NA for x in result.iloc[1])
| Backport PR #54585: Use NaN as na_value for new pyarrow_numpy StringDtype | https://api.github.com/repos/pandas-dev/pandas/pulls/54767 | 2023-08-26T10:41:39Z | 2023-08-26T13:14:49Z | 2023-08-26T13:14:49Z | 2023-08-26T13:14:49Z |
Backport PR #54750 on branch 2.1.x (Revert deprecation of con as keyword only arg) | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index e3f18067e354d..f5758a079b1b5 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -586,7 +586,7 @@ Other Deprecations
- Deprecated the use of non-supported datetime64 and timedelta64 resolutions with :func:`pandas.array`. Supported resolutions are: "s", "ms", "us", "ns" resolutions (:issue:`53058`)
- Deprecated values ``"pad"``, ``"ffill"``, ``"bfill"``, ``"backfill"`` for :meth:`Series.interpolate` and :meth:`DataFrame.interpolate`, use ``obj.ffill()`` or ``obj.bfill()`` instead (:issue:`53581`)
- Deprecated the behavior of :meth:`Index.argmax`, :meth:`Index.argmin`, :meth:`Series.argmax`, :meth:`Series.argmin` with either all-NAs and ``skipna=True`` or any-NAs and ``skipna=False`` returning -1; in a future version this will raise ``ValueError`` (:issue:`33941`, :issue:`33942`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_sql` except ``name`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_sql` except ``name`` and ``con`` (:issue:`54229`)
.. ---------------------------------------------------------------------------
.. _whatsnew_210.performance:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 09ebd9387220f..b4281f6959997 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -2796,7 +2796,7 @@ def to_hdf(
@final
@deprecate_nonkeyword_arguments(
- version="3.0", allowed_args=["self", "name"], name="to_sql"
+ version="3.0", allowed_args=["self", "name", "con"], name="to_sql"
)
def to_sql(
self,
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 2f446e6b8c81d..9ec0ba0b12a76 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -2849,13 +2849,14 @@ def setup_driver(cls):
def test_keyword_deprecation(self):
# GH 54397
msg = (
- "tarting with pandas version 3.0 all arguments of to_sql except for the "
- "argument 'name' will be keyword-only."
+ "Starting with pandas version 3.0 all arguments of to_sql except for the "
+ "arguments 'name' and 'con' will be keyword-only."
)
df = DataFrame([{"A": 1, "B": 2, "C": 3}, {"A": 1, "B": 2, "C": 3}])
+ df.to_sql("example", self.conn)
with tm.assert_produces_warning(FutureWarning, match=msg):
- df.to_sql("example", self.conn)
+ df.to_sql("example", self.conn, None, if_exists="replace")
def test_default_type_conversion(self):
df = sql.read_sql_table("types", self.conn)
| Backport PR #54750: Revert deprecation of con as keyword only arg | https://api.github.com/repos/pandas-dev/pandas/pulls/54766 | 2023-08-26T07:57:48Z | 2023-08-26T10:40:15Z | 2023-08-26T10:40:15Z | 2023-08-26T10:40:16Z |
PERF: skip libjoin fastpath for MultiIndex | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index a49db84450bb3..1fbf4381cb64e 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -124,6 +124,7 @@
from pandas.core.dtypes.generic import (
ABCDataFrame,
ABCDatetimeIndex,
+ ABCIntervalIndex,
ABCMultiIndex,
ABCPeriodIndex,
ABCSeries,
@@ -3492,8 +3493,6 @@ def _intersection(self, other: Index, sort: bool = False):
and other.is_monotonic_increasing
and self._can_use_libjoin
and other._can_use_libjoin
- and not isinstance(self, ABCMultiIndex)
- and not isinstance(other, ABCMultiIndex)
):
try:
res_indexer, indexer, _ = self._inner_indexer(other)
@@ -4632,28 +4631,13 @@ def join(
_validate_join_method(how)
- if not self.is_unique and not other.is_unique:
- return self._join_non_unique(other, how=how, sort=sort)
- elif not self.is_unique or not other.is_unique:
- if self.is_monotonic_increasing and other.is_monotonic_increasing:
- # Note: 2023-08-15 we *do* have tests that get here with
- # Categorical, string[python] (can use libjoin)
- # and Interval (cannot)
- if self._can_use_libjoin and other._can_use_libjoin:
- # otherwise we will fall through to _join_via_get_indexer
- # GH#39133
- # go through object dtype for ea till engine is supported properly
- return self._join_monotonic(other, how=how)
- else:
- return self._join_non_unique(other, how=how, sort=sort)
- elif (
- # GH48504: exclude MultiIndex to avoid going through MultiIndex._values
- self.is_monotonic_increasing
+ if (
+ not isinstance(self.dtype, CategoricalDtype)
+ and self.is_monotonic_increasing
and other.is_monotonic_increasing
and self._can_use_libjoin
and other._can_use_libjoin
- and not isinstance(self, ABCMultiIndex)
- and not isinstance(self.dtype, CategoricalDtype)
+ and (self.is_unique or other.is_unique)
):
# Categorical is monotonic if data are ordered as categories, but join can
# not handle this in case of not lexicographically monotonic GH#38502
@@ -4662,6 +4646,8 @@ def join(
except TypeError:
# object dtype; non-comparable objects
pass
+ elif not self.is_unique or not other.is_unique:
+ return self._join_non_unique(other, how=how, sort=sort)
return self._join_via_get_indexer(other, how, sort)
@@ -4797,6 +4783,9 @@ def _join_non_unique(
join_idx = self.take(left_idx)
right = other.take(right_idx)
join_index = join_idx.putmask(mask, right)
+ if isinstance(join_index, ABCMultiIndex) and how == "outer":
+ # test_join_index_levels
+ join_index = join_index._sort_levels_monotonic()
return join_index, left_idx, right_idx
@final
@@ -5042,10 +5031,10 @@ def _can_use_libjoin(self) -> bool:
or isinstance(self._values, (ArrowExtensionArray, BaseMaskedArray))
or self.dtype == "string[python]"
)
- # For IntervalIndex, the conversion to numpy converts
- # to object dtype, which negates the performance benefit of libjoin
- # TODO: exclude RangeIndex and MultiIndex as these also make copies?
- return not isinstance(self.dtype, IntervalDtype)
+ # Exclude index types where the conversion to numpy converts to object dtype,
+ # which negates the performance benefit of libjoin
+ # TODO: exclude RangeIndex? Seems to break test_concat_datetime_timezone
+ return not isinstance(self, (ABCIntervalIndex, ABCMultiIndex))
# --------------------------------------------------------------------
# Uncategorized Methods
@@ -5180,8 +5169,7 @@ def _get_join_target(self) -> np.ndarray:
# present
return self._values.to_numpy()
- # TODO: exclude ABCRangeIndex, ABCMultiIndex cases here as those create
- # copies.
+ # TODO: exclude ABCRangeIndex case here as it copies
target = self._get_engine_target()
if not isinstance(target, np.ndarray):
raise ValueError("_can_use_libjoin should return False.")
| - [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.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
Addresses #54646 for `MultiIndex` but leaves `RangeIndex` as is. The `RangeIndex` case
seems to have a few side effects - I'll add comments separately to #54646 for `RangeIndex`.
Also, simplifies the logic in `Index.join` which improves perf for a few `MultiIndex` and non-`MultiIndex` cases.
`multiindex_object` benchmarks:
```
before after ratio
- 18.7±0.2ms 16.6±0.4ms 0.89 multiindex_object.SetOperations.time_operation('monotonic', 'ea_int', 'symmetric_difference', False)
- 19.0±0.7ms 16.5±0.2ms 0.87 multiindex_object.SetOperations.time_operation('monotonic', 'int', 'intersection', False)
- 60.6±10ms 49.8±1ms 0.82 multiindex_object.SetOperations.time_operation('monotonic', 'string', 'intersection', None)
- 40.1±1ms 32.2±0.4ms 0.80 multiindex_object.SetOperations.time_operation('monotonic', 'ea_int', 'intersection', None)
```
`join_merge` benchmarks:
```
before after ratio
- 9.98±0.2ms 8.99±0.1ms 0.90 join_merge.ConcatIndexDtype.time_concat_series('Int64', 'has_na', 1, True)
- 12.2±0.3ms 10.5±0.05ms 0.86 join_merge.ConcatIndexDtype.time_concat_series('int64[pyarrow]', 'has_na', 1, True)
- 13.9±2ms 11.8±0.2ms 0.85 join_merge.ConcatIndexDtype.time_concat_series('datetime64[ns]', 'has_na', 1, False)
- 26.3±3ms 22.3±0.05ms 0.85 join_merge.ConcatIndexDtype.time_concat_series('string[python]', 'monotonic', 1, False)
- 6.50±1ms 5.19±0.05ms 0.80 join_merge.ConcatIndexDtype.time_concat_series('datetime64[ns]', 'monotonic', 1, False)
- 133±2ms 51.1±2ms 0.38 join_merge.Align.time_series_align_int64_index
- 105±0.9ms 23.7±0.5ms 0.22 join_merge.Align.time_series_align_left_monotonic
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/54765 | 2023-08-26T01:45:57Z | 2023-08-28T15:34:18Z | 2023-08-28T15:34:18Z | 2023-09-06T00:53:59Z |
Backport PR #54759 on branch 2.1.x (CI: Pin more cython) | diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index 030c9546fecca..6410f2edd6175 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -234,7 +234,7 @@ jobs:
/opt/python/cp311-cp311/bin/python -m venv ~/virtualenvs/pandas-dev
. ~/virtualenvs/pandas-dev/bin/activate
python -m pip install --no-cache-dir -U pip wheel setuptools meson[ninja]==1.0.1 meson-python==0.13.1
- python -m pip install --no-cache-dir versioneer[toml] cython numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
+ python -m pip install --no-cache-dir versioneer[toml] "cython<3.0.1" numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
python -m pip install --no-cache-dir --no-build-isolation -e .
python -m pip list --no-cache-dir
export PANDAS_CI=1
@@ -272,7 +272,7 @@ jobs:
/opt/python/cp311-cp311/bin/python -m venv ~/virtualenvs/pandas-dev
. ~/virtualenvs/pandas-dev/bin/activate
python -m pip install --no-cache-dir -U pip wheel setuptools meson-python==0.13.1 meson[ninja]==1.0.1
- python -m pip install --no-cache-dir versioneer[toml] cython numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
+ python -m pip install --no-cache-dir versioneer[toml] "cython<3.0.1" numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
python -m pip install --no-cache-dir --no-build-isolation -e .
python -m pip list --no-cache-dir
@@ -345,7 +345,7 @@ jobs:
python -m pip install --upgrade pip setuptools wheel meson[ninja]==1.0.1 meson-python==0.13.1
python -m pip install --pre --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple numpy
python -m pip install versioneer[toml]
- python -m pip install python-dateutil pytz tzdata cython hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-cov pytest-asyncio>=0.17
+ python -m pip install python-dateutil pytz tzdata "cython<3.0.1" hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-cov pytest-asyncio>=0.17
python -m pip install -ve . --no-build-isolation --no-index
python -m pip list
diff --git a/ci/deps/actions-311-numpydev.yaml b/ci/deps/actions-311-numpydev.yaml
index 1766721459ed2..acf94fce5288b 100644
--- a/ci/deps/actions-311-numpydev.yaml
+++ b/ci/deps/actions-311-numpydev.yaml
@@ -25,7 +25,7 @@ dependencies:
- pip
- pip:
- - "cython<=3.0.1"
+ - "cython<3.0.1"
- "--extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple"
- "--pre"
- "numpy"
| Backport PR #54759: CI: Pin more cython | https://api.github.com/repos/pandas-dev/pandas/pulls/54764 | 2023-08-26T00:46:51Z | 2023-08-26T07:57:20Z | 2023-08-26T07:57:20Z | 2023-08-26T07:57:20Z |
Backport PR #54752 on branch 2.1.x (REGR: groupby.count returning string dtype instead of numeric for string input) | diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 5a7f42a535951..dd0c995e6acca 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -107,6 +107,7 @@ class providing the base-class of operations.
IntegerArray,
SparseArray,
)
+from pandas.core.arrays.string_ import StringDtype
from pandas.core.base import (
PandasObject,
SelectionMixin,
@@ -2261,7 +2262,9 @@ def hfunc(bvalues: ArrayLike) -> ArrayLike:
return IntegerArray(
counted[0], mask=np.zeros(counted.shape[1], dtype=np.bool_)
)
- elif isinstance(bvalues, ArrowExtensionArray):
+ elif isinstance(bvalues, ArrowExtensionArray) and not isinstance(
+ bvalues.dtype, StringDtype
+ ):
return type(bvalues)._from_sequence(counted[0])
if is_series:
assert counted.ndim == 2
diff --git a/pandas/tests/groupby/test_counting.py b/pandas/tests/groupby/test_counting.py
index 6c27344ce3110..885e7848b76cb 100644
--- a/pandas/tests/groupby/test_counting.py
+++ b/pandas/tests/groupby/test_counting.py
@@ -379,3 +379,14 @@ def __eq__(self, other):
result = df.groupby("grp").count()
expected = DataFrame({"a": [2, 2]}, index=Index(list("ab"), name="grp"))
tm.assert_frame_equal(result, expected)
+
+
+def test_count_arrow_string_array(any_string_dtype):
+ # GH#54751
+ pytest.importorskip("pyarrow")
+ df = DataFrame(
+ {"a": [1, 2, 3], "b": Series(["a", "b", "a"], dtype=any_string_dtype)}
+ )
+ result = df.groupby("a").count()
+ expected = DataFrame({"b": 1}, index=Index([1, 2, 3], name="a"))
+ tm.assert_frame_equal(result, expected)
| Backport PR #54752: REGR: groupby.count returning string dtype instead of numeric for string input | https://api.github.com/repos/pandas-dev/pandas/pulls/54762 | 2023-08-25T18:59:26Z | 2023-08-25T20:59:11Z | 2023-08-25T20:59:11Z | 2023-08-25T20:59:11Z |
Backport PR #54699 on branch 2.1.x (BUG: setitem with object type inserting Series maintains Series) | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index fabe910261c3d..e3f18067e354d 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -729,6 +729,7 @@ Indexing
- Bug in :meth:`DataFrame.__setitem__` losing dtype when setting a :class:`DataFrame` into duplicated columns (:issue:`53143`)
- Bug in :meth:`DataFrame.__setitem__` with a boolean mask and :meth:`DataFrame.putmask` with mixed non-numeric dtypes and a value other than ``NaN`` incorrectly raising ``TypeError`` (:issue:`53291`)
- Bug in :meth:`DataFrame.iloc` when using ``nan`` as the only element (:issue:`52234`)
+- Bug in :meth:`Series.loc` casting :class:`Series` to ``np.dnarray`` when assigning :class:`Series` at predefined index of ``object`` dtype :class:`Series` (:issue:`48933`)
Missing
^^^^^^^
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index ecb9cd47d7995..6df90eece3cc8 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1133,7 +1133,9 @@ def setitem(self, indexer, value, using_cow: bool = False) -> Block:
# length checking
check_setitem_lengths(indexer, value, values)
- value = extract_array(value, extract_numpy=True)
+ if self.dtype != _dtype_obj:
+ # GH48933: extract_array would convert a pd.Series value to np.ndarray
+ value = extract_array(value, extract_numpy=True)
try:
casted = np_can_hold_element(values.dtype, value)
except LossySetitemError:
diff --git a/pandas/tests/indexing/test_indexing.py b/pandas/tests/indexing/test_indexing.py
index d6d8a63797bb6..224555399ff8f 100644
--- a/pandas/tests/indexing/test_indexing.py
+++ b/pandas/tests/indexing/test_indexing.py
@@ -1132,3 +1132,19 @@ def test_scalar_setitem_series_with_nested_value_length1(value, indexer_sli):
assert (ser.loc[0] == value).all()
else:
assert ser.loc[0] == value
+
+
+def test_object_dtype_series_set_series_element():
+ # GH 48933
+ s1 = Series(dtype="O", index=["a", "b"])
+
+ s1["a"] = Series()
+ s1.loc["b"] = Series()
+
+ tm.assert_series_equal(s1.loc["a"], Series())
+ tm.assert_series_equal(s1.loc["b"], Series())
+
+ s2 = Series(dtype="O", index=["a", "b"])
+
+ s2.iloc[1] = Series()
+ tm.assert_series_equal(s2.iloc[1], Series())
| Backport PR #54699: BUG: setitem with object type inserting Series maintains Series | https://api.github.com/repos/pandas-dev/pandas/pulls/54760 | 2023-08-25T18:01:53Z | 2023-08-25T20:58:27Z | 2023-08-25T20:58:27Z | 2023-08-25T20:58:27Z |
CI: Pin more cython | diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index 030c9546fecca..6410f2edd6175 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -234,7 +234,7 @@ jobs:
/opt/python/cp311-cp311/bin/python -m venv ~/virtualenvs/pandas-dev
. ~/virtualenvs/pandas-dev/bin/activate
python -m pip install --no-cache-dir -U pip wheel setuptools meson[ninja]==1.0.1 meson-python==0.13.1
- python -m pip install --no-cache-dir versioneer[toml] cython numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
+ python -m pip install --no-cache-dir versioneer[toml] "cython<3.0.1" numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
python -m pip install --no-cache-dir --no-build-isolation -e .
python -m pip list --no-cache-dir
export PANDAS_CI=1
@@ -272,7 +272,7 @@ jobs:
/opt/python/cp311-cp311/bin/python -m venv ~/virtualenvs/pandas-dev
. ~/virtualenvs/pandas-dev/bin/activate
python -m pip install --no-cache-dir -U pip wheel setuptools meson-python==0.13.1 meson[ninja]==1.0.1
- python -m pip install --no-cache-dir versioneer[toml] cython numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
+ python -m pip install --no-cache-dir versioneer[toml] "cython<3.0.1" numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-asyncio>=0.17 hypothesis>=6.46.1
python -m pip install --no-cache-dir --no-build-isolation -e .
python -m pip list --no-cache-dir
@@ -345,7 +345,7 @@ jobs:
python -m pip install --upgrade pip setuptools wheel meson[ninja]==1.0.1 meson-python==0.13.1
python -m pip install --pre --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple numpy
python -m pip install versioneer[toml]
- python -m pip install python-dateutil pytz tzdata cython hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-cov pytest-asyncio>=0.17
+ python -m pip install python-dateutil pytz tzdata "cython<3.0.1" hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0 pytest-cov pytest-asyncio>=0.17
python -m pip install -ve . --no-build-isolation --no-index
python -m pip list
diff --git a/ci/deps/actions-311-numpydev.yaml b/ci/deps/actions-311-numpydev.yaml
index 1766721459ed2..acf94fce5288b 100644
--- a/ci/deps/actions-311-numpydev.yaml
+++ b/ci/deps/actions-311-numpydev.yaml
@@ -25,7 +25,7 @@ dependencies:
- pip
- pip:
- - "cython<=3.0.1"
+ - "cython<3.0.1"
- "--extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple"
- "--pre"
- "numpy"
| - [ ] 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/54759 | 2023-08-25T17:38:42Z | 2023-08-26T00:36:20Z | 2023-08-26T00:36:20Z | 2023-08-26T00:45:48Z |
Backport PR #54757 on branch 2.1.x (CI: Pin Cython on CI) | diff --git a/ci/deps/actions-310.yaml b/ci/deps/actions-310.yaml
index 638aaedecf2b5..2190136220c6c 100644
--- a/ci/deps/actions-310.yaml
+++ b/ci/deps/actions-310.yaml
@@ -6,7 +6,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-311-downstream_compat.yaml b/ci/deps/actions-311-downstream_compat.yaml
index 4d925786c22d6..cf85345cb0cc2 100644
--- a/ci/deps/actions-311-downstream_compat.yaml
+++ b/ci/deps/actions-311-downstream_compat.yaml
@@ -7,7 +7,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-311-numpydev.yaml b/ci/deps/actions-311-numpydev.yaml
index 2cd4d5f3528f8..1766721459ed2 100644
--- a/ci/deps/actions-311-numpydev.yaml
+++ b/ci/deps/actions-311-numpydev.yaml
@@ -25,7 +25,7 @@ dependencies:
- pip
- pip:
- - "cython"
+ - "cython<=3.0.1"
- "--extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple"
- "--pre"
- "numpy"
diff --git a/ci/deps/actions-311-pyarrownightly.yaml b/ci/deps/actions-311-pyarrownightly.yaml
index f24e866af0439..e850f69f945c5 100644
--- a/ci/deps/actions-311-pyarrownightly.yaml
+++ b/ci/deps/actions-311-pyarrownightly.yaml
@@ -7,7 +7,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- meson[ninja]=1.0.1
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson-python=0.13.1
# test dependencies
diff --git a/ci/deps/actions-311.yaml b/ci/deps/actions-311.yaml
index 698107341c26d..3c1630714a041 100644
--- a/ci/deps/actions-311.yaml
+++ b/ci/deps/actions-311.yaml
@@ -6,7 +6,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-39-minimum_versions.yaml b/ci/deps/actions-39-minimum_versions.yaml
index a0aafb1d772a7..b1cea49e22d15 100644
--- a/ci/deps/actions-39-minimum_versions.yaml
+++ b/ci/deps/actions-39-minimum_versions.yaml
@@ -8,7 +8,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index 6c6b1de165496..b8a119ece4b03 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -6,7 +6,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-pypy-39.yaml b/ci/deps/actions-pypy-39.yaml
index 035395d55eb3a..23c3706f43dad 100644
--- a/ci/deps/actions-pypy-39.yaml
+++ b/ci/deps/actions-pypy-39.yaml
@@ -9,7 +9,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/circle-310-arm64.yaml b/ci/deps/circle-310-arm64.yaml
index d436e90fa6186..71686837451b4 100644
--- a/ci/deps/circle-310-arm64.yaml
+++ b/ci/deps/circle-310-arm64.yaml
@@ -6,7 +6,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
| Backport PR #54757: CI: Pin Cython on CI | https://api.github.com/repos/pandas-dev/pandas/pulls/54758 | 2023-08-25T17:07:52Z | 2023-08-26T00:45:16Z | 2023-08-26T00:45:15Z | 2023-08-26T00:45:29Z |
CI: Pin Cython on CI | diff --git a/ci/deps/actions-310.yaml b/ci/deps/actions-310.yaml
index ffa7732c604a0..0534f54c42e9a 100644
--- a/ci/deps/actions-310.yaml
+++ b/ci/deps/actions-310.yaml
@@ -6,7 +6,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-311-downstream_compat.yaml b/ci/deps/actions-311-downstream_compat.yaml
index 596f3476c9c4e..66daccb4827ba 100644
--- a/ci/deps/actions-311-downstream_compat.yaml
+++ b/ci/deps/actions-311-downstream_compat.yaml
@@ -7,7 +7,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-311-numpydev.yaml b/ci/deps/actions-311-numpydev.yaml
index 2cd4d5f3528f8..1766721459ed2 100644
--- a/ci/deps/actions-311-numpydev.yaml
+++ b/ci/deps/actions-311-numpydev.yaml
@@ -25,7 +25,7 @@ dependencies:
- pip
- pip:
- - "cython"
+ - "cython<=3.0.1"
- "--extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple"
- "--pre"
- "numpy"
diff --git a/ci/deps/actions-311-pyarrownightly.yaml b/ci/deps/actions-311-pyarrownightly.yaml
index f24e866af0439..e850f69f945c5 100644
--- a/ci/deps/actions-311-pyarrownightly.yaml
+++ b/ci/deps/actions-311-pyarrownightly.yaml
@@ -7,7 +7,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- meson[ninja]=1.0.1
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson-python=0.13.1
# test dependencies
diff --git a/ci/deps/actions-311.yaml b/ci/deps/actions-311.yaml
index 9d60d734db5b3..59f61196e7038 100644
--- a/ci/deps/actions-311.yaml
+++ b/ci/deps/actions-311.yaml
@@ -6,7 +6,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-39-minimum_versions.yaml b/ci/deps/actions-39-minimum_versions.yaml
index 91961e4af2d1c..c418c9fbc9ffe 100644
--- a/ci/deps/actions-39-minimum_versions.yaml
+++ b/ci/deps/actions-39-minimum_versions.yaml
@@ -8,7 +8,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index 6ea0d41b947dc..ebe102af49e64 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -6,7 +6,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/actions-pypy-39.yaml b/ci/deps/actions-pypy-39.yaml
index 035395d55eb3a..23c3706f43dad 100644
--- a/ci/deps/actions-pypy-39.yaml
+++ b/ci/deps/actions-pypy-39.yaml
@@ -9,7 +9,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
diff --git a/ci/deps/circle-310-arm64.yaml b/ci/deps/circle-310-arm64.yaml
index df4e8e285bd02..ba6b7f81501a0 100644
--- a/ci/deps/circle-310-arm64.yaml
+++ b/ci/deps/circle-310-arm64.yaml
@@ -6,7 +6,7 @@ dependencies:
# build dependencies
- versioneer[toml]
- - cython>=0.29.33
+ - cython>=0.29.33, <3.0.1
- meson[ninja]=1.0.1
- meson-python=0.13.1
| - [ ] ref #54756 (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/54757 | 2023-08-25T14:48:41Z | 2023-08-25T17:06:42Z | 2023-08-25T17:06:42Z | 2023-08-25T17:33:11Z |
BUG: merge raising for ea int and numpy float | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index f5758a079b1b5..19a8500928ab7 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -816,6 +816,7 @@ Reshaping
- Bug in :func:`merge_asof` raising ``KeyError`` for extension dtypes (:issue:`52904`)
- Bug in :func:`merge_asof` raising ``ValueError`` for data backed by read-only ndarrays (:issue:`53513`)
- Bug in :func:`merge_asof` with ``left_index=True`` or ``right_index=True`` with mismatched index dtypes giving incorrect results in some cases instead of raising ``MergeError`` (:issue:`53870`)
+- Bug in :func:`merge` when merging on integer ``ExtensionDtype`` and float NumPy dtype raising ``TypeError`` (:issue:`46178`)
- Bug in :meth:`DataFrame.agg` and :meth:`Series.agg` on non-unique columns would return incorrect type when dist-like argument passed in (:issue:`51099`)
- Bug in :meth:`DataFrame.combine_first` ignoring other's columns if ``other`` is empty (:issue:`53792`)
- Bug in :meth:`DataFrame.idxmin` and :meth:`DataFrame.idxmax`, where the axis dtype would be lost for empty frames (:issue:`53265`)
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 140a3024a8684..13bc1008698b2 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -53,6 +53,7 @@
ensure_object,
is_bool,
is_bool_dtype,
+ is_extension_array_dtype,
is_float_dtype,
is_integer,
is_integer_dtype,
@@ -1385,6 +1386,21 @@ def _maybe_coerce_merge_keys(self) -> None:
if lk.dtype.kind == rk.dtype.kind:
continue
+ if is_extension_array_dtype(lk.dtype) and not is_extension_array_dtype(
+ rk.dtype
+ ):
+ ct = find_common_type([lk.dtype, rk.dtype])
+ if is_extension_array_dtype(ct):
+ rk = ct.construct_array_type()._from_sequence(rk) # type: ignore[union-attr] # noqa: E501
+ else:
+ rk = rk.astype(ct) # type: ignore[arg-type]
+ elif is_extension_array_dtype(rk.dtype):
+ ct = find_common_type([lk.dtype, rk.dtype])
+ if is_extension_array_dtype(ct):
+ lk = ct.construct_array_type()._from_sequence(lk) # type: ignore[union-attr] # noqa: E501
+ else:
+ lk = lk.astype(ct) # type: ignore[arg-type]
+
# check whether ints and floats
if is_integer_dtype(rk.dtype) and is_float_dtype(lk.dtype):
# GH 47391 numpy > 1.24 will raise a RuntimeError for nan -> int
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 50a534ad36bcc..02d7e2059e8e1 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -2924,3 +2924,26 @@ def test_merge_combinations(
expected = expected.reset_index(drop=True)
tm.assert_frame_equal(result, expected)
+
+
+def test_merge_ea_int_and_float_numpy():
+ # GH#46178
+ df1 = DataFrame([1.0, np.nan], dtype=pd.Int64Dtype())
+ df2 = DataFrame([1.5])
+ expected = DataFrame(columns=[0], dtype="Int64")
+
+ with tm.assert_produces_warning(UserWarning, match="You are merging"):
+ result = df1.merge(df2)
+ tm.assert_frame_equal(result, expected)
+
+ with tm.assert_produces_warning(UserWarning, match="You are merging"):
+ result = df2.merge(df1)
+ tm.assert_frame_equal(result, expected.astype("float64"))
+
+ df2 = DataFrame([1.0])
+ expected = DataFrame([1], columns=[0], dtype="Int64")
+ result = df1.merge(df2)
+ tm.assert_frame_equal(result, expected)
+
+ result = df2.merge(df1)
+ tm.assert_frame_equal(result, expected.astype("float64"))
| - [ ] closes #46178 (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.
Ideally I'd like to get this in, but not a blocker | https://api.github.com/repos/pandas-dev/pandas/pulls/54755 | 2023-08-25T14:29:41Z | 2023-08-26T19:10:37Z | 2023-08-26T19:10:37Z | 2023-08-27T15:03:33Z |
REGR: groupby.count returning string dtype instead of numeric for string input | diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 49b47545d6297..f0d73811227fa 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -107,6 +107,7 @@ class providing the base-class of operations.
IntegerArray,
SparseArray,
)
+from pandas.core.arrays.string_ import StringDtype
from pandas.core.base import (
PandasObject,
SelectionMixin,
@@ -2281,7 +2282,9 @@ def hfunc(bvalues: ArrayLike) -> ArrayLike:
return IntegerArray(
counted[0], mask=np.zeros(counted.shape[1], dtype=np.bool_)
)
- elif isinstance(bvalues, ArrowExtensionArray):
+ elif isinstance(bvalues, ArrowExtensionArray) and not isinstance(
+ bvalues.dtype, StringDtype
+ ):
return type(bvalues)._from_sequence(counted[0])
if is_series:
assert counted.ndim == 2
diff --git a/pandas/tests/groupby/test_counting.py b/pandas/tests/groupby/test_counting.py
index 6c27344ce3110..885e7848b76cb 100644
--- a/pandas/tests/groupby/test_counting.py
+++ b/pandas/tests/groupby/test_counting.py
@@ -379,3 +379,14 @@ def __eq__(self, other):
result = df.groupby("grp").count()
expected = DataFrame({"a": [2, 2]}, index=Index(list("ab"), name="grp"))
tm.assert_frame_equal(result, expected)
+
+
+def test_count_arrow_string_array(any_string_dtype):
+ # GH#54751
+ pytest.importorskip("pyarrow")
+ df = DataFrame(
+ {"a": [1, 2, 3], "b": Series(["a", "b", "a"], dtype=any_string_dtype)}
+ )
+ result = df.groupby("a").count()
+ expected = DataFrame({"b": 1}, index=Index([1, 2, 3], name="a"))
+ tm.assert_frame_equal(result, expected)
| - [ ] closes #54751 (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/54752 | 2023-08-25T09:43:36Z | 2023-08-25T18:59:18Z | 2023-08-25T18:59:18Z | 2023-08-25T22:52:20Z |
Revert deprecation of con as keyword only arg | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index e3f18067e354d..f5758a079b1b5 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -586,7 +586,7 @@ Other Deprecations
- Deprecated the use of non-supported datetime64 and timedelta64 resolutions with :func:`pandas.array`. Supported resolutions are: "s", "ms", "us", "ns" resolutions (:issue:`53058`)
- Deprecated values ``"pad"``, ``"ffill"``, ``"bfill"``, ``"backfill"`` for :meth:`Series.interpolate` and :meth:`DataFrame.interpolate`, use ``obj.ffill()`` or ``obj.bfill()`` instead (:issue:`53581`)
- Deprecated the behavior of :meth:`Index.argmax`, :meth:`Index.argmin`, :meth:`Series.argmax`, :meth:`Series.argmin` with either all-NAs and ``skipna=True`` or any-NAs and ``skipna=False`` returning -1; in a future version this will raise ``ValueError`` (:issue:`33941`, :issue:`33942`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_sql` except ``name`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_sql` except ``name`` and ``con`` (:issue:`54229`)
.. ---------------------------------------------------------------------------
.. _whatsnew_210.performance:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 9682e5a864e2c..021725899a1bb 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -2801,7 +2801,7 @@ def to_hdf(
@final
@deprecate_nonkeyword_arguments(
- version="3.0", allowed_args=["self", "name"], name="to_sql"
+ version="3.0", allowed_args=["self", "name", "con"], name="to_sql"
)
def to_sql(
self,
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 2f446e6b8c81d..9ec0ba0b12a76 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -2849,13 +2849,14 @@ def setup_driver(cls):
def test_keyword_deprecation(self):
# GH 54397
msg = (
- "tarting with pandas version 3.0 all arguments of to_sql except for the "
- "argument 'name' will be keyword-only."
+ "Starting with pandas version 3.0 all arguments of to_sql except for the "
+ "arguments 'name' and 'con' will be keyword-only."
)
df = DataFrame([{"A": 1, "B": 2, "C": 3}, {"A": 1, "B": 2, "C": 3}])
+ df.to_sql("example", self.conn)
with tm.assert_produces_warning(FutureWarning, match=msg):
- df.to_sql("example", self.conn)
+ df.to_sql("example", self.conn, None, if_exists="replace")
def test_default_type_conversion(self):
df = sql.read_sql_table("types", self.conn)
| - [x] closes #54749 (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/54750 | 2023-08-25T09:23:41Z | 2023-08-26T07:57:40Z | 2023-08-26T07:57:40Z | 2023-08-26T07:57:44Z |
PERF: Increase threashold for using binary search in IndexEngine | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 01c43486f800f..604fd9256e10f 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -153,7 +153,7 @@ Deprecations
Performance improvements
~~~~~~~~~~~~~~~~~~~~~~~~
--
+- Performance improvement when indexing with more than 4 keys (:issue:`54550`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index e974b5d0eec46..5c7680bc6fb6c 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -375,7 +375,7 @@ cdef class IndexEngine:
# map each starget to its position in the index
if (
stargets and
- len(stargets) < 5 and
+ len(stargets) < (n / (2 * n.bit_length())) and
not na_in_stargets and
self.is_monotonic_increasing
):
| # Checklist
- [x] closes #54550 (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.
# Explanation
So after a bit of research for #54550, I found that the source of the behavior is coming from PR #22826 at [this line](https://github.com/pandas-dev/pandas/blob/0f437949513225922d851e9581723d82120684a6/pandas/_libs/index.pyx#L361) and particularly this comment [here](https://github.com/pandas-dev/pandas/pull/22826#discussion_r220715797).
In the comment, @rtlee9 makes an excellent explanation for the reason behind the threshold. The default behavior is a linear search (`O(n)`) in the pandas index and #22826 added a binary search optimization for monotonically increasing index which is in `O(m*log(n))` where `m` is the number of target indexes.
# Proposed Solution
I'm proposing we increase the limit, which was set conservatively to 5. We could at least increase it to n / (2 * log2[n]) which is derivable from m*log2[n]<n and dividing per 2 for keeping a certain margin. I'll open a PR for that.
# New results of benchmarking + homemade script
Here is a screenshot of `asv continuous -f 1.1 -E virtualenv upstream/main HEAD -b ^indexing.*Index*` output (done on Macbook Air m1, inside the docker container provided by pandas):
Here is also a new output for the script use to demonstrate the problem in #54700:
```
With all at once: num_indexes=1 => 0.00048s
With all at once: num_indexes=2 => 0.00045s
With all at once: num_indexes=3 => 0.00038s
With all at once: num_indexes=4 => 0.00035s
With all at once: num_indexes=5 => 0.00035s
With all at once: num_indexes=6 => 0.00045s
With all at once: num_indexes=7 => 0.00042s
With all at once: num_indexes=8 => 0.00066s
With all at once: num_indexes=9 => 0.00049s
With all at once: num_indexes=10 => 0.00048s
```
Thanks in advance for the review! | https://api.github.com/repos/pandas-dev/pandas/pulls/54746 | 2023-08-25T02:31:53Z | 2023-08-26T19:12:09Z | 2023-08-26T19:12:09Z | 2023-08-26T21:49:54Z |
CLN: Update LICENCES and reference where used | diff --git a/LICENSES/BOTTLENECK_LICENCE b/LICENSES/BOTTLENECK_LICENCE
new file mode 100644
index 0000000000000..f4bdbb1647ee6
--- /dev/null
+++ b/LICENSES/BOTTLENECK_LICENCE
@@ -0,0 +1,25 @@
+Copyright (c) 2010-2019 Keith Goodman
+Copyright (c) 2019 Bottleneck Developers
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/LICENSES/DATEUTIL_LICENSE b/LICENSES/DATEUTIL_LICENSE
index 6053d35cfc60b..1e65815cf0b31 100644
--- a/LICENSES/DATEUTIL_LICENSE
+++ b/LICENSES/DATEUTIL_LICENSE
@@ -51,4 +51,4 @@ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-The above BSD License Applies to all code, even that also covered by Apache 2.0.
+The above BSD License Applies to all code, even that also covered by Apache 2.0.
\ No newline at end of file
diff --git a/LICENSES/KLIB_LICENSE b/LICENSES/KLIB_LICENSE
index 0a996fae3360f..2de13e402643b 100644
--- a/LICENSES/KLIB_LICENSE
+++ b/LICENSES/KLIB_LICENSE
@@ -20,4 +20,4 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.
\ No newline at end of file
diff --git a/LICENSES/MUSL_LICENSE b/LICENSES/MUSL_LICENSE
index a8833d4bc4744..5ff71b5f5a7fe 100644
--- a/LICENSES/MUSL_LICENSE
+++ b/LICENSES/MUSL_LICENSE
@@ -1,7 +1,7 @@
musl as a whole is licensed under the following standard MIT license:
----------------------------------------------------------------------
-Copyright © 2005-2014 Rich Felker, et al.
+Copyright © 2005-2020 Rich Felker, et al.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
@@ -25,37 +25,88 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Authors/contributors include:
+A. Wilcox
+Ada Worcester
+Alex Dowad
+Alex Suykov
+Alexander Monakov
+Andre McCurdy
+Andrew Kelley
Anthony G. Basile
+Aric Belsito
Arvid Picciani
+Bartosz Brachaczek
+Benjamin Peterson
Bobby Bingham
Boris Brezillon
Brent Cook
Chris Spiegel
Clément Vasseur
+Daniel Micay
+Daniel Sabogal
+Daurnimator
+David Carlier
+David Edelsohn
+Denys Vlasenko
+Dmitry Ivanov
+Dmitry V. Levin
+Drew DeVault
Emil Renner Berthing
+Fangrui Song
+Felix Fietkau
+Felix Janda
+Gianluca Anzolin
+Hauke Mehrtens
+He X
Hiltjo Posthuma
Isaac Dunham
+Jaydeep Patil
Jens Gustedt
Jeremy Huntwork
+Jo-Philipp Wich
+Joakim Sindholt
John Spencer
+Julien Ramseier
Justin Cormack
+Kaarle Ritvanen
+Khem Raj
+Kylie McClain
+Leah Neukirchen
Luca Barbato
Luka Perkov
M Farkas-Dyck (Strake)
+Mahesh Bodapati
+Markus Wichmann
+Masanori Ogino
+Michael Clark
Michael Forney
+Mikhail Kremnyov
+Natanael Copa
Nicholas J. Kain
orc
Pascal Cuoq
+Patrick Oppenlander
+Petr Hosek
+Petr Skocik
Pierre Carrier
+Reini Urban
Rich Felker
Richard Pennington
+Ryan Fairfax
+Samuel Holland
+Segev Finer
+Shiz
sin
Solar Designer
Stefan Kristiansson
+Stefan O'Rear
Szabolcs Nagy
Timo Teräs
+Trutz Behn
Valentin Ochs
+Will Dietz
William Haddon
+William Pitcock
Portions of this software are derived from third-party works licensed
under terms compatible with the above MIT license:
@@ -71,18 +122,22 @@ Copyright © 1993,2004 Sun Microsystems or
Copyright © 2003-2011 David Schultz or
Copyright © 2003-2009 Steven G. Kargl or
Copyright © 2003-2009 Bruce D. Evans or
-Copyright © 2008 Stephen L. Moshier
+Copyright © 2008 Stephen L. Moshier or
+Copyright © 2017-2018 Arm Limited
and labelled as such in comments in the individual source files. All
have been licensed under extremely permissive terms.
-The ARM memcpy code (src/string/armel/memcpy.s) is Copyright © 2008
+The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
The Android Open Source Project and is licensed under a two-clause BSD
license. It was taken from Bionic libc, used on Android.
-The implementation of DES for crypt (src/misc/crypt_des.c) is
+The AArch64 memcpy and memset code (src/string/aarch64/*) are
+Copyright © 1999-2019, Arm Limited.
+
+The implementation of DES for crypt (src/crypt/crypt_des.c) is
Copyright © 1994 David Burren. It is licensed under a BSD license.
-The implementation of blowfish crypt (src/misc/crypt_blowfish.c) was
+The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
originally written by Solar Designer and placed into the public
domain. The code also comes with a fallback permissive license for use
in jurisdictions that may not recognize the public domain.
@@ -90,22 +145,17 @@ in jurisdictions that may not recognize the public domain.
The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
Valentin Ochs and is licensed under an MIT-style license.
-The BSD PRNG implementation (src/prng/random.c) and XSI search API
-(src/search/*.c) functions are Copyright © 2011 Szabolcs Nagy and
-licensed under following terms: "Permission to use, copy, modify,
-and/or distribute this code for any purpose with or without fee is
-hereby granted. There is no warranty."
-
-The x86_64 port was written by Nicholas J. Kain. Several files (crt)
-were released into the public domain; others are licensed under the
-standard MIT license terms at the top of this file. See individual
-files for their copyright status.
+The x86_64 port was written by Nicholas J. Kain and is licensed under
+the standard MIT terms.
The mips and microblaze ports were originally written by Richard
Pennington for use in the ellcc project. The original code was adapted
by Rich Felker for build system and code conventions during upstream
integration. It is licensed under the standard MIT terms.
+The mips64 port was contributed by Imagination Technologies and is
+licensed under the standard MIT terms.
+
The powerpc port was also originally written by Richard Pennington,
and later supplemented and integrated by John Spencer. It is licensed
under the standard MIT terms.
@@ -118,15 +168,26 @@ can be found in the git version control history of the project. The
omission of copyright and license comments in each file is in the
interest of source tree size.
-All public header files (include/* and arch/*/bits/*) should be
-treated as Public Domain as they intentionally contain no content
-which can be covered by copyright. Some source modules may fall in
-this category as well. If you believe that a file is so trivial that
-it should be in the Public Domain, please contact the authors and
-request an explicit statement releasing it from copyright.
+In addition, permission is hereby granted for all public header files
+(include/* and arch/*/bits/*) and crt files intended to be linked into
+applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
+the copyright notice and permission notice otherwise required by the
+license, and to use these files without any requirement of
+attribution. These files include substantial contributions from:
+
+Bobby Bingham
+John Spencer
+Nicholas J. Kain
+Rich Felker
+Richard Pennington
+Stefan Kristiansson
+Szabolcs Nagy
-The following files are trivial, believed not to be copyrightable in
-the first place, and hereby explicitly released to the Public Domain:
+all of whom have explicitly granted such permission.
-All public headers: include/*, arch/*/bits/*
-Startup files: crt/*
+This file previously contained text expressing a belief that most of
+the files covered by the above exception were sufficiently trivial not
+to be subject to copyright, resulting in confusion over whether it
+negated the permissions granted in the license. In the spirit of
+permissive licensing, and of not having licensing issues being an
+obstacle to adoption, that text has been removed.
\ No newline at end of file
diff --git a/LICENSES/NUMPY_LICENSE b/LICENSES/NUMPY_LICENSE
index 7e972cff80759..f2d647bf0bc48 100644
--- a/LICENSES/NUMPY_LICENSE
+++ b/LICENSES/NUMPY_LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2005-2011, NumPy Developers.
+Copyright (c) 2005-2023, NumPy Developers.
All rights reserved.
Redistribution and use in source and binary forms, with or without
@@ -27,4 +27,4 @@ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/LICENSES/OTHER b/LICENSES/OTHER
deleted file mode 100644
index e156152990cc4..0000000000000
--- a/LICENSES/OTHER
+++ /dev/null
@@ -1,57 +0,0 @@
-Bottleneck license
-------------------
-
-Copyright (c) 2010-2012 Archipel Asset Management AB.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- * Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
-
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-
-Pyperclip v1.3 license
-----------------------
-
-Copyright (c) 2010, Albert Sweigart
-All rights reserved.
-
-BSD-style license:
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
- * Neither the name of the pyperclip nor the
- names of its contributors may be used to endorse or promote products
- derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY Albert Sweigart "AS IS" AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL Albert Sweigart BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/LICENSES/PACKAGING_LICENSE b/LICENSES/PACKAGING_LICENSE
index 4216ea1ce2379..2bfcd5297c470 100644
--- a/LICENSES/PACKAGING_LICENSE
+++ b/LICENSES/PACKAGING_LICENSE
@@ -199,4 +199,4 @@ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/LICENSES/PSF_LICENSE b/LICENSES/PSF_LICENSE
index 5cdb01e8d24af..f26bcf4d2de6e 100644
--- a/LICENSES/PSF_LICENSE
+++ b/LICENSES/PSF_LICENSE
@@ -2,25 +2,24 @@ A. HISTORY OF THE SOFTWARE
==========================
Python was created in the early 1990s by Guido van Rossum at Stichting
-Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands
as a successor of a language called ABC. Guido remains Python's
principal author, although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for
-National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
+National Research Initiatives (CNRI, see https://www.cnri.reston.va.us)
in Reston, Virginia where he released several versions of the
software.
In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
-year, the PythonLabs team moved to Digital Creations (now Zope
-Corporation, see http://www.zope.com). In 2001, the Python Software
-Foundation (PSF, see http://www.python.org/psf/) was formed, a
-non-profit organization created specifically to own Python-related
-Intellectual Property. Zope Corporation is a sponsoring member of
-the PSF.
-
-All Python releases are Open Source (see http://www.opensource.org for
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation. In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see https://opensource.org for
the Open Source Definition). Historically, most, but not all, Python
releases have also been GPL-compatible; the table below summarizes
the various releases.
@@ -36,34 +35,9 @@ the various releases.
2.1 2.0+1.6.1 2001 PSF no
2.0.1 2.0+1.6.1 2001 PSF yes
2.1.1 2.1+2.0.1 2001 PSF yes
- 2.2 2.1.1 2001 PSF yes
2.1.2 2.1.1 2002 PSF yes
2.1.3 2.1.2 2002 PSF yes
- 2.2.1 2.2 2002 PSF yes
- 2.2.2 2.2.1 2002 PSF yes
- 2.2.3 2.2.2 2003 PSF yes
- 2.3 2.2.2 2002-2003 PSF yes
- 2.3.1 2.3 2002-2003 PSF yes
- 2.3.2 2.3.1 2002-2003 PSF yes
- 2.3.3 2.3.2 2002-2003 PSF yes
- 2.3.4 2.3.3 2004 PSF yes
- 2.3.5 2.3.4 2005 PSF yes
- 2.4 2.3 2004 PSF yes
- 2.4.1 2.4 2005 PSF yes
- 2.4.2 2.4.1 2005 PSF yes
- 2.4.3 2.4.2 2006 PSF yes
- 2.4.4 2.4.3 2006 PSF yes
- 2.5 2.4 2006 PSF yes
- 2.5.1 2.5 2007 PSF yes
- 2.5.2 2.5.1 2008 PSF yes
- 2.5.3 2.5.2 2008 PSF yes
- 2.6 2.5 2008 PSF yes
- 2.6.1 2.6 2008 PSF yes
- 2.6.2 2.6.1 2009 PSF yes
- 2.6.3 2.6.2 2009 PSF yes
- 2.6.4 2.6.3 2009 PSF yes
- 2.6.5 2.6.4 2010 PSF yes
- 2.7 2.6 2010 PSF yes
+ 2.2 and above 2.1.1 2001-now PSF yes
Footnotes:
@@ -85,6 +59,17 @@ direction to make these releases possible.
B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
===============================================================
+Python software and documentation are licensed under the
+Python Software Foundation License Version 2.
+
+Starting with Python 3.8.6, examples, recipes, and other code in
+the documentation are dual licensed under the PSF License Version 2
+and the Zero-Clause BSD license.
+
+Some software incorporated into Python is under different licenses.
+The licenses are listed with code falling under that license.
+
+
PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
--------------------------------------------
@@ -98,9 +83,10 @@ grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python alone or in any derivative version,
provided, however, that PSF's License Agreement and PSF's notice of copyright,
-i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-Python Software Foundation; All Rights Reserved" are retained in Python alone or
-in any derivative version prepared by Licensee.
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
3. In the event Licensee prepares a derivative work that is based on
or incorporates Python or any part thereof, and wants to make
@@ -205,9 +191,9 @@ version prepared by Licensee. Alternately, in lieu of CNRI's License
Agreement, Licensee may substitute the following text (omitting the
quotes): "Python 1.6.1 is made available subject to the terms and
conditions in CNRI's License Agreement. This Agreement together with
-Python 1.6.1 may be located on the Internet using the following
+Python 1.6.1 may be located on the internet using the following
unique, persistent identifier (known as a handle): 1895.22/1013. This
-Agreement may also be obtained from a proxy server on the Internet
+Agreement may also be obtained from a proxy server on the internet
using the following URL: http://hdl.handle.net/1895.22/1013".
3. In the event Licensee prepares a derivative work that is based on
@@ -277,3 +263,17 @@ FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
+----------------------------------------------------------------------
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
diff --git a/LICENSES/PYPERCLIP_LICENSE b/LICENSES/PYPERCLIP_LICENSE
new file mode 100644
index 0000000000000..07cc746cd5ad6
--- /dev/null
+++ b/LICENSES/PYPERCLIP_LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2014, Al Sweigart
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/LICENSES/PYUPGRADE_LICENSE b/LICENSES/PYUPGRADE_LICENSE
index 522fbe20b8991..edeac73dade04 100644
--- a/LICENSES/PYUPGRADE_LICENSE
+++ b/LICENSES/PYUPGRADE_LICENSE
@@ -16,4 +16,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+THE SOFTWARE.
\ No newline at end of file
diff --git a/LICENSES/SAS7BDAT_LICENSE b/LICENSES/SAS7BDAT_LICENSE
index 8fbf194013e93..94b7fe934e85c 100644
--- a/LICENSES/SAS7BDAT_LICENSE
+++ b/LICENSES/SAS7BDAT_LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2015 Jared Hobbs
+Copyright (c) 2015-2019 Jared Hobbs
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
@@ -16,4 +16,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.
\ No newline at end of file
diff --git a/LICENSES/SCIPY_LICENSE b/LICENSES/SCIPY_LICENSE
deleted file mode 100644
index d887ce5f9890f..0000000000000
--- a/LICENSES/SCIPY_LICENSE
+++ /dev/null
@@ -1,31 +0,0 @@
-Copyright (c) 2001, 2002 Enthought, Inc.
-All rights reserved.
-
-Copyright (c) 2003-2012 SciPy Developers.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- a. Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
- b. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
- c. Neither the name of Enthought nor the names of the SciPy Developers
- may be used to endorse or promote products derived from this software
- without specific prior written permission.
-
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.
-
diff --git a/LICENSES/ULTRAJSON_LICENSE b/LICENSES/ULTRAJSON_LICENSE
index a905fb017d813..58fc9dfc0a35b 100644
--- a/LICENSES/ULTRAJSON_LICENSE
+++ b/LICENSES/ULTRAJSON_LICENSE
@@ -1,21 +1,22 @@
-Copyright (c) 2011-2013, ESN Social Software AB and Jonas Tarnstrom
+Developed by ESN, an Electronic Arts Inc. studio.
+Copyright (c) 2014, Electronic Arts Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
- * Neither the name of the ESN Social Software AB nor the
- names of its contributors may be used to endorse or promote products
- derived from this software without specific prior written permission.
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+* Neither the name of ESN, Electronic Arts Inc. nor the
+names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL ESN SOCIAL SOFTWARE AB OR JONAS TARNSTROM BE LIABLE
+DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS INC. BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
@@ -23,12 +24,91 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+----
Portions of code from MODP_ASCII - Ascii transformations (upper/lower, etc)
https://github.com/client9/stringencoders
-Copyright (c) 2007 Nick Galbreath -- nickg [at] modp [dot] com. All rights reserved.
-Numeric decoder derived from TCL library
-http://www.opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
+ Copyright 2005, 2006, 2007
+ Nick Galbreath -- nickg [at] modp [dot] com
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ Neither the name of the modp.com nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ This is the standard "new" BSD license:
+ http://www.opensource.org/licenses/bsd-license.php
+
+https://github.com/client9/stringencoders/blob/cfd5c1507325ae497ea9bacdacba12c0ffd79d30/COPYING
+
+----
+
+Numeric decoder derived from from TCL library
+https://opensource.apple.com/source/tcl/tcl-14/tcl/license.terms
* Copyright (c) 1988-1993 The Regents of the University of California.
* Copyright (c) 1994 Sun Microsystems, Inc.
+
+ This software is copyrighted by the Regents of the University of
+ California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState
+ Corporation and other parties. The following terms apply to all files
+ associated with the software unless explicitly disclaimed in
+ individual files.
+
+ The authors hereby grant permission to use, copy, modify, distribute,
+ and license this software and its documentation for any purpose, provided
+ that existing copyright notices are retained in all copies and that this
+ notice is included verbatim in any distributions. No written agreement,
+ license, or royalty fee is required for any of the authorized uses.
+ Modifications to this software may be copyrighted by their authors
+ and need not follow the licensing terms described here, provided that
+ the new terms are clearly indicated on the first page of each file where
+ they apply.
+
+ IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
+ FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
+ DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
+ IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
+ NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
+ MODIFICATIONS.
+
+ GOVERNMENT USE: If you are acquiring this software on behalf of the
+ U.S. government, the Government shall have only "Restricted Rights"
+ in the software and related documentation as defined in the Federal
+ Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you
+ are acquiring the software on behalf of the Department of Defense, the
+ software shall be classified as "Commercial Computer Software" and the
+ Government shall have only "Restricted Rights" as defined in Clause
+ 252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the
+ authors grant the U.S. Government and others acting in its behalf
+ permission to use and distribute the software in accordance with the
+ terms specified in this license.
\ No newline at end of file
diff --git a/LICENSES/XARRAY_LICENSE b/LICENSES/XARRAY_LICENSE
index 6bafeb9d3d80e..8405e89a0b120 100644
--- a/LICENSES/XARRAY_LICENSE
+++ b/LICENSES/XARRAY_LICENSE
@@ -1,7 +1,3 @@
-Copyright 2014-2019, xarray Developers
-
---------------------------------------------------------------------------------
-
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
@@ -192,4 +188,4 @@ third-party archives.
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
- limitations under the License.
+ limitations under the License.
\ No newline at end of file
diff --git a/pandas/_libs/include/pandas/portable.h b/pandas/_libs/include/pandas/portable.h
index 954b5c3cce082..2569aa4fded08 100644
--- a/pandas/_libs/include/pandas/portable.h
+++ b/pandas/_libs/include/pandas/portable.h
@@ -16,7 +16,7 @@ The full license is in the LICENSE file, distributed with this software.
#endif
// GH-23516 - works around locale perf issues
-// from MUSL libc, MIT Licensed - see LICENSES
+// from MUSL libc, licence at LICENSES/MUSL_LICENSE
#define isdigit_ascii(c) (((unsigned)(c) - '0') < 10u)
#define getdigit_ascii(c, default) (isdigit_ascii(c) ? ((int)((c) - '0')) : default)
#define isspace_ascii(c) (((c) == ' ') || (((unsigned)(c) - '\t') < 5))
diff --git a/pandas/_libs/include/pandas/vendored/klib/khash.h b/pandas/_libs/include/pandas/vendored/klib/khash.h
index 95b25d053a9df..758f089cc11a5 100644
--- a/pandas/_libs/include/pandas/vendored/klib/khash.h
+++ b/pandas/_libs/include/pandas/vendored/klib/khash.h
@@ -1,27 +1,4 @@
-/* The MIT License
-
- Copyright (c) 2008, 2009, 2011 by Attractive Chaos <attractor@live.co.uk>
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
-*/
+//Licence at LICENSES/KLIB_LICENSE
/*
An example:
diff --git a/pandas/_libs/include/pandas/vendored/klib/khash_python.h b/pandas/_libs/include/pandas/vendored/klib/khash_python.h
index 76b212a4b4660..1009671adc56b 100644
--- a/pandas/_libs/include/pandas/vendored/klib/khash_python.h
+++ b/pandas/_libs/include/pandas/vendored/klib/khash_python.h
@@ -1,3 +1,5 @@
+//Licence at LICENSES/KLIB_LICENSE
+
#include <string.h>
#include <Python.h>
diff --git a/pandas/_libs/sas.pyx b/pandas/_libs/sas.pyx
index cf2e0e4d80bb5..9e1af2cb9c3e7 100644
--- a/pandas/_libs/sas.pyx
+++ b/pandas/_libs/sas.pyx
@@ -62,6 +62,7 @@ cdef buf_free(Buffer buf):
# algorithm. It is partially documented here:
#
# https://cran.r-project.org/package=sas7bdat/vignettes/sas7bdat.pdf
+# Licence at LICENSES/SAS7BDAT_LICENSE
cdef int rle_decompress(Buffer inbuff, Buffer outbuff) except? 0:
cdef:
diff --git a/pandas/_libs/src/vendored/numpy/datetime/np_datetime.c b/pandas/_libs/src/vendored/numpy/datetime/np_datetime.c
index 7e5cb53cf8f62..49016f79de5b9 100644
--- a/pandas/_libs/src/vendored/numpy/datetime/np_datetime.c
+++ b/pandas/_libs/src/vendored/numpy/datetime/np_datetime.c
@@ -14,6 +14,8 @@ 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
diff --git a/pandas/_libs/src/vendored/numpy/datetime/np_datetime_strings.c b/pandas/_libs/src/vendored/numpy/datetime/np_datetime_strings.c
index 629d88ca6f589..9646183fa1786 100644
--- a/pandas/_libs/src/vendored/numpy/datetime/np_datetime_strings.c
+++ b/pandas/_libs/src/vendored/numpy/datetime/np_datetime_strings.c
@@ -19,6 +19,8 @@ This file implements string parsing and creation for NumPy datetime.
*/
+// LICENSES/NUMPY_LICENSE
+
#define PY_SSIZE_T_CLEAN
#define NO_IMPORT
diff --git a/pandas/_libs/src/vendored/ujson/lib/ultrajsondec.c b/pandas/_libs/src/vendored/ujson/lib/ultrajsondec.c
index 9ec12cb242728..70794786016fb 100644
--- a/pandas/_libs/src/vendored/ujson/lib/ultrajsondec.c
+++ b/pandas/_libs/src/vendored/ujson/lib/ultrajsondec.c
@@ -38,6 +38,8 @@ Numeric decoder derived from TCL library
* Copyright (c) 1994 Sun Microsystems, Inc.
*/
+// Licence at LICENSES/ULTRAJSON_LICENSE
+
#include <assert.h>
#include <errno.h>
#include <limits.h>
diff --git a/pandas/_libs/src/vendored/ujson/lib/ultrajsonenc.c b/pandas/_libs/src/vendored/ujson/lib/ultrajsonenc.c
index 726676799af65..e3e710ce1b876 100644
--- a/pandas/_libs/src/vendored/ujson/lib/ultrajsonenc.c
+++ b/pandas/_libs/src/vendored/ujson/lib/ultrajsonenc.c
@@ -38,6 +38,8 @@ Numeric decoder derived from TCL library
* Copyright (c) 1994 Sun Microsystems, Inc.
*/
+// Licence at LICENSES/ULTRAJSON_LICENSE
+
#include <assert.h>
#include <float.h>
#include <locale.h>
diff --git a/pandas/_libs/src/vendored/ujson/python/JSONtoObj.c b/pandas/_libs/src/vendored/ujson/python/JSONtoObj.c
index f4055fcedcfa6..d230642b0632d 100644
--- a/pandas/_libs/src/vendored/ujson/python/JSONtoObj.c
+++ b/pandas/_libs/src/vendored/ujson/python/JSONtoObj.c
@@ -35,6 +35,8 @@ Numeric decoder derived from TCL library
* Copyright (c) 1994 Sun Microsystems, Inc.
*/
+// Licence at LICENSES/ULTRAJSON_LICENSE
+
#define PY_ARRAY_UNIQUE_SYMBOL UJSON_NUMPY
#define NO_IMPORT_ARRAY
#define PY_SSIZE_T_CLEAN
diff --git a/pandas/_libs/src/vendored/ujson/python/objToJSON.c b/pandas/_libs/src/vendored/ujson/python/objToJSON.c
index 30b940726af0a..8c55505f61b51 100644
--- a/pandas/_libs/src/vendored/ujson/python/objToJSON.c
+++ b/pandas/_libs/src/vendored/ujson/python/objToJSON.c
@@ -36,6 +36,8 @@ Numeric decoder derived from TCL library
* Copyright (c) 1994 Sun Microsystems, Inc.
*/
+// Licence at LICENSES/ULTRAJSON_LICENSE
+
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <math.h>
diff --git a/pandas/_libs/src/vendored/ujson/python/ujson.c b/pandas/_libs/src/vendored/ujson/python/ujson.c
index 6a6a1bdcbe0e0..12dbb33f2874f 100644
--- a/pandas/_libs/src/vendored/ujson/python/ujson.c
+++ b/pandas/_libs/src/vendored/ujson/python/ujson.c
@@ -35,6 +35,8 @@ Numeric decoder derived from TCL library
* Copyright (c) 1994 Sun Microsystems, Inc.
*/
+// Licence at LICENSES/ULTRAJSON_LICENSE
+
#include "pandas/vendored/ujson/python/version.h"
#define PY_SSIZE_T_CLEAN
#include <Python.h>
diff --git a/pandas/_libs/tslibs/parsing.pyx b/pandas/_libs/tslibs/parsing.pyx
index 3643c840a50a6..ef1a870b8653c 100644
--- a/pandas/_libs/tslibs/parsing.pyx
+++ b/pandas/_libs/tslibs/parsing.pyx
@@ -796,7 +796,7 @@ def try_parse_year_month_day(
# is not practical. In fact, using this class issues warnings (xref gh-21322).
# Thus, we port the class over so that both issues are resolved.
#
-# Copyright (c) 2017 - dateutil contributors
+# Licence at LICENSES/DATEUTIL_LICENSE
class _timelex:
def __init__(self, instream):
if getattr(instream, "decode", None) is not None:
diff --git a/pandas/_libs/tslibs/strptime.pyx b/pandas/_libs/tslibs/strptime.pyx
index 542afa9315a60..e6924a4e24dff 100644
--- a/pandas/_libs/tslibs/strptime.pyx
+++ b/pandas/_libs/tslibs/strptime.pyx
@@ -3,6 +3,7 @@
TimeRE, _calc_julian_from_U_or_W are vendored
from the standard library, see
https://github.com/python/cpython/blob/main/Lib/_strptime.py
+Licence at LICENSES/PSF_LICENSE
The original module-level docstring follows.
Strptime-related classes and functions.
@@ -672,7 +673,8 @@ cdef tzinfo parse_timezone_directive(str z):
Notes
-----
This is essentially similar to the cpython implementation
- https://github.com/python/cpython/blob/master/Lib/_strptime.py#L457-L479
+ https://github.com/python/cpython/blob/546cab84448b892c92e68d9c1a3d3b58c13b3463/Lib/_strptime.py#L437-L454
+ Licence at LICENSES/PSF_LICENSE
"""
cdef:
diff --git a/pandas/_libs/window/aggregations.pyx b/pandas/_libs/window/aggregations.pyx
index 9c151b8269a52..6365c030b695b 100644
--- a/pandas/_libs/window/aggregations.pyx
+++ b/pandas/_libs/window/aggregations.pyx
@@ -987,9 +987,8 @@ def roll_median_c(const float64_t[:] values, ndarray[int64_t] start,
# ----------------------------------------------------------------------
-# Moving maximum / minimum code taken from Bottleneck under the terms
-# of its Simplified BSD license
-# https://github.com/pydata/bottleneck
+# Moving maximum / minimum code taken from Bottleneck
+# Licence at LICENSES/BOTTLENECK_LICENCE
cdef float64_t init_mm(float64_t ai, Py_ssize_t *nobs, bint is_max) noexcept nogil:
diff --git a/pandas/core/accessor.py b/pandas/core/accessor.py
index 1b36659944561..698abb2ec4989 100644
--- a/pandas/core/accessor.py
+++ b/pandas/core/accessor.py
@@ -187,7 +187,7 @@ def add_delegate_accessors(cls):
return add_delegate_accessors
-# Ported with modifications from xarray
+# Ported with modifications from xarray; licence at LICENSES/XARRAY_LICENSE
# https://github.com/pydata/xarray/blob/master/xarray/core/extensions.py
# 1. We don't need to catch and re-raise AttributeErrors as RuntimeErrors
# 2. We use a UserWarning instead of a custom Warning
diff --git a/pandas/io/clipboard/__init__.py b/pandas/io/clipboard/__init__.py
index c07f51d875d4d..806d42381afc6 100644
--- a/pandas/io/clipboard/__init__.py
+++ b/pandas/io/clipboard/__init__.py
@@ -4,7 +4,7 @@
A cross-platform clipboard module for Python,
with copy & paste functions for plain text.
By Al Sweigart al@inventwithpython.com
-BSD License
+Licence at LICENSES/PYPERCLIP_LICENSE
Usage:
import pyperclip
diff --git a/pandas/tests/io/test_spss.py b/pandas/tests/io/test_spss.py
index d1d0795234e72..5d8dce72d69c9 100644
--- a/pandas/tests/io/test_spss.py
+++ b/pandas/tests/io/test_spss.py
@@ -15,6 +15,7 @@
@pytest.mark.parametrize("path_klass", [lambda p: p, Path])
def test_spss_labelled_num(path_klass, datapath):
# test file from the Haven project (https://haven.tidyverse.org/)
+ # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
fname = path_klass(datapath("io", "data", "spss", "labelled-num.sav"))
df = pd.read_spss(fname, convert_categoricals=True)
@@ -30,6 +31,7 @@ def test_spss_labelled_num(path_klass, datapath):
@pytest.mark.filterwarnings("ignore::pandas.errors.ChainedAssignmentError")
def test_spss_labelled_num_na(datapath):
# test file from the Haven project (https://haven.tidyverse.org/)
+ # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
fname = datapath("io", "data", "spss", "labelled-num-na.sav")
df = pd.read_spss(fname, convert_categoricals=True)
@@ -45,6 +47,7 @@ def test_spss_labelled_num_na(datapath):
@pytest.mark.filterwarnings("ignore::pandas.errors.ChainedAssignmentError")
def test_spss_labelled_str(datapath):
# test file from the Haven project (https://haven.tidyverse.org/)
+ # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
fname = datapath("io", "data", "spss", "labelled-str.sav")
df = pd.read_spss(fname, convert_categoricals=True)
@@ -60,6 +63,7 @@ def test_spss_labelled_str(datapath):
@pytest.mark.filterwarnings("ignore::pandas.errors.ChainedAssignmentError")
def test_spss_umlauts(datapath):
# test file from the Haven project (https://haven.tidyverse.org/)
+ # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
fname = datapath("io", "data", "spss", "umlauts.sav")
df = pd.read_spss(fname, convert_categoricals=True)
@@ -84,6 +88,7 @@ def test_spss_usecols(datapath):
def test_spss_umlauts_dtype_backend(datapath, dtype_backend):
# test file from the Haven project (https://haven.tidyverse.org/)
+ # Licence at LICENSES/HAVEN_LICENSE, LICENSES/HAVEN_MIT
fname = datapath("io", "data", "spss", "umlauts.sav")
df = pd.read_spss(fname, convert_categoricals=False, dtype_backend=dtype_backend)
diff --git a/pandas/util/version/__init__.py b/pandas/util/version/__init__.py
index c72598eb50410..3a5efbbb09c1e 100644
--- a/pandas/util/version/__init__.py
+++ b/pandas/util/version/__init__.py
@@ -4,8 +4,7 @@
# 04/30/2021
# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
+# 2.0, and the BSD License. Licence at LICENSES/PACKAGING_LICENSE
from __future__ import annotations
import collections
diff --git a/scripts/no_bool_in_generic.py b/scripts/no_bool_in_generic.py
index 3368b485662ad..c483d221a4266 100644
--- a/scripts/no_bool_in_generic.py
+++ b/scripts/no_bool_in_generic.py
@@ -9,6 +9,7 @@
The function `visit` is adapted from a function by the same name in pyupgrade:
https://github.com/asottile/pyupgrade/blob/5495a248f2165941c5d3b82ac3226ba7ad1fa59d/pyupgrade/_data.py#L70-L113
+Licence at LICENSES/PYUPGRADE_LICENSE
"""
from __future__ import annotations
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/54743 | 2023-08-25T00:21:27Z | 2023-08-25T17:18:30Z | 2023-08-25T17:18:30Z | 2023-08-25T17:18:32Z |
Backport PR #54728 on branch 2.1.x (Docs: Update doc string to not reference deprecated function fillna for ffill) | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 954573febed41..09ebd9387220f 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -7348,7 +7348,7 @@ def ffill(
downcast: dict | None | lib.NoDefault = lib.no_default,
) -> Self | None:
"""
- Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.
+ Fill NA/NaN values by propagating the last valid observation to next valid.
Returns
-------
| Backport PR #54728: Docs: Update doc string to not reference deprecated function fillna for ffill | https://api.github.com/repos/pandas-dev/pandas/pulls/54740 | 2023-08-24T21:07:38Z | 2023-08-24T22:44:39Z | 2023-08-24T22:44:39Z | 2023-08-24T22:44:39Z |
TYP: Added type hint to Index.repeat | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 796aadf9e4061..32c1ef1ff50f3 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1205,7 +1205,7 @@ def _maybe_disallow_fill(self, allow_fill: bool, fill_value, indices) -> bool:
"""
@Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
- def repeat(self, repeats, axis=None):
+ def repeat(self, repeats, axis: None = None):
repeats = ensure_platform_int(repeats)
nv.validate_repeat((), {"axis": axis})
res_values = self._values.repeat(repeats)
| - [ ] Fixes a bullet point on https://github.com/noatamir/pyladies-aug23-sprint/issues/5#issue-1805063243
- [ ] [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.
@noatamir @phofl | https://api.github.com/repos/pandas-dev/pandas/pulls/54739 | 2023-08-24T20:58:20Z | 2023-08-29T16:28:07Z | 2023-08-29T16:28:07Z | 2023-08-29T16:30:22Z |
DOC: fix an example which raises an Error in whatsnew/v0.24.0.rst | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 38c6e1123aaae..4ad5f4e7b5c3d 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1377,18 +1377,22 @@ the object's ``freq`` attribute (:issue:`21939`, :issue:`23878`).
*New behavior*:
-.. ipython:: python
- :okexcept:
- :okwarning:
+.. code-block:: ipython
+
+ In [108]: ts = pd.Timestamp('1994-05-06 12:15:16', freq=pd.offsets.Hour())
+
+ In[109]: ts + 2 * ts.freq
+ Out[109]: Timestamp('1994-05-06 14:15:16', freq='H')
+
+ In [110]: tdi = pd.timedelta_range('1D', periods=2)
- ts = pd.Timestamp('1994-05-06 12:15:16', freq=pd.offsets.Hour())
- ts + 2 * ts.freq
+ In [111]: tdi - np.array([2 * tdi.freq, 1 * tdi.freq])
+ Out[111]: TimedeltaIndex(['-1 days', '1 days'], dtype='timedelta64[ns]', freq=None)
- tdi = pd.timedelta_range('1D', periods=2)
- tdi - np.array([2 * tdi.freq, 1 * tdi.freq])
+ In [112]: dti = pd.date_range('2001-01-01', periods=2, freq='7D')
- dti = pd.date_range('2001-01-01', periods=2, freq='7D')
- dti + pd.Index([1 * dti.freq, 2 * dti.freq])
+ In [113]: dti + pd.Index([1 * dti.freq, 2 * dti.freq])
+ Out[113]: DatetimeIndex(['2001-01-08', '2001-01-22'], dtype='datetime64[ns]', freq=None)
.. _whatsnew_0240.deprecations.integer_tz:
| Fix an example in doc/source/whatsnew/v0.24.0.rst, which raises an Error (see https://pandas.pydata.org/docs/dev/whatsnew/v0.24.0.html#integer-addition-subtraction-with-datetimes-and-timedeltas-is-deprecated) | https://api.github.com/repos/pandas-dev/pandas/pulls/54738 | 2023-08-24T20:31:18Z | 2023-08-25T13:05:32Z | 2023-08-25T13:05:32Z | 2023-08-25T13:05:32Z |
MAINT: small simplification of meson.build following best practices | diff --git a/meson.build b/meson.build
index a927b59abeaf9..e16f565d491fe 100644
--- a/meson.build
+++ b/meson.build
@@ -2,13 +2,10 @@
project(
'pandas',
'c', 'cpp', 'cython',
- version: run_command(['python', 'generate_version.py', '--print'], check: true).stdout().strip(),
+ version: run_command(['python3', 'generate_version.py', '--print'], check: true).stdout().strip(),
license: 'BSD-3',
meson_version: '>=1.0.1',
default_options: [
- # TODO: investigate, does meson try to compile against debug Python
- # when buildtype = debug, this seems to be causing problems on CI
- # where provided Python is not compiled in debug mode
'buildtype=release',
# TODO: Reactivate werror, some warnings on Windows
#'werror=true',
@@ -16,10 +13,8 @@ project(
]
)
-py_mod = import('python')
fs = import('fs')
-py = py_mod.find_installation('python')
-py_dep = py.dependency()
+py = import('python').find_installation()
tempita = files('generate_pxi.py')
versioneer = files('generate_version.py')
diff --git a/pandas/_libs/window/meson.build b/pandas/_libs/window/meson.build
index b83d8730f9447..85aa060a26406 100644
--- a/pandas/_libs/window/meson.build
+++ b/pandas/_libs/window/meson.build
@@ -3,7 +3,6 @@ py.extension_module(
['aggregations.pyx'],
cython_args: ['-X always_allow_keywords=true'],
include_directories: [inc_np, inc_pd],
- dependencies: [py_dep],
subdir: 'pandas/_libs/window',
override_options : ['cython_language=cpp'],
install: true
@@ -14,7 +13,6 @@ py.extension_module(
['indexers.pyx'],
cython_args: ['-X always_allow_keywords=true'],
include_directories: [inc_np, inc_pd],
- dependencies: [py_dep],
subdir: 'pandas/_libs/window',
install: true
)
| Just a couple of things I observed having a quick look at `meson.build`. | https://api.github.com/repos/pandas-dev/pandas/pulls/54737 | 2023-08-24T20:27:46Z | 2023-08-28T11:44:35Z | 2023-08-28T11:44:35Z | 2023-08-28T13:12:17Z |
Docs: fix for links on see also for DataFrame.agg | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 07756b6af04f5..53ab03696551e 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -9818,12 +9818,12 @@ def _gotitem(
--------
DataFrame.apply : Perform any type of operations.
DataFrame.transform : Perform transformation type operations.
- core.groupby.GroupBy : Perform operations over groups.
- core.resample.Resampler : Perform operations over resampled bins.
- core.window.Rolling : Perform operations over rolling window.
- core.window.Expanding : Perform operations over expanding window.
- core.window.ExponentialMovingWindow : Perform operation over exponential weighted
- window.
+ pandas.core.groupby.GroupBy : Perform operations over groups.
+ pandas.core.resample.Resampler : Perform operations over resampled bins.
+ pandas.core.window.Rolling : Perform operations over rolling window.
+ pandas.core.window.Expanding : Perform operations over expanding window.
+ pandas.core.window.ExponentialMovingWindow : Perform operation over exponential
+ weighted window.
"""
)
| - [x] fix for 1st bullet point on https://github.com/noatamir/pyladies-aug23-sprint/issues/13
- [ ] [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.
@noatamir @phofl PyLadies Berlin Aug Sprint
| https://api.github.com/repos/pandas-dev/pandas/pulls/54736 | 2023-08-24T20:11:24Z | 2023-08-25T17:59:26Z | 2023-08-25T17:59:26Z | 2023-08-25T17:59:36Z |
Backport PR #54720 on branch 2.1.x (Infer strings as pyarrow_numpy backed strings) | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 5d46f819b07f9..fabe910261c3d 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -21,7 +21,7 @@ PyArrow will become a required dependency with pandas 3.0
`PyArrow <https://arrow.apache.org/docs/python/index.html>`_ will become a required
dependency of pandas starting with pandas 3.0. This decision was made based on
-`PDEP 12 <https://pandas.pydata.org/pdeps/0010-required-pyarrow-dependency.html>`_.
+`PDEP 10 <https://pandas.pydata.org/pdeps/0010-required-pyarrow-dependency.html>`_.
This will enable more changes that are hugely beneficial to pandas users, including
but not limited to:
@@ -41,7 +41,9 @@ Avoid NumPy object dtype for strings by default
Previously, all strings were stored in columns with NumPy object dtype.
This release introduces an option ``future.infer_string`` that infers all
-strings as PyArrow backed strings with dtype ``pd.ArrowDtype(pa.string())`` instead.
+strings as PyArrow backed strings with dtype ``"string[pyarrow_numpy]"`` instead.
+This is a new string dtype implementation that follows NumPy semantics in comparison
+operations and will return ``np.nan`` as the missing value indicator.
This option only works if PyArrow is installed. PyArrow backed strings have a
significantly reduced memory footprint and provide a big performance improvement
compared to NumPy object (:issue:`54430`).
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 2681115bbdcfb..859cb8e5ebead 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -2682,11 +2682,9 @@ def maybe_convert_objects(ndarray[object] objects,
elif seen.str_:
if using_pyarrow_string_dtype() and is_string_array(objects, skipna=True):
- import pyarrow as pa
+ from pandas.core.arrays.string_ import StringDtype
- from pandas.core.dtypes.dtypes import ArrowDtype
-
- dtype = ArrowDtype(pa.string())
+ dtype = StringDtype(storage="pyarrow_numpy")
return dtype.construct_array_type()._from_sequence(objects, dtype=dtype)
seen.object_ = True
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index f733ba3b445fd..aaac0dc73486f 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -51,10 +51,7 @@
is_object_dtype,
pandas_dtype,
)
-from pandas.core.dtypes.dtypes import (
- ArrowDtype,
- NumpyEADtype,
-)
+from pandas.core.dtypes.dtypes import NumpyEADtype
from pandas.core.dtypes.generic import (
ABCDataFrame,
ABCExtensionArray,
@@ -595,9 +592,9 @@ def sanitize_array(
if data.dtype == object:
subarr = maybe_infer_to_datetimelike(data)
elif data.dtype.kind == "U" and using_pyarrow_string_dtype():
- import pyarrow as pa
+ from pandas.core.arrays.string_ import StringDtype
- dtype = ArrowDtype(pa.string())
+ dtype = StringDtype(storage="pyarrow_numpy")
subarr = dtype.construct_array_type()._from_sequence(data, dtype=dtype)
if subarr is data and copy:
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 657cbce40087a..8ed57e9bf5532 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -799,10 +799,9 @@ def infer_dtype_from_scalar(val) -> tuple[DtypeObj, Any]:
dtype = _dtype_obj
if using_pyarrow_string_dtype():
- import pyarrow as pa
+ from pandas.core.arrays.string_ import StringDtype
- pa_dtype = pa.string()
- dtype = ArrowDtype(pa_dtype)
+ dtype = StringDtype(storage="pyarrow_numpy")
elif isinstance(val, (np.datetime64, dt.datetime)):
try:
diff --git a/pandas/core/internals/construction.py b/pandas/core/internals/construction.py
index 8879d3318f7ca..8aafb9dd623c5 100644
--- a/pandas/core/internals/construction.py
+++ b/pandas/core/internals/construction.py
@@ -32,10 +32,7 @@
is_named_tuple,
is_object_dtype,
)
-from pandas.core.dtypes.dtypes import (
- ArrowDtype,
- ExtensionDtype,
-)
+from pandas.core.dtypes.dtypes import ExtensionDtype
from pandas.core.dtypes.generic import (
ABCDataFrame,
ABCSeries,
@@ -379,10 +376,9 @@ def ndarray_to_mgr(
nb = new_block_2d(values, placement=bp, refs=refs)
block_values = [nb]
elif dtype is None and values.dtype.kind == "U" and using_pyarrow_string_dtype():
- import pyarrow as pa
+ dtype = StringDtype(storage="pyarrow_numpy")
obj_columns = list(values)
- dtype = ArrowDtype(pa.string())
block_values = [
new_block(
dtype.construct_array_type()._from_sequence(data, dtype=dtype),
diff --git a/pandas/io/_util.py b/pandas/io/_util.py
index 27316b3ab0af0..915595833468d 100644
--- a/pandas/io/_util.py
+++ b/pandas/io/_util.py
@@ -28,4 +28,4 @@ def _arrow_dtype_mapping() -> dict:
def arrow_string_types_mapper() -> Callable:
pa = import_optional_dependency("pyarrow")
- return {pa.string(): pd.ArrowDtype(pa.string())}.get
+ return {pa.string(): pd.StringDtype(storage="pyarrow_numpy")}.get
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index f26411f65d91f..d3055f0ad2a38 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -68,7 +68,6 @@
)
from pandas.core.dtypes.missing import array_equivalent
-import pandas as pd
from pandas import (
DataFrame,
DatetimeIndex,
@@ -3224,9 +3223,7 @@ def read(
values = self.read_array("values", start=start, stop=stop)
result = Series(values, index=index, name=self.name, copy=False)
if using_pyarrow_string_dtype() and is_string_array(values, skipna=True):
- import pyarrow as pa
-
- result = result.astype(pd.ArrowDtype(pa.string()))
+ result = result.astype("string[pyarrow_numpy]")
return result
# error: Signature of "write" incompatible with supertype "Fixed"
@@ -3296,9 +3293,7 @@ def read(
columns = items[items.get_indexer(blk_items)]
df = DataFrame(values.T, columns=columns, index=axes[1], copy=False)
if using_pyarrow_string_dtype() and is_string_array(values, skipna=True):
- import pyarrow as pa
-
- df = df.astype(pd.ArrowDtype(pa.string()))
+ df = df.astype("string[pyarrow_numpy]")
dfs.append(df)
if len(dfs) > 0:
@@ -4686,9 +4681,7 @@ def read(
values, # type: ignore[arg-type]
skipna=True,
):
- import pyarrow as pa
-
- df = df.astype(pd.ArrowDtype(pa.string()))
+ df = df.astype("string[pyarrow_numpy]")
frames.append(df)
if len(frames) == 1:
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 63cddb7f192e6..a8ab3ce1ba014 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -2685,8 +2685,8 @@ def test_construct_with_strings_and_none(self):
def test_frame_string_inference(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = DataFrame(
{"a": ["a", "b"]}, dtype=dtype, columns=Index(["a"], dtype=dtype)
)
@@ -2720,8 +2720,8 @@ def test_frame_string_inference(self):
def test_frame_string_inference_array_string_dtype(self):
# GH#54496
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = DataFrame(
{"a": ["a", "b"]}, dtype=dtype, columns=Index(["a"], dtype=dtype)
)
diff --git a/pandas/tests/indexes/base_class/test_constructors.py b/pandas/tests/indexes/base_class/test_constructors.py
index 638124ac20e06..60abbfc441e8e 100644
--- a/pandas/tests/indexes/base_class/test_constructors.py
+++ b/pandas/tests/indexes/base_class/test_constructors.py
@@ -46,8 +46,8 @@ def test_construct_empty_tuples(self, tuple_list):
def test_index_string_inference(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = Index(["a", "b"], dtype=dtype)
with pd.option_context("future.infer_string", True):
ser = Index(["a", "b"])
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 637d62b98a831..437012d836941 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -2099,7 +2099,7 @@ def test_pyarrow_engine_lines_false():
def test_json_roundtrip_string_inference(orient):
- pa = pytest.importorskip("pyarrow")
+ pytest.importorskip("pyarrow")
df = DataFrame(
[["a", "b"], ["c", "d"]], index=["row 1", "row 2"], columns=["col 1", "col 2"]
)
@@ -2108,8 +2108,8 @@ def test_json_roundtrip_string_inference(orient):
result = read_json(StringIO(out))
expected = DataFrame(
[["a", "b"], ["c", "d"]],
- dtype=pd.ArrowDtype(pa.string()),
- index=pd.Index(["row 1", "row 2"], dtype=pd.ArrowDtype(pa.string())),
- columns=pd.Index(["col 1", "col 2"], dtype=pd.ArrowDtype(pa.string())),
+ dtype="string[pyarrow_numpy]",
+ index=pd.Index(["row 1", "row 2"], dtype="string[pyarrow_numpy]"),
+ columns=pd.Index(["col 1", "col 2"], dtype="string[pyarrow_numpy]"),
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/dtypes/test_dtypes_basic.py b/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
index 1c0f0939029ff..8494c5d58171b 100644
--- a/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
+++ b/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
@@ -542,8 +542,8 @@ def test_ea_int_avoid_overflow(all_parsers):
def test_string_inference(all_parsers):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
data = """a,b
x,1
diff --git a/pandas/tests/io/pytables/test_read.py b/pandas/tests/io/pytables/test_read.py
index 425828cb881a7..bc5ed4d208e0f 100644
--- a/pandas/tests/io/pytables/test_read.py
+++ b/pandas/tests/io/pytables/test_read.py
@@ -392,7 +392,7 @@ def test_read_py2_hdf_file_in_py3(datapath):
def test_read_infer_string(tmp_path, setup_path):
# GH#54431
- pa = pytest.importorskip("pyarrow")
+ pytest.importorskip("pyarrow")
df = DataFrame({"a": ["a", "b", None]})
path = tmp_path / setup_path
df.to_hdf(path, key="data", format="table")
@@ -400,7 +400,7 @@ def test_read_infer_string(tmp_path, setup_path):
result = read_hdf(path, key="data", mode="r")
expected = DataFrame(
{"a": ["a", "b", None]},
- dtype=pd.ArrowDtype(pa.string()),
- columns=Index(["a"], dtype=pd.ArrowDtype(pa.string())),
+ dtype="string[pyarrow_numpy]",
+ columns=Index(["a"], dtype="string[pyarrow_numpy]"),
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
index a0fee6751bf53..cf43203466ef4 100644
--- a/pandas/tests/io/test_feather.py
+++ b/pandas/tests/io/test_feather.py
@@ -222,14 +222,10 @@ def test_invalid_dtype_backend(self):
def test_string_inference(self, tmp_path):
# GH#54431
- import pyarrow as pa
-
path = tmp_path / "test_string_inference.p"
df = pd.DataFrame(data={"a": ["x", "y"]})
df.to_feather(path)
with pd.option_context("future.infer_string", True):
result = read_feather(path)
- expected = pd.DataFrame(
- data={"a": ["x", "y"]}, dtype=pd.ArrowDtype(pa.string())
- )
+ expected = pd.DataFrame(data={"a": ["x", "y"]}, dtype="string[pyarrow_numpy]")
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/test_orc.py b/pandas/tests/io/test_orc.py
index c2d791ba24c87..d90f803f1e607 100644
--- a/pandas/tests/io/test_orc.py
+++ b/pandas/tests/io/test_orc.py
@@ -426,7 +426,7 @@ def test_string_inference(tmp_path):
result = read_orc(path)
expected = pd.DataFrame(
data={"a": ["x", "y"]},
- dtype=pd.ArrowDtype(pa.string()),
- columns=pd.Index(["a"], dtype=pd.ArrowDtype(pa.string())),
+ dtype="string[pyarrow_numpy]",
+ columns=pd.Index(["a"], dtype="string[pyarrow_numpy]"),
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index a4c6cfcf9fe0e..ccba44b7f8fe4 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1099,8 +1099,6 @@ def test_df_attrs_persistence(self, tmp_path, pa):
def test_string_inference(self, tmp_path, pa):
# GH#54431
- import pyarrow as pa
-
path = tmp_path / "test_string_inference.p"
df = pd.DataFrame(data={"a": ["x", "y"]}, index=["a", "b"])
df.to_parquet(path, engine="pyarrow")
@@ -1108,8 +1106,8 @@ def test_string_inference(self, tmp_path, pa):
result = read_parquet(path, engine="pyarrow")
expected = pd.DataFrame(
data={"a": ["x", "y"]},
- dtype=pd.ArrowDtype(pa.string()),
- index=pd.Index(["a", "b"], dtype=pd.ArrowDtype(pa.string())),
+ dtype="string[pyarrow_numpy]",
+ index=pd.Index(["a", "b"], dtype="string[pyarrow_numpy]"),
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 02736406e109b..2f446e6b8c81d 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -2946,7 +2946,7 @@ def test_read_sql_dtype_backend_table(self, string_storage, func):
def test_read_sql_string_inference(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
+ pytest.importorskip("pyarrow")
table = "test"
df = DataFrame({"a": ["x", "y"]})
df.to_sql(table, con=self.conn, index=False, if_exists="replace")
@@ -2954,7 +2954,7 @@ def test_read_sql_string_inference(self):
with pd.option_context("future.infer_string", True):
result = read_sql_table(table, self.conn)
- dtype = pd.ArrowDtype(pa.string())
+ dtype = "string[pyarrow_numpy]"
expected = DataFrame(
{"a": ["x", "y"]}, dtype=dtype, columns=Index(["a"], dtype=dtype)
)
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 97bd8633954d8..ef734e9664844 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -2077,8 +2077,8 @@ def test_series_from_index_dtype_equal_does_not_copy(self):
def test_series_string_inference(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = Series(["a", "b"], dtype=dtype)
with pd.option_context("future.infer_string", True):
ser = Series(["a", "b"])
@@ -2092,8 +2092,8 @@ def test_series_string_inference(self):
@pytest.mark.parametrize("na_value", [None, np.nan, pd.NA])
def test_series_string_with_na_inference(self, na_value):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = Series(["a", na_value], dtype=dtype)
with pd.option_context("future.infer_string", True):
ser = Series(["a", na_value])
@@ -2101,16 +2101,16 @@ def test_series_string_with_na_inference(self, na_value):
def test_series_string_inference_scalar(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- expected = Series("a", index=[1], dtype=pd.ArrowDtype(pa.string()))
+ pytest.importorskip("pyarrow")
+ expected = Series("a", index=[1], dtype="string[pyarrow_numpy]")
with pd.option_context("future.infer_string", True):
ser = Series("a", index=[1])
tm.assert_series_equal(ser, expected)
def test_series_string_inference_array_string_dtype(self):
# GH#54496
- pa = pytest.importorskip("pyarrow")
- expected = Series(["a", "b"], dtype=pd.ArrowDtype(pa.string()))
+ pytest.importorskip("pyarrow")
+ expected = Series(["a", "b"], dtype="string[pyarrow_numpy]")
with pd.option_context("future.infer_string", True):
ser = Series(np.array(["a", "b"]))
tm.assert_series_equal(ser, expected)
| Backport PR #54720: Infer strings as pyarrow_numpy backed strings | https://api.github.com/repos/pandas-dev/pandas/pulls/54735 | 2023-08-24T19:30:11Z | 2023-08-24T21:33:27Z | 2023-08-24T21:33:27Z | 2023-08-24T21:33:27Z |
Deleted non-existing method reference. | diff --git a/pandas/core/series.py b/pandas/core/series.py
index 9a934217ed5c1..761ec3cec66bf 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -5753,7 +5753,6 @@ def to_period(self, freq: str | None = None, copy: bool | None = None) -> Series
See Also
--------
Series.reindex : Conform Series to new index.
- Series.set_index : Set Series as DataFrame index.
Index : The base pandas index type.
Notes
| - [ ] 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/54734 | 2023-08-24T18:40:55Z | 2023-08-24T21:06:00Z | 2023-08-24T21:06:00Z | 2023-08-24T21:06:07Z |
DOC: fix formatting in .at docstring | diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index a2871f364f092..97578e3f1668b 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -604,12 +604,12 @@ def at(self) -> _AtIndexer:
Raises
------
KeyError
- * If getting a value and 'label' does not exist in a DataFrame or
- Series.
+ If getting a value and 'label' does not exist in a DataFrame or Series.
+
ValueError
- * If row/column label pair is not a tuple or if any label from
- the pair is not a scalar for DataFrame.
- * If label is list-like (*excluding* NamedTuple) for Series.
+ If row/column label pair is not a tuple or if any label
+ from the pair is not a scalar for DataFrame.
+ If label is list-like (*excluding* NamedTuple) for Series.
See Also
--------
| - [x] Fix for 9th bullet point of https://github.com/noatamir/pyladies-aug23-sprint/issues/13
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
Done during the 'Let's contribute to pandas - mentored workshop' event - PyLadies Berlin
@noatamir
@phofl
| https://api.github.com/repos/pandas-dev/pandas/pulls/54730 | 2023-08-24T18:30:02Z | 2023-08-28T15:09:54Z | 2023-08-28T15:09:54Z | 2023-08-28T15:09:55Z |
typing improvements on level and fill_value in Series.eq | diff --git a/pandas/core/series.py b/pandas/core/series.py
index 318f3fee2756b..f1bc67810b788 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -166,6 +166,7 @@
DtypeBackend,
DtypeObj,
FilePath,
+ Frequency,
IgnoreRaise,
IndexKeyFunc,
IndexLabel,
@@ -5630,7 +5631,7 @@ def dropna(
def to_timestamp(
self,
- freq=None,
+ freq: Frequency | None = None,
how: Literal["s", "e", "start", "end"] = "start",
copy: bool | None = None,
) -> Series:
@@ -5946,7 +5947,13 @@ def _flex_method(self, other, op, *, level=None, fill_value=None, axis: Axis = 0
return op(self, other)
@Appender(ops.make_flex_doc("eq", "series"))
- def eq(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
+ def eq(
+ self,
+ other,
+ level: Level | None = None,
+ fill_value: float | None = None,
+ axis: Axis = 0,
+ ) -> Series:
return self._flex_method(
other, operator.eq, level=level, fill_value=fill_value, axis=axis
)
| - [x] item 6 and 7 in [issue#11](https://github.com/noatamir/pyladies-aug23-sprint/issues/11)
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit). | https://api.github.com/repos/pandas-dev/pandas/pulls/54729 | 2023-08-24T18:24:28Z | 2023-08-25T13:14:13Z | 2023-08-25T13:14:13Z | 2023-08-26T07:05:00Z |
Docs: Update doc string to not reference deprecated function fillna for ffill | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 6e4d3610f4ffa..9682e5a864e2c 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -7368,7 +7368,7 @@ def ffill(
downcast: dict | None | lib.NoDefault = lib.no_default,
) -> Self | None:
"""
- Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.
+ Fill NA/NaN values by propagating the last valid observation to next valid.
Returns
-------
| - [x] fix for 1st bullet point on https://github.com/noatamir/pyladies-aug23-sprint/issues/13
- [ ] [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.
@noatamir @phofl PyLadies Berlin Aug Sprint
| https://api.github.com/repos/pandas-dev/pandas/pulls/54728 | 2023-08-24T17:31:53Z | 2023-08-24T21:07:30Z | 2023-08-24T21:07:30Z | 2023-08-25T00:42:34Z |
Backport PR #54721 on branch 2.1.x (BUG/WARN: Passing EA object to dtype instead of an instance) | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index b79797fa86431..5d46f819b07f9 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -837,6 +837,7 @@ ExtensionArray
- Bug in :meth:`Series.rank` returning wrong order for small values with ``Float64`` dtype (:issue:`52471`)
- Bug in :meth:`Series.unique` for boolean ``ArrowDtype`` with ``NA`` values (:issue:`54667`)
- Bug in :meth:`~arrays.ArrowExtensionArray.__iter__` and :meth:`~arrays.ArrowExtensionArray.__getitem__` returning python datetime and timedelta objects for non-nano dtypes (:issue:`53326`)
+- Bug when passing an :class:`ExtensionArray` subclass to ``dtype`` keywords. This will now raise a ``UserWarning`` to encourage passing an instance instead (:issue:`31356`, :issue:`54592`)
- Bug where the :class:`DataFrame` repr would not work when a column had an :class:`ArrowDtype` with a ``pyarrow.ExtensionDtype`` (:issue:`54063`)
- Bug where the ``__from_arrow__`` method of masked ExtensionDtypes (e.g. :class:`Float64Dtype`, :class:`BooleanDtype`) would not accept PyArrow arrays of type ``pyarrow.null()`` (:issue:`52223`)
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index c2e498e75b7d3..3db36fc50e343 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -1614,6 +1614,15 @@ def pandas_dtype(dtype) -> DtypeObj:
# registered extension types
result = registry.find(dtype)
if result is not None:
+ if isinstance(result, type):
+ # GH 31356, GH 54592
+ warnings.warn(
+ f"Instantiating {result.__name__} without any arguments."
+ f"Pass a {result.__name__} instance to silence this warning.",
+ UserWarning,
+ stacklevel=find_stack_level(),
+ )
+ result = result()
return result
# try a numpy dtype
diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
index 471e456146178..165bf61302145 100644
--- a/pandas/tests/dtypes/test_common.py
+++ b/pandas/tests/dtypes/test_common.py
@@ -782,3 +782,9 @@ def test_pandas_dtype_numpy_warning():
match="Converting `np.integer` or `np.signedinteger` to a dtype is deprecated",
):
pandas_dtype(np.integer)
+
+
+def test_pandas_dtype_ea_not_instance():
+ # GH 31356 GH 54592
+ with tm.assert_produces_warning(UserWarning):
+ assert pandas_dtype(CategoricalDtype) == CategoricalDtype()
| Backport PR #54721: BUG/WARN: Passing EA object to dtype instead of an instance | https://api.github.com/repos/pandas-dev/pandas/pulls/54726 | 2023-08-24T16:14:24Z | 2023-08-24T19:00:43Z | 2023-08-24T19:00:43Z | 2023-08-24T19:00:43Z |
TYP: Return type for eq/ne/div/... | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index e9d8ba6aab4a8..07756b6af04f5 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -8067,43 +8067,49 @@ def _flex_cmp_method(self, other, op, *, axis: Axis = "columns", level=None):
return self._construct_result(new_data)
@Appender(ops.make_flex_doc("eq", "dataframe"))
- def eq(self, other, axis: Axis = "columns", level=None):
+ def eq(self, other, axis: Axis = "columns", level=None) -> DataFrame:
return self._flex_cmp_method(other, operator.eq, axis=axis, level=level)
@Appender(ops.make_flex_doc("ne", "dataframe"))
- def ne(self, other, axis: Axis = "columns", level=None):
+ def ne(self, other, axis: Axis = "columns", level=None) -> DataFrame:
return self._flex_cmp_method(other, operator.ne, axis=axis, level=level)
@Appender(ops.make_flex_doc("le", "dataframe"))
- def le(self, other, axis: Axis = "columns", level=None):
+ def le(self, other, axis: Axis = "columns", level=None) -> DataFrame:
return self._flex_cmp_method(other, operator.le, axis=axis, level=level)
@Appender(ops.make_flex_doc("lt", "dataframe"))
- def lt(self, other, axis: Axis = "columns", level=None):
+ def lt(self, other, axis: Axis = "columns", level=None) -> DataFrame:
return self._flex_cmp_method(other, operator.lt, axis=axis, level=level)
@Appender(ops.make_flex_doc("ge", "dataframe"))
- def ge(self, other, axis: Axis = "columns", level=None):
+ def ge(self, other, axis: Axis = "columns", level=None) -> DataFrame:
return self._flex_cmp_method(other, operator.ge, axis=axis, level=level)
@Appender(ops.make_flex_doc("gt", "dataframe"))
- def gt(self, other, axis: Axis = "columns", level=None):
+ def gt(self, other, axis: Axis = "columns", level=None) -> DataFrame:
return self._flex_cmp_method(other, operator.gt, axis=axis, level=level)
@Appender(ops.make_flex_doc("add", "dataframe"))
- def add(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def add(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, operator.add, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("radd", "dataframe"))
- def radd(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def radd(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, roperator.radd, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("sub", "dataframe"))
- def sub(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def sub(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, operator.sub, level=level, fill_value=fill_value, axis=axis
)
@@ -8111,13 +8117,17 @@ def sub(self, other, axis: Axis = "columns", level=None, fill_value=None):
subtract = sub
@Appender(ops.make_flex_doc("rsub", "dataframe"))
- def rsub(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def rsub(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, roperator.rsub, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("mul", "dataframe"))
- def mul(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def mul(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, operator.mul, level=level, fill_value=fill_value, axis=axis
)
@@ -8125,13 +8135,17 @@ def mul(self, other, axis: Axis = "columns", level=None, fill_value=None):
multiply = mul
@Appender(ops.make_flex_doc("rmul", "dataframe"))
- def rmul(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def rmul(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, roperator.rmul, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("truediv", "dataframe"))
- def truediv(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def truediv(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, operator.truediv, level=level, fill_value=fill_value, axis=axis
)
@@ -8140,7 +8154,9 @@ def truediv(self, other, axis: Axis = "columns", level=None, fill_value=None):
divide = truediv
@Appender(ops.make_flex_doc("rtruediv", "dataframe"))
- def rtruediv(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def rtruediv(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, roperator.rtruediv, level=level, fill_value=fill_value, axis=axis
)
@@ -8148,37 +8164,49 @@ def rtruediv(self, other, axis: Axis = "columns", level=None, fill_value=None):
rdiv = rtruediv
@Appender(ops.make_flex_doc("floordiv", "dataframe"))
- def floordiv(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def floordiv(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, operator.floordiv, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("rfloordiv", "dataframe"))
- def rfloordiv(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def rfloordiv(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, roperator.rfloordiv, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("mod", "dataframe"))
- def mod(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def mod(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, operator.mod, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("rmod", "dataframe"))
- def rmod(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def rmod(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, roperator.rmod, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("pow", "dataframe"))
- def pow(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def pow(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, operator.pow, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("rpow", "dataframe"))
- def rpow(self, other, axis: Axis = "columns", level=None, fill_value=None):
+ def rpow(
+ self, other, axis: Axis = "columns", level=None, fill_value=None
+ ) -> DataFrame:
return self._flex_arith_method(
other, roperator.rpow, level=level, fill_value=fill_value, axis=axis
)
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 9a934217ed5c1..318f3fee2756b 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -5946,55 +5946,55 @@ def _flex_method(self, other, op, *, level=None, fill_value=None, axis: Axis = 0
return op(self, other)
@Appender(ops.make_flex_doc("eq", "series"))
- def eq(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def eq(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.eq, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("ne", "series"))
- def ne(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def ne(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.ne, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("le", "series"))
- def le(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def le(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.le, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("lt", "series"))
- def lt(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def lt(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.lt, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("ge", "series"))
- def ge(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def ge(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.ge, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("gt", "series"))
- def gt(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def gt(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.gt, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("add", "series"))
- def add(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def add(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.add, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("radd", "series"))
- def radd(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def radd(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, roperator.radd, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("sub", "series"))
- def sub(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def sub(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.sub, level=level, fill_value=fill_value, axis=axis
)
@@ -6002,7 +6002,7 @@ def sub(self, other, level=None, fill_value=None, axis: Axis = 0):
subtract = sub
@Appender(ops.make_flex_doc("rsub", "series"))
- def rsub(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def rsub(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, roperator.rsub, level=level, fill_value=fill_value, axis=axis
)
@@ -6014,7 +6014,7 @@ def mul(
level: Level | None = None,
fill_value: float | None = None,
axis: Axis = 0,
- ):
+ ) -> Series:
return self._flex_method(
other, operator.mul, level=level, fill_value=fill_value, axis=axis
)
@@ -6022,13 +6022,13 @@ def mul(
multiply = mul
@Appender(ops.make_flex_doc("rmul", "series"))
- def rmul(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def rmul(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, roperator.rmul, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("truediv", "series"))
- def truediv(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def truediv(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.truediv, level=level, fill_value=fill_value, axis=axis
)
@@ -6037,7 +6037,7 @@ def truediv(self, other, level=None, fill_value=None, axis: Axis = 0):
divide = truediv
@Appender(ops.make_flex_doc("rtruediv", "series"))
- def rtruediv(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def rtruediv(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, roperator.rtruediv, level=level, fill_value=fill_value, axis=axis
)
@@ -6045,49 +6045,49 @@ def rtruediv(self, other, level=None, fill_value=None, axis: Axis = 0):
rdiv = rtruediv
@Appender(ops.make_flex_doc("floordiv", "series"))
- def floordiv(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def floordiv(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.floordiv, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("rfloordiv", "series"))
- def rfloordiv(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def rfloordiv(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, roperator.rfloordiv, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("mod", "series"))
- def mod(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def mod(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.mod, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("rmod", "series"))
- def rmod(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def rmod(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, roperator.rmod, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("pow", "series"))
- def pow(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def pow(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, operator.pow, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("rpow", "series"))
- def rpow(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def rpow(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, roperator.rpow, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("divmod", "series"))
- def divmod(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def divmod(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, divmod, level=level, fill_value=fill_value, axis=axis
)
@Appender(ops.make_flex_doc("rdivmod", "series"))
- def rdivmod(self, other, level=None, fill_value=None, axis: Axis = 0):
+ def rdivmod(self, other, level=None, fill_value=None, axis: Axis = 0) -> Series:
return self._flex_method(
other, roperator.rdivmod, level=level, fill_value=fill_value, axis=axis
)
| I was first trying to use `Self` (not sure whether it should be used here) but that seems to confuse mypy when the method is assigned to an alias (e.g., `subtract = sub`) as it then seems to loose track of what Self refers to. | https://api.github.com/repos/pandas-dev/pandas/pulls/54725 | 2023-08-24T14:01:24Z | 2023-08-24T16:18:16Z | 2023-08-24T16:18:16Z | 2023-09-19T15:24:48Z |
BUG/WARN: Passing EA object to dtype instead of an instance | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index b79797fa86431..5d46f819b07f9 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -837,6 +837,7 @@ ExtensionArray
- Bug in :meth:`Series.rank` returning wrong order for small values with ``Float64`` dtype (:issue:`52471`)
- Bug in :meth:`Series.unique` for boolean ``ArrowDtype`` with ``NA`` values (:issue:`54667`)
- Bug in :meth:`~arrays.ArrowExtensionArray.__iter__` and :meth:`~arrays.ArrowExtensionArray.__getitem__` returning python datetime and timedelta objects for non-nano dtypes (:issue:`53326`)
+- Bug when passing an :class:`ExtensionArray` subclass to ``dtype`` keywords. This will now raise a ``UserWarning`` to encourage passing an instance instead (:issue:`31356`, :issue:`54592`)
- Bug where the :class:`DataFrame` repr would not work when a column had an :class:`ArrowDtype` with a ``pyarrow.ExtensionDtype`` (:issue:`54063`)
- Bug where the ``__from_arrow__`` method of masked ExtensionDtypes (e.g. :class:`Float64Dtype`, :class:`BooleanDtype`) would not accept PyArrow arrays of type ``pyarrow.null()`` (:issue:`52223`)
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index c2e498e75b7d3..3db36fc50e343 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -1614,6 +1614,15 @@ def pandas_dtype(dtype) -> DtypeObj:
# registered extension types
result = registry.find(dtype)
if result is not None:
+ if isinstance(result, type):
+ # GH 31356, GH 54592
+ warnings.warn(
+ f"Instantiating {result.__name__} without any arguments."
+ f"Pass a {result.__name__} instance to silence this warning.",
+ UserWarning,
+ stacklevel=find_stack_level(),
+ )
+ result = result()
return result
# try a numpy dtype
diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
index 471e456146178..165bf61302145 100644
--- a/pandas/tests/dtypes/test_common.py
+++ b/pandas/tests/dtypes/test_common.py
@@ -782,3 +782,9 @@ def test_pandas_dtype_numpy_warning():
match="Converting `np.integer` or `np.signedinteger` to a dtype is deprecated",
):
pandas_dtype(np.integer)
+
+
+def test_pandas_dtype_ea_not_instance():
+ # GH 31356 GH 54592
+ with tm.assert_produces_warning(UserWarning):
+ assert pandas_dtype(CategoricalDtype) == CategoricalDtype()
| - [x] closes #31356 (Replace xxxx with the GitHub issue number)
- [x] closes #54592 (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).
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
Instantiating an empty instance is an imperfect solution since the EADtype could require positional arguments, so raises a UserWarning to encourage users to pass instances instead
| https://api.github.com/repos/pandas-dev/pandas/pulls/54721 | 2023-08-23T22:37:14Z | 2023-08-24T16:13:19Z | 2023-08-24T16:13:19Z | 2023-08-24T16:13:35Z |
Infer strings as pyarrow_numpy backed strings | diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index b79797fa86431..8056e6f3393e9 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -21,7 +21,7 @@ PyArrow will become a required dependency with pandas 3.0
`PyArrow <https://arrow.apache.org/docs/python/index.html>`_ will become a required
dependency of pandas starting with pandas 3.0. This decision was made based on
-`PDEP 12 <https://pandas.pydata.org/pdeps/0010-required-pyarrow-dependency.html>`_.
+`PDEP 10 <https://pandas.pydata.org/pdeps/0010-required-pyarrow-dependency.html>`_.
This will enable more changes that are hugely beneficial to pandas users, including
but not limited to:
@@ -41,7 +41,9 @@ Avoid NumPy object dtype for strings by default
Previously, all strings were stored in columns with NumPy object dtype.
This release introduces an option ``future.infer_string`` that infers all
-strings as PyArrow backed strings with dtype ``pd.ArrowDtype(pa.string())`` instead.
+strings as PyArrow backed strings with dtype ``"string[pyarrow_numpy]"`` instead.
+This is a new string dtype implementation that follows NumPy semantics in comparison
+operations and will return ``np.nan`` as the missing value indicator.
This option only works if PyArrow is installed. PyArrow backed strings have a
significantly reduced memory footprint and provide a big performance improvement
compared to NumPy object (:issue:`54430`).
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 2681115bbdcfb..859cb8e5ebead 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -2682,11 +2682,9 @@ def maybe_convert_objects(ndarray[object] objects,
elif seen.str_:
if using_pyarrow_string_dtype() and is_string_array(objects, skipna=True):
- import pyarrow as pa
+ from pandas.core.arrays.string_ import StringDtype
- from pandas.core.dtypes.dtypes import ArrowDtype
-
- dtype = ArrowDtype(pa.string())
+ dtype = StringDtype(storage="pyarrow_numpy")
return dtype.construct_array_type()._from_sequence(objects, dtype=dtype)
seen.object_ = True
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index f733ba3b445fd..aaac0dc73486f 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -51,10 +51,7 @@
is_object_dtype,
pandas_dtype,
)
-from pandas.core.dtypes.dtypes import (
- ArrowDtype,
- NumpyEADtype,
-)
+from pandas.core.dtypes.dtypes import NumpyEADtype
from pandas.core.dtypes.generic import (
ABCDataFrame,
ABCExtensionArray,
@@ -595,9 +592,9 @@ def sanitize_array(
if data.dtype == object:
subarr = maybe_infer_to_datetimelike(data)
elif data.dtype.kind == "U" and using_pyarrow_string_dtype():
- import pyarrow as pa
+ from pandas.core.arrays.string_ import StringDtype
- dtype = ArrowDtype(pa.string())
+ dtype = StringDtype(storage="pyarrow_numpy")
subarr = dtype.construct_array_type()._from_sequence(data, dtype=dtype)
if subarr is data and copy:
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index aa228191adc62..1d5db123068e2 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -799,10 +799,9 @@ def infer_dtype_from_scalar(val) -> tuple[DtypeObj, Any]:
dtype = _dtype_obj
if using_pyarrow_string_dtype():
- import pyarrow as pa
+ from pandas.core.arrays.string_ import StringDtype
- pa_dtype = pa.string()
- dtype = ArrowDtype(pa_dtype)
+ dtype = StringDtype(storage="pyarrow_numpy")
elif isinstance(val, (np.datetime64, dt.datetime)):
try:
diff --git a/pandas/core/internals/construction.py b/pandas/core/internals/construction.py
index f9f9e6d053b5f..5c8873d4324e0 100644
--- a/pandas/core/internals/construction.py
+++ b/pandas/core/internals/construction.py
@@ -32,10 +32,7 @@
is_named_tuple,
is_object_dtype,
)
-from pandas.core.dtypes.dtypes import (
- ArrowDtype,
- ExtensionDtype,
-)
+from pandas.core.dtypes.dtypes import ExtensionDtype
from pandas.core.dtypes.generic import (
ABCDataFrame,
ABCSeries,
@@ -379,10 +376,9 @@ def ndarray_to_mgr(
nb = new_block_2d(values, placement=bp, refs=refs)
block_values = [nb]
elif dtype is None and values.dtype.kind == "U" and using_pyarrow_string_dtype():
- import pyarrow as pa
+ dtype = StringDtype(storage="pyarrow_numpy")
obj_columns = list(values)
- dtype = ArrowDtype(pa.string())
block_values = [
new_block(
dtype.construct_array_type()._from_sequence(data, dtype=dtype),
diff --git a/pandas/io/_util.py b/pandas/io/_util.py
index 27316b3ab0af0..915595833468d 100644
--- a/pandas/io/_util.py
+++ b/pandas/io/_util.py
@@ -28,4 +28,4 @@ def _arrow_dtype_mapping() -> dict:
def arrow_string_types_mapper() -> Callable:
pa = import_optional_dependency("pyarrow")
- return {pa.string(): pd.ArrowDtype(pa.string())}.get
+ return {pa.string(): pd.StringDtype(storage="pyarrow_numpy")}.get
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 89c3f7bbc4f84..fb0354ef9df6c 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -68,7 +68,6 @@
)
from pandas.core.dtypes.missing import array_equivalent
-import pandas as pd
from pandas import (
DataFrame,
DatetimeIndex,
@@ -3224,9 +3223,7 @@ def read(
values = self.read_array("values", start=start, stop=stop)
result = Series(values, index=index, name=self.name, copy=False)
if using_pyarrow_string_dtype() and is_string_array(values, skipna=True):
- import pyarrow as pa
-
- result = result.astype(pd.ArrowDtype(pa.string()))
+ result = result.astype("string[pyarrow_numpy]")
return result
# error: Signature of "write" incompatible with supertype "Fixed"
@@ -3296,9 +3293,7 @@ def read(
columns = items[items.get_indexer(blk_items)]
df = DataFrame(values.T, columns=columns, index=axes[1], copy=False)
if using_pyarrow_string_dtype() and is_string_array(values, skipna=True):
- import pyarrow as pa
-
- df = df.astype(pd.ArrowDtype(pa.string()))
+ df = df.astype("string[pyarrow_numpy]")
dfs.append(df)
if len(dfs) > 0:
@@ -4686,9 +4681,7 @@ def read(
values, # type: ignore[arg-type]
skipna=True,
):
- import pyarrow as pa
-
- df = df.astype(pd.ArrowDtype(pa.string()))
+ df = df.astype("string[pyarrow_numpy]")
frames.append(df)
if len(frames) == 1:
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 63cddb7f192e6..a8ab3ce1ba014 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -2685,8 +2685,8 @@ def test_construct_with_strings_and_none(self):
def test_frame_string_inference(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = DataFrame(
{"a": ["a", "b"]}, dtype=dtype, columns=Index(["a"], dtype=dtype)
)
@@ -2720,8 +2720,8 @@ def test_frame_string_inference(self):
def test_frame_string_inference_array_string_dtype(self):
# GH#54496
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = DataFrame(
{"a": ["a", "b"]}, dtype=dtype, columns=Index(["a"], dtype=dtype)
)
diff --git a/pandas/tests/indexes/base_class/test_constructors.py b/pandas/tests/indexes/base_class/test_constructors.py
index 638124ac20e06..60abbfc441e8e 100644
--- a/pandas/tests/indexes/base_class/test_constructors.py
+++ b/pandas/tests/indexes/base_class/test_constructors.py
@@ -46,8 +46,8 @@ def test_construct_empty_tuples(self, tuple_list):
def test_index_string_inference(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = Index(["a", "b"], dtype=dtype)
with pd.option_context("future.infer_string", True):
ser = Index(["a", "b"])
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 4ee9e1e2d1598..ca3ce6ba34515 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -2095,7 +2095,7 @@ def test_pyarrow_engine_lines_false():
def test_json_roundtrip_string_inference(orient):
- pa = pytest.importorskip("pyarrow")
+ pytest.importorskip("pyarrow")
df = DataFrame(
[["a", "b"], ["c", "d"]], index=["row 1", "row 2"], columns=["col 1", "col 2"]
)
@@ -2104,9 +2104,9 @@ def test_json_roundtrip_string_inference(orient):
result = read_json(StringIO(out))
expected = DataFrame(
[["a", "b"], ["c", "d"]],
- dtype=pd.ArrowDtype(pa.string()),
- index=pd.Index(["row 1", "row 2"], dtype=pd.ArrowDtype(pa.string())),
- columns=pd.Index(["col 1", "col 2"], dtype=pd.ArrowDtype(pa.string())),
+ dtype="string[pyarrow_numpy]",
+ index=pd.Index(["row 1", "row 2"], dtype="string[pyarrow_numpy]"),
+ columns=pd.Index(["col 1", "col 2"], dtype="string[pyarrow_numpy]"),
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/parser/dtypes/test_dtypes_basic.py b/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
index 1c0f0939029ff..8494c5d58171b 100644
--- a/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
+++ b/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
@@ -542,8 +542,8 @@ def test_ea_int_avoid_overflow(all_parsers):
def test_string_inference(all_parsers):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
data = """a,b
x,1
diff --git a/pandas/tests/io/pytables/test_read.py b/pandas/tests/io/pytables/test_read.py
index 72fc2361c5053..9b4590ca3f01f 100644
--- a/pandas/tests/io/pytables/test_read.py
+++ b/pandas/tests/io/pytables/test_read.py
@@ -392,7 +392,7 @@ def test_read_py2_hdf_file_in_py3(datapath):
def test_read_infer_string(tmp_path, setup_path):
# GH#54431
- pa = pytest.importorskip("pyarrow")
+ pytest.importorskip("pyarrow")
df = DataFrame({"a": ["a", "b", None]})
path = tmp_path / setup_path
df.to_hdf(path, key="data", format="table")
@@ -400,7 +400,7 @@ def test_read_infer_string(tmp_path, setup_path):
result = read_hdf(path, key="data", mode="r")
expected = DataFrame(
{"a": ["a", "b", None]},
- dtype=pd.ArrowDtype(pa.string()),
- columns=Index(["a"], dtype=pd.ArrowDtype(pa.string())),
+ dtype="string[pyarrow_numpy]",
+ columns=Index(["a"], dtype="string[pyarrow_numpy]"),
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
index a0fee6751bf53..cf43203466ef4 100644
--- a/pandas/tests/io/test_feather.py
+++ b/pandas/tests/io/test_feather.py
@@ -222,14 +222,10 @@ def test_invalid_dtype_backend(self):
def test_string_inference(self, tmp_path):
# GH#54431
- import pyarrow as pa
-
path = tmp_path / "test_string_inference.p"
df = pd.DataFrame(data={"a": ["x", "y"]})
df.to_feather(path)
with pd.option_context("future.infer_string", True):
result = read_feather(path)
- expected = pd.DataFrame(
- data={"a": ["x", "y"]}, dtype=pd.ArrowDtype(pa.string())
- )
+ expected = pd.DataFrame(data={"a": ["x", "y"]}, dtype="string[pyarrow_numpy]")
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/test_orc.py b/pandas/tests/io/test_orc.py
index c2d791ba24c87..d90f803f1e607 100644
--- a/pandas/tests/io/test_orc.py
+++ b/pandas/tests/io/test_orc.py
@@ -426,7 +426,7 @@ def test_string_inference(tmp_path):
result = read_orc(path)
expected = pd.DataFrame(
data={"a": ["x", "y"]},
- dtype=pd.ArrowDtype(pa.string()),
- columns=pd.Index(["a"], dtype=pd.ArrowDtype(pa.string())),
+ dtype="string[pyarrow_numpy]",
+ columns=pd.Index(["a"], dtype="string[pyarrow_numpy]"),
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index 9182e4c4e7674..6ca71b9507322 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1113,8 +1113,6 @@ def test_df_attrs_persistence(self, tmp_path, pa):
def test_string_inference(self, tmp_path, pa):
# GH#54431
- import pyarrow as pa
-
path = tmp_path / "test_string_inference.p"
df = pd.DataFrame(data={"a": ["x", "y"]}, index=["a", "b"])
df.to_parquet(path, engine="pyarrow")
@@ -1122,8 +1120,8 @@ def test_string_inference(self, tmp_path, pa):
result = read_parquet(path, engine="pyarrow")
expected = pd.DataFrame(
data={"a": ["x", "y"]},
- dtype=pd.ArrowDtype(pa.string()),
- index=pd.Index(["a", "b"], dtype=pd.ArrowDtype(pa.string())),
+ dtype="string[pyarrow_numpy]",
+ index=pd.Index(["a", "b"], dtype="string[pyarrow_numpy]"),
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 02736406e109b..2f446e6b8c81d 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -2946,7 +2946,7 @@ def test_read_sql_dtype_backend_table(self, string_storage, func):
def test_read_sql_string_inference(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
+ pytest.importorskip("pyarrow")
table = "test"
df = DataFrame({"a": ["x", "y"]})
df.to_sql(table, con=self.conn, index=False, if_exists="replace")
@@ -2954,7 +2954,7 @@ def test_read_sql_string_inference(self):
with pd.option_context("future.infer_string", True):
result = read_sql_table(table, self.conn)
- dtype = pd.ArrowDtype(pa.string())
+ dtype = "string[pyarrow_numpy]"
expected = DataFrame(
{"a": ["x", "y"]}, dtype=dtype, columns=Index(["a"], dtype=dtype)
)
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 97bd8633954d8..ef734e9664844 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -2077,8 +2077,8 @@ def test_series_from_index_dtype_equal_does_not_copy(self):
def test_series_string_inference(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = Series(["a", "b"], dtype=dtype)
with pd.option_context("future.infer_string", True):
ser = Series(["a", "b"])
@@ -2092,8 +2092,8 @@ def test_series_string_inference(self):
@pytest.mark.parametrize("na_value", [None, np.nan, pd.NA])
def test_series_string_with_na_inference(self, na_value):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- dtype = pd.ArrowDtype(pa.string())
+ pytest.importorskip("pyarrow")
+ dtype = "string[pyarrow_numpy]"
expected = Series(["a", na_value], dtype=dtype)
with pd.option_context("future.infer_string", True):
ser = Series(["a", na_value])
@@ -2101,16 +2101,16 @@ def test_series_string_with_na_inference(self, na_value):
def test_series_string_inference_scalar(self):
# GH#54430
- pa = pytest.importorskip("pyarrow")
- expected = Series("a", index=[1], dtype=pd.ArrowDtype(pa.string()))
+ pytest.importorskip("pyarrow")
+ expected = Series("a", index=[1], dtype="string[pyarrow_numpy]")
with pd.option_context("future.infer_string", True):
ser = Series("a", index=[1])
tm.assert_series_equal(ser, expected)
def test_series_string_inference_array_string_dtype(self):
# GH#54496
- pa = pytest.importorskip("pyarrow")
- expected = Series(["a", "b"], dtype=pd.ArrowDtype(pa.string()))
+ pytest.importorskip("pyarrow")
+ expected = Series(["a", "b"], dtype="string[pyarrow_numpy]")
with pd.option_context("future.infer_string", True):
ser = Series(np.array(["a", "b"]))
tm.assert_series_equal(ser, expected)
| - [x] closes #54724 (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.
Follow-up on https://github.com/pandas-dev/pandas/pull/54533#issuecomment-1686137395
Context: https://github.com/pandas-dev/pandas/issues/54792 | https://api.github.com/repos/pandas-dev/pandas/pulls/54720 | 2023-08-23T21:58:39Z | 2023-08-24T19:30:03Z | 2023-08-24T19:30:03Z | 2023-08-28T09:48:30Z |
TST: clean ups in extension tests | diff --git a/pandas/tests/extension/base/accumulate.py b/pandas/tests/extension/base/accumulate.py
index 776ff80cd6e17..9a41a3a582c4a 100644
--- a/pandas/tests/extension/base/accumulate.py
+++ b/pandas/tests/extension/base/accumulate.py
@@ -23,14 +23,6 @@ def check_accumulate(self, ser: pd.Series, op_name: str, skipna: bool):
alt = ser.astype(object)
result = getattr(ser, op_name)(skipna=skipna)
-
- if result.dtype == pd.Float32Dtype() and op_name == "cumprod" and skipna:
- # TODO: avoid special-casing here
- pytest.skip(
- f"Float32 precision lead to large differences with op {op_name} "
- f"and skipna={skipna}"
- )
-
expected = getattr(alt, op_name)(skipna=skipna)
tm.assert_series_equal(result, expected, check_dtype=False)
diff --git a/pandas/tests/extension/base/constructors.py b/pandas/tests/extension/base/constructors.py
index 8828f33b7c62c..7215e910365cf 100644
--- a/pandas/tests/extension/base/constructors.py
+++ b/pandas/tests/extension/base/constructors.py
@@ -35,7 +35,8 @@ def test_series_constructor(self, data):
if hasattr(result._mgr, "blocks"):
assert isinstance(result2._mgr.blocks[0], EABackedBlock)
- def test_series_constructor_no_data_with_index(self, dtype, na_value):
+ def test_series_constructor_no_data_with_index(self, dtype):
+ na_value = dtype.na_value
result = pd.Series(index=[1, 2, 3], dtype=dtype)
expected = pd.Series([na_value] * 3, index=[1, 2, 3], dtype=dtype)
tm.assert_series_equal(result, expected)
@@ -45,7 +46,8 @@ def test_series_constructor_no_data_with_index(self, dtype, na_value):
expected = pd.Series([], index=pd.Index([], dtype="object"), dtype=dtype)
tm.assert_series_equal(result, expected)
- def test_series_constructor_scalar_na_with_index(self, dtype, na_value):
+ def test_series_constructor_scalar_na_with_index(self, dtype):
+ na_value = dtype.na_value
result = pd.Series(na_value, index=[1, 2, 3], dtype=dtype)
expected = pd.Series([na_value] * 3, index=[1, 2, 3], dtype=dtype)
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/extension/base/getitem.py b/pandas/tests/extension/base/getitem.py
index 5f0c1b960a475..be16a105384c6 100644
--- a/pandas/tests/extension/base/getitem.py
+++ b/pandas/tests/extension/base/getitem.py
@@ -148,7 +148,8 @@ def test_getitem_invalid(self, data):
with pytest.raises(IndexError, match=msg):
data[-ub - 1]
- def test_getitem_scalar_na(self, data_missing, na_cmp, na_value):
+ def test_getitem_scalar_na(self, data_missing, na_cmp):
+ na_value = data_missing.dtype.na_value
result = data_missing[0]
assert na_cmp(result, na_value)
@@ -348,7 +349,8 @@ def test_take_sequence(self, data):
assert result.iloc[1] == data[1]
assert result.iloc[2] == data[3]
- def test_take(self, data, na_value, na_cmp):
+ def test_take(self, data, na_cmp):
+ na_value = data.dtype.na_value
result = data.take([0, -1])
assert result.dtype == data.dtype
assert result[0] == data[0]
@@ -361,7 +363,8 @@ def test_take(self, data, na_value, na_cmp):
with pytest.raises(IndexError, match="out of bounds"):
data.take([len(data) + 1])
- def test_take_empty(self, data, na_value, na_cmp):
+ def test_take_empty(self, data, na_cmp):
+ na_value = data.dtype.na_value
empty = data[:0]
result = empty.take([-1], allow_fill=True)
@@ -393,7 +396,8 @@ def test_take_non_na_fill_value(self, data_missing):
expected = arr.take([1, 1])
tm.assert_extension_array_equal(result, expected)
- def test_take_pandas_style_negative_raises(self, data, na_value):
+ def test_take_pandas_style_negative_raises(self, data):
+ na_value = data.dtype.na_value
with pytest.raises(ValueError, match=""):
data.take([0, -2], fill_value=na_value, allow_fill=True)
@@ -413,7 +417,8 @@ def test_take_series(self, data):
)
tm.assert_series_equal(result, expected)
- def test_reindex(self, data, na_value):
+ def test_reindex(self, data):
+ na_value = data.dtype.na_value
s = pd.Series(data)
result = s.reindex([0, 1, 3])
expected = pd.Series(data.take([0, 1, 3]), index=[0, 1, 3])
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index 16059155a7a8f..4e0bc8d804bab 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -121,7 +121,7 @@ def test_argsort_missing(self, data_missing_for_sorting):
expected = pd.Series(np.array([1, -1, 0], dtype=np.intp))
tm.assert_series_equal(result, expected)
- def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting, na_value):
+ def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting):
# GH 24382
is_bool = data_for_sorting.dtype._is_boolean
@@ -154,9 +154,10 @@ def test_argmin_argmax_empty_array(self, method, data):
getattr(data[:0], method)()
@pytest.mark.parametrize("method", ["argmax", "argmin"])
- def test_argmin_argmax_all_na(self, method, data, na_value):
+ def test_argmin_argmax_all_na(self, method, data):
# all missing with skipna=True is the same as empty
err_msg = "attempt to get"
+ na_value = data.dtype.na_value
data_na = type(data)._from_sequence([na_value, na_value], dtype=data.dtype)
with pytest.raises(ValueError, match=err_msg):
getattr(data_na, method)()
@@ -543,7 +544,8 @@ def _test_searchsorted_bool_dtypes(self, data_for_sorting, as_series):
sorter = np.array([1, 0])
assert data_for_sorting.searchsorted(a, sorter=sorter) == 0
- def test_where_series(self, data, na_value, as_frame):
+ def test_where_series(self, data, as_frame):
+ na_value = data.dtype.na_value
assert data[0] != data[1]
cls = type(data)
a, b = data[:2]
@@ -670,7 +672,8 @@ def test_insert_invalid_loc(self, data):
data.insert(1.5, data[0])
@pytest.mark.parametrize("box", [pd.array, pd.Series, pd.DataFrame])
- def test_equals(self, data, na_value, as_series, box):
+ def test_equals(self, data, as_series, box):
+ na_value = data.dtype.na_value
data2 = type(data)._from_sequence([data[0]] * len(data), dtype=data.dtype)
data_na = type(data)._from_sequence([na_value] * len(data), dtype=data.dtype)
diff --git a/pandas/tests/extension/base/ops.py b/pandas/tests/extension/base/ops.py
index d5eb65ec9d35d..d2aa4bd63c428 100644
--- a/pandas/tests/extension/base/ops.py
+++ b/pandas/tests/extension/base/ops.py
@@ -5,6 +5,8 @@
import numpy as np
import pytest
+from pandas.core.dtypes.common import is_string_dtype
+
import pandas as pd
import pandas._testing as tm
from pandas.core import ops
@@ -128,12 +130,18 @@ class BaseArithmeticOpsTests(BaseOpsUtil):
def test_arith_series_with_scalar(self, data, all_arithmetic_operators):
# series & scalar
+ if all_arithmetic_operators == "__rmod__" and is_string_dtype(data.dtype):
+ pytest.skip("Skip testing Python string formatting")
+
op_name = all_arithmetic_operators
ser = pd.Series(data)
self.check_opname(ser, op_name, ser.iloc[0])
def test_arith_frame_with_scalar(self, data, all_arithmetic_operators):
# frame & scalar
+ if all_arithmetic_operators == "__rmod__" and is_string_dtype(data.dtype):
+ pytest.skip("Skip testing Python string formatting")
+
op_name = all_arithmetic_operators
df = pd.DataFrame({"A": data})
self.check_opname(df, op_name, data[0])
diff --git a/pandas/tests/extension/base/reshaping.py b/pandas/tests/extension/base/reshaping.py
index a9bd12917e73e..13ab56adfe914 100644
--- a/pandas/tests/extension/base/reshaping.py
+++ b/pandas/tests/extension/base/reshaping.py
@@ -72,7 +72,8 @@ def test_concat_mixed_dtypes(self, data):
expected = pd.concat([df1["A"].astype("object"), df2["A"].astype("object")])
tm.assert_series_equal(result, expected)
- def test_concat_columns(self, data, na_value):
+ def test_concat_columns(self, data):
+ na_value = data.dtype.na_value
df1 = pd.DataFrame({"A": data[:3]})
df2 = pd.DataFrame({"B": [1, 2, 3]})
@@ -96,8 +97,9 @@ def test_concat_columns(self, data, na_value):
result = pd.concat([df1["A"], df2["B"]], axis=1)
tm.assert_frame_equal(result, expected)
- def test_concat_extension_arrays_copy_false(self, data, na_value):
+ def test_concat_extension_arrays_copy_false(self, data):
# GH 20756
+ na_value = data.dtype.na_value
df1 = pd.DataFrame({"A": data[:3]})
df2 = pd.DataFrame({"B": data[3:7]})
expected = pd.DataFrame(
@@ -122,7 +124,8 @@ def test_concat_with_reindex(self, data):
)
tm.assert_frame_equal(result, expected)
- def test_align(self, data, na_value):
+ def test_align(self, data):
+ na_value = data.dtype.na_value
a = data[:3]
b = data[2:5]
r1, r2 = pd.Series(a).align(pd.Series(b, index=[1, 2, 3]))
@@ -133,7 +136,8 @@ def test_align(self, data, na_value):
tm.assert_series_equal(r1, e1)
tm.assert_series_equal(r2, e2)
- def test_align_frame(self, data, na_value):
+ def test_align_frame(self, data):
+ na_value = data.dtype.na_value
a = data[:3]
b = data[2:5]
r1, r2 = pd.DataFrame({"A": a}).align(pd.DataFrame({"A": b}, index=[1, 2, 3]))
@@ -148,8 +152,9 @@ def test_align_frame(self, data, na_value):
tm.assert_frame_equal(r1, e1)
tm.assert_frame_equal(r2, e2)
- def test_align_series_frame(self, data, na_value):
+ def test_align_series_frame(self, data):
# https://github.com/pandas-dev/pandas/issues/20576
+ na_value = data.dtype.na_value
ser = pd.Series(data, name="a")
df = pd.DataFrame({"col": np.arange(len(ser) + 1)})
r1, r2 = ser.align(df)
@@ -180,7 +185,7 @@ def test_set_frame_overwrite_object(self, data):
df["A"] = data
assert df.dtypes["A"] == data.dtype
- def test_merge(self, data, na_value):
+ def test_merge(self, data):
# GH-20743
df1 = pd.DataFrame({"ext": data[:3], "int1": [1, 2, 3], "key": [0, 1, 2]})
df2 = pd.DataFrame({"int2": [1, 2, 3, 4], "key": [0, 0, 1, 3]})
@@ -205,7 +210,8 @@ def test_merge(self, data, na_value):
"int2": [1, 2, 3, np.nan, 4],
"key": [0, 0, 1, 2, 3],
"ext": data._from_sequence(
- [data[0], data[0], data[1], data[2], na_value], dtype=data.dtype
+ [data[0], data[0], data[1], data[2], data.dtype.na_value],
+ dtype=data.dtype,
),
}
)
diff --git a/pandas/tests/extension/base/setitem.py b/pandas/tests/extension/base/setitem.py
index fd90635deffac..c975138837e6b 100644
--- a/pandas/tests/extension/base/setitem.py
+++ b/pandas/tests/extension/base/setitem.py
@@ -359,7 +359,8 @@ def test_setitem_with_expansion_dataframe_column(self, data, full_indexer):
tm.assert_frame_equal(result, expected)
- def test_setitem_with_expansion_row(self, data, na_value):
+ def test_setitem_with_expansion_row(self, data):
+ na_value = data.dtype.na_value
df = pd.DataFrame({"data": data[:1]})
df.loc[1, "data"] = data[1]
diff --git a/pandas/tests/extension/conftest.py b/pandas/tests/extension/conftest.py
index 7b7945b15ed83..eb60aea7cc8c2 100644
--- a/pandas/tests/extension/conftest.py
+++ b/pandas/tests/extension/conftest.py
@@ -116,12 +116,6 @@ def na_cmp():
return operator.is_
-@pytest.fixture
-def na_value(dtype):
- """The scalar missing value for this type. Default dtype.na_value"""
- return dtype.na_value
-
-
@pytest.fixture
def data_for_grouping():
"""
diff --git a/pandas/tests/extension/json/test_json.py b/pandas/tests/extension/json/test_json.py
index 9e1a4fb5da251..68a27a28b160f 100644
--- a/pandas/tests/extension/json/test_json.py
+++ b/pandas/tests/extension/json/test_json.py
@@ -97,24 +97,24 @@ def test_from_dtype(self, data):
super().test_from_dtype(data)
@pytest.mark.xfail(reason="RecursionError, GH-33900")
- def test_series_constructor_no_data_with_index(self, dtype, na_value):
+ def test_series_constructor_no_data_with_index(self, dtype):
# RecursionError: maximum recursion depth exceeded in comparison
rec_limit = sys.getrecursionlimit()
try:
# Limit to avoid stack overflow on Windows CI
sys.setrecursionlimit(100)
- super().test_series_constructor_no_data_with_index(dtype, na_value)
+ super().test_series_constructor_no_data_with_index(dtype)
finally:
sys.setrecursionlimit(rec_limit)
@pytest.mark.xfail(reason="RecursionError, GH-33900")
- def test_series_constructor_scalar_na_with_index(self, dtype, na_value):
+ def test_series_constructor_scalar_na_with_index(self, dtype):
# RecursionError: maximum recursion depth exceeded in comparison
rec_limit = sys.getrecursionlimit()
try:
# Limit to avoid stack overflow on Windows CI
sys.setrecursionlimit(100)
- super().test_series_constructor_scalar_na_with_index(dtype, na_value)
+ super().test_series_constructor_scalar_na_with_index(dtype)
finally:
sys.setrecursionlimit(rec_limit)
@@ -214,19 +214,19 @@ def test_combine_first(self, data):
super().test_combine_first(data)
@pytest.mark.xfail(reason="broadcasting error")
- def test_where_series(self, data, na_value):
+ def test_where_series(self, data):
# Fails with
# *** ValueError: operands could not be broadcast together
# with shapes (4,) (4,) (0,)
- super().test_where_series(data, na_value)
+ super().test_where_series(data)
@pytest.mark.xfail(reason="Can't compare dicts.")
def test_searchsorted(self, data_for_sorting):
super().test_searchsorted(data_for_sorting)
@pytest.mark.xfail(reason="Can't compare dicts.")
- def test_equals(self, data, na_value, as_series):
- super().test_equals(data, na_value, as_series)
+ def test_equals(self, data, as_series):
+ super().test_equals(data, as_series)
@pytest.mark.skip("fill-value is interpreted as a dict of values")
def test_fillna_copy_frame(self, data_missing):
diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
index 890ffd6dfbdd9..cb79539cd2bd1 100644
--- a/pandas/tests/extension/test_arrow.py
+++ b/pandas/tests/extension/test_arrow.py
@@ -518,9 +518,7 @@ def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna, reque
super().test_reduce_series_numeric(data, all_numeric_reductions, skipna)
@pytest.mark.parametrize("skipna", [True, False])
- def test_reduce_series_boolean(
- self, data, all_boolean_reductions, skipna, na_value, request
- ):
+ def test_reduce_series_boolean(self, data, all_boolean_reductions, skipna, request):
pa_dtype = data.dtype.pyarrow_dtype
xfail_mark = pytest.mark.xfail(
raises=TypeError,
@@ -753,9 +751,7 @@ def test_value_counts_returns_pyarrow_int64(self, data):
result = data.value_counts()
assert result.dtype == ArrowDtype(pa.int64())
- def test_argmin_argmax(
- self, data_for_sorting, data_missing_for_sorting, na_value, request
- ):
+ def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting, request):
pa_dtype = data_for_sorting.dtype.pyarrow_dtype
if pa.types.is_decimal(pa_dtype) and pa_version_under7p0:
request.node.add_marker(
@@ -764,7 +760,7 @@ def test_argmin_argmax(
raises=pa.ArrowNotImplementedError,
)
)
- super().test_argmin_argmax(data_for_sorting, data_missing_for_sorting, na_value)
+ super().test_argmin_argmax(data_for_sorting, data_missing_for_sorting)
@pytest.mark.parametrize(
"op_name, skipna, expected",
@@ -1033,9 +1029,7 @@ def _get_arith_xfail_marker(self, opname, pa_dtype):
def test_arith_series_with_scalar(self, data, all_arithmetic_operators, request):
pa_dtype = data.dtype.pyarrow_dtype
- if all_arithmetic_operators == "__rmod__" and (
- pa.types.is_string(pa_dtype) or pa.types.is_binary(pa_dtype)
- ):
+ if all_arithmetic_operators == "__rmod__" and (pa.types.is_binary(pa_dtype)):
pytest.skip("Skip testing Python string formatting")
mark = self._get_arith_xfail_marker(all_arithmetic_operators, pa_dtype)
diff --git a/pandas/tests/extension/test_categorical.py b/pandas/tests/extension/test_categorical.py
index 79b8e9ddbf8f5..82b6c54bc3106 100644
--- a/pandas/tests/extension/test_categorical.py
+++ b/pandas/tests/extension/test_categorical.py
@@ -165,14 +165,14 @@ def test_arith_series_with_scalar(self, data, all_arithmetic_operators, request)
)
super().test_arith_series_with_scalar(data, op_name)
- def _compare_other(self, s, data, op, other):
+ def _compare_other(self, ser: pd.Series, data, op, other):
op_name = f"__{op.__name__}__"
if op_name not in ["__eq__", "__ne__"]:
msg = "Unordered Categoricals can only compare equality or not"
with pytest.raises(TypeError, match=msg):
op(data, other)
else:
- return super()._compare_other(s, data, op, other)
+ return super()._compare_other(ser, data, op, other)
@pytest.mark.xfail(reason="Categorical overrides __repr__")
@pytest.mark.parametrize("size", ["big", "small"])
diff --git a/pandas/tests/extension/test_masked.py b/pandas/tests/extension/test_masked.py
index 7efb8fbad8cd1..f5b0b6f4efa98 100644
--- a/pandas/tests/extension/test_masked.py
+++ b/pandas/tests/extension/test_masked.py
@@ -323,6 +323,13 @@ def check_accumulate(self, ser: pd.Series, op_name: str, skipna: bool):
else:
expected_dtype = f"Int{length}"
+ if expected_dtype == "Float32" and op_name == "cumprod" and skipna:
+ # TODO: xfail?
+ pytest.skip(
+ f"Float32 precision lead to large differences with op {op_name} "
+ f"and skipna={skipna}"
+ )
+
if op_name == "cumsum":
result = getattr(ser, op_name)(skipna=skipna)
expected = pd.Series(
diff --git a/pandas/tests/extension/test_sparse.py b/pandas/tests/extension/test_sparse.py
index 7330e03a57daf..f56dea3f43de7 100644
--- a/pandas/tests/extension/test_sparse.py
+++ b/pandas/tests/extension/test_sparse.py
@@ -146,29 +146,29 @@ def test_concat_mixed_dtypes(self, data):
def test_stack(self, data, columns, future_stack):
super().test_stack(data, columns, future_stack)
- def test_concat_columns(self, data, na_value):
+ def test_concat_columns(self, data):
self._check_unsupported(data)
- super().test_concat_columns(data, na_value)
+ super().test_concat_columns(data)
- def test_concat_extension_arrays_copy_false(self, data, na_value):
+ def test_concat_extension_arrays_copy_false(self, data):
self._check_unsupported(data)
- super().test_concat_extension_arrays_copy_false(data, na_value)
+ super().test_concat_extension_arrays_copy_false(data)
- def test_align(self, data, na_value):
+ def test_align(self, data):
self._check_unsupported(data)
- super().test_align(data, na_value)
+ super().test_align(data)
- def test_align_frame(self, data, na_value):
+ def test_align_frame(self, data):
self._check_unsupported(data)
- super().test_align_frame(data, na_value)
+ super().test_align_frame(data)
- def test_align_series_frame(self, data, na_value):
+ def test_align_series_frame(self, data):
self._check_unsupported(data)
- super().test_align_series_frame(data, na_value)
+ super().test_align_series_frame(data)
- def test_merge(self, data, na_value):
+ def test_merge(self, data):
self._check_unsupported(data)
- super().test_merge(data, na_value)
+ super().test_merge(data)
class TestGetitem(BaseSparseTests, base.BaseGetitemTests):
@@ -180,9 +180,9 @@ def test_get(self, data):
assert ser.get(4) == ser.iloc[2]
assert ser.get(2) == ser.iloc[1]
- def test_reindex(self, data, na_value):
+ def test_reindex(self, data):
self._check_unsupported(data)
- super().test_reindex(data, na_value)
+ super().test_reindex(data)
class TestSetitem(BaseSparseTests, base.BaseSetitemTests):
@@ -282,7 +282,7 @@ def test_fillna_copy_series(self, data_missing, using_copy_on_write):
def test_fillna_length_mismatch(self, data_missing):
super().test_fillna_length_mismatch(data_missing)
- def test_where_series(self, data, na_value):
+ def test_where_series(self, data):
assert data[0] != data[1]
cls = type(data)
a, b = data[:2]
@@ -293,6 +293,7 @@ def test_where_series(self, data, na_value):
result = ser.where(cond)
new_dtype = SparseDtype("float", 0.0)
+ na_value = data.dtype.na_value
expected = pd.Series(
cls._from_sequence([a, a, na_value, na_value], dtype=new_dtype)
)
@@ -316,15 +317,15 @@ def test_shift_0_periods(self, data):
assert result._sparse_values[0] != result._sparse_values[1]
@pytest.mark.parametrize("method", ["argmax", "argmin"])
- def test_argmin_argmax_all_na(self, method, data, na_value):
+ def test_argmin_argmax_all_na(self, method, data):
# overriding because Sparse[int64, 0] cannot handle na_value
self._check_unsupported(data)
- super().test_argmin_argmax_all_na(method, data, na_value)
+ super().test_argmin_argmax_all_na(method, data)
@pytest.mark.parametrize("box", [pd.array, pd.Series, pd.DataFrame])
- def test_equals(self, data, na_value, as_series, box):
+ def test_equals(self, data, as_series, box):
self._check_unsupported(data)
- super().test_equals(data, na_value, as_series, box)
+ super().test_equals(data, as_series, box)
@pytest.mark.parametrize(
"func, na_action, expected",
| - [ ] 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/54719 | 2023-08-23T21:48:49Z | 2023-08-24T16:21:07Z | 2023-08-24T16:21:07Z | 2023-08-25T18:26:06Z |
DOC: add awkward-pandas to ecosystem page | diff --git a/web/pandas/community/ecosystem.md b/web/pandas/community/ecosystem.md
index e9f5c8643b493..561503de416a5 100644
--- a/web/pandas/community/ecosystem.md
+++ b/web/pandas/community/ecosystem.md
@@ -511,9 +511,16 @@ assumptions about your datasets and check that they're *actually* true.
Pandas provides an interface for defining
[extension types](https://pandas.pydata.org/docs/development/extending.html#extension-types) to extend NumPy's type system.
-The following librariesimplement that interface to provide types not found in NumPy or pandas,
+The following libraries implement that interface to provide types not found in NumPy or pandas,
which work well with pandas' data containers.
+### [awkward-pandas](https://awkward-pandas.readthedocs.io/)
+
+Awkward-pandas provides an extension type for storing [Awkward
+Arrays](https://awkward-array.org/) inside pandas' Series and
+DataFrame. It also provides an accessor for using awkward functions
+on Series that are of awkward type.
+
### [cyberpandas](https://cyberpandas.readthedocs.io/en/latest)
Cyberpandas provides an extension type for storing arrays of IP
@@ -553,6 +560,7 @@ authors to coordinate on the namespace.
| Library | Accessor | Classes |
| -------------------------------------------------------------------- | ---------- | --------------------- |
+ | [awkward-pandas](https://awkward-pandas.readthedocs.io/en/latest/) | `ak` | `Series` |
| [cyberpandas](https://cyberpandas.readthedocs.io/en/latest) | `ip` | `Series` |
| [pdvega](https://altair-viz.github.io/pdvega/) | `vgplot` | `Series`, `DataFrame` |
| [pandas-genomics](https://pandas-genomics.readthedocs.io/en/latest/) | `genomics` | `Series`, `DataFrame` |
| We'd love to have [awkward-pandas](https://github.com/intake/awkward-pandas) listed on the ecosystem webpage. (I added the package to the existing lists in alphabetical order, would be happy to reorder)
- [ ] 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/54718 | 2023-08-23T21:26:54Z | 2023-08-24T16:22:23Z | 2023-08-24T16:22:23Z | 2023-08-24T16:33:39Z |
Backport PR #54533 on branch 2.1.x (Implement Arrow String Array that is compatible with NumPy semantics) | diff --git a/pandas/conftest.py b/pandas/conftest.py
index 5210e727aeb3c..10826f50d1fe1 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -1321,6 +1321,7 @@ def nullable_string_dtype(request):
params=[
"python",
pytest.param("pyarrow", marks=td.skip_if_no("pyarrow")),
+ pytest.param("pyarrow_numpy", marks=td.skip_if_no("pyarrow")),
]
)
def string_storage(request):
@@ -1329,6 +1330,7 @@ def string_storage(request):
* 'python'
* 'pyarrow'
+ * 'pyarrow_numpy'
"""
return request.param
@@ -1380,6 +1382,7 @@ def object_dtype(request):
"object",
"string[python]",
pytest.param("string[pyarrow]", marks=td.skip_if_no("pyarrow")),
+ pytest.param("string[pyarrow_numpy]", marks=td.skip_if_no("pyarrow")),
]
)
def any_string_dtype(request):
@@ -2000,4 +2003,4 @@ def warsaw(request) -> str:
@pytest.fixture()
def arrow_string_storage():
- return ("pyarrow",)
+ return ("pyarrow", "pyarrow_numpy")
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 48ff769f6c737..c4960f49e3ba5 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -515,7 +515,10 @@ def __getitem__(self, item: PositionalIndexer):
if isinstance(item, np.ndarray):
if not len(item):
# Removable once we migrate StringDtype[pyarrow] to ArrowDtype[string]
- if self._dtype.name == "string" and self._dtype.storage == "pyarrow":
+ if self._dtype.name == "string" and self._dtype.storage in (
+ "pyarrow",
+ "pyarrow_numpy",
+ ):
pa_dtype = pa.string()
else:
pa_dtype = self._dtype.pyarrow_dtype
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 25f1c2ec6ce4f..1e285f90e9fea 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -76,7 +76,7 @@ class StringDtype(StorageExtensionDtype):
Parameters
----------
- storage : {"python", "pyarrow"}, optional
+ storage : {"python", "pyarrow", "pyarrow_numpy"}, optional
If not given, the value of ``pd.options.mode.string_storage``.
Attributes
@@ -108,11 +108,11 @@ def na_value(self) -> libmissing.NAType:
def __init__(self, storage=None) -> None:
if storage is None:
storage = get_option("mode.string_storage")
- if storage not in {"python", "pyarrow"}:
+ if storage not in {"python", "pyarrow", "pyarrow_numpy"}:
raise ValueError(
f"Storage must be 'python' or 'pyarrow'. Got {storage} instead."
)
- if storage == "pyarrow" and pa_version_under7p0:
+ if storage in ("pyarrow", "pyarrow_numpy") and pa_version_under7p0:
raise ImportError(
"pyarrow>=7.0.0 is required for PyArrow backed StringArray."
)
@@ -160,6 +160,8 @@ def construct_from_string(cls, string):
return cls(storage="python")
elif string == "string[pyarrow]":
return cls(storage="pyarrow")
+ elif string == "string[pyarrow_numpy]":
+ return cls(storage="pyarrow_numpy")
else:
raise TypeError(f"Cannot construct a '{cls.__name__}' from '{string}'")
@@ -176,12 +178,17 @@ def construct_array_type( # type: ignore[override]
-------
type
"""
- from pandas.core.arrays.string_arrow import ArrowStringArray
+ from pandas.core.arrays.string_arrow import (
+ ArrowStringArray,
+ ArrowStringArrayNumpySemantics,
+ )
if self.storage == "python":
return StringArray
- else:
+ elif self.storage == "pyarrow":
return ArrowStringArray
+ else:
+ return ArrowStringArrayNumpySemantics
def __from_arrow__(
self, array: pyarrow.Array | pyarrow.ChunkedArray
@@ -193,6 +200,10 @@ def __from_arrow__(
from pandas.core.arrays.string_arrow import ArrowStringArray
return ArrowStringArray(array)
+ elif self.storage == "pyarrow_numpy":
+ from pandas.core.arrays.string_arrow import ArrowStringArrayNumpySemantics
+
+ return ArrowStringArrayNumpySemantics(array)
else:
import pyarrow
diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index 4a70fcf6b5a93..bc1d7cb52e196 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -1,5 +1,6 @@
from __future__ import annotations
+from functools import partial
import re
from typing import (
TYPE_CHECKING,
@@ -27,6 +28,7 @@
)
from pandas.core.dtypes.missing import isna
+from pandas.core.arrays._arrow_string_mixins import ArrowStringArrayMixin
from pandas.core.arrays.arrow import ArrowExtensionArray
from pandas.core.arrays.boolean import BooleanDtype
from pandas.core.arrays.integer import Int64Dtype
@@ -113,10 +115,11 @@ class ArrowStringArray(ObjectStringArrayMixin, ArrowExtensionArray, BaseStringAr
# error: Incompatible types in assignment (expression has type "StringDtype",
# base class "ArrowExtensionArray" defined the type as "ArrowDtype")
_dtype: StringDtype # type: ignore[assignment]
+ _storage = "pyarrow"
def __init__(self, values) -> None:
super().__init__(values)
- self._dtype = StringDtype(storage="pyarrow")
+ self._dtype = StringDtype(storage=self._storage)
if not pa.types.is_string(self._pa_array.type) and not (
pa.types.is_dictionary(self._pa_array.type)
@@ -144,7 +147,10 @@ def _from_sequence(cls, scalars, dtype: Dtype | None = None, copy: bool = False)
if dtype and not (isinstance(dtype, str) and dtype == "string"):
dtype = pandas_dtype(dtype)
- assert isinstance(dtype, StringDtype) and dtype.storage == "pyarrow"
+ assert isinstance(dtype, StringDtype) and dtype.storage in (
+ "pyarrow",
+ "pyarrow_numpy",
+ )
if isinstance(scalars, BaseMaskedArray):
# avoid costly conversion to object dtype in ensure_string_array and
@@ -178,6 +184,10 @@ def insert(self, loc: int, item) -> ArrowStringArray:
raise TypeError("Scalar must be NA or str")
return super().insert(loc, item)
+ @classmethod
+ def _result_converter(cls, values, na=None):
+ return BooleanDtype().__from_arrow__(values)
+
def _maybe_convert_setitem_value(self, value):
"""Maybe convert value to be pyarrow compatible."""
if is_scalar(value):
@@ -313,7 +323,7 @@ def _str_contains(
result = pc.match_substring_regex(self._pa_array, pat, ignore_case=not case)
else:
result = pc.match_substring(self._pa_array, pat, ignore_case=not case)
- result = BooleanDtype().__from_arrow__(result)
+ result = self._result_converter(result, na=na)
if not isna(na):
result[isna(result)] = bool(na)
return result
@@ -322,7 +332,7 @@ def _str_startswith(self, pat: str, na=None):
result = pc.starts_with(self._pa_array, pattern=pat)
if not isna(na):
result = result.fill_null(na)
- result = BooleanDtype().__from_arrow__(result)
+ result = self._result_converter(result)
if not isna(na):
result[isna(result)] = bool(na)
return result
@@ -331,7 +341,7 @@ def _str_endswith(self, pat: str, na=None):
result = pc.ends_with(self._pa_array, pattern=pat)
if not isna(na):
result = result.fill_null(na)
- result = BooleanDtype().__from_arrow__(result)
+ result = self._result_converter(result)
if not isna(na):
result[isna(result)] = bool(na)
return result
@@ -369,39 +379,39 @@ def _str_fullmatch(
def _str_isalnum(self):
result = pc.utf8_is_alnum(self._pa_array)
- return BooleanDtype().__from_arrow__(result)
+ return self._result_converter(result)
def _str_isalpha(self):
result = pc.utf8_is_alpha(self._pa_array)
- return BooleanDtype().__from_arrow__(result)
+ return self._result_converter(result)
def _str_isdecimal(self):
result = pc.utf8_is_decimal(self._pa_array)
- return BooleanDtype().__from_arrow__(result)
+ return self._result_converter(result)
def _str_isdigit(self):
result = pc.utf8_is_digit(self._pa_array)
- return BooleanDtype().__from_arrow__(result)
+ return self._result_converter(result)
def _str_islower(self):
result = pc.utf8_is_lower(self._pa_array)
- return BooleanDtype().__from_arrow__(result)
+ return self._result_converter(result)
def _str_isnumeric(self):
result = pc.utf8_is_numeric(self._pa_array)
- return BooleanDtype().__from_arrow__(result)
+ return self._result_converter(result)
def _str_isspace(self):
result = pc.utf8_is_space(self._pa_array)
- return BooleanDtype().__from_arrow__(result)
+ return self._result_converter(result)
def _str_istitle(self):
result = pc.utf8_is_title(self._pa_array)
- return BooleanDtype().__from_arrow__(result)
+ return self._result_converter(result)
def _str_isupper(self):
result = pc.utf8_is_upper(self._pa_array)
- return BooleanDtype().__from_arrow__(result)
+ return self._result_converter(result)
def _str_len(self):
result = pc.utf8_length(self._pa_array)
@@ -433,3 +443,114 @@ def _str_rstrip(self, to_strip=None):
else:
result = pc.utf8_rtrim(self._pa_array, characters=to_strip)
return type(self)(result)
+
+
+class ArrowStringArrayNumpySemantics(ArrowStringArray):
+ _storage = "pyarrow_numpy"
+
+ @classmethod
+ def _result_converter(cls, values, na=None):
+ if not isna(na):
+ values = values.fill_null(bool(na))
+ return ArrowExtensionArray(values).to_numpy(na_value=np.nan)
+
+ def __getattribute__(self, item):
+ # ArrowStringArray and we both inherit from ArrowExtensionArray, which
+ # creates inheritance problems (Diamond inheritance)
+ if item in ArrowStringArrayMixin.__dict__ and item != "_pa_array":
+ return partial(getattr(ArrowStringArrayMixin, item), self)
+ return super().__getattribute__(item)
+
+ def _str_map(
+ self, f, na_value=None, dtype: Dtype | None = None, convert: bool = True
+ ):
+ if dtype is None:
+ dtype = self.dtype
+ if na_value is None:
+ na_value = self.dtype.na_value
+
+ mask = isna(self)
+ arr = np.asarray(self)
+
+ if is_integer_dtype(dtype) or is_bool_dtype(dtype):
+ if is_integer_dtype(dtype):
+ na_value = np.nan
+ else:
+ na_value = False
+ try:
+ result = lib.map_infer_mask(
+ arr,
+ f,
+ mask.view("uint8"),
+ convert=False,
+ na_value=na_value,
+ dtype=np.dtype(dtype), # type: ignore[arg-type]
+ )
+ return result
+
+ except ValueError:
+ result = lib.map_infer_mask(
+ arr,
+ f,
+ mask.view("uint8"),
+ convert=False,
+ na_value=na_value,
+ )
+ if convert and result.dtype == object:
+ result = lib.maybe_convert_objects(result)
+ return result
+
+ elif is_string_dtype(dtype) and not is_object_dtype(dtype):
+ # i.e. StringDtype
+ result = lib.map_infer_mask(
+ arr, f, mask.view("uint8"), convert=False, na_value=na_value
+ )
+ result = pa.array(result, mask=mask, type=pa.string(), from_pandas=True)
+ return type(self)(result)
+ else:
+ # This is when the result type is object. We reach this when
+ # -> We know the result type is truly object (e.g. .encode returns bytes
+ # or .findall returns a list).
+ # -> We don't know the result type. E.g. `.get` can return anything.
+ return lib.map_infer_mask(arr, f, mask.view("uint8"))
+
+ def _convert_int_dtype(self, result):
+ if result.dtype == np.int32:
+ result = result.astype(np.int64)
+ return result
+
+ def _str_count(self, pat: str, flags: int = 0):
+ if flags:
+ return super()._str_count(pat, flags)
+ result = pc.count_substring_regex(self._pa_array, pat).to_numpy()
+ return self._convert_int_dtype(result)
+
+ def _str_len(self):
+ result = pc.utf8_length(self._pa_array).to_numpy()
+ return self._convert_int_dtype(result)
+
+ def _str_find(self, sub: str, start: int = 0, end: int | None = None):
+ if start != 0 and end is not None:
+ slices = pc.utf8_slice_codeunits(self._pa_array, start, stop=end)
+ result = pc.find_substring(slices, sub)
+ not_found = pc.equal(result, -1)
+ offset_result = pc.add(result, end - start)
+ result = pc.if_else(not_found, result, offset_result)
+ elif start == 0 and end is None:
+ slices = self._pa_array
+ result = pc.find_substring(slices, sub)
+ else:
+ return super()._str_find(sub, start, end)
+ return self._convert_int_dtype(result.to_numpy())
+
+ def _cmp_method(self, other, op):
+ result = super()._cmp_method(other, op)
+ return result.to_numpy(np.bool_, na_value=False)
+
+ def value_counts(self, dropna: bool = True):
+ from pandas import Series
+
+ result = super().value_counts(dropna)
+ return Series(
+ result._values.to_numpy(), index=result.index, name=result.name, copy=False
+ )
diff --git a/pandas/core/config_init.py b/pandas/core/config_init.py
index 27e9bf8958ab0..745689ab1fcc8 100644
--- a/pandas/core/config_init.py
+++ b/pandas/core/config_init.py
@@ -500,7 +500,7 @@ def use_inf_as_na_cb(key) -> None:
"string_storage",
"python",
string_storage_doc,
- validator=is_one_of_factory(["python", "pyarrow"]),
+ validator=is_one_of_factory(["python", "pyarrow", "pyarrow_numpy"]),
)
diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py
index becf9b47b3af1..124ca546c4583 100644
--- a/pandas/core/strings/accessor.py
+++ b/pandas/core/strings/accessor.py
@@ -145,7 +145,9 @@ def _map_and_wrap(name: str | None, docstring: str | None):
@forbid_nonstring_types(["bytes"], name=name)
def wrapper(self):
result = getattr(self._data.array, f"_str_{name}")()
- return self._wrap_result(result)
+ return self._wrap_result(
+ result, returns_string=name not in ("isnumeric", "isdecimal")
+ )
wrapper.__doc__ = docstring
return wrapper
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
index de93e89ecacd5..e29a72e1a5338 100644
--- a/pandas/tests/arrays/string_/test_string.py
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -5,12 +5,16 @@
import numpy as np
import pytest
+from pandas.compat.pyarrow import pa_version_under12p0
+
from pandas.core.dtypes.common import is_dtype_equal
import pandas as pd
import pandas._testing as tm
-from pandas.core.arrays.string_arrow import ArrowStringArray
-from pandas.util.version import Version
+from pandas.core.arrays.string_arrow import (
+ ArrowStringArray,
+ ArrowStringArrayNumpySemantics,
+)
@pytest.fixture
@@ -33,7 +37,12 @@ def test_repr(dtype):
expected = "0 a\n1 <NA>\n2 b\nName: A, dtype: string"
assert repr(df.A) == expected
- arr_name = "ArrowStringArray" if dtype.storage == "pyarrow" else "StringArray"
+ if dtype.storage == "pyarrow":
+ arr_name = "ArrowStringArray"
+ elif dtype.storage == "pyarrow_numpy":
+ arr_name = "ArrowStringArrayNumpySemantics"
+ else:
+ arr_name = "StringArray"
expected = f"<{arr_name}>\n['a', <NA>, 'b']\nLength: 3, dtype: string"
assert repr(df.A.array) == expected
@@ -195,19 +204,34 @@ def test_comparison_methods_scalar(comparison_op, dtype):
a = pd.array(["a", None, "c"], dtype=dtype)
other = "a"
result = getattr(a, op_name)(other)
- expected_dtype = "boolean[pyarrow]" if dtype.storage == "pyarrow" else "boolean"
- expected = np.array([getattr(item, op_name)(other) for item in a], dtype=object)
- expected = pd.array(expected, dtype=expected_dtype)
- tm.assert_extension_array_equal(result, expected)
+ if dtype.storage == "pyarrow_numpy":
+ expected = np.array([getattr(item, op_name)(other) for item in a], dtype=object)
+ expected = (
+ pd.array(expected, dtype="boolean")
+ .to_numpy(na_value=False)
+ .astype(np.bool_)
+ )
+ tm.assert_numpy_array_equal(result, expected)
+ else:
+ expected_dtype = "boolean[pyarrow]" if dtype.storage == "pyarrow" else "boolean"
+ expected = np.array([getattr(item, op_name)(other) for item in a], dtype=object)
+ expected = pd.array(expected, dtype=expected_dtype)
+ tm.assert_extension_array_equal(result, expected)
def test_comparison_methods_scalar_pd_na(comparison_op, dtype):
op_name = f"__{comparison_op.__name__}__"
a = pd.array(["a", None, "c"], dtype=dtype)
result = getattr(a, op_name)(pd.NA)
- expected_dtype = "boolean[pyarrow]" if dtype.storage == "pyarrow" else "boolean"
- expected = pd.array([None, None, None], dtype=expected_dtype)
- tm.assert_extension_array_equal(result, expected)
+
+ if dtype.storage == "pyarrow_numpy":
+ expected = np.array([False, False, False])
+ tm.assert_numpy_array_equal(result, expected)
+ else:
+ expected_dtype = "boolean[pyarrow]" if dtype.storage == "pyarrow" else "boolean"
+ expected = pd.array([None, None, None], dtype=expected_dtype)
+ tm.assert_extension_array_equal(result, expected)
+ tm.assert_extension_array_equal(result, expected)
def test_comparison_methods_scalar_not_string(comparison_op, dtype):
@@ -223,12 +247,21 @@ def test_comparison_methods_scalar_not_string(comparison_op, dtype):
return
result = getattr(a, op_name)(other)
- expected_data = {"__eq__": [False, None, False], "__ne__": [True, None, True]}[
- op_name
- ]
- expected_dtype = "boolean[pyarrow]" if dtype.storage == "pyarrow" else "boolean"
- expected = pd.array(expected_data, dtype=expected_dtype)
- tm.assert_extension_array_equal(result, expected)
+
+ if dtype.storage == "pyarrow_numpy":
+ expected_data = {
+ "__eq__": [False, False, False],
+ "__ne__": [True, False, True],
+ }[op_name]
+ expected = np.array(expected_data)
+ tm.assert_numpy_array_equal(result, expected)
+ else:
+ expected_data = {"__eq__": [False, None, False], "__ne__": [True, None, True]}[
+ op_name
+ ]
+ expected_dtype = "boolean[pyarrow]" if dtype.storage == "pyarrow" else "boolean"
+ expected = pd.array(expected_data, dtype=expected_dtype)
+ tm.assert_extension_array_equal(result, expected)
def test_comparison_methods_array(comparison_op, dtype):
@@ -237,15 +270,25 @@ def test_comparison_methods_array(comparison_op, dtype):
a = pd.array(["a", None, "c"], dtype=dtype)
other = [None, None, "c"]
result = getattr(a, op_name)(other)
- expected_dtype = "boolean[pyarrow]" if dtype.storage == "pyarrow" else "boolean"
- expected = np.full(len(a), fill_value=None, dtype="object")
- expected[-1] = getattr(other[-1], op_name)(a[-1])
- expected = pd.array(expected, dtype=expected_dtype)
- tm.assert_extension_array_equal(result, expected)
+ if dtype.storage == "pyarrow_numpy":
+ expected = np.array([False, False, False])
+ expected[-1] = getattr(other[-1], op_name)(a[-1])
+ tm.assert_numpy_array_equal(result, expected)
- result = getattr(a, op_name)(pd.NA)
- expected = pd.array([None, None, None], dtype=expected_dtype)
- tm.assert_extension_array_equal(result, expected)
+ result = getattr(a, op_name)(pd.NA)
+ expected = np.array([False, False, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ else:
+ expected_dtype = "boolean[pyarrow]" if dtype.storage == "pyarrow" else "boolean"
+ expected = np.full(len(a), fill_value=None, dtype="object")
+ expected[-1] = getattr(other[-1], op_name)(a[-1])
+ expected = pd.array(expected, dtype=expected_dtype)
+ tm.assert_extension_array_equal(result, expected)
+
+ result = getattr(a, op_name)(pd.NA)
+ expected = pd.array([None, None, None], dtype=expected_dtype)
+ tm.assert_extension_array_equal(result, expected)
def test_constructor_raises(cls):
@@ -297,7 +340,7 @@ def test_from_sequence_no_mutate(copy, cls, request):
result = cls._from_sequence(nan_arr, copy=copy)
- if cls is ArrowStringArray:
+ if cls in (ArrowStringArray, ArrowStringArrayNumpySemantics):
import pyarrow as pa
expected = cls(pa.array(na_arr, type=pa.string(), from_pandas=True))
@@ -412,7 +455,7 @@ def test_arrow_array(dtype):
data = pd.array(["a", "b", "c"], dtype=dtype)
arr = pa.array(data)
expected = pa.array(list(data), type=pa.string(), from_pandas=True)
- if dtype.storage == "pyarrow" and Version(pa.__version__) <= Version("11.0.0"):
+ if dtype.storage in ("pyarrow", "pyarrow_numpy") and pa_version_under12p0:
expected = pa.chunked_array(expected)
assert arr.equals(expected)
@@ -455,6 +498,8 @@ def test_arrow_load_from_zero_chunks(dtype, string_storage2):
def test_value_counts_na(dtype):
if getattr(dtype, "storage", "") == "pyarrow":
exp_dtype = "int64[pyarrow]"
+ elif getattr(dtype, "storage", "") == "pyarrow_numpy":
+ exp_dtype = "int64"
else:
exp_dtype = "Int64"
arr = pd.array(["a", "b", "a", pd.NA], dtype=dtype)
@@ -470,6 +515,8 @@ def test_value_counts_na(dtype):
def test_value_counts_with_normalize(dtype):
if getattr(dtype, "storage", "") == "pyarrow":
exp_dtype = "double[pyarrow]"
+ elif getattr(dtype, "storage", "") == "pyarrow_numpy":
+ exp_dtype = np.float64
else:
exp_dtype = "Float64"
ser = pd.Series(["a", "b", "a", pd.NA], dtype=dtype)
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 9eee2e0bea687..20530e37116f2 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -324,7 +324,12 @@ def test_searchsorted_castable_strings(self, arr1d, box, string_storage):
):
arr.searchsorted("foo")
- arr_type = "StringArray" if string_storage == "python" else "ArrowStringArray"
+ if string_storage == "python":
+ arr_type = "StringArray"
+ elif string_storage == "pyarrow":
+ arr_type = "ArrowStringArray"
+ else:
+ arr_type = "ArrowStringArrayNumpySemantics"
with pd.option_context("string_storage", string_storage):
with pytest.raises(
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index 2dd62a4ca7538..16059155a7a8f 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -70,6 +70,9 @@ def test_value_counts_with_normalize(self, data):
):
# TODO: avoid special-casing
expected = expected.astype("double[pyarrow]")
+ elif getattr(data.dtype, "storage", "") == "pyarrow_numpy":
+ # TODO: avoid special-casing
+ expected = expected.astype("float64")
elif na_value_for_dtype(data.dtype) is pd.NA:
# TODO(GH#44692): avoid special-casing
expected = expected.astype("Float64")
diff --git a/pandas/tests/extension/test_string.py b/pandas/tests/extension/test_string.py
index 4e142eb6e14b8..069d53aeb248f 100644
--- a/pandas/tests/extension/test_string.py
+++ b/pandas/tests/extension/test_string.py
@@ -184,6 +184,8 @@ def _cast_pointwise_result(self, op_name: str, obj, other, pointwise_result):
# attribute "storage"
if dtype.storage == "pyarrow": # type: ignore[union-attr]
cast_to = "boolean[pyarrow]"
+ elif dtype.storage == "pyarrow_numpy": # type: ignore[union-attr]
+ cast_to = np.bool_ # type: ignore[assignment]
else:
cast_to = "boolean"
return pointwise_result.astype(cast_to)
diff --git a/pandas/tests/io/conftest.py b/pandas/tests/io/conftest.py
index 170e2f61e7d4a..701bfe3767db4 100644
--- a/pandas/tests/io/conftest.py
+++ b/pandas/tests/io/conftest.py
@@ -234,3 +234,19 @@ def compression_format(request):
@pytest.fixture(params=_compression_formats_params)
def compression_ext(request):
return request.param[0]
+
+
+@pytest.fixture(
+ params=[
+ "python",
+ pytest.param("pyarrow", marks=td.skip_if_no("pyarrow")),
+ ]
+)
+def string_storage(request):
+ """
+ Parametrized fixture for pd.options.mode.string_storage.
+
+ * 'python'
+ * 'pyarrow'
+ """
+ return request.param
diff --git a/pandas/tests/strings/__init__.py b/pandas/tests/strings/__init__.py
index 496a2d095d85b..bf119f2721ed4 100644
--- a/pandas/tests/strings/__init__.py
+++ b/pandas/tests/strings/__init__.py
@@ -2,7 +2,7 @@
import pandas as pd
-object_pyarrow_numpy = ("object",)
+object_pyarrow_numpy = ("object", "string[pyarrow_numpy]")
def _convert_na_value(ser, expected):
diff --git a/pandas/tests/strings/test_case_justify.py b/pandas/tests/strings/test_case_justify.py
index ced941187f548..1dee25e631648 100644
--- a/pandas/tests/strings/test_case_justify.py
+++ b/pandas/tests/strings/test_case_justify.py
@@ -278,6 +278,11 @@ def test_center_ljust_rjust_mixed_object():
def test_center_ljust_rjust_fillchar(any_string_dtype):
+ if any_string_dtype == "string[pyarrow_numpy]":
+ pytest.skip(
+ "Arrow logic is different, "
+ "see https://github.com/pandas-dev/pandas/pull/54533/files#r1299808126",
+ )
s = Series(["a", "bb", "cccc", "ddddd", "eeeeee"], dtype=any_string_dtype)
result = s.str.center(5, fillchar="X")
diff --git a/pandas/tests/strings/test_find_replace.py b/pandas/tests/strings/test_find_replace.py
index d5017b1c47d85..78f0730d730e8 100644
--- a/pandas/tests/strings/test_find_replace.py
+++ b/pandas/tests/strings/test_find_replace.py
@@ -22,7 +22,7 @@
def using_pyarrow(dtype):
- return dtype in ("string[pyarrow]",)
+ return dtype in ("string[pyarrow]", "string[pyarrow_numpy]")
def test_contains(any_string_dtype):
@@ -223,6 +223,8 @@ def test_contains_nan(any_string_dtype):
result = s.str.contains("foo", na="foo")
if any_string_dtype == "object":
expected = Series(["foo", "foo", "foo"], dtype=np.object_)
+ elif any_string_dtype == "string[pyarrow_numpy]":
+ expected = Series([True, True, True], dtype=np.bool_)
else:
expected = Series([True, True, True], dtype="boolean")
tm.assert_series_equal(result, expected)
@@ -807,7 +809,7 @@ def test_find(any_string_dtype):
ser = Series(
["ABCDEFG", "BCDEFEF", "DEFGHIJEF", "EFGHEF", "XXXX"], dtype=any_string_dtype
)
- expected_dtype = np.int64 if any_string_dtype == "object" else "Int64"
+ expected_dtype = np.int64 if any_string_dtype in object_pyarrow_numpy else "Int64"
result = ser.str.find("EF")
expected = Series([4, 3, 1, 0, -1], dtype=expected_dtype)
| Backport PR #54533: Implement Arrow String Array that is compatible with NumPy semantics | https://api.github.com/repos/pandas-dev/pandas/pulls/54713 | 2023-08-23T16:46:02Z | 2023-08-23T21:09:24Z | 2023-08-23T21:09:24Z | 2023-08-23T21:09:24Z |
Backport PR #54707 on branch 2.1.x (BUG: ArrowExtensionArray.fillna with duration types) | diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 48ff769f6c737..4ba0e70393efb 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -381,8 +381,7 @@ def _box_pa_scalar(cls, value, pa_type: pa.DataType | None = None) -> pa.Scalar:
elif isna(value):
pa_scalar = pa.scalar(None, type=pa_type)
else:
- # GH 53171: pyarrow does not yet handle pandas non-nano correctly
- # see https://github.com/apache/arrow/issues/33321
+ # Workaround https://github.com/apache/arrow/issues/37291
if isinstance(value, Timedelta):
if pa_type is None:
pa_type = pa.duration(value.unit)
@@ -448,8 +447,7 @@ def _box_pa_array(
and pa.types.is_duration(pa_type)
and (not isinstance(value, np.ndarray) or value.dtype.kind not in "mi")
):
- # GH 53171: pyarrow does not yet handle pandas non-nano correctly
- # see https://github.com/apache/arrow/issues/33321
+ # Workaround https://github.com/apache/arrow/issues/37291
from pandas.core.tools.timedeltas import to_timedelta
value = to_timedelta(value, unit=pa_type.unit).as_unit(pa_type.unit)
@@ -462,8 +460,7 @@ def _box_pa_array(
pa_array = pa.array(value, from_pandas=True)
if pa_type is None and pa.types.is_duration(pa_array.type):
- # GH 53171: pyarrow does not yet handle pandas non-nano correctly
- # see https://github.com/apache/arrow/issues/33321
+ # Workaround https://github.com/apache/arrow/issues/37291
from pandas.core.tools.timedeltas import to_timedelta
value = to_timedelta(value)
@@ -965,26 +962,11 @@ def fillna(
f" expected {len(self)}"
)
- def convert_fill_value(value, pa_type, dtype):
- if value is None:
- return value
- if isinstance(value, (pa.Scalar, pa.Array, pa.ChunkedArray)):
- return value
- if isinstance(value, Timedelta) and value.unit in ("s", "ms"):
- # Workaround https://github.com/apache/arrow/issues/37291
- value = value.to_numpy()
- if is_array_like(value):
- pa_box = pa.array
- else:
- pa_box = pa.scalar
- try:
- value = pa_box(value, type=pa_type, from_pandas=True)
- except pa.ArrowTypeError as err:
- msg = f"Invalid value '{str(value)}' for dtype {dtype}"
- raise TypeError(msg) from err
- return value
-
- fill_value = convert_fill_value(value, self._pa_array.type, self.dtype)
+ try:
+ fill_value = self._box_pa(value, pa_type=self._pa_array.type)
+ except pa.ArrowTypeError as err:
+ msg = f"Invalid value '{str(value)}' for dtype {self.dtype}"
+ raise TypeError(msg) from err
try:
if method is None:
diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
index a9b7a8c655032..86a7f20214a9a 100644
--- a/pandas/tests/extension/test_arrow.py
+++ b/pandas/tests/extension/test_arrow.py
@@ -3049,3 +3049,13 @@ def test_arrowextensiondtype_dataframe_repr():
# pyarrow.ExtensionType values are displayed
expected = " col\n0 15340\n1 15341\n2 15342"
assert result == expected
+
+
+@pytest.mark.parametrize("pa_type", tm.TIMEDELTA_PYARROW_DTYPES)
+def test_duration_fillna_numpy(pa_type):
+ # GH 54707
+ ser1 = pd.Series([None, 2], dtype=ArrowDtype(pa_type))
+ ser2 = pd.Series(np.array([1, 3], dtype=f"m8[{pa_type.unit}]"))
+ result = ser1.fillna(ser2)
+ expected = pd.Series([1, 2], dtype=ArrowDtype(pa_type))
+ tm.assert_series_equal(result, expected)
| Backport PR #54707: BUG: ArrowExtensionArray.fillna with duration types | https://api.github.com/repos/pandas-dev/pandas/pulls/54711 | 2023-08-23T15:42:30Z | 2023-08-23T18:39:10Z | 2023-08-23T18:39:10Z | 2023-08-23T18:39:10Z |
DEPR: downcasting in replace | diff --git a/doc/source/user_guide/missing_data.rst b/doc/source/user_guide/missing_data.rst
index e0e752099b77a..4a2aa565dd15c 100644
--- a/doc/source/user_guide/missing_data.rst
+++ b/doc/source/user_guide/missing_data.rst
@@ -401,7 +401,7 @@ Limit the number of NA values filled
df.ffill(limit=1)
-NA values can be replaced with corresponding value from a :class:`Series`` or :class:`DataFrame``
+NA values can be replaced with corresponding value from a :class:`Series` or :class:`DataFrame`
where the index and column aligns between the original object and the filled object.
.. ipython:: python
@@ -660,7 +660,7 @@ Pass a list of regular expressions that will replace matches with a scalar.
.. ipython:: python
- df.replace([r"\s*\.\s*", r"a|b"], np.nan, regex=True)
+ df.replace([r"\s*\.\s*", r"a|b"], "placeholder", regex=True)
All of the regular expression examples can also be passed with the
``to_replace`` argument as the ``regex`` argument. In this case the ``value``
@@ -669,7 +669,7 @@ dictionary.
.. ipython:: python
- df.replace(regex=[r"\s*\.\s*", r"a|b"], value=np.nan)
+ df.replace(regex=[r"\s*\.\s*", r"a|b"], value="placeholder")
.. note::
diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 54e855f61905a..dec6638a239a4 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -162,7 +162,8 @@ Deprecations
- 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 downcasting behavior in :meth:`Series.where`, :meth:`DataFrame.where`, :meth:`Series.mask`, :meth:`DataFrame.mask`, :meth:`Series.clip`, :meth:`DataFrame.clip`; in a future version these will not infer object-dtype columns to non-object dtype, or all-round floats to integer dtype. Call ``result.infer_objects(copy=False)`` on the result for object inference, or explicitly cast floats to ints. To opt in to the future version, use ``pd.set_option("future.downcasting", True)`` (:issue:`53656`)
+- Deprecated automatic downcasting of object-dtype results in :meth:`Series.replace` and :meth:`DataFrame.replace`, explicitly call ``result = result.infer_objects(copy=False)`` instead. To opt in to the future version, use ``pd.set_option("future.no_silent_downcasting", True)`` (:issue:`54710`)
+- Deprecated downcasting behavior in :meth:`Series.where`, :meth:`DataFrame.where`, :meth:`Series.mask`, :meth:`DataFrame.mask`, :meth:`Series.clip`, :meth:`DataFrame.clip`; in a future version these will not infer object-dtype columns to non-object dtype, or all-round floats to integer dtype. Call ``result.infer_objects(copy=False)`` on the result for object inference, or explicitly cast floats to ints. To opt in to the future version, use ``pd.set_option("future.no_silent_downcasting", True)`` (:issue:`53656`)
- Deprecated including the groups in computations when using :meth:`DataFrameGroupBy.apply` and :meth:`DataFrameGroupBy.resample`; pass ``include_groups=False`` to exclude the groups (:issue:`7155`)
- Deprecated not passing a tuple to :class:`DataFrameGroupBy.get_group` or :class:`SeriesGroupBy.get_group` when grouping by a length-1 list-like (:issue:`25971`)
- Deprecated strings ``S``, ``U``, and ``N`` denoting units in :func:`to_timedelta` (:issue:`52536`)
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 6399f85723ae5..57833c1d626ee 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -761,7 +761,23 @@ def replace(
if not (self.is_object and value is None):
# if the user *explicitly* gave None, we keep None, otherwise
# may downcast to NaN
- blocks = blk.convert(copy=False, using_cow=using_cow)
+ if get_option("future.no_silent_downcasting") is True:
+ blocks = [blk]
+ else:
+ blocks = blk.convert(copy=False, using_cow=using_cow)
+ 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
@@ -836,7 +852,21 @@ def _replace_regex(
replace_regex(block.values, rx, value, mask)
- return block.convert(copy=False, using_cow=using_cow)
+ nbs = block.convert(copy=False, using_cow=using_cow)
+ 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
@final
def replace_list(
@@ -902,6 +932,7 @@ def replace_list(
else:
rb = [self if inplace else self.copy()]
+ 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] = []
@@ -939,14 +970,33 @@ def replace_list(
b.refs.referenced_blocks.index(ref)
)
- if convert and blk.is_object and not all(x is None for x in dest_list):
+ 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
- result = extend_blocks(
- [
- b.convert(copy=True and not using_cow, using_cow=using_cow)
- for b in result
- ]
- )
+ nbs = []
+ for res_blk in result:
+ converted = res_blk.convert(
+ copy=True and not using_cow, using_cow=using_cow
+ )
+ 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
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index 61e44b4e24c08..f07c53060a06b 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -289,7 +289,9 @@ def test_regex_replace_dict_nested_non_first_character(self, any_string_dtype):
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})
- result = df.replace({"Type": {"Q": 0, "T": 1}})
+ msg = "Downcasting behavior in `replace`"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ result = df.replace({"Type": {"Q": 0, "T": 1}})
tm.assert_frame_equal(result, expected)
def test_regex_replace_list_to_scalar(self, mix_abc):
@@ -301,16 +303,20 @@ def test_regex_replace_list_to_scalar(self, mix_abc):
"c": [np.nan, np.nan, np.nan, "d"],
}
)
- res = df.replace([r"\s*\.\s*", "a|b"], np.nan, regex=True)
+ 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)
res2 = df.copy()
res3 = df.copy()
- return_value = res2.replace(
- [r"\s*\.\s*", "a|b"], np.nan, regex=True, inplace=True
- )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ return_value = res2.replace(
+ [r"\s*\.\s*", "a|b"], np.nan, regex=True, inplace=True
+ )
assert return_value is None
- return_value = res3.replace(
- regex=[r"\s*\.\s*", "a|b"], value=np.nan, inplace=True
- )
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ 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)
@@ -520,7 +526,9 @@ def test_replace_convert(self):
# gh 3907
df = DataFrame([["foo", "bar", "bah"], ["bar", "foo", "bah"]])
m = {"foo": 1, "bar": 2, "bah": 3}
- rep = df.replace(m)
+ msg = "Downcasting behavior in `replace` "
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ rep = df.replace(m)
expec = Series([np.int64] * 3)
res = rep.dtypes
tm.assert_series_equal(expec, res)
@@ -838,7 +846,12 @@ def test_replace_for_new_dtypes(self, datetime_frame):
],
)
def test_replace_dtypes(self, frame, to_replace, value, expected):
- result = frame.replace(to_replace, value)
+ 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)
tm.assert_frame_equal(result, expected)
def test_replace_input_formats_listlike(self):
@@ -927,7 +940,9 @@ def test_replace_dict_no_regex(self):
"Strongly Disagree": 1,
}
expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1})
- result = answer.replace(weights)
+ msg = "Downcasting behavior in `replace` "
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ result = answer.replace(weights)
tm.assert_series_equal(result, expected)
def test_replace_series_no_regex(self):
@@ -950,7 +965,9 @@ def test_replace_series_no_regex(self):
}
)
expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1})
- result = answer.replace(weights)
+ msg = "Downcasting behavior in `replace` "
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ result = answer.replace(weights)
tm.assert_series_equal(result, expected)
def test_replace_dict_tuple_list_ordering_remains_the_same(self):
@@ -1076,7 +1093,9 @@ def test_replace_period(self):
expected = DataFrame({"fname": [d["fname"][k] for k in df.fname.values]})
assert expected.dtypes.iloc[0] == "Period[M]"
- result = df.replace(d)
+ 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_datetime(self):
@@ -1106,7 +1125,9 @@ def test_replace_datetime(self):
)
assert set(df.fname.values) == set(d["fname"].keys())
expected = DataFrame({"fname": [d["fname"][k] for k in df.fname.values]})
- result = df.replace(d)
+ 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):
@@ -1307,10 +1328,12 @@ def test_replace_commutative(self, df, to_replace, exp):
np.float64(1),
],
)
- def test_replace_replacer_dtype(self, request, replacer):
+ def test_replace_replacer_dtype(self, replacer):
# GH26632
df = DataFrame(["a"])
- result = df.replace({"a": replacer, "b": replacer})
+ msg = "Downcasting behavior in `replace` "
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ result = df.replace({"a": replacer, "b": replacer})
expected = DataFrame([replacer])
tm.assert_frame_equal(result, expected)
@@ -1564,12 +1587,15 @@ def test_replace_regex_dtype_frame(self, regex):
# GH-48644
df1 = DataFrame({"A": ["0"], "B": ["0"]})
expected_df1 = DataFrame({"A": [1], "B": [1]})
- result_df1 = df1.replace(to_replace="0", value=1, regex=regex)
+ msg = "Downcasting behavior in `replace`"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ 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"]})
- result_df2 = df2.replace(to_replace="0", value=1, regex=regex)
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ 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/indexing/test_coercion.py b/pandas/tests/indexing/test_coercion.py
index 2c39729097487..82368c67dc6d4 100644
--- a/pandas/tests/indexing/test_coercion.py
+++ b/pandas/tests/indexing/test_coercion.py
@@ -836,8 +836,6 @@ def test_replace_series(self, how, to_key, from_key, replacer):
# tested below
return
- result = obj.replace(replacer)
-
if (from_key == "float64" and to_key in ("int64")) or (
from_key == "complex128" and to_key in ("int64", "float64")
):
@@ -851,6 +849,17 @@ 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)
@pytest.mark.parametrize(
@@ -866,11 +875,14 @@ def test_replace_series_datetime_tz(self, how, to_key, from_key, replacer):
obj = pd.Series(self.rep[from_key], index=index, name="yyy")
assert obj.dtype == from_key
- result = obj.replace(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 != object else None
+ with tm.assert_produces_warning(warn, match=msg):
+ result = obj.replace(replacer)
+
tm.assert_series_equal(result, exp)
@pytest.mark.parametrize(
@@ -888,16 +900,22 @@ def test_replace_series_datetime_datetime(self, how, to_key, from_key, replacer)
obj = pd.Series(self.rep[from_key], index=index, name="yyy")
assert obj.dtype == from_key
- result = obj.replace(replacer)
-
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)
diff --git a/pandas/tests/io/excel/test_writers.py b/pandas/tests/io/excel/test_writers.py
index 9cbb29605a1ec..c54d06b6ab4ce 100644
--- a/pandas/tests/io/excel/test_writers.py
+++ b/pandas/tests/io/excel/test_writers.py
@@ -1197,7 +1197,9 @@ def test_render_as_column_name(self, path):
def test_true_and_false_value_options(self, path):
# see gh-13347
df = DataFrame([["foo", "bar"]], columns=["col1", "col2"])
- expected = df.replace({"foo": True, "bar": False})
+ msg = "Downcasting behavior in `replace`"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ expected = df.replace({"foo": True, "bar": False})
df.to_excel(path)
read_frame = pd.read_excel(
diff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py
index ec9db8c3830d6..f08966c3816c0 100644
--- a/pandas/tests/series/methods/test_replace.py
+++ b/pandas/tests/series/methods/test_replace.py
@@ -76,7 +76,9 @@ def test_replace(self):
ser[20:30] = "bar"
# replace list with a single value
- rs = ser.replace([np.nan, "foo", "bar"], -1)
+ msg = "Downcasting behavior in `replace`"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ rs = ser.replace([np.nan, "foo", "bar"], -1)
assert (rs[:5] == -1).all()
assert (rs[6:10] == -1).all()
@@ -84,7 +86,8 @@ def test_replace(self):
assert (pd.isna(ser[:5])).all()
# replace with different values
- rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
assert (rs[:5] == -1).all()
assert (rs[6:10] == -2).all()
@@ -92,11 +95,13 @@ def test_replace(self):
assert (pd.isna(ser[:5])).all()
# replace with different values with 2 lists
- rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
tm.assert_series_equal(rs, rs2)
# replace inplace
- return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
assert return_value is None
assert (ser[:5] == -1).all()
@@ -294,7 +299,9 @@ def test_replace2(self):
ser[20:30] = "bar"
# replace list with a single value
- rs = ser.replace([np.nan, "foo", "bar"], -1)
+ msg = "Downcasting behavior in `replace`"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ rs = ser.replace([np.nan, "foo", "bar"], -1)
assert (rs[:5] == -1).all()
assert (rs[6:10] == -1).all()
@@ -302,7 +309,8 @@ def test_replace2(self):
assert (pd.isna(ser[:5])).all()
# replace with different values
- rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
assert (rs[:5] == -1).all()
assert (rs[6:10] == -2).all()
@@ -310,11 +318,13 @@ def test_replace2(self):
assert (pd.isna(ser[:5])).all()
# replace with different values with 2 lists
- rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
tm.assert_series_equal(rs, rs2)
# replace inplace
- return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ 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()
@@ -373,7 +383,9 @@ 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])
- result = s.replace([2, "4"], np.nan)
+ 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])
tm.assert_series_equal(expected, result)
@@ -387,7 +399,9 @@ def test_replace_mixed_types_with_string(self):
def test_replace_categorical(self, categorical, numeric):
# GH 24971, GH#23305
ser = pd.Series(categorical)
- result = ser.replace({"A": 1, "B": 2})
+ msg = "Downcasting behavior in `replace`"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ result = ser.replace({"A": 1, "B": 2})
expected = pd.Series(numeric).astype("category")
if 2 not in expected.cat.categories:
# i.e. categories should be [1, 2] even if there are no "B"s present
@@ -710,7 +724,9 @@ def test_replace_regex_dtype_series(self, regex):
# GH-48644
series = pd.Series(["0"])
expected = pd.Series([1])
- result = series.replace(to_replace="0", value=1, regex=regex)
+ msg = "Downcasting behavior in `replace`"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ 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):
| - [ ] 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).
- [ ] 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/54710 | 2023-08-23T15:32:08Z | 2023-09-18T17:20:39Z | 2023-09-18T17:20:38Z | 2023-09-18T17:44:11Z |
BUG: ArrowExtensionArray.fillna with duration types | diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 48ff769f6c737..4ba0e70393efb 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -381,8 +381,7 @@ def _box_pa_scalar(cls, value, pa_type: pa.DataType | None = None) -> pa.Scalar:
elif isna(value):
pa_scalar = pa.scalar(None, type=pa_type)
else:
- # GH 53171: pyarrow does not yet handle pandas non-nano correctly
- # see https://github.com/apache/arrow/issues/33321
+ # Workaround https://github.com/apache/arrow/issues/37291
if isinstance(value, Timedelta):
if pa_type is None:
pa_type = pa.duration(value.unit)
@@ -448,8 +447,7 @@ def _box_pa_array(
and pa.types.is_duration(pa_type)
and (not isinstance(value, np.ndarray) or value.dtype.kind not in "mi")
):
- # GH 53171: pyarrow does not yet handle pandas non-nano correctly
- # see https://github.com/apache/arrow/issues/33321
+ # Workaround https://github.com/apache/arrow/issues/37291
from pandas.core.tools.timedeltas import to_timedelta
value = to_timedelta(value, unit=pa_type.unit).as_unit(pa_type.unit)
@@ -462,8 +460,7 @@ def _box_pa_array(
pa_array = pa.array(value, from_pandas=True)
if pa_type is None and pa.types.is_duration(pa_array.type):
- # GH 53171: pyarrow does not yet handle pandas non-nano correctly
- # see https://github.com/apache/arrow/issues/33321
+ # Workaround https://github.com/apache/arrow/issues/37291
from pandas.core.tools.timedeltas import to_timedelta
value = to_timedelta(value)
@@ -965,26 +962,11 @@ def fillna(
f" expected {len(self)}"
)
- def convert_fill_value(value, pa_type, dtype):
- if value is None:
- return value
- if isinstance(value, (pa.Scalar, pa.Array, pa.ChunkedArray)):
- return value
- if isinstance(value, Timedelta) and value.unit in ("s", "ms"):
- # Workaround https://github.com/apache/arrow/issues/37291
- value = value.to_numpy()
- if is_array_like(value):
- pa_box = pa.array
- else:
- pa_box = pa.scalar
- try:
- value = pa_box(value, type=pa_type, from_pandas=True)
- except pa.ArrowTypeError as err:
- msg = f"Invalid value '{str(value)}' for dtype {dtype}"
- raise TypeError(msg) from err
- return value
-
- fill_value = convert_fill_value(value, self._pa_array.type, self.dtype)
+ try:
+ fill_value = self._box_pa(value, pa_type=self._pa_array.type)
+ except pa.ArrowTypeError as err:
+ msg = f"Invalid value '{str(value)}' for dtype {self.dtype}"
+ raise TypeError(msg) from err
try:
if method is None:
diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
index f9c420607812c..890ffd6dfbdd9 100644
--- a/pandas/tests/extension/test_arrow.py
+++ b/pandas/tests/extension/test_arrow.py
@@ -2997,3 +2997,13 @@ def test_arrowextensiondtype_dataframe_repr():
# pyarrow.ExtensionType values are displayed
expected = " col\n0 15340\n1 15341\n2 15342"
assert result == expected
+
+
+@pytest.mark.parametrize("pa_type", tm.TIMEDELTA_PYARROW_DTYPES)
+def test_duration_fillna_numpy(pa_type):
+ # GH 54707
+ ser1 = pd.Series([None, 2], dtype=ArrowDtype(pa_type))
+ ser2 = pd.Series(np.array([1, 3], dtype=f"m8[{pa_type.unit}]"))
+ result = ser1.fillna(ser2)
+ expected = pd.Series([1, 2], dtype=ArrowDtype(pa_type))
+ tm.assert_series_equal(result, expected)
| - [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.
cc @mroeschke - this expands on #54678 to cover a few more cases.
| https://api.github.com/repos/pandas-dev/pandas/pulls/54707 | 2023-08-23T10:29:28Z | 2023-08-23T15:37:37Z | 2023-08-23T15:37:37Z | 2023-09-06T00:53:59Z |
DOC: updated date_format description for read_csv | diff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py
index f01595a684344..10d3ab230cb9d 100644
--- a/pandas/io/parsers/readers.py
+++ b/pandas/io/parsers/readers.py
@@ -280,11 +280,20 @@
Use ``date_format`` instead, or read in as ``object`` and then apply
:func:`~pandas.to_datetime` as-needed.
date_format : str or dict of column -> format, optional
- Format to use for parsing dates when used in conjunction with ``parse_dates``.
- For anything more complex, please read in as ``object`` and then apply
- :func:`~pandas.to_datetime` as-needed.
-
- .. versionadded:: 2.0.0
+ Format to use for parsing dates when used in conjunction with ``parse_dates``.
+ The strftime to parse time, e.g. :const:`"%d/%m/%Y"`. See
+ `strftime documentation
+ <https://docs.python.org/3/library/datetime.html
+ #strftime-and-strptime-behavior>`_ for more information on choices, though
+ note that :const:`"%f"` will parse all the way up to nanoseconds.
+ You can also pass:
+
+ - "ISO8601", to parse any `ISO8601 <https://en.wikipedia.org/wiki/ISO_8601>`_
+ time string (not necessarily in exactly the same format);
+ - "mixed", to infer the format for each element individually. This is risky,
+ and you should probably use it along with `dayfirst`.
+
+ .. versionadded:: 2.0.0
dayfirst : bool, default False
DD/MM format dates, international and European format.
cache_dates : bool, default True
| - [x] closes #54285
- [ ] [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). | https://api.github.com/repos/pandas-dev/pandas/pulls/54705 | 2023-08-23T06:59:08Z | 2023-08-23T15:50:25Z | 2023-08-23T15:50:25Z | 2023-08-24T05:43:24Z |
DEPR: deprecated nonkeyword arguments in to_gbq | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index a9522a09d73be..f03a091541d03 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -134,6 +134,7 @@ Deprecations
- 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_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`)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index c52f9cae78c91..e9d8ba6aab4a8 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -2048,6 +2048,9 @@ def to_dict(
return to_dict(self, orient, into, index)
+ @deprecate_nonkeyword_arguments(
+ version="3.0", allowed_args=["self", "destination_table"], name="to_gbq"
+ )
def to_gbq(
self,
destination_table: str,
| - [x] xref #54229
- [ ] [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 an entry in the latest `doc/source/whatsnew/v2.2.0.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/54704 | 2023-08-23T06:18:06Z | 2023-08-23T15:45:50Z | 2023-08-23T15:45:49Z | 2023-08-23T15:53:28Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.