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 |
|---|---|---|---|---|---|---|---|
BUG: Bug in fillna with method = bfill/ffill and datetime64[ns] dtype (GH6587) | diff --git a/doc/source/release.rst b/doc/source/release.rst
index 5c7d090becf83..b161d1f785114 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -225,6 +225,7 @@ Bug Fixes
- Bug in indexing: empty list lookup caused ``IndexError`` exceptions (:issue:`6536`, :issue:`6551`)
- Series.quantile raising on an ``object`` dtype (:issue:`6555`)
- Bug in ``.xs`` with a ``nan`` in level when dropped (:issue:`6574`)
+- Bug in fillna with method = 'bfill/ffill' and ``datetime64[ns]`` dtype (:issue:`6587`)
pandas 0.13.1
-------------
diff --git a/pandas/core/common.py b/pandas/core/common.py
index eb3c159ae916d..60a533db01f7f 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -1244,13 +1244,14 @@ def wrapper(arr, mask, limit=None):
np.int64)
-def pad_1d(values, limit=None, mask=None):
+def pad_1d(values, limit=None, mask=None, dtype=None):
- dtype = values.dtype.name
+ if dtype is None:
+ dtype = values.dtype
_method = None
if is_float_dtype(values):
- _method = getattr(algos, 'pad_inplace_%s' % dtype, None)
- elif is_datetime64_dtype(values):
+ _method = getattr(algos, 'pad_inplace_%s' % dtype.name, None)
+ elif dtype in _DATELIKE_DTYPES or is_datetime64_dtype(values):
_method = _pad_1d_datetime
elif is_integer_dtype(values):
values = _ensure_float64(values)
@@ -1259,7 +1260,7 @@ def pad_1d(values, limit=None, mask=None):
_method = algos.pad_inplace_object
if _method is None:
- raise ValueError('Invalid dtype for pad_1d [%s]' % dtype)
+ raise ValueError('Invalid dtype for pad_1d [%s]' % dtype.name)
if mask is None:
mask = isnull(values)
@@ -1268,13 +1269,14 @@ def pad_1d(values, limit=None, mask=None):
return values
-def backfill_1d(values, limit=None, mask=None):
+def backfill_1d(values, limit=None, mask=None, dtype=None):
- dtype = values.dtype.name
+ if dtype is None:
+ dtype = values.dtype
_method = None
if is_float_dtype(values):
- _method = getattr(algos, 'backfill_inplace_%s' % dtype, None)
- elif is_datetime64_dtype(values):
+ _method = getattr(algos, 'backfill_inplace_%s' % dtype.name, None)
+ elif dtype in _DATELIKE_DTYPES or is_datetime64_dtype(values):
_method = _backfill_1d_datetime
elif is_integer_dtype(values):
values = _ensure_float64(values)
@@ -1283,7 +1285,7 @@ def backfill_1d(values, limit=None, mask=None):
_method = algos.backfill_inplace_object
if _method is None:
- raise ValueError('Invalid dtype for backfill_1d [%s]' % dtype)
+ raise ValueError('Invalid dtype for backfill_1d [%s]' % dtype.name)
if mask is None:
mask = isnull(values)
@@ -1293,13 +1295,14 @@ def backfill_1d(values, limit=None, mask=None):
return values
-def pad_2d(values, limit=None, mask=None):
+def pad_2d(values, limit=None, mask=None, dtype=None):
- dtype = values.dtype.name
+ if dtype is None:
+ dtype = values.dtype
_method = None
if is_float_dtype(values):
- _method = getattr(algos, 'pad_2d_inplace_%s' % dtype, None)
- elif is_datetime64_dtype(values):
+ _method = getattr(algos, 'pad_2d_inplace_%s' % dtype.name, None)
+ elif dtype in _DATELIKE_DTYPES or is_datetime64_dtype(values):
_method = _pad_2d_datetime
elif is_integer_dtype(values):
values = _ensure_float64(values)
@@ -1308,7 +1311,7 @@ def pad_2d(values, limit=None, mask=None):
_method = algos.pad_2d_inplace_object
if _method is None:
- raise ValueError('Invalid dtype for pad_2d [%s]' % dtype)
+ raise ValueError('Invalid dtype for pad_2d [%s]' % dtype.name)
if mask is None:
mask = isnull(values)
@@ -1322,13 +1325,14 @@ def pad_2d(values, limit=None, mask=None):
return values
-def backfill_2d(values, limit=None, mask=None):
+def backfill_2d(values, limit=None, mask=None, dtype=None):
- dtype = values.dtype.name
+ if dtype is None:
+ dtype = values.dtype
_method = None
if is_float_dtype(values):
- _method = getattr(algos, 'backfill_2d_inplace_%s' % dtype, None)
- elif is_datetime64_dtype(values):
+ _method = getattr(algos, 'backfill_2d_inplace_%s' % dtype.name, None)
+ elif dtype in _DATELIKE_DTYPES or is_datetime64_dtype(values):
_method = _backfill_2d_datetime
elif is_integer_dtype(values):
values = _ensure_float64(values)
@@ -1337,7 +1341,7 @@ def backfill_2d(values, limit=None, mask=None):
_method = algos.backfill_2d_inplace_object
if _method is None:
- raise ValueError('Invalid dtype for backfill_2d [%s]' % dtype)
+ raise ValueError('Invalid dtype for backfill_2d [%s]' % dtype.name)
if mask is None:
mask = isnull(values)
@@ -1503,7 +1507,7 @@ def _interpolate_scipy_wrapper(x, y, new_x, method, fill_value=None,
return new_y
-def interpolate_2d(values, method='pad', axis=0, limit=None, fill_value=None):
+def interpolate_2d(values, method='pad', axis=0, limit=None, fill_value=None, dtype=None):
""" perform an actual interpolation of values, values will be make 2-d if
needed fills inplace, returns the result
"""
@@ -1525,9 +1529,9 @@ def interpolate_2d(values, method='pad', axis=0, limit=None, fill_value=None):
method = _clean_fill_method(method)
if method == 'pad':
- values = transf(pad_2d(transf(values), limit=limit, mask=mask))
+ values = transf(pad_2d(transf(values), limit=limit, mask=mask, dtype=dtype))
else:
- values = transf(backfill_2d(transf(values), limit=limit, mask=mask))
+ values = transf(backfill_2d(transf(values), limit=limit, mask=mask, dtype=dtype))
# reshape back
if ndim == 1:
diff --git a/pandas/core/internals.py b/pandas/core/internals.py
index 39eb03eebdb8c..2a4ee4dcf8cf6 100644
--- a/pandas/core/internals.py
+++ b/pandas/core/internals.py
@@ -878,7 +878,12 @@ def _interpolate_with_fill(self, method='pad', axis=0, inplace=False,
fill_value = self._try_fill(fill_value)
values = self.values if inplace else self.values.copy()
values = self._try_operate(values)
- values = com.interpolate_2d(values, method, axis, limit, fill_value)
+ values = com.interpolate_2d(values,
+ method=method,
+ axis=axis,
+ limit=limit,
+ fill_value=fill_value,
+ dtype=self.dtype)
values = self._try_coerce_result(values)
blocks = [make_block(values, self.items, self.ref_items,
diff --git a/pandas/tests/test_series.py b/pandas/tests/test_series.py
index 4b0af8d0cbdd2..ca1b23ee26da4 100644
--- a/pandas/tests/test_series.py
+++ b/pandas/tests/test_series.py
@@ -2854,6 +2854,14 @@ def test_datetime64_fillna(self):
Timestamp('20130103 9:01:01')])
assert_series_equal(result, expected)
+ # GH 6587
+ # make sure that we are treating as integer when filling
+ s = Series([pd.NaT, pd.NaT, '2013-08-05 15:30:00.000001'])
+ expected = Series(['2013-08-05 15:30:00.000001', '2013-08-05 15:30:00.000001', '2013-08-05 15:30:00.000001'], dtype='M8[ns]')
+ result = s.fillna(method='backfill')
+ assert_series_equal(result, expected)
+
+
def test_fillna_int(self):
s = Series(np.random.randint(-100, 100, 50))
s.fillna(method='ffill', inplace=True)
| closes #6587
| https://api.github.com/repos/pandas-dev/pandas/pulls/6588 | 2014-03-10T17:16:19Z | 2014-03-10T18:14:52Z | 2014-03-10T18:14:52Z | 2014-07-16T08:57:38Z |
CLN: Finish changing assert_(...) to specialized forms | diff --git a/pandas/io/tests/test_parsers.py b/pandas/io/tests/test_parsers.py
index 79d96aa8115b0..612840e82e3ff 100644
--- a/pandas/io/tests/test_parsers.py
+++ b/pandas/io/tests/test_parsers.py
@@ -873,8 +873,7 @@ def test_parse_dates_implicit_first_col(self):
"""
df = self.read_csv(StringIO(data), parse_dates=True)
expected = self.read_csv(StringIO(data), index_col=0, parse_dates=True)
- self.assert_(
- isinstance(df.index[0], (datetime, np.datetime64, Timestamp)))
+ self.assertIsInstance(df.index[0], (datetime, np.datetime64, Timestamp))
tm.assert_frame_equal(df, expected)
def test_parse_dates_string(self):
diff --git a/pandas/tests/test_graphics.py b/pandas/tests/test_graphics.py
index 6cc4c0a691096..30ba5cd5a70fe 100644
--- a/pandas/tests/test_graphics.py
+++ b/pandas/tests/test_graphics.py
@@ -964,7 +964,7 @@ def test_hexbin_basic(self):
ax = df.plot(kind='hexbin', x='A', y='B', gridsize=10)
# TODO: need better way to test. This just does existence.
- self.assert_(len(ax.collections) == 1)
+ self.assertEqual(len(ax.collections), 1)
@slow
def test_hexbin_with_c(self):
@@ -973,11 +973,11 @@ def test_hexbin_with_c(self):
"C": np.arange(20) + np.random.uniform(size=20)})
ax = df.plot(kind='hexbin', x='A', y='B', C='C')
- self.assert_(len(ax.collections) == 1)
+ self.assertEqual(len(ax.collections), 1)
ax = df.plot(kind='hexbin', x='A', y='B', C='C',
reduce_C_function=np.std)
- self.assert_(len(ax.collections) == 1)
+ self.assertEqual(len(ax.collections), 1)
@slow
def test_hexbin_cmap(self):
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index bfbf4625aefa1..1385e7a56e2c4 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -679,8 +679,8 @@ def test_reset_index_with_drop(self):
deleveled = self.series.reset_index()
tm.assert_isinstance(deleveled, DataFrame)
- self.assert_(
- len(deleveled.columns) == len(self.series.index.levels) + 1)
+ self.assertEqual(len(deleveled.columns),
+ len(self.series.index.levels) + 1)
deleveled = self.series.reset_index(drop=True)
tm.assert_isinstance(deleveled, Series)
diff --git a/pandas/tests/test_series.py b/pandas/tests/test_series.py
index 48d97c5fe9031..4b0af8d0cbdd2 100644
--- a/pandas/tests/test_series.py
+++ b/pandas/tests/test_series.py
@@ -2879,8 +2879,8 @@ def test_fillna(self):
ts[2] = np.NaN
- self.assert_(
- np.array_equal(ts.fillna(method='ffill'), [0., 1., 1., 3., 4.]))
+ self.assert_numpy_array_equal(ts.fillna(method='ffill'),
+ [0., 1., 1., 3., 4.])
self.assert_numpy_array_equal(ts.fillna(method='backfill'),
[0., 1., 3., 3., 4.])
diff --git a/pandas/tseries/tests/test_timeseries.py b/pandas/tseries/tests/test_timeseries.py
index bcea8469c8028..4113419ba8004 100644
--- a/pandas/tseries/tests/test_timeseries.py
+++ b/pandas/tseries/tests/test_timeseries.py
@@ -894,11 +894,9 @@ def test_to_datetime_types(self):
def test_to_datetime_unprocessable_input(self):
# GH 4928
- self.assert_(
- np.array_equal(
- to_datetime([1, '1']),
- np.array([1, '1'], dtype='O')
- )
+ self.assert_numpy_array_equal(
+ to_datetime([1, '1']),
+ np.array([1, '1'], dtype='O')
)
self.assertRaises(TypeError, to_datetime, [1, '1'], errors='raise')
@@ -953,11 +951,9 @@ def test_to_datetime_array_of_dt64s(self):
# Assuming all datetimes are in bounds, to_datetime() returns
# an array that is equal to Timestamp() parsing
- self.assert_(
- np.array_equal(
- pd.to_datetime(dts, box=False),
- np.array([Timestamp(x).asm8 for x in dts])
- )
+ self.assert_numpy_array_equal(
+ pd.to_datetime(dts, box=False),
+ np.array([Timestamp(x).asm8 for x in dts])
)
# A list of datetimes where the last one is out of bounds
@@ -971,30 +967,26 @@ def test_to_datetime_array_of_dt64s(self):
errors='raise'
)
- self.assert_(
- np.array_equal(
- pd.to_datetime(dts_with_oob, box=False, coerce=True),
- np.array(
+ self.assert_numpy_array_equal(
+ pd.to_datetime(dts_with_oob, box=False, coerce=True),
+ np.array(
[
Timestamp(dts_with_oob[0]).asm8,
Timestamp(dts_with_oob[1]).asm8,
iNaT,
],
dtype='M8'
- )
)
)
# With coerce=False and errors='ignore', out of bounds datetime64s
# are converted to their .item(), which depending on the version of
# numpy is either a python datetime.datetime or datetime.date
- self.assert_(
- np.array_equal(
- pd.to_datetime(dts_with_oob, box=False, coerce=False),
- np.array(
+ self.assert_numpy_array_equal(
+ pd.to_datetime(dts_with_oob, box=False, coerce=False),
+ np.array(
[dt.item() for dt in dts_with_oob],
dtype='O'
- )
)
)
diff --git a/pandas/tseries/tests/test_tslib.py b/pandas/tseries/tests/test_tslib.py
index b23b7b65825c5..0700e38d831d1 100644
--- a/pandas/tseries/tests/test_tslib.py
+++ b/pandas/tseries/tests/test_tslib.py
@@ -91,30 +91,26 @@ def test_does_not_convert_mixed_integer(self):
class TestArrayToDatetime(tm.TestCase):
def test_parsing_valid_dates(self):
arr = np.array(['01-01-2013', '01-02-2013'], dtype=object)
- self.assert_(
- np.array_equal(
- tslib.array_to_datetime(arr),
- np.array(
+ self.assert_numpy_array_equal(
+ tslib.array_to_datetime(arr),
+ np.array(
[
'2013-01-01T00:00:00.000000000-0000',
'2013-01-02T00:00:00.000000000-0000'
],
dtype='M8[ns]'
- )
)
)
arr = np.array(['Mon Sep 16 2013', 'Tue Sep 17 2013'], dtype=object)
- self.assert_(
- np.array_equal(
- tslib.array_to_datetime(arr),
- np.array(
+ self.assert_numpy_array_equal(
+ tslib.array_to_datetime(arr),
+ np.array(
[
'2013-09-16T00:00:00.000000000-0000',
'2013-09-17T00:00:00.000000000-0000'
],
dtype='M8[ns]'
- )
)
)
@@ -155,16 +151,14 @@ def test_coercing_dates_outside_of_datetime64_ns_bounds(self):
)
arr = np.array(['1/1/1000', '1/1/2000'], dtype=object)
- self.assert_(
- np.array_equal(
- tslib.array_to_datetime(arr, coerce=True),
- np.array(
+ self.assert_numpy_array_equal(
+ tslib.array_to_datetime(arr, coerce=True),
+ np.array(
[
tslib.iNaT,
'2000-01-01T00:00:00.000000000-0000'
],
dtype='M8[ns]'
- )
)
)
@@ -176,17 +170,15 @@ def test_coerce_of_invalid_datetimes(self):
self.assert_numpy_array_equal(tslib.array_to_datetime(arr), arr)
# With coercing, the invalid dates becomes iNaT
- self.assert_(
- np.array_equal(
- tslib.array_to_datetime(arr, coerce=True),
- np.array(
+ self.assert_numpy_array_equal(
+ tslib.array_to_datetime(arr, coerce=True),
+ np.array(
[
'2013-01-01T00:00:00.000000000-0000',
tslib.iNaT,
tslib.iNaT
],
dtype='M8[ns]'
- )
)
)
@@ -205,13 +197,11 @@ def test_parsing_timezone_offsets(self):
)
for dt_string in dt_strings:
- self.assert_(
- np.array_equal(
- tslib.array_to_datetime(
- np.array([dt_string], dtype=object)
- ),
- expected_output
- )
+ self.assert_numpy_array_equal(
+ tslib.array_to_datetime(
+ np.array([dt_string], dtype=object)
+ ),
+ expected_output
)
class TestTimestampNsOperations(tm.TestCase):
| Finishes #6175, to the extent that everything remaining can be mapped to assertTrue or assertFalse, unless larger refactorings are desired.
| https://api.github.com/repos/pandas-dev/pandas/pulls/6580 | 2014-03-09T15:41:55Z | 2014-03-09T16:05:42Z | 2014-03-09T16:05:42Z | 2014-06-30T15:30:00Z |
BUG: Bug in .xs with a nan in level when dropped (GH6574) | diff --git a/doc/source/release.rst b/doc/source/release.rst
index fa1d1bef333d4..267f373a9e534 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -222,6 +222,7 @@ Bug Fixes
- Bug in preserving frequency across Timestamp addition/subtraction (:issue:`4547`)
- Bug in indexing: empty list lookup caused ``IndexError`` exceptions (:issue:`6536`, :issue:`6551`)
- Series.quantile raising on an ``object`` dtype (:issue:`6555`)
+- Bug in ``.xs`` with a ``nan`` in level when dropped (:issue:`6574`)
pandas 0.13.1
-------------
diff --git a/pandas/core/index.py b/pandas/core/index.py
index 30e18d239d950..3bc3783fffcbd 100644
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -2947,7 +2947,13 @@ def droplevel(self, level=0):
new_names.pop(i)
if len(new_levels) == 1:
+
+ # set nan if needed
+ mask = new_labels[0] == -1
result = new_levels[0].take(new_labels[0])
+ if mask.any():
+ np.putmask(result, mask, np.nan)
+
result.name = new_names[0]
return result
else:
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index 1e1d91d0db866..96272bab18dc2 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -391,6 +391,22 @@ def test_xs(self):
assert_series_equal(xs, xs2)
assert_almost_equal(xs.values, self.frame.values[4])
+ # GH 6574
+ # missing values in returned index should be preserrved
+ acc = [
+ ('a','abcde',1),
+ ('b','bbcde',2),
+ ('y','yzcde',25),
+ ('z','xbcde',24),
+ ('z',None,26),
+ ('z','zbcde',25),
+ ('z','ybcde',26),
+ ]
+ df = DataFrame(acc, columns=['a1','a2','cnt']).set_index(['a1','a2'])
+ expected = DataFrame({ 'cnt' : [24,26,25,26] }, index=Index(['xbcde',np.nan,'zbcde','ybcde'],name='a2'))
+ result = df.xs('z',level='a1')
+ assert_frame_equal(result, expected)
+
def test_xs_partial(self):
result = self.frame.xs('foo')
result2 = self.frame.ix['foo']
| closes #6574
| https://api.github.com/repos/pandas-dev/pandas/pulls/6579 | 2014-03-09T14:46:56Z | 2014-03-09T15:15:00Z | 2014-03-09T15:15:00Z | 2014-06-22T14:52:08Z |
FIX raise when groupby selecting cols not in frame | diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py
index 031088c4e5672..770c4ae27dbdb 100644
--- a/pandas/core/groupby.py
+++ b/pandas/core/groupby.py
@@ -2568,15 +2568,27 @@ def __getitem__(self, key):
if self._selection is not None:
raise Exception('Column(s) %s already selected' % self._selection)
- if (isinstance(key, (list, tuple, Series, np.ndarray)) or
- not self.as_index):
+ if isinstance(key, (list, tuple, Series, np.ndarray)):
+ if len(self.obj.columns.intersection(key)) != len(key):
+ bad_keys = list(set(key).difference(self.obj.columns))
+ raise KeyError("Columns not found: %s"
+ % str(bad_keys)[1:-1])
return DataFrameGroupBy(self.obj, self.grouper, selection=key,
grouper=self.grouper,
exclusions=self.exclusions,
as_index=self.as_index)
+
+ elif not self.as_index:
+ if key not in self.obj.columns:
+ raise KeyError("Column not found: %s" % key)
+ return DataFrameGroupBy(self.obj, self.grouper, selection=key,
+ grouper=self.grouper,
+ exclusions=self.exclusions,
+ as_index=self.as_index)
+
else:
- if key not in self.obj: # pragma: no cover
- raise KeyError(str(key))
+ if key not in self.obj:
+ raise KeyError("Column not found: %s" % key)
# kind of a kludge
return SeriesGroupBy(self.obj[key], selection=key,
grouper=self.grouper,
diff --git a/pandas/tests/test_groupby.py b/pandas/tests/test_groupby.py
index 8bbc8e6326639..01bff979ee9f6 100644
--- a/pandas/tests/test_groupby.py
+++ b/pandas/tests/test_groupby.py
@@ -14,7 +14,7 @@
from pandas.core.series import Series
from pandas.util.testing import (assert_panel_equal, assert_frame_equal,
assert_series_equal, assert_almost_equal,
- assert_index_equal)
+ assert_index_equal, assertRaisesRegexp)
from pandas.compat import(
range, long, lrange, StringIO, lmap, lzip, map, zip, builtins, OrderedDict
)
@@ -30,6 +30,7 @@
import pandas.util.testing as tm
import pandas as pd
+
def commonSetUp(self):
self.dateRange = bdate_range('1/1/2005', periods=250)
self.stringIndex = Index([rands(8).upper() for x in range(250)])
@@ -72,7 +73,8 @@ def setUp(self):
'B': ['one', 'one', 'two', 'three',
'two', 'two', 'one', 'three'],
'C': np.random.randn(8),
- 'D': np.array(np.random.randn(8),dtype='float32')})
+ 'D': np.array(np.random.randn(8),
+ dtype='float32')})
index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'],
['one', 'two', 'three']],
@@ -114,7 +116,7 @@ def checkit(dtype):
assert_series_equal(agged, grouped.agg(np.mean)) # shorthand
assert_series_equal(agged, grouped.mean())
- assert_series_equal(grouped.agg(np.sum),grouped.sum())
+ assert_series_equal(grouped.agg(np.sum), grouped.sum())
transformed = grouped.transform(lambda x: x * x.sum())
self.assertEqual(transformed[7], 12)
@@ -138,10 +140,20 @@ def checkit(dtype):
# corner cases
self.assertRaises(Exception, grouped.aggregate, lambda x: x * 2)
-
- for dtype in ['int64','int32','float64','float32']:
+ for dtype in ['int64', 'int32', 'float64', 'float32']:
checkit(dtype)
+ def test_select_bad_cols(self):
+ df = DataFrame([[1, 2]], columns=['A', 'B'])
+ g = df.groupby('A')
+ self.assertRaises(KeyError, g.__getitem__, ['C']) # g[['C']]
+
+ self.assertRaises(KeyError, g.__getitem__, ['A', 'C']) # g[['A', 'C']]
+ with assertRaisesRegexp(KeyError, '^[^A]+$'):
+ # A should not be referenced as a bad column...
+ # will have to rethink regex if you change message!
+ g[['A', 'C']]
+
def test_first_last_nth(self):
# tests for first / last / nth
grouped = self.df.groupby('A')
| KeyError part of #5264
| https://api.github.com/repos/pandas-dev/pandas/pulls/6578 | 2014-03-09T09:14:10Z | 2014-05-02T12:51:52Z | 2014-05-02T12:51:52Z | 2014-07-16T08:57:30Z |
CLN: Change assert_([not] isinstance(a,b)) to specialized forms | diff --git a/pandas/io/tests/test_packers.py b/pandas/io/tests/test_packers.py
index 0bbf81384672e..1386439d51757 100644
--- a/pandas/io/tests/test_packers.py
+++ b/pandas/io/tests/test_packers.py
@@ -359,7 +359,7 @@ def test_multi(self):
l = [self.frame['float'], self.frame['float']
.A, self.frame['float'].B, None]
l_rec = self.encode_decode(l)
- self.assert_(isinstance(l_rec, tuple))
+ self.assertIsInstance(l_rec, tuple)
check_arbitrary(l, l_rec)
def test_iterator(self):
diff --git a/pandas/io/tests/test_parsers.py b/pandas/io/tests/test_parsers.py
index 35cbb8089cbe7..79d96aa8115b0 100644
--- a/pandas/io/tests/test_parsers.py
+++ b/pandas/io/tests/test_parsers.py
@@ -415,7 +415,7 @@ def test_multiple_date_cols_with_header(self):
KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000"""
df = self.read_csv(StringIO(data), parse_dates={'nominal': [1, 2]})
- self.assert_(not isinstance(df.nominal[0], compat.string_types))
+ self.assertNotIsInstance(df.nominal[0], compat.string_types)
ts_data = """\
ID,date,nominalTime,actualTime,A,B,C,D,E
@@ -1006,8 +1006,7 @@ def test_read_csv_dataframe(self):
parse_dates=True)
self.assert_numpy_array_equal(df.columns, ['A', 'B', 'C', 'D'])
self.assertEqual(df.index.name, 'index')
- self.assert_(isinstance(df.index[0], (datetime, np.datetime64,
- Timestamp)))
+ self.assertIsInstance(df.index[0], (datetime, np.datetime64, Timestamp))
self.assertEqual(df.values.dtype, np.float64)
tm.assert_frame_equal(df, df2)
@@ -1016,8 +1015,7 @@ def test_read_csv_no_index_name(self):
df2 = self.read_table(self.csv2, sep=',', index_col=0,
parse_dates=True)
self.assert_numpy_array_equal(df.columns, ['A', 'B', 'C', 'D', 'E'])
- self.assert_(isinstance(df.index[0], (datetime, np.datetime64,
- Timestamp)))
+ self.assertIsInstance(df.index[0], (datetime, np.datetime64, Timestamp))
self.assertEqual(df.ix[:, ['A', 'B', 'C', 'D']].values.dtype, np.float64)
tm.assert_frame_equal(df, df2)
@@ -1441,13 +1439,13 @@ def test_multi_index_parse_dates(self):
20090103,three,c,4,5
"""
df = self.read_csv(StringIO(data), index_col=[0, 1], parse_dates=True)
- self.assert_(isinstance(df.index.levels[0][0],
- (datetime, np.datetime64, Timestamp)))
+ self.assertIsInstance(df.index.levels[0][0],
+ (datetime, np.datetime64, Timestamp))
# specify columns out of order!
df2 = self.read_csv(StringIO(data), index_col=[1, 0], parse_dates=True)
- self.assert_(isinstance(df2.index.levels[1][0],
- (datetime, np.datetime64, Timestamp)))
+ self.assertIsInstance(df2.index.levels[1][0],
+ (datetime, np.datetime64, Timestamp))
def test_skip_footer(self):
data = """A,B,C
diff --git a/pandas/io/tests/test_pytables.py b/pandas/io/tests/test_pytables.py
index 7b9b9d50f2178..c579e8502eb84 100644
--- a/pandas/io/tests/test_pytables.py
+++ b/pandas/io/tests/test_pytables.py
@@ -3554,7 +3554,7 @@ def f():
# valid
result = store.select_column('df', 'index')
tm.assert_almost_equal(result.values, Series(df.index).values)
- self.assert_(isinstance(result,Series))
+ self.assertIsInstance(result,Series)
# not a data indexable column
self.assertRaises(
@@ -3622,7 +3622,7 @@ def test_coordinates(self):
result = store.select('df', where=c)
expected = df.ix[3:4, :]
tm.assert_frame_equal(result, expected)
- self.assert_(isinstance(c, Index))
+ self.assertIsInstance(c, Index)
# multiple tables
_maybe_remove(store, 'df1')
diff --git a/pandas/io/tests/test_stata.py b/pandas/io/tests/test_stata.py
index 307cd1bd591fb..a99420493d047 100644
--- a/pandas/io/tests/test_stata.py
+++ b/pandas/io/tests/test_stata.py
@@ -277,11 +277,11 @@ def test_encoding(self):
if compat.PY3:
expected = raw.kreis1849[0]
self.assertEqual(result, expected)
- self.assert_(isinstance(result, compat.string_types))
+ self.assertIsInstance(result, compat.string_types)
else:
expected = raw.kreis1849.str.decode("latin-1")[0]
self.assertEqual(result, expected)
- self.assert_(isinstance(result, unicode))
+ self.assertIsInstance(result, unicode)
def test_read_write_dta11(self):
# skip_if_not_little_endian()
diff --git a/pandas/sparse/tests/test_sparse.py b/pandas/sparse/tests/test_sparse.py
index 603edbf2de0a1..030fe5fb821c4 100644
--- a/pandas/sparse/tests/test_sparse.py
+++ b/pandas/sparse/tests/test_sparse.py
@@ -405,7 +405,7 @@ def _compare_with_dense(sp):
def _compare(idx):
dense_result = dense.take(idx).values
sparse_result = sp.take(idx)
- self.assert_(isinstance(sparse_result, SparseSeries))
+ self.assertIsInstance(sparse_result, SparseSeries)
assert_almost_equal(dense_result, sparse_result.values.values)
_compare([1., 2., 3., 4., 5., 0.])
@@ -652,7 +652,7 @@ def test_dropna(self):
result = self.bseries.dropna()
expected = self.bseries.to_dense().dropna()
- self.assert_(not isinstance(result, SparseSeries))
+ self.assertNotIsInstance(result, SparseSeries)
tm.assert_series_equal(result, expected)
def test_homogenize(self):
diff --git a/pandas/tests/test_compat.py b/pandas/tests/test_compat.py
index a8b9a88126861..0d38bb23d6aa7 100644
--- a/pandas/tests/test_compat.py
+++ b/pandas/tests/test_compat.py
@@ -11,10 +11,10 @@
import nose
import pandas.util.testing as tm
-class TestBuiltinIterators(unittest.TestCase):
+class TestBuiltinIterators(tm.TestCase):
def check_result(self, actual, expected, lengths):
for (iter_res, list_res), exp, length in zip(actual, expected, lengths):
- self.assert_(not isinstance(iter_res, list))
+ self.assertNotIsInstance(iter_res, list)
tm.assert_isinstance(list_res, list)
iter_res = list(iter_res)
self.assertEqual(len(list_res), length)
diff --git a/pandas/tests/test_frame.py b/pandas/tests/test_frame.py
index 1cc357ce2a260..4758670517df0 100644
--- a/pandas/tests/test_frame.py
+++ b/pandas/tests/test_frame.py
@@ -10427,11 +10427,11 @@ def _check_stat_op(self, name, alternative, frame=None, has_skipna=True,
df = DataFrame({'b': date_range('1/1/2001', periods=2)})
_f = getattr(df, name)
result = _f()
- self.assert_(isinstance(result, Series))
+ self.assertIsInstance(result, Series)
df['a'] = lrange(len(df))
result = getattr(df, name)()
- self.assert_(isinstance(result, Series))
+ self.assertIsInstance(result, Series)
self.assert_(len(result))
if has_skipna:
diff --git a/pandas/tests/test_graphics.py b/pandas/tests/test_graphics.py
index 829f375ba7a3a..6cc4c0a691096 100644
--- a/pandas/tests/test_graphics.py
+++ b/pandas/tests/test_graphics.py
@@ -469,13 +469,13 @@ def test_xcompat(self):
df = tm.makeTimeDataFrame()
ax = df.plot(x_compat=True)
lines = ax.get_lines()
- self.assert_(not isinstance(lines[0].get_xdata(), PeriodIndex))
+ self.assertNotIsInstance(lines[0].get_xdata(), PeriodIndex)
tm.close()
pd.plot_params['xaxis.compat'] = True
ax = df.plot()
lines = ax.get_lines()
- self.assert_(not isinstance(lines[0].get_xdata(), PeriodIndex))
+ self.assertNotIsInstance(lines[0].get_xdata(), PeriodIndex)
tm.close()
pd.plot_params['x_compat'] = False
@@ -488,7 +488,7 @@ def test_xcompat(self):
with pd.plot_params.use('x_compat', True):
ax = df.plot()
lines = ax.get_lines()
- self.assert_(not isinstance(lines[0].get_xdata(), PeriodIndex))
+ self.assertNotIsInstance(lines[0].get_xdata(), PeriodIndex)
tm.close()
ax = df.plot()
diff --git a/pandas/tests/test_index.py b/pandas/tests/test_index.py
index 3e578a5e36bb1..c6c405306afb8 100644
--- a/pandas/tests/test_index.py
+++ b/pandas/tests/test_index.py
@@ -295,7 +295,7 @@ def _check(op):
index_result = op(index, element)
tm.assert_isinstance(index_result, np.ndarray)
- self.assert_(not isinstance(index_result, Index))
+ self.assertNotIsInstance(index_result, Index)
self.assert_numpy_array_equal(arr_result, index_result)
_check(operator.eq)
@@ -762,7 +762,7 @@ def test_boolean_cmp(self):
self.assert_(res.all())
self.assertEqual(res.dtype, 'bool')
- self.assert_(not isinstance(res, Index))
+ self.assertNotIsInstance(res, Index)
def test_get_level_values(self):
result = self.strIndex.get_level_values(0)
@@ -808,12 +808,13 @@ def test_repr_roundtrip(self):
tm.assert_index_equal(eval(repr(ind)), ind)
def check_is_index(self, i):
- self.assert_(isinstance(i, Index) and not isinstance(i, Float64Index))
+ self.assertIsInstance(i, Index)
+ self.assertNotIsInstance(i, Float64Index)
def check_coerce(self, a, b, is_float_index=True):
self.assert_(a.equals(b))
if is_float_index:
- self.assert_(isinstance(b, Float64Index))
+ self.assertIsInstance(b, Float64Index)
else:
self.check_is_index(b)
@@ -821,22 +822,22 @@ def test_constructor(self):
# explicit construction
index = Float64Index([1,2,3,4,5])
- self.assert_(isinstance(index, Float64Index))
+ self.assertIsInstance(index, Float64Index)
self.assert_((index.values == np.array([1,2,3,4,5],dtype='float64')).all())
index = Float64Index(np.array([1,2,3,4,5]))
- self.assert_(isinstance(index, Float64Index))
+ self.assertIsInstance(index, Float64Index)
index = Float64Index([1.,2,3,4,5])
- self.assert_(isinstance(index, Float64Index))
+ self.assertIsInstance(index, Float64Index)
index = Float64Index(np.array([1.,2,3,4,5]))
- self.assert_(isinstance(index, Float64Index))
+ self.assertIsInstance(index, Float64Index)
self.assertEqual(index.dtype, object)
index = Float64Index(np.array([1.,2,3,4,5]),dtype=np.float32)
- self.assert_(isinstance(index, Float64Index))
+ self.assertIsInstance(index, Float64Index)
self.assertEqual(index.dtype, object)
index = Float64Index(np.array([1,2,3,4,5]),dtype=np.float32)
- self.assert_(isinstance(index, Float64Index))
+ self.assertIsInstance(index, Float64Index)
self.assertEqual(index.dtype, object)
# nan handling
@@ -1548,7 +1549,7 @@ def test_constructor_single_level(self):
labels=[[0, 1, 2, 3]],
names=['first'])
tm.assert_isinstance(single_level, Index)
- self.assert_(not isinstance(single_level, MultiIndex))
+ self.assertNotIsInstance(single_level, MultiIndex)
self.assertEqual(single_level.name, 'first')
single_level = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux']],
diff --git a/pandas/tests/test_internals.py b/pandas/tests/test_internals.py
index a4f78a31066f6..2c9c8a94a1902 100644
--- a/pandas/tests/test_internals.py
+++ b/pandas/tests/test_internals.py
@@ -378,7 +378,7 @@ def test_sparse(self):
def test_sparse_mixed(self):
mgr = create_blockmanager([get_sparse_ex1(),get_sparse_ex2(),get_float_ex()])
self.assertEqual(len(mgr.blocks), 3)
- self.assert_(isinstance(mgr,BlockManager))
+ self.assertIsInstance(mgr, BlockManager)
# what to test here?
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index 1e1d91d0db866..bfbf4625aefa1 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -75,7 +75,7 @@ def test_dataframe_constructor(self):
index=[np.array(['a', 'a', 'b', 'b']),
np.array(['x', 'y', 'x', 'y'])])
tm.assert_isinstance(multi.index, MultiIndex)
- self.assert_(not isinstance(multi.columns, MultiIndex))
+ self.assertNotIsInstance(multi.columns, MultiIndex)
multi = DataFrame(np.random.randn(4, 4),
columns=[['a', 'a', 'b', 'b'],
diff --git a/pandas/tests/test_series.py b/pandas/tests/test_series.py
index 71e506374c08d..48d97c5fe9031 100644
--- a/pandas/tests/test_series.py
+++ b/pandas/tests/test_series.py
@@ -343,7 +343,7 @@ def test_scalar_conversion(self):
# Pass in scalar is disabled
scalar = Series(0.5)
- self.assert_(not isinstance(scalar, float))
+ self.assertNotIsInstance(scalar, float)
# coercion
self.assertEqual(float(Series([1.])), 1.0)
@@ -1175,10 +1175,10 @@ def test_reshape_non_2d(self):
def test_reshape_2d_return_array(self):
x = Series(np.random.random(201), name='x')
result = x.reshape((-1, 1))
- self.assert_(not isinstance(result, Series))
+ self.assertNotIsInstance(result, Series)
result2 = np.reshape(x, (-1, 1))
- self.assert_(not isinstance(result, Series))
+ self.assertNotIsInstance(result, Series)
result = x[:, None]
expected = x.reshape((-1, 1))
@@ -2091,7 +2091,7 @@ def test_round(self):
def test_prod_numpy16_bug(self):
s = Series([1., 1., 1.], index=lrange(3))
result = s.prod()
- self.assert_(not isinstance(result, Series))
+ self.assertNotIsInstance(result, Series)
def test_quantile(self):
from pandas.compat.scipy import scoreatpercentile
@@ -5722,7 +5722,7 @@ def test_timeseries_coercion(self):
idx = tm.makeDateIndex(10000)
ser = Series(np.random.randn(len(idx)), idx.astype(object))
self.assertTrue(ser.is_time_series)
- self.assert_(isinstance(ser.index, DatetimeIndex))
+ self.assertIsInstance(ser.index, DatetimeIndex)
def test_replace(self):
N = 100
diff --git a/pandas/tseries/tests/test_offsets.py b/pandas/tseries/tests/test_offsets.py
index 50a9558350c5f..b303b7bb50526 100644
--- a/pandas/tseries/tests/test_offsets.py
+++ b/pandas/tseries/tests/test_offsets.py
@@ -107,7 +107,7 @@ def test_apply_out_of_range(self):
offset = self._offset(10000)
result = Timestamp('20080101') + offset
- self.assert_(isinstance(result, datetime))
+ self.assertIsInstance(result, datetime)
except (OutOfBoundsDatetime):
raise
except (ValueError, KeyError):
diff --git a/pandas/tseries/tests/test_timeseries.py b/pandas/tseries/tests/test_timeseries.py
index eeab4f46414df..bcea8469c8028 100644
--- a/pandas/tseries/tests/test_timeseries.py
+++ b/pandas/tseries/tests/test_timeseries.py
@@ -2042,7 +2042,7 @@ def test_insert(self):
result = idx.insert(1, 'inserted')
expected = Index([datetime(2000, 1, 4), 'inserted', datetime(2000, 1, 1),
datetime(2000, 1, 2)])
- self.assert_(not isinstance(result, DatetimeIndex))
+ self.assertNotIsInstance(result, DatetimeIndex)
tm.assert_index_equal(result, expected)
idx = date_range('1/1/2000', periods=3, freq='M')
@@ -3321,7 +3321,7 @@ def test_1700(self):
r2 = date_range(start=Timestamp('1710-10-01'),
periods=5,
freq='D').to_julian_date()
- self.assert_(isinstance(r2, Float64Index))
+ self.assertIsInstance(r2, Float64Index)
tm.assert_index_equal(r1, r2)
def test_2000(self):
@@ -3333,7 +3333,7 @@ def test_2000(self):
r2 = date_range(start=Timestamp('2000-02-27'),
periods=5,
freq='D').to_julian_date()
- self.assert_(isinstance(r2, Float64Index))
+ self.assertIsInstance(r2, Float64Index)
tm.assert_index_equal(r1, r2)
def test_hour(self):
@@ -3345,7 +3345,7 @@ def test_hour(self):
r2 = date_range(start=Timestamp('2000-02-27'),
periods=5,
freq='H').to_julian_date()
- self.assert_(isinstance(r2, Float64Index))
+ self.assertIsInstance(r2, Float64Index)
tm.assert_index_equal(r1, r2)
def test_minute(self):
@@ -3357,7 +3357,7 @@ def test_minute(self):
r2 = date_range(start=Timestamp('2000-02-27'),
periods=5,
freq='T').to_julian_date()
- self.assert_(isinstance(r2, Float64Index))
+ self.assertIsInstance(r2, Float64Index)
tm.assert_index_equal(r1, r2)
def test_second(self):
@@ -3369,7 +3369,7 @@ def test_second(self):
r2 = date_range(start=Timestamp('2000-02-27'),
periods=5,
freq='S').to_julian_date()
- self.assert_(isinstance(r2, Float64Index))
+ self.assertIsInstance(r2, Float64Index)
tm.assert_index_equal(r1, r2)
if __name__ == '__main__':
diff --git a/pandas/util/testing.py b/pandas/util/testing.py
index e19ef9b934947..007dc8af5ed12 100644
--- a/pandas/util/testing.py
+++ b/pandas/util/testing.py
@@ -99,6 +99,21 @@ def assertNotIn(self, first, second, msg=''):
a, b = first, second
assert a not in b, "%s: %r is in %r" % (msg.format(a,b), a, b)
+ def assertIsInstance(self, obj, cls, msg=''):
+ """Test that obj is an instance of cls
+ (which can be a class or a tuple of classes,
+ as supported by isinstance())."""
+ assert isinstance(obj, cls), (
+ "%sExpected object to be of type %r, found %r instead" % (
+ msg, cls, type(obj)))
+
+ def assertNotIsInstance(self, obj, cls, msg=''):
+ """Test that obj is not an instance of cls
+ (which can be a class or a tuple of classes,
+ as supported by isinstance())."""
+ assert not isinstance(obj, cls), (
+ "%sExpected object to be of type %r, found %r instead" % (
+ msg, cls, type(obj)))
# NOTE: don't pass an NDFrame or index to this function - may not handle it
# well.
| Work on #6175. Changes instances of assert_([not] isinstance(a,b)) to specialized assert[Not]IsInstance(a, b).
| https://api.github.com/repos/pandas-dev/pandas/pulls/6577 | 2014-03-08T15:30:22Z | 2014-03-09T14:48:34Z | 2014-03-09T14:48:34Z | 2014-07-16T08:57:26Z |
API: default value for read_excel sheet | diff --git a/doc/source/io.rst b/doc/source/io.rst
index ac2cabe009694..f43582ded4473 100644
--- a/doc/source/io.rst
+++ b/doc/source/io.rst
@@ -1820,7 +1820,7 @@ a DataFrame. See the :ref:`cookbook<cookbook.excel>` for some
advanced strategies
Besides ``read_excel`` you can also read Excel files using the ``ExcelFile``
-class. The following two command are equivalent:
+class. The following two commands are equivalent:
.. code-block:: python
@@ -1843,10 +1843,13 @@ the sheet names using the ``sheet_names`` attribute.
.. versionadded:: 0.13
There are now two ways to read in sheets from an Excel file. You can provide
-either the index of a sheet or its name. If the value provided is an integer
-then it is assumed that the integer refers to the index of a sheet, otherwise
-if a string is passed then it is assumed that the string refers to the name of
-a particular sheet in the file.
+either the index of a sheet or its name to by passing different values for
+``sheet_name``.
+
+- Pass a string to refer to the name of a particular sheet in the workbook.
+- Pass an integer to refer to the index of a sheet. Indices follow Python
+ convention, beginning at 0.
+- The default value is ``sheet_name=0``. This reads the first sheet.
Using the sheet name:
@@ -1860,6 +1863,12 @@ Using the sheet index:
read_excel('path_to_file.xls', 0, index_col=None, na_values=['NA'])
+Using all default values:
+
+.. code-block:: python
+
+ read_excel('path_to_file.xls')
+
It is often the case that users will insert columns to do temporary computations
in Excel and you may not want to read in those columns. `read_excel` takes
a `parse_cols` keyword to allow you to specify a subset of columns to parse.
diff --git a/doc/source/release.rst b/doc/source/release.rst
index 434477d071c4b..d6c319cc0be01 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -63,6 +63,7 @@ New features
API Changes
~~~~~~~~~~~
+- ``read_excel`` uses 0 as the default sheet (:issue:`6573`)
- ``iloc`` will now accept out-of-bounds indexers, e.g. a value that exceeds the length of the object being
indexed. These will be excluded. This will make pandas conform more with pandas/numpy indexing of out-of-bounds
values. A single indexer that is out-of-bounds and drops the dimensions of the object will still raise
diff --git a/doc/source/v0.14.0.txt b/doc/source/v0.14.0.txt
index d773f3e7df799..fe9e291c02d10 100644
--- a/doc/source/v0.14.0.txt
+++ b/doc/source/v0.14.0.txt
@@ -15,6 +15,7 @@ Highlights include:
API changes
~~~~~~~~~~~
+``read_excel`` uses 0 as the default sheet (:issue:`6573`)
- ``iloc`` will now accept out-of-bounds indexers for slices, e.g. a value that exceeds the length of the object being
indexed. These will be excluded. This will make pandas conform more with pandas/numpy indexing of out-of-bounds
values. A single indexer / list of indexers that is out-of-bounds will still raise
diff --git a/pandas/io/excel.py b/pandas/io/excel.py
index e1c956c625091..0abb2a789f1ab 100644
--- a/pandas/io/excel.py
+++ b/pandas/io/excel.py
@@ -49,17 +49,17 @@ def get_writer(engine_name):
raise ValueError("No Excel writer '%s'" % engine_name)
-def read_excel(io, sheetname, **kwds):
+def read_excel(io, sheetname=0, **kwds):
"""Read an Excel table into a pandas DataFrame
Parameters
----------
io : string, file-like object or xlrd workbook
If a string, expected to be a path to xls or xlsx file
- sheetname : string
- Name of Excel sheet
+ sheetname : string or int, default 0
+ Name of Excel sheet or the page number of the sheet
header : int, default 0
- Row to use for the column labels of the parsed DataFrame
+ Row to use for the column labels of the parsed DataFrame
skiprows : list-like
Rows to skip at the beginning (0-indexed)
skip_footer : int, default 0
@@ -147,7 +147,7 @@ def __init__(self, io, **kwds):
raise ValueError('Must explicitly set engine if not passing in'
' buffer or path for io.')
- def parse(self, sheetname, header=0, skiprows=None, skip_footer=0,
+ def parse(self, sheetname=0, header=0, skiprows=None, skip_footer=0,
index_col=None, parse_cols=None, parse_dates=False,
date_parser=None, na_values=None, thousands=None, chunksize=None,
convert_float=True, has_index_names=False, **kwds):
@@ -200,7 +200,8 @@ def parse(self, sheetname, header=0, skiprows=None, skip_footer=0,
if skipfooter is not None:
skip_footer = skipfooter
- return self._parse_excel(sheetname, header=header, skiprows=skiprows,
+ return self._parse_excel(sheetname=sheetname, header=header,
+ skiprows=skiprows,
index_col=index_col,
has_index_names=has_index_names,
parse_cols=parse_cols,
@@ -244,7 +245,7 @@ def _excel2num(x):
else:
return i in parse_cols
- def _parse_excel(self, sheetname, header=0, skiprows=None, skip_footer=0,
+ def _parse_excel(self, sheetname=0, header=0, skiprows=None, skip_footer=0,
index_col=None, has_index_names=None, parse_cols=None,
parse_dates=False, date_parser=None, na_values=None,
thousands=None, chunksize=None, convert_float=True,
diff --git a/pandas/io/tests/test_excel.py b/pandas/io/tests/test_excel.py
index 46e5fd74fbbfd..55a0bc0dfd879 100644
--- a/pandas/io/tests/test_excel.py
+++ b/pandas/io/tests/test_excel.py
@@ -445,6 +445,15 @@ def test_roundtrip(self):
na_values=[88, 88.0])
tm.assert_frame_equal(self.frame, recons)
+ # GH 6573
+ self.frame.to_excel(path, 'Sheet1')
+ recons = read_excel(path, index_col=0)
+ tm.assert_frame_equal(self.frame, recons)
+
+ self.frame.to_excel(path, '0')
+ recons = read_excel(path, index_col=0)
+ tm.assert_frame_equal(self.frame, recons)
+
def test_mixed(self):
_skip_if_no_xlrd()
| closes #6573
Implements a default sheetname of 0 for `read_excel` #6573.
Before: `read_excel(io, sheetname, **kwds)`
After: `read_excel(io, sheetname=0, **kwds)`
| https://api.github.com/repos/pandas-dev/pandas/pulls/6576 | 2014-03-08T06:23:16Z | 2014-03-12T13:12:25Z | 2014-03-12T13:12:25Z | 2014-06-18T20:59:40Z |
ENH: including offset/freq in Timestamp repr (#4553) | diff --git a/doc/source/release.rst b/doc/source/release.rst
index b161d1f785114..0e6924e4b0122 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -150,6 +150,7 @@ Improvements to existing features
(e.g. MonthEnd,BusinessMonthEnd), (:issue:`6479`)
- perf improvements in single-dtyped indexing (:issue:`6484`)
- ``StataWriter`` and ``DataFrame.to_stata`` accept time stamp and data labels (:issue:`6545`)
+- offset/freq info now in Timestamp __repr__ (:issue:`4553`)
.. _release.bug_fixes-0.14.0:
diff --git a/pandas/tseries/tests/test_tslib.py b/pandas/tseries/tests/test_tslib.py
index 0700e38d831d1..19703b9e30ef6 100644
--- a/pandas/tseries/tests/test_tslib.py
+++ b/pandas/tseries/tests/test_tslib.py
@@ -13,6 +13,41 @@
import pandas.util.testing as tm
class TestTimestamp(tm.TestCase):
+ def test_repr(self):
+ date = '2014-03-07'
+ tz = 'US/Eastern'
+ freq = 'M'
+
+ date_only = Timestamp(date)
+ self.assertIn(date, repr(date_only))
+ self.assertNotIn(tz, repr(date_only))
+ self.assertNotIn(freq, repr(date_only))
+ self.assertEqual(date_only, eval(repr(date_only)))
+
+ date_tz = Timestamp(date, tz=tz)
+ self.assertIn(date, repr(date_tz))
+ self.assertIn(tz, repr(date_tz))
+ self.assertNotIn(freq, repr(date_tz))
+ self.assertEqual(date_tz, eval(repr(date_tz)))
+
+ date_freq = Timestamp(date, offset=freq)
+ self.assertIn(date, repr(date_freq))
+ self.assertNotIn(tz, repr(date_freq))
+ self.assertIn(freq, repr(date_freq))
+ self.assertEqual(date_freq, eval(repr(date_freq)))
+
+ date_tz_freq = Timestamp(date, tz=tz, offset=freq)
+ self.assertIn(date, repr(date_tz_freq))
+ self.assertIn(tz, repr(date_tz_freq))
+ self.assertIn(freq, repr(date_tz_freq))
+ self.assertEqual(date_tz_freq, eval(repr(date_tz_freq)))
+
+ # this can cause the tz field to be populated, but it's redundant to information in the datestring
+ date_with_utc_offset = Timestamp('2014-03-13 00:00:00-0400', tz=None)
+ self.assertIn('2014-03-13 00:00:00-0400', repr(date_with_utc_offset))
+ self.assertNotIn('tzoffset', repr(date_with_utc_offset))
+ self.assertEqual(date_with_utc_offset, eval(repr(date_with_utc_offset)))
+
def test_bounds_with_different_units(self):
out_of_bounds_dates = (
'1677-09-21',
diff --git a/pandas/tslib.pyx b/pandas/tslib.pyx
index da767b77d934c..88559fdfee9de 100644
--- a/pandas/tslib.pyx
+++ b/pandas/tslib.pyx
@@ -34,6 +34,7 @@ cimport cython
from datetime import timedelta, datetime
from datetime import time as datetime_time
+from dateutil.tz import tzoffset
from pandas.compat import parse_date
from sys import version_info
@@ -183,6 +184,10 @@ class Timestamp(_Timestamp):
if ts.value == NPY_NAT:
return NaT
+ if util.is_string_object(offset):
+ from pandas.tseries.frequencies import to_offset
+ offset = to_offset(offset)
+
# make datetime happy
ts_base = _Timestamp.__new__(cls, ts.dts.year, ts.dts.month,
ts.dts.day, ts.dts.hour, ts.dts.min,
@@ -196,26 +201,28 @@ class Timestamp(_Timestamp):
return ts_base
def __repr__(self):
- result = self._repr_base
+ stamp = self._repr_base
zone = None
try:
- result += self.strftime('%z')
+ stamp += self.strftime('%z')
if self.tzinfo:
zone = _get_zone(self.tzinfo)
except ValueError:
year2000 = self.replace(year=2000)
- result += year2000.strftime('%z')
+ stamp += year2000.strftime('%z')
if self.tzinfo:
zone = _get_zone(self.tzinfo)
try:
- result += zone.strftime(' %%Z')
+ stamp += zone.strftime(' %%Z')
except:
pass
- zone = "'%s'" % zone if zone else 'None'
- return "Timestamp('%s', tz=%s)" % (result, zone)
+ tz = ", tz='{0}'".format(zone) if zone is not None and not isinstance(zone, tzoffset) else ""
+ offset = ", offset='{0}'".format(self.offset.freqstr) if self.offset is not None else ""
+
+ return "Timestamp('{stamp}'{tz}{offset})".format(stamp=stamp, tz=tz, offset=offset)
@property
def _date_repr(self):
| fixes #4553
Hopefully the `test_repr()` implementation I included was sufficient. I see some `test_repr()` instances in the code that are more minimal - literally just making sure that repr(obj) doesn't blow up. And some which are pretty detailed, which makes me worry they might be a bit fragile. I went more middle-of-the-road.
``` python
In [1]: from pandas import Timestamp
In [2]: date = '2014-03-07'
In [3]: tz = 'US/Eastern'
In [4]: freq = 'M'
In [5]: repr(Timestamp(date)) # date_only_repr
Out[5]: "Timestamp('2014-03-07 00:00:00')"
In [6]: repr(Timestamp(date, tz=tz)) # date_tz_repr
Out[6]: "Timestamp('2014-03-07 00:00:00-0500', tz='US/Eastern')"
In [7]: repr(Timestamp(date, offset=freq)) # date_freq_repr
Out[7]: "Timestamp('2014-03-07 00:00:00', offset='M')"
In [8]: repr(Timestamp(date, tz=tz, offset=freq)) # date_tz_freq_repr
Out[8]: "Timestamp('2014-03-07 00:00:00-0500', tz='US/Eastern', offset='M')"
In [9]: repr(Timestamp('2014-03-13 00:00:00-0400', tz=None)) # date_with_utc_offset_repr
Out[9]: "Timestamp('2014-03-13 00:00:00-0400')"
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/6575 | 2014-03-07T22:19:12Z | 2014-03-10T20:01:30Z | 2014-03-10T20:01:30Z | 2014-06-24T18:38:06Z |
FIX use selected_obj rather the obj throughout groupby | diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py
index 031088c4e5672..1bdb3973ee92c 100644
--- a/pandas/core/groupby.py
+++ b/pandas/core/groupby.py
@@ -208,6 +208,8 @@ class GroupBy(PandasObject):
Number of groups
"""
_apply_whitelist = _common_apply_whitelist
+ _internal_names = ['_cache']
+ _internal_names_set = set(_internal_names)
def __init__(self, obj, keys=None, axis=0, level=None,
grouper=None, exclusions=None, selection=None, as_index=True,
@@ -288,10 +290,12 @@ def _local_dir(self):
return sorted(set(self.obj._local_dir() + list(self._apply_whitelist)))
def __getattr__(self, attr):
+ if attr in self._internal_names_set:
+ return object.__getattribute__(self, attr)
if attr in self.obj:
return self[attr]
- if hasattr(self.obj, attr) and attr != '_cache':
+ if hasattr(self.obj, attr):
return self._make_wrapper(attr)
raise AttributeError("%r object has no attribute %r" %
@@ -302,18 +306,18 @@ def __getitem__(self, key):
def _make_wrapper(self, name):
if name not in self._apply_whitelist:
- is_callable = callable(getattr(self.obj, name, None))
+ is_callable = callable(getattr(self._selected_obj, name, None))
kind = ' callable ' if is_callable else ' '
msg = ("Cannot access{0}attribute {1!r} of {2!r} objects, try "
"using the 'apply' method".format(kind, name,
type(self).__name__))
raise AttributeError(msg)
- f = getattr(self.obj, name)
+ f = getattr(self._selected_obj, name)
if not isinstance(f, types.MethodType):
return self.apply(lambda self: getattr(self, name))
- f = getattr(type(self.obj), name)
+ f = getattr(type(self._selected_obj), name)
def wrapper(*args, **kwargs):
# a little trickery for aggregation functions that need an axis
@@ -362,7 +366,7 @@ def get_group(self, name, obj=None):
group : type of obj
"""
if obj is None:
- obj = self.obj
+ obj = self._selected_obj
inds = self._get_index(name)
return obj.take(inds, axis=self.axis, convert=False)
@@ -424,7 +428,8 @@ def f(g):
return self._python_apply_general(f)
def _python_apply_general(self, f):
- keys, values, mutated = self.grouper.apply(f, self.obj, self.axis)
+ keys, values, mutated = self.grouper.apply(f, self._selected_obj,
+ self.axis)
return self._wrap_applied_output(keys, values,
not_indexed_same=mutated)
@@ -437,7 +442,7 @@ def agg(self, func, *args, **kwargs):
return self.aggregate(func, *args, **kwargs)
def _iterate_slices(self):
- yield self.name, self.obj
+ yield self.name, self._selected_obj
def transform(self, func, *args, **kwargs):
raise NotImplementedError
@@ -573,7 +578,7 @@ def nth(self, n, dropna=None):
return self._selected_obj[is_nth]
if (isinstance(self._selected_obj, DataFrame)
- and dropna not in ['any', 'all']):
+ and dropna not in ['any', 'all']):
# Note: when agg-ing picker doesn't raise this, just returns NaN
raise ValueError("For a DataFrame groupby, dropna must be "
"either None, 'any' or 'all', "
@@ -582,6 +587,7 @@ def nth(self, n, dropna=None):
# old behaviour, but with all and any support for DataFrames.
max_len = n if n >= 0 else - 1 - n
+
def picker(x):
x = x.dropna(how=dropna) # Note: how is ignored if Series
if len(x) <= max_len:
@@ -591,7 +597,6 @@ def picker(x):
return self.agg(picker)
-
def cumcount(self, **kwargs):
"""
Number each item in each group from 0 to the length of that group - 1.
@@ -638,7 +643,7 @@ def cumcount(self, **kwargs):
"""
ascending = kwargs.pop('ascending', True)
- index = self.obj.index
+ index = self._selected_obj.index
cumcounts = self._cumcount_array(ascending=ascending)
return Series(cumcounts, index)
@@ -706,8 +711,9 @@ def _cumcount_array(self, arr=None, **kwargs):
if arr is None:
arr = np.arange(self.grouper._max_groupsize, dtype='int64')
- len_index = len(self.obj.index)
+ len_index = len(self._selected_obj.index)
cumcounts = np.empty(len_index, dtype=arr.dtype)
+
if ascending:
for v in self.indices.values():
cumcounts[v] = arr[:len(v)]
@@ -722,7 +728,7 @@ def _selected_obj(self):
return self.obj
else:
return self.obj[self._selection]
-
+
def _index_with_as_index(self, b):
"""
Take boolean mask of index to be returned from apply, if as_index=True
@@ -730,7 +736,7 @@ def _index_with_as_index(self, b):
"""
# TODO perf, it feels like this should already be somewhere...
from itertools import chain
- original = self.obj.index
+ original = self._selected_obj.index
gp = self.grouper
levels = chain((gp.levels[i][gp.labels[i][b]]
for i in range(len(gp.groupings))),
@@ -812,7 +818,7 @@ def _concat_objects(self, keys, values, not_indexed_same=False):
if not not_indexed_same:
result = concat(values, axis=self.axis)
- ax = self.obj._get_axis(self.axis)
+ ax = self._selected_obj._get_axis(self.axis)
if isinstance(result, Series):
result = result.reindex(ax)
@@ -835,14 +841,14 @@ def _apply_filter(self, indices, dropna):
else:
indices = np.sort(np.concatenate(indices))
if dropna:
- filtered = self.obj.take(indices)
+ filtered = self._selected_obj.take(indices)
else:
- mask = np.empty(len(self.obj.index), dtype=bool)
+ mask = np.empty(len(self._selected_obj.index), dtype=bool)
mask.fill(False)
mask[indices.astype(int)] = True
# mask fails to broadcast when passed to where; broadcast manually.
- mask = np.tile(mask, list(self.obj.shape[1:]) + [1]).T
- filtered = self.obj.where(mask) # Fill with NaNs.
+ mask = np.tile(mask, list(self._selected_obj.shape[1:]) + [1]).T
+ filtered = self._selected_obj.where(mask) # Fill with NaNs.
return filtered
@@ -1908,7 +1914,7 @@ def transform(self, func, *args, **kwargs):
-------
transformed : Series
"""
- result = self.obj.copy()
+ result = self._selected_obj.copy()
if hasattr(result, 'values'):
result = result.values
dtype = result.dtype
@@ -1933,8 +1939,8 @@ def transform(self, func, *args, **kwargs):
# downcast if we can (and need)
result = _possibly_downcast_to_dtype(result, dtype)
- return self.obj.__class__(result, index=self.obj.index,
- name=self.obj.name)
+ return self._selected_obj.__class__(result, index=self._selected_obj.index,
+ name=self._selected_obj.name)
def filter(self, func, dropna=True, *args, **kwargs):
"""
@@ -2082,7 +2088,7 @@ def aggregate(self, arg, *args, **kwargs):
if self.axis != 0: # pragma: no cover
raise ValueError('Can only pass dict with axis=0')
- obj = self.obj
+ obj = self._selected_obj
if any(isinstance(x, (list, tuple, dict)) for x in arg.values()):
new_arg = OrderedDict()
@@ -2095,7 +2101,7 @@ def aggregate(self, arg, *args, **kwargs):
keys = []
if self._selection is not None:
- subset = obj[self._selection]
+ subset = obj
if isinstance(subset, DataFrame):
raise NotImplementedError
@@ -2294,7 +2300,7 @@ def _wrap_applied_output(self, keys, values, not_indexed_same=False):
if isinstance(v, (np.ndarray, Series)):
if isinstance(v, Series):
- applied_index = self.obj._get_axis(self.axis)
+ applied_index = self._selected_obj._get_axis(self.axis)
all_indexed_same = _all_indexes_same([
x.index for x in values
])
@@ -2367,7 +2373,11 @@ def _wrap_applied_output(self, keys, values, not_indexed_same=False):
# if we have date/time like in the original, then coerce dates
# as we are stacking can easily have object dtypes here
- cd = 'coerce' if self.obj.ndim == 2 and self.obj.dtypes.isin(_DATELIKE_DTYPES).any() else True
+ if (self._selected_obj.ndim == 2
+ and self._selected_obj.dtypes.isin(_DATELIKE_DTYPES).any()):
+ cd = 'coerce'
+ else:
+ cd = True
return result.convert_objects(convert_dates=cd)
else:
@@ -2668,8 +2678,8 @@ def _wrap_agged_blocks(self, blocks):
return result.convert_objects()
def _iterate_column_groupbys(self):
- for i, colname in enumerate(self.obj.columns):
- yield colname, SeriesGroupBy(self.obj.iloc[:, i],
+ for i, colname in enumerate(self._selected_obj.columns):
+ yield colname, SeriesGroupBy(self._selected_obj.iloc[:, i],
selection=colname,
grouper=self.grouper,
exclusions=self.exclusions)
@@ -2679,7 +2689,7 @@ def _apply_to_column_groupbys(self, func):
return concat(
(func(col_groupby) for _, col_groupby
in self._iterate_column_groupbys()),
- keys=self.obj.columns, axis=1)
+ keys=self._selected_obj.columns, axis=1)
def ohlc(self):
"""
@@ -2701,10 +2711,10 @@ def _iterate_slices(self):
if self.axis == 0:
# kludge
if self._selection is None:
- slice_axis = self.obj.items
+ slice_axis = self._selected_obj.items
else:
slice_axis = self._selection_list
- slicer = lambda x: self.obj[x]
+ slicer = lambda x: self._selected_obj[x]
else:
raise NotImplementedError
diff --git a/pandas/tests/test_groupby.py b/pandas/tests/test_groupby.py
index 8bbc8e6326639..3b613bb1705a3 100644
--- a/pandas/tests/test_groupby.py
+++ b/pandas/tests/test_groupby.py
@@ -3466,6 +3466,44 @@ def test_index_label_overlaps_location(self):
expected = ser.take([1, 3, 4])
assert_series_equal(actual, expected)
+ def test_groupby_selection_with_methods(self):
+ # some methods which require DatetimeIndex
+ rng = pd.date_range('2014', periods=len(self.df))
+ self.df.index = rng
+
+ g = self.df.groupby(['A'])[['C']]
+ g_exp = self.df[['C']].groupby(self.df['A'])
+ # TODO check groupby with > 1 col ?
+
+ # methods which are called as .foo()
+ methods = ['count',
+ 'corr',
+ 'cummax', 'cummin', 'cumprod',
+ 'describe', 'rank',
+ 'quantile',
+ 'diff', 'shift',
+ 'all', 'any',
+ 'idxmin', 'idxmax',
+ 'ffill', 'bfill',
+ 'pct_change',
+ 'tshift'
+ ]
+
+ for m in methods:
+ res = getattr(g, m)()
+ exp = getattr(g_exp, m)()
+ assert_frame_equal(res, exp) # should always be frames!
+
+ # methods which aren't just .foo()
+ assert_frame_equal(g.fillna(0), g_exp.fillna(0))
+ assert_frame_equal(g.dtypes, g_exp.dtypes)
+ assert_frame_equal(g.apply(lambda x: x.sum()),
+ g_exp.apply(lambda x: x.sum()))
+
+ assert_frame_equal(g.resample('D'), g_exp.resample('D'))
+
+
+
def test_groupby_whitelist(self):
from string import ascii_lowercase
letters = np.array(list(ascii_lowercase))
| fixes many parts of for #5264... Changes lots of `self.obj` to `self._selected_obj`.
probably should vbench before merging?
cc @jreback @TomAugspurger
| https://api.github.com/repos/pandas-dev/pandas/pulls/6570 | 2014-03-07T18:33:48Z | 2014-03-09T19:09:40Z | 2014-03-09T19:09:40Z | 2014-06-30T09:34:37Z |
ENH/BUG groupby nth now filters, works with DataFrames | diff --git a/doc/source/groupby.rst b/doc/source/groupby.rst
index 4fb8061939fbc..b5c15f83bb9d3 100644
--- a/doc/source/groupby.rst
+++ b/doc/source/groupby.rst
@@ -738,6 +738,34 @@ This shows the first or last n rows from each group.
1 0 1 2
5 2 5 6
+Taking the nth row of each group
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To select from a DataFrame or Series the nth item, use the nth method:
+
+.. ipython:: python
+
+ DataFrame([[1, np.nan], [1, 4], [5, 6]], columns=['A', 'B'])
+ g = df.groupby('A')
+ g.nth(0)
+
+ g.nth(1)
+
+ g.nth(-1)
+
+If you want to select the nth not-null method, use the dropna kwarg. For a DataFrame this should be either 'any' or 'all' just like you would pass to dropna, for a Series this just needs to be truthy.
+
+.. ipython:: python
+
+ g.nth(0, dropna='any')
+
+ g.nth(1, dropna='any') # NaNs denote group exhausted when using dropna
+
+ g.B.nth(0, dropna=True)
+
+.. warning::
+
+ Before 0.14.0 this method existed but did not work correctly on DataFrames. The API has changed so that it filters by default, but the old behaviour (for Series) can be achieved by passing dropna. An alternative is to dropna before doing the groupby.
Enumerate group items
~~~~~~~~~~~~~~~~~~~~~
diff --git a/doc/source/v0.14.0.txt b/doc/source/v0.14.0.txt
index 7c6e6a01cd041..345b11e9171e7 100644
--- a/doc/source/v0.14.0.txt
+++ b/doc/source/v0.14.0.txt
@@ -62,7 +62,7 @@ These are out-of-bounds selections
s.index.year
- More consistent behaviour for some groupby methods:
- - groupby head and tail now act more like filter rather than an aggregation:
+ - groupby ``head`` and ``tail`` now act more like ``filter`` rather than an aggregation:
.. ipython:: python
@@ -78,6 +78,16 @@ These are out-of-bounds selections
g[['B']].head(1)
+ - groupby ``nth`` now filters by default, with optional dropna argument to ignore
+ NaN (to replicate the previous behaviour.)
+
+ .. ipython:: python
+
+ DataFrame([[1, np.nan], [1, 4], [5, 6]], columns=['A', 'B'])
+ g = df.groupby('A')
+ g.nth(0) # can also use negative ints
+
+ g.nth(0, dropna='any') # similar to old behaviour
- Local variable usage has changed in
:func:`pandas.eval`/:meth:`DataFrame.eval`/:meth:`DataFrame.query`
diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py
index 2116beefb633b..031088c4e5672 100644
--- a/pandas/core/groupby.py
+++ b/pandas/core/groupby.py
@@ -523,15 +523,75 @@ def ohlc(self):
"""
return self._cython_agg_general('ohlc')
- def nth(self, n):
- def picker(arr):
- arr = arr[notnull(arr)]
- if len(arr) >= n + 1:
- return arr.iget(n)
+ def nth(self, n, dropna=None):
+ """
+ Take the nth row from each group.
+
+ If dropna, will not show nth non-null row, dropna is either
+ Truthy (if a Series) or 'all', 'any' (if a DataFrame); this is equivalent
+ to calling dropna(how=dropna) before the groupby.
+
+ Examples
+ --------
+ >>> DataFrame([[1, np.nan], [1, 4], [5, 6]], columns=['A', 'B'])
+ >>> g = df.groupby('A')
+ >>> g.nth(0)
+ A B
+ 0 1 NaN
+ 2 5 6
+ >>> g.nth(1)
+ A B
+ 1 1 4
+ >>> g.nth(-1)
+ A B
+ 1 1 4
+ 2 5 6
+ >>> g.nth(0, dropna='any')
+ B
+ A
+ 1 4
+ 5 6
+ >>> g.nth(1, dropna='any') # NaNs denote group exhausted when using dropna
+ B
+ A
+ 1 NaN
+ 5 NaN
+
+ """
+
+ if not dropna: # good choice
+ m = self.grouper._max_groupsize
+ if n >= m or n < -m:
+ return self._selected_obj.loc[[]]
+ rng = np.zeros(m, dtype=bool)
+ if n >= 0:
+ rng[n] = True
+ is_nth = self._cumcount_array(rng)
else:
+ rng[- n - 1] = True
+ is_nth = self._cumcount_array(rng, ascending=False)
+ return self._selected_obj[is_nth]
+
+ if (isinstance(self._selected_obj, DataFrame)
+ and dropna not in ['any', 'all']):
+ # Note: when agg-ing picker doesn't raise this, just returns NaN
+ raise ValueError("For a DataFrame groupby, dropna must be "
+ "either None, 'any' or 'all', "
+ "(was passed %s)." % (dropna),)
+
+ # old behaviour, but with all and any support for DataFrames.
+
+ max_len = n if n >= 0 else - 1 - n
+ def picker(x):
+ x = x.dropna(how=dropna) # Note: how is ignored if Series
+ if len(x) <= max_len:
return np.nan
+ else:
+ return x.iloc[n]
+
return self.agg(picker)
+
def cumcount(self, **kwargs):
"""
Number each item in each group from 0 to the length of that group - 1.
@@ -579,8 +639,7 @@ def cumcount(self, **kwargs):
ascending = kwargs.pop('ascending', True)
index = self.obj.index
- rng = np.arange(self.grouper._max_groupsize, dtype='int64')
- cumcounts = self._cumcount_array(rng, ascending=ascending)
+ cumcounts = self._cumcount_array(ascending=ascending)
return Series(cumcounts, index)
def head(self, n=5):
@@ -606,8 +665,7 @@ def head(self, n=5):
"""
obj = self._selected_obj
- rng = np.arange(self.grouper._max_groupsize, dtype='int64')
- in_head = self._cumcount_array(rng) < n
+ in_head = self._cumcount_array() < n
head = obj[in_head]
return head
@@ -639,11 +697,17 @@ def tail(self, n=5):
tail = obj[in_tail]
return tail
- def _cumcount_array(self, arr, **kwargs):
+ def _cumcount_array(self, arr=None, **kwargs):
+ """
+ arr is where cumcount gets it's values from
+ """
ascending = kwargs.pop('ascending', True)
+ if arr is None:
+ arr = np.arange(self.grouper._max_groupsize, dtype='int64')
+
len_index = len(self.obj.index)
- cumcounts = np.zeros(len_index, dtype='int64')
+ cumcounts = np.empty(len_index, dtype=arr.dtype)
if ascending:
for v in self.indices.values():
cumcounts[v] = arr[:len(v)]
diff --git a/pandas/tests/test_groupby.py b/pandas/tests/test_groupby.py
index c67a4d65c4c73..8bbc8e6326639 100644
--- a/pandas/tests/test_groupby.py
+++ b/pandas/tests/test_groupby.py
@@ -156,8 +156,7 @@ def test_first_last_nth(self):
assert_frame_equal(last, expected, check_names=False)
nth = grouped.nth(1)
- expected = self.df.ix[[3, 2], ['B', 'C', 'D']]
- expected.index = ['bar', 'foo']
+ expected = self.df.iloc[[2, 3]]
assert_frame_equal(nth, expected, check_names=False)
# it works!
@@ -165,10 +164,10 @@ def test_first_last_nth(self):
grouped['B'].last()
grouped['B'].nth(0)
- self.df['B'][self.df['A'] == 'foo'] = np.nan
+ self.df.loc[self.df['A'] == 'foo', 'B'] = np.nan
self.assert_(com.isnull(grouped['B'].first()['foo']))
self.assert_(com.isnull(grouped['B'].last()['foo']))
- self.assert_(com.isnull(grouped['B'].nth(0)['foo']))
+ self.assert_(com.isnull(grouped['B'].nth(0)[0])) # not sure what this is testing
def test_first_last_nth_dtypes(self):
@@ -189,8 +188,7 @@ def test_first_last_nth_dtypes(self):
assert_frame_equal(last, expected, check_names=False)
nth = grouped.nth(1)
- expected = df.ix[[3, 2], ['B', 'C', 'D', 'E', 'F']]
- expected.index = ['bar', 'foo']
+ expected = df.iloc[[2, 3]]
assert_frame_equal(nth, expected, check_names=False)
# GH 2763, first/last shifting dtypes
@@ -201,6 +199,29 @@ def test_first_last_nth_dtypes(self):
f = s.groupby(level=0).first()
self.assertEqual(f.dtype, 'int64')
+ def test_nth(self):
+ df = DataFrame([[1, np.nan], [1, 4], [5, 6]], columns=['A', 'B'])
+ g = df.groupby('A')
+
+ assert_frame_equal(g.nth(0), df.iloc[[0, 2]])
+ assert_frame_equal(g.nth(1), df.iloc[[1]])
+ assert_frame_equal(g.nth(2), df.loc[[]])
+ assert_frame_equal(g.nth(-1), df.iloc[[1, 2]])
+ assert_frame_equal(g.nth(-2), df.iloc[[0]])
+ assert_frame_equal(g.nth(-3), df.loc[[]])
+ assert_series_equal(g.B.nth(0), df.B.iloc[[0, 2]])
+ assert_series_equal(g.B.nth(1), df.B.iloc[[1]])
+ assert_frame_equal(g[['B']].nth(0), df.ix[[0, 2], ['B']])
+
+ exp = df.set_index('A')
+ assert_frame_equal(g.nth(0, dropna='any'), exp.iloc[[1, 2]])
+ assert_frame_equal(g.nth(-1, dropna='any'), exp.iloc[[1, 2]])
+
+ exp['B'] = np.nan
+ assert_frame_equal(g.nth(7, dropna='any'), exp.iloc[[1, 2]])
+ assert_frame_equal(g.nth(2, dropna='any'), exp.iloc[[1, 2]])
+
+
def test_grouper_index_types(self):
# related GH5375
# groupby misbehaving when using a Floatlike index
diff --git a/vb_suite/groupby.py b/vb_suite/groupby.py
index 01b44cbd5351c..dc8103b0ceea2 100644
--- a/vb_suite/groupby.py
+++ b/vb_suite/groupby.py
@@ -269,6 +269,22 @@ def f(g):
groupby_frame_apply = Benchmark("df.groupby(['key', 'key2']).apply(f)", setup,
start_date=datetime(2011, 10, 1))
+
+#----------------------------------------------------------------------
+# DataFrame nth
+
+setup = common_setup + """
+df = pd.DataFrame(np.random.randint(1, 100, (10000, 2)))
+"""
+
+# Not really a fair test as behaviour has changed!
+groupby_frame_nth = Benchmark("df.groupby(0).nth(0)", setup,
+ start_date=datetime(2014, 3, 1))
+
+groupby_series_nth = Benchmark("df[1].groupby(df[0]).nth(0)", setup,
+ start_date=datetime(2014, 3, 1))
+
+
#----------------------------------------------------------------------
# Sum booleans #2692
| fixes #5552
partial for #5264
```
In [101]: df = pd.DataFrame([[1, np.nan], [1, 4], [5, 6]], columns=['A', 'B'])
In [102]: g = df.groupby('A')
In [103]: g.nth(0)
Out[103]:
A B
0 1 NaN
2 5 6
In [104]: g.nth(1)
Out[104]:
A B
1 1 4
In [105]: g.nth(-1)
Out[105]:
A B
1 1 4
2 5 6
In [106]: g.nth(0, dropna='any') # old behaviour-like
Out[106]:
B
A
1 4
5 6
In [107]: g.nth(1, dropna='any') # old behaviour-like
Out[107]:
B
A
1 NaN
5 NaN
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/6569 | 2014-03-07T17:50:43Z | 2014-03-07T20:24:22Z | 2014-03-07T20:24:22Z | 2014-07-03T18:44:46Z |
BLD: change wheel url to pandas.pydata.org | diff --git a/ci/install.sh b/ci/install.sh
index 0525a8c89ccc3..fc1740857bfd2 100755
--- a/ci/install.sh
+++ b/ci/install.sh
@@ -35,7 +35,8 @@ pip install -I -U setuptools
pip install wheel
# comment this line to disable the fetching of wheel files
-base_url=http://cache27diy-cpycloud.rhcloud.com
+base_url=http://pandas.pydata.org/pandas-build/dev/wheels
+
wheel_box=${TRAVIS_PYTHON_VERSION}${JOB_TAG}
PIP_ARGS+=" -I --use-wheel --find-links=$base_url/$wheel_box/ --allow-external --allow-insecure"
diff --git a/ci/requirements-2.7.txt b/ci/requirements-2.7.txt
index 721204f5c8f6e..8fc289b5e1511 100644
--- a/ci/requirements-2.7.txt
+++ b/ci/requirements-2.7.txt
@@ -13,7 +13,6 @@ xlrd==0.9.2
patsy==0.1.0
html5lib==1.0b2
lxml==3.2.1
-scikits.timeseries==0.91.3
scipy==0.10.0
beautifulsoup4==4.2.1
statsmodels==0.5.0
diff --git a/ci/requirements-2.7_NUMPY_DEV_master.txt b/ci/requirements-2.7_NUMPY_DEV_master.txt
index 90fa8f11c1cfd..7d1d11daf9eeb 100644
--- a/ci/requirements-2.7_NUMPY_DEV_master.txt
+++ b/ci/requirements-2.7_NUMPY_DEV_master.txt
@@ -1,3 +1,3 @@
python-dateutil
-pytz==2013b
+pytz
cython==0.19.1
| BLD: remove scikit-timeseries from the deps and builds
closes #6566
| https://api.github.com/repos/pandas-dev/pandas/pulls/6567 | 2014-03-06T22:01:25Z | 2014-03-06T22:41:36Z | 2014-03-06T22:41:35Z | 2014-06-23T13:11:39Z |
BUG: preserve frequency across Timestamp addition/subtraction (#4547) | diff --git a/doc/source/release.rst b/doc/source/release.rst
index 183d662f1578d..c273ae11aa1dc 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -218,6 +218,7 @@ Bug Fixes
- Bug in ``DataFrame.to_stata`` that lead to data loss in certain cases, and could exported using the
wrong data types and missing values (:issue:`6335`)
- Inconsistent types in Timestamp addition/subtraction (:issue:`6543`)
+- Bug in preserving frequency across Timestamp addition/subtraction (:issue:`4547`)
- Bug in indexing: empty list lookup caused ``IndexError`` exceptions (:issue:`6536`, :issue:`6551`)
diff --git a/pandas/tseries/tests/test_tslib.py b/pandas/tseries/tests/test_tslib.py
index a24f545901ccd..b23b7b65825c5 100644
--- a/pandas/tseries/tests/test_tslib.py
+++ b/pandas/tseries/tests/test_tslib.py
@@ -330,6 +330,20 @@ def test_addition_subtraction_types(self):
self.assertEqual(type(timestamp_instance + timedelta64_instance), Timestamp)
self.assertEqual(type(timestamp_instance - timedelta64_instance), Timestamp)
+ def test_addition_subtraction_preserve_frequency(self):
+ timestamp_instance = date_range('2014-03-05', periods=1, freq='D')[0]
+ timedelta_instance = datetime.timedelta(days=1)
+ original_freq = timestamp_instance.freq
+ self.assertEqual((timestamp_instance + 1).freq, original_freq)
+ self.assertEqual((timestamp_instance - 1).freq, original_freq)
+ self.assertEqual((timestamp_instance + timedelta_instance).freq, original_freq)
+ self.assertEqual((timestamp_instance - timedelta_instance).freq, original_freq)
+
+ if not _np_version_under1p7:
+ timedelta64_instance = np.timedelta64(1, 'D')
+ self.assertEqual((timestamp_instance + timedelta64_instance).freq, original_freq)
+ self.assertEqual((timestamp_instance - timedelta64_instance).freq, original_freq)
+
if __name__ == '__main__':
nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
exit=False)
diff --git a/pandas/tslib.pyx b/pandas/tslib.pyx
index 9ff73e7c92fdb..da767b77d934c 100644
--- a/pandas/tslib.pyx
+++ b/pandas/tslib.pyx
@@ -681,17 +681,17 @@ cdef class _Timestamp(datetime):
if is_timedelta64_object(other):
other_int = other.astype('timedelta64[ns]').astype(int)
- return Timestamp(self.value + other_int, tz=self.tzinfo)
+ return Timestamp(self.value + other_int, tz=self.tzinfo, offset=self.offset)
if is_integer_object(other):
if self.offset is None:
raise ValueError("Cannot add integral value to Timestamp "
"without offset.")
- return Timestamp((self.offset * other).apply(self))
+ return Timestamp((self.offset * other).apply(self), offset=self.offset)
if isinstance(other, timedelta) or hasattr(other, 'delta'):
nanos = _delta_to_nanoseconds(other)
- return Timestamp(self.value + nanos, tz=self.tzinfo)
+ return Timestamp(self.value + nanos, tz=self.tzinfo, offset=self.offset)
result = datetime.__add__(self, other)
if isinstance(result, datetime):
| closes #4547
My second PR, on basically the same code.
Assuming people agree with my comments on #4547 (that users adding timedeltas that don't match frequencies better know what they are doing), then this would be my submission.
I'm also assuming that something is up with Travis and it is not anything I have done - nosetests passes fine for me though Travis still dies more or less at startup, while it didn't on older code. That problem is true of builds not including any code I have added, e.g. https://travis-ci.org/pydata/pandas/jobs/20167915 . Maybe something in PR #6068, or does this kind of thing happen from time to time?
| https://api.github.com/repos/pandas-dev/pandas/pulls/6560 | 2014-03-06T00:23:30Z | 2014-03-07T00:04:40Z | 2014-03-07T00:04:40Z | 2014-06-27T01:15:56Z |
BUG: Series.quantile raising on an object dtype (GH6555) | diff --git a/doc/source/release.rst b/doc/source/release.rst
index 183d662f1578d..03e21a26c9398 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -219,7 +219,7 @@ Bug Fixes
wrong data types and missing values (:issue:`6335`)
- Inconsistent types in Timestamp addition/subtraction (:issue:`6543`)
- Bug in indexing: empty list lookup caused ``IndexError`` exceptions (:issue:`6536`, :issue:`6551`)
-
+- Series.quantile raising on an ``object`` dtype (:issue:`6555`)
pandas 0.13.1
-------------
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 4fc7ced6e8900..409bbf60193af 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1287,7 +1287,7 @@ def quantile(self, q=0.5):
if len(valid_values) == 0:
return pa.NA
result = _quantile(valid_values, q * 100)
- if result.dtype == _TD_DTYPE:
+ if not np.isscalar and com.is_timedelta64_dtype(result):
from pandas.tseries.timedeltas import to_timedelta
return to_timedelta(result)
diff --git a/pandas/tests/test_series.py b/pandas/tests/test_series.py
index faf5341276ae5..71e506374c08d 100644
--- a/pandas/tests/test_series.py
+++ b/pandas/tests/test_series.py
@@ -2102,6 +2102,10 @@ def test_quantile(self):
q = self.ts.quantile(0.9)
self.assertEqual(q, scoreatpercentile(self.ts.valid(), 90))
+ # object dtype
+ q = Series(self.ts,dtype=object).quantile(0.9)
+ self.assertEqual(q, scoreatpercentile(self.ts.valid(), 90))
+
def test_describe(self):
_ = self.series.describe()
_ = self.ts.describe()
| closes #6555
| https://api.github.com/repos/pandas-dev/pandas/pulls/6558 | 2014-03-05T22:35:59Z | 2014-03-06T23:35:30Z | 2014-03-06T23:35:30Z | 2014-06-16T07:04:38Z |
ENH: Allow timestamp and data label to be set when exporting to Stata | diff --git a/doc/source/release.rst b/doc/source/release.rst
index 183d662f1578d..192d96884a02b 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -147,6 +147,7 @@ Improvements to existing features
- perf improvements in DataFrame construction with certain offsets, by removing faulty caching
(e.g. MonthEnd,BusinessMonthEnd), (:issue:`6479`)
- perf improvements in single-dtyped indexing (:issue:`6484`)
+- ``StataWriter`` and ``DataFrame.to_stata`` accept time stamp and data labels (:issue:`6545`)
.. _release.bug_fixes-0.14.0:
diff --git a/doc/source/v0.14.0.txt b/doc/source/v0.14.0.txt
index 7c6e6a01cd041..86034c20f63d8 100644
--- a/doc/source/v0.14.0.txt
+++ b/doc/source/v0.14.0.txt
@@ -312,6 +312,9 @@ Enhancements
- ``DataFrame.to_stata`` will now check data for compatibility with Stata data types
and will upcast when needed. When it isn't possibly to losslessly upcast, a warning
is raised (:issue:`6327`)
+- ``DataFrame.to_stata`` and ``StataWriter`` will accept keyword arguments time_stamp
+ and data_label which allow the time stamp and dataset label to be set when creating a
+ file. (:issue:`6545`)
Performance
~~~~~~~~~~~
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 4c02c8abab353..6885ce95a8505 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1216,7 +1216,7 @@ def to_excel(self, excel_writer, sheet_name='Sheet1', na_rep='',
def to_stata(
self, fname, convert_dates=None, write_index=True, encoding="latin-1",
- byteorder=None):
+ byteorder=None, time_stamp=None, data_label=None):
"""
A class for writing Stata binary dta files from array-like objects
@@ -1247,7 +1247,8 @@ def to_stata(
"""
from pandas.io.stata import StataWriter
writer = StataWriter(fname, self, convert_dates=convert_dates,
- encoding=encoding, byteorder=byteorder)
+ encoding=encoding, byteorder=byteorder,
+ time_stamp=time_stamp, data_label=data_label)
writer.write_file()
def to_sql(self, name, con, flavor='sqlite', if_exists='fail', **kwargs):
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index 2ecdb22a5cc7b..7d9d272eea1b6 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -375,6 +375,18 @@ def __init__(self, encoding):
'd': np.float64(struct.unpack('<d', b'\x00\x00\x00\x00\x00\x00\xe0\x7f')[0])
}
+ # Reserved words cannot be used as variable names
+ self.RESERVED_WORDS = ('aggregate', 'array', 'boolean', 'break',
+ 'byte', 'case', 'catch', 'class', 'colvector',
+ 'complex', 'const', 'continue', 'default',
+ 'delegate', 'delete', 'do', 'double', 'else',
+ 'eltypedef', 'end', 'enum', 'explicit',
+ 'export', 'external', 'float', 'for', 'friend',
+ 'function', 'global', 'goto', 'if', 'inline',
+ 'int', 'local', 'long', 'NULL', 'pragma',
+ 'protected', 'quad', 'rowvector', 'short',
+ 'typedef', 'typename', 'virtual')
+
def _decode_bytes(self, str, errors=None):
if compat.PY3 or self._encoding is not None:
return str.decode(self._encoding, errors)
@@ -449,10 +461,10 @@ def _read_header(self):
self.path_or_buf.read(4))[0]
self.path_or_buf.read(11) # </N><label>
strlen = struct.unpack('b', self.path_or_buf.read(1))[0]
- self.data_label = self.path_or_buf.read(strlen)
+ self.data_label = self._null_terminate(self.path_or_buf.read(strlen))
self.path_or_buf.read(19) # </label><timestamp>
strlen = struct.unpack('b', self.path_or_buf.read(1))[0]
- self.time_stamp = self.path_or_buf.read(strlen)
+ self.time_stamp = self._null_terminate(self.path_or_buf.read(strlen))
self.path_or_buf.read(26) # </timestamp></header><map>
self.path_or_buf.read(8) # 0x0000000000000000
self.path_or_buf.read(8) # position of <map>
@@ -543,11 +555,11 @@ def _read_header(self):
self.nobs = struct.unpack(self.byteorder + 'I',
self.path_or_buf.read(4))[0]
if self.format_version > 105:
- self.data_label = self.path_or_buf.read(81)
+ self.data_label = self._null_terminate(self.path_or_buf.read(81))
else:
- self.data_label = self.path_or_buf.read(32)
+ self.data_label = self._null_terminate(self.path_or_buf.read(32))
if self.format_version > 104:
- self.time_stamp = self.path_or_buf.read(18)
+ self.time_stamp = self._null_terminate(self.path_or_buf.read(18))
# descriptors
if self.format_version > 108:
@@ -1029,6 +1041,11 @@ class StataWriter(StataParser):
byteorder : str
Can be ">", "<", "little", or "big". The default is None which uses
`sys.byteorder`
+ time_stamp : datetime
+ A date time to use when writing the file. Can be None, in which
+ case the current time is used.
+ dataset_label : str
+ A label for the data set. Should be 80 characters or smaller.
Returns
-------
@@ -1047,10 +1064,13 @@ class StataWriter(StataParser):
>>> writer.write_file()
"""
def __init__(self, fname, data, convert_dates=None, write_index=True,
- encoding="latin-1", byteorder=None):
+ encoding="latin-1", byteorder=None, time_stamp=None,
+ data_label=None):
super(StataWriter, self).__init__(encoding)
self._convert_dates = convert_dates
self._write_index = write_index
+ self._time_stamp = time_stamp
+ self._data_label = data_label
# attach nobs, nvars, data, varlist, typlist
self._prepare_pandas(data)
@@ -1086,7 +1106,7 @@ def __iter__(self):
if self._write_index:
data = data.reset_index()
- # Check columns for compatbaility with stata
+ # Check columns for compatibility with stata
data = _cast_to_stata_types(data)
self.datarows = DataFrameRowIter(data)
self.nobs, self.nvar = data.shape
@@ -1110,7 +1130,8 @@ def __iter__(self):
self.fmtlist[key] = self._convert_dates[key]
def write_file(self):
- self._write_header()
+ self._write_header(time_stamp=self._time_stamp,
+ data_label=self._data_label)
self._write_descriptors()
self._write_variable_labels()
# write 5 zeros for expansion fields
@@ -1147,7 +1168,7 @@ def _write_header(self, data_label=None, time_stamp=None):
# format dd Mon yyyy hh:mm
if time_stamp is None:
time_stamp = datetime.datetime.now()
- elif not isinstance(time_stamp, datetime):
+ elif not isinstance(time_stamp, datetime.datetime):
raise ValueError("time_stamp should be datetime type")
self._file.write(
self._null_terminate(time_stamp.strftime("%d %b %Y %H:%M"))
@@ -1169,7 +1190,9 @@ def _write_descriptors(self, typlist=None, varlist=None, srtlist=None,
for c in name:
if (c < 'A' or c > 'Z') and (c < 'a' or c > 'z') and (c < '0' or c > '9') and c != '_':
name = name.replace(c, '_')
-
+ # Variable name must not be a reserved word
+ if name in self.RESERVED_WORDS:
+ name = '_' + name
# Variable name may not start with a number
if name[0] > '0' and name[0] < '9':
name = '_' + name
diff --git a/pandas/io/tests/test_stata.py b/pandas/io/tests/test_stata.py
index ac4b9662fc57e..307cd1bd591fb 100644
--- a/pandas/io/tests/test_stata.py
+++ b/pandas/io/tests/test_stata.py
@@ -1,6 +1,7 @@
# pylint: disable=E1101
from datetime import datetime
+import datetime as dt
import os
import warnings
import nose
@@ -248,7 +249,7 @@ def test_read_write_dta10(self):
original = DataFrame(data=[["string", "object", 1, 1.1,
np.datetime64('2003-12-25')]],
- columns=['string', 'object', 'integer', 'float',
+ columns=['string', 'object', 'integer', 'floating',
'datetime'])
original["object"] = Series(original["object"], dtype=object)
original.index.name = 'index'
@@ -304,10 +305,20 @@ def test_read_write_dta11(self):
def test_read_write_dta12(self):
# skip_if_not_little_endian()
- original = DataFrame([(1, 2, 3, 4)],
- columns=['astringwithmorethan32characters_1', 'astringwithmorethan32characters_2', '+', '-'])
- formatted = DataFrame([(1, 2, 3, 4)],
- columns=['astringwithmorethan32characters_', '_0astringwithmorethan32character', '_', '_1_'])
+ original = DataFrame([(1, 2, 3, 4, 5, 6)],
+ columns=['astringwithmorethan32characters_1',
+ 'astringwithmorethan32characters_2',
+ '+',
+ '-',
+ 'short',
+ 'delete'])
+ formatted = DataFrame([(1, 2, 3, 4, 5, 6)],
+ columns=['astringwithmorethan32characters_',
+ '_0astringwithmorethan32character',
+ '_',
+ '_1_',
+ '_short',
+ '_delete'])
formatted.index.name = 'index'
formatted = formatted.astype(np.int32)
@@ -376,6 +387,17 @@ def test_read_write_reread_dta15(self):
tm.assert_frame_equal(parsed_113, parsed_114)
tm.assert_frame_equal(parsed_114, parsed_115)
+ def test_timestamp_and_label(self):
+ original = DataFrame([(1,)], columns=['var'])
+ time_stamp = datetime(2000, 2, 29, 14, 21)
+ data_label = 'This is a data file.'
+ with tm.ensure_clean() as path:
+ original.to_stata(path, time_stamp=time_stamp, data_label=data_label)
+ reader = StataReader(path)
+ parsed_time_stamp = dt.datetime.strptime(reader.time_stamp, ('%d %b %Y %H:%M'))
+ assert parsed_time_stamp == time_stamp
+ assert reader.data_label == data_label
+
if __name__ == '__main__':
| closes #6545
Added code which allows the time stamp and the data label to be set using
either StataWriter or to_stata. Also simplified reading these values using
StataReader by removing null bytes from the string values read.
Added basic test for both.
Also fixed one small bug where variables could be stored using Stata reserved
words.
| https://api.github.com/repos/pandas-dev/pandas/pulls/6553 | 2014-03-05T13:46:45Z | 2014-03-07T00:01:16Z | 2014-03-07T00:01:16Z | 2014-07-16T08:57:07Z |
BUG: fix fancy indexing with empty list | diff --git a/doc/source/release.rst b/doc/source/release.rst
index 1819272c59243..9eceb4b767eac 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -207,6 +207,7 @@ Bug Fixes
- Bug in ``pd.read_stata`` which would use the wrong data types and missing values (:issue:`6327`)
- Bug in ``DataFrame.to_stata`` that lead to data loss in certain cases, and could exported using the
wrong data types and missing values (:issue:`6335`)
+- Bug in indexing: empty list lookup caused ``IndexError`` exceptions (:issue:`6536`, :issue:`6551`)
pandas 0.13.1
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index e3cbddebb6643..39ddc9a7ee22a 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -1555,6 +1555,10 @@ def _maybe_convert_indices(indices, n):
"""
if isinstance(indices, list):
indices = np.array(indices)
+ if len(indices) == 0:
+ # If list is empty, np.array will return float and cause indexing
+ # errors.
+ return np.empty(0, dtype=np.int_)
mask = indices < 0
if mask.any():
diff --git a/pandas/tests/test_indexing.py b/pandas/tests/test_indexing.py
index 325d770fb62c9..3f6ae24756d47 100644
--- a/pandas/tests/test_indexing.py
+++ b/pandas/tests/test_indexing.py
@@ -3175,6 +3175,26 @@ def test_set_ix_out_of_bounds_axis_1(self):
df = pd.DataFrame(randn(5, 2), index=["row%s" % i for i in range(5)], columns=["col%s" % i for i in range(2)])
self.assertRaises(ValueError, df.ix.__setitem__, (0 , 2), 100)
+ def test_iloc_empty_list_indexer_is_ok(self):
+ from pandas.util.testing import makeCustomDataframe as mkdf
+ df = mkdf(5, 2)
+ assert_frame_equal(df.iloc[:,[]], df.iloc[:, :0]) # vertical empty
+ assert_frame_equal(df.iloc[[],:], df.iloc[:0, :]) # horizontal empty
+
+ # FIXME: fix loc & xs
+ def test_loc_empty_list_indexer_is_ok(self):
+ raise nose.SkipTest('loc discards columns names')
+ from pandas.util.testing import makeCustomDataframe as mkdf
+ df = mkdf(5, 2)
+ assert_frame_equal(df.loc[:,[]], df.iloc[:, :0]) # vertical empty
+ assert_frame_equal(df.loc[[],:], df.iloc[:0, :]) # horizontal empty
+
+ def test_ix_empty_list_indexer_is_ok(self):
+ raise nose.SkipTest('ix discards columns names')
+ from pandas.util.testing import makeCustomDataframe as mkdf
+ df = mkdf(5, 2)
+ assert_frame_equal(df.ix[:,[]], df.iloc[:, :0]) # vertical empty
+ assert_frame_equal(df.ix[[],:], df.iloc[:0, :]) # horizontal empty
if __name__ == '__main__':
import nose
| This should fix #6536.
There's a side issue though with loc/ix indexers that somehow discard column names for empty indexers.
| https://api.github.com/repos/pandas-dev/pandas/pulls/6551 | 2014-03-05T12:03:51Z | 2014-03-06T23:01:26Z | 2014-03-06T23:01:26Z | 2014-10-15T13:40:48Z |
BUG: Bug in setitem with loc on mixed integer Indexes (GH6546) | diff --git a/doc/source/release.rst b/doc/source/release.rst
index f5e2c80289c5c..d84afc66bf9ac 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -200,6 +200,7 @@ Bug Fixes
- Regression from 0.13 in the treatmenet of numpy ``datetime64`` non-ns dtypes in Series creation (:issue:`6529`)
- ``.names`` attribute of MultiIndexes passed to ``set_index`` are now preserved (:issue:`6459`).
- Bug in setitem with a duplicate index and an alignable rhs (:issue:`6541`)
+- Bug in setitem with loc on mixed integer Indexes (:issue:`6546`)
pandas 0.13.1
-------------
diff --git a/pandas/core/index.py b/pandas/core/index.py
index f67270530c3f8..30e18d239d950 100644
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -555,6 +555,29 @@ def _convert_list_indexer(self, key, typ=None):
""" convert a list indexer. these should be locations """
return key
+ def _convert_list_indexer_for_mixed(self, keyarr, typ=None):
+ """ passed a key that is tuplesafe that is integer based
+ and we have a mixed index (e.g. number/labels). figure out
+ the indexer. return None if we can't help
+ """
+ if com.is_integer_dtype(keyarr) and not self.is_floating():
+ if self.inferred_type != 'integer':
+ keyarr = np.where(keyarr < 0,
+ len(self) + keyarr, keyarr)
+
+ if self.inferred_type == 'mixed-integer':
+ indexer = self.get_indexer(keyarr)
+ if (indexer >= 0).all():
+ return indexer
+
+ from pandas.core.indexing import _maybe_convert_indices
+ return _maybe_convert_indices(indexer, len(self))
+
+ elif not self.inferred_type == 'integer':
+ return keyarr
+
+ return None
+
def _convert_indexer_error(self, key, msg=None):
if msg is None:
msg = 'label'
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 288934dbd27f4..c7970309a6558 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -911,20 +911,10 @@ def _reindex(keys, level=None):
# asarray can be unsafe, NumPy strings are weird
keyarr = _asarray_tuplesafe(key)
- if is_integer_dtype(keyarr) and not labels.is_floating():
- if labels.inferred_type != 'integer':
- keyarr = np.where(keyarr < 0,
- len(labels) + keyarr, keyarr)
-
- if labels.inferred_type == 'mixed-integer':
- indexer = labels.get_indexer(keyarr)
- if (indexer >= 0).all():
- self.obj.take(indexer, axis=axis, convert=True)
- else:
- return self.obj.take(keyarr, axis=axis)
- elif not labels.inferred_type == 'integer':
-
- return self.obj.take(keyarr, axis=axis)
+ # handle a mixed integer scenario
+ indexer = labels._convert_list_indexer_for_mixed(keyarr, typ=self.name)
+ if indexer is not None:
+ return self.obj.take(indexer, axis=axis)
# this is not the most robust, but...
if (isinstance(labels, MultiIndex) and
@@ -1064,11 +1054,9 @@ def _convert_to_indexer(self, obj, axis=0, is_setter=False):
objarr = _asarray_tuplesafe(obj)
# If have integer labels, defer to label-based indexing
- if is_integer_dtype(objarr) and not is_int_index:
- if labels.inferred_type != 'integer':
- objarr = np.where(objarr < 0,
- len(labels) + objarr, objarr)
- return objarr
+ indexer = labels._convert_list_indexer_for_mixed(objarr, typ=self.name)
+ if indexer is not None:
+ return indexer
# this is not the most robust, but...
if (isinstance(labels, MultiIndex) and
diff --git a/pandas/tests/test_indexing.py b/pandas/tests/test_indexing.py
index f466ea302ee1c..1d033782a0175 100644
--- a/pandas/tests/test_indexing.py
+++ b/pandas/tests/test_indexing.py
@@ -835,6 +835,19 @@ def test_loc_setitem_frame(self):
expected = DataFrame(dict(A = Series(val1,index=keys1), B = Series(val2,index=keys2))).reindex(index=index)
assert_frame_equal(df, expected)
+ # GH 6546
+ # setting with mixed labels
+ df = DataFrame({1:[1,2],2:[3,4],'a':['a','b']})
+
+ result = df.loc[0,[1,2]]
+ expected = Series([1,3],index=[1,2],dtype=object)
+ assert_series_equal(result,expected)
+
+ expected = DataFrame({1:[5,2],2:[6,4],'a':['a','b']})
+ df.loc[0,[1,2]] = [5,6]
+ assert_frame_equal(df, expected)
+
+
def test_loc_setitem_frame_multiples(self):
# multiple setting
| closes #6546
| https://api.github.com/repos/pandas-dev/pandas/pulls/6548 | 2014-03-05T00:25:42Z | 2014-03-05T01:02:29Z | 2014-03-05T01:02:29Z | 2014-06-12T11:59:19Z |
BUG: Bug in setitem with a duplicate index and an alignable rhs (GH6541) | diff --git a/doc/source/release.rst b/doc/source/release.rst
index 29fd5bad16986..f5e2c80289c5c 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -199,6 +199,7 @@ Bug Fixes
- Bug that caused _ref_locs corruption when slice indexing across columns axis of a DataFrame (:issue:`6525`)
- Regression from 0.13 in the treatmenet of numpy ``datetime64`` non-ns dtypes in Series creation (:issue:`6529`)
- ``.names`` attribute of MultiIndexes passed to ``set_index`` are now preserved (:issue:`6459`).
+- Bug in setitem with a duplicate index and an alignable rhs (:issue:`6541`)
pandas 0.13.1
-------------
diff --git a/pandas/core/index.py b/pandas/core/index.py
index c16e2eff06904..f67270530c3f8 100644
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -987,8 +987,13 @@ def intersection(self, other):
except TypeError:
pass
- indexer = self.get_indexer(other.values)
- indexer = indexer.take((indexer != -1).nonzero()[0])
+ try:
+ indexer = self.get_indexer(other.values)
+ indexer = indexer.take((indexer != -1).nonzero()[0])
+ except:
+ # duplicates
+ indexer = self.get_indexer_non_unique(other.values)[0].unique()
+
return self.take(indexer)
def diff(self, other):
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 6691db5f35bb4..288934dbd27f4 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -441,7 +441,9 @@ def can_do_equal_len():
# align to
if item in value:
v = value[item]
- v = v.reindex(self.obj[item].index & v.index)
+ i = self.obj[item].index
+ v = v.reindex(i & v.index)
+
setter(item, v.values)
else:
setter(item, np.nan)
diff --git a/pandas/tests/test_indexing.py b/pandas/tests/test_indexing.py
index d373f2f43ad3e..f466ea302ee1c 100644
--- a/pandas/tests/test_indexing.py
+++ b/pandas/tests/test_indexing.py
@@ -564,6 +564,29 @@ def test_loc_setitem(self):
expected = DataFrame({'a' : [0.5,-0.5,-1.5], 'b' : [0,1,2] })
assert_frame_equal(df,expected)
+ def test_loc_setitem_dups(self):
+
+ # GH 6541
+ df_orig = DataFrame({'me' : list('rttti'),
+ 'foo': list('aaade'),
+ 'bar': np.arange(5,dtype='float64')*1.34+2,
+ 'bar2': np.arange(5,dtype='float64')*-.34+2}).set_index('me')
+
+ indexer = tuple(['r',['bar','bar2']])
+ df = df_orig.copy()
+ df.loc[indexer]*=2.0
+ assert_series_equal(df.loc[indexer],2.0*df_orig.loc[indexer])
+
+ indexer = tuple(['r','bar'])
+ df = df_orig.copy()
+ df.loc[indexer]*=2.0
+ self.assertEqual(df.loc[indexer],2.0*df_orig.loc[indexer])
+
+ indexer = tuple(['t',['bar','bar2']])
+ df = df_orig.copy()
+ df.loc[indexer]*=2.0
+ assert_frame_equal(df.loc[indexer],2.0*df_orig.loc[indexer])
+
def test_chained_getitem_with_lists(self):
# GH6394
| closes #6541
| https://api.github.com/repos/pandas-dev/pandas/pulls/6542 | 2014-03-04T18:33:03Z | 2014-03-04T19:10:20Z | 2014-03-04T19:10:20Z | 2014-07-11T04:46:38Z |
BUG: informative error message with Series ValueError | diff --git a/doc/source/release.rst b/doc/source/release.rst
index ae31f1e7fc495..30cb5fb56f96f 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -139,6 +139,7 @@ Improvements to existing features
Bug Fixes
~~~~~~~~~
+- Bug in Series ValueError when index doesn't match data (:issue:`6532`)
- Bug in ``pd.DataFrame.sort_index`` where mergesort wasn't stable when ``ascending=False`` (:issue:`6399`)
- Bug in ``pd.tseries.frequencies.to_offset`` when argument has leading zeroes (:issue:`6391`)
- Bug in version string gen. for dev versions with shallow clones / install from tarball (:issue:`6127`)
diff --git a/pandas/core/internals.py b/pandas/core/internals.py
index 6d2b2933eb597..e3deed52f4b3f 100644
--- a/pandas/core/internals.py
+++ b/pandas/core/internals.py
@@ -61,8 +61,8 @@ def __init__(self, values, items, ref_items, ndim=None, fastpath=False,
raise ValueError('Wrong number of dimensions')
if len(items) != len(values):
- raise ValueError('Wrong number of items passed %d, indices imply '
- '%d' % (len(items), len(values)))
+ raise ValueError('Wrong number of items passed %d, index implies '
+ '%d' % (len(values), len(items)))
self.set_ref_locs(placement)
self.values = values
| Fixes issue #6532.
| https://api.github.com/repos/pandas-dev/pandas/pulls/6535 | 2014-03-04T03:51:05Z | 2014-03-04T05:51:10Z | 2014-03-04T05:51:10Z | 2014-06-16T02:20:16Z |
API change in groupby head and tail | diff --git a/doc/source/groupby.rst b/doc/source/groupby.rst
index a88b7332d9b9e..76c4280d8b728 100644
--- a/doc/source/groupby.rst
+++ b/doc/source/groupby.rst
@@ -707,6 +707,38 @@ can be used as group keys. If so, the order of the levels will be preserved:
data.groupby(factor).mean()
+
+Taking the first rows of each group
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Just like for a DataFrame or Series you can call head and tail on a groupby:
+
+.. ipython:: python
+
+ df = DataFrame([[1, 2], [1, 4], [5, 6]], columns=['A', 'B'])
+ df
+
+ g = df.groupby('A')
+ g.head(1)
+
+ g.tail(1)
+
+This shows the first or last n rows from each group.
+
+.. warning::
+
+ Before 0.14.0 this was implemented with a fall-through apply,
+ so the result would incorrectly respect the as_index flag:
+
+ .. code-block:: python
+
+ >>> g.head(1): # was equivalent to g.apply(lambda x: x.head(1))
+ A B
+ A
+ 1 0 1 2
+ 5 2 5 6
+
+
Enumerate group items
~~~~~~~~~~~~~~~~~~~~~
diff --git a/doc/source/v0.14.0.txt b/doc/source/v0.14.0.txt
index 4432e9e891e7d..a3d6d255db9a9 100644
--- a/doc/source/v0.14.0.txt
+++ b/doc/source/v0.14.0.txt
@@ -61,6 +61,24 @@ These are out-of-bounds selections
s.year
s.index.year
+- More consistent behaviour for some groupby methods:
+ - groupby head and tail now act more like filter rather than an aggregation:
+
+ .. ipython:: python
+
+ df = pd.DataFrame([[1, 2], [1, 4], [5, 6]], columns=['A', 'B'])
+ g = df.groupby('A')
+ g.head(1) # filters DataFrame
+
+ g.apply(lambda x: x.head(1)) # used to simply fall-through
+
+ - groupby head and tail respect column selection:
+
+ .. ipython:: python
+
+ g[['B']].head(1)
+
+
- Local variable usage has changed in
:func:`pandas.eval`/:meth:`DataFrame.eval`/:meth:`DataFrame.query`
(:issue:`5987`). For the :class:`~pandas.DataFrame` methods, two things have
diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py
index f0588524e16eb..598df5507fa69 100644
--- a/pandas/core/groupby.py
+++ b/pandas/core/groupby.py
@@ -587,7 +587,8 @@ def head(self, n=5):
"""
Returns first n rows of each group.
- Essentially equivalent to ``.apply(lambda x: x.head(n))``
+ Essentially equivalent to ``.apply(lambda x: x.head(n))``,
+ except ignores as_index flag.
Example
-------
@@ -599,24 +600,23 @@ def head(self, n=5):
0 1 2
2 5 6
>>> df.groupby('A').head(1)
- A B
- A
- 1 0 1 2
- 5 2 5 6
+ A B
+ 0 1 2
+ 2 5 6
"""
+ obj = self._selected_obj
rng = np.arange(self.grouper._max_groupsize, dtype='int64')
in_head = self._cumcount_array(rng) < n
- head = self.obj[in_head]
- if self.as_index:
- head.index = self._index_with_as_index(in_head)
+ head = obj[in_head]
return head
def tail(self, n=5):
"""
Returns last n rows of each group
- Essentially equivalent to ``.apply(lambda x: x.tail(n))``
+ Essentially equivalent to ``.apply(lambda x: x.tail(n))``,
+ except ignores as_index flag.
Example
-------
@@ -628,17 +628,15 @@ def tail(self, n=5):
0 1 2
2 5 6
>>> df.groupby('A').head(1)
- A B
- A
- 1 0 1 2
- 5 2 5 6
+ A B
+ 0 1 2
+ 2 5 6
"""
+ obj = self._selected_obj
rng = np.arange(0, -self.grouper._max_groupsize, -1, dtype='int64')
in_tail = self._cumcount_array(rng, ascending=False) > -n
- tail = self.obj[in_tail]
- if self.as_index:
- tail.index = self._index_with_as_index(in_tail)
+ tail = obj[in_tail]
return tail
def _cumcount_array(self, arr, **kwargs):
@@ -654,6 +652,13 @@ def _cumcount_array(self, arr, **kwargs):
cumcounts[v] = arr[len(v)-1::-1]
return cumcounts
+ @cache_readonly
+ def _selected_obj(self):
+ if self._selection is None or isinstance(self.obj, Series):
+ return self.obj
+ else:
+ return self.obj[self._selection]
+
def _index_with_as_index(self, b):
"""
Take boolean mask of index to be returned from apply, if as_index=True
diff --git a/pandas/tests/test_groupby.py b/pandas/tests/test_groupby.py
index 4eee1d3a212e0..8af11c8bf77e1 100644
--- a/pandas/tests/test_groupby.py
+++ b/pandas/tests/test_groupby.py
@@ -1315,12 +1315,10 @@ def test_groupby_as_index_apply(self):
g_not_as = df.groupby('user_id', as_index=False)
res_as = g_as.head(2).index
- exp_as = MultiIndex.from_tuples([(1, 0), (2, 1), (1, 2), (3, 4)])
- assert_index_equal(res_as, exp_as)
-
res_not_as = g_not_as.head(2).index
- exp_not_as = Index([0, 1, 2, 4])
- assert_index_equal(res_not_as, exp_not_as)
+ exp = Index([0, 1, 2, 4])
+ assert_index_equal(res_as, exp)
+ assert_index_equal(res_not_as, exp)
res_as_apply = g_as.apply(lambda x: x.head(2)).index
res_not_as_apply = g_not_as.apply(lambda x: x.head(2)).index
@@ -1355,11 +1353,8 @@ def test_groupby_head_tail(self):
assert_frame_equal(df, g_not_as.head(7)) # contains all
assert_frame_equal(df, g_not_as.tail(7))
- # as_index=True, yuck
- # prepend the A column as an index, in a roundabout way
- df_as = df.copy()
- df_as.index = df.set_index('A', append=True,
- drop=False).index.swaplevel(0, 1)
+ # as_index=True, (used to be different)
+ df_as = df
assert_frame_equal(df_as.loc[[0, 2]], g_as.head(1))
assert_frame_equal(df_as.loc[[1, 2]], g_as.tail(1))
@@ -1373,6 +1368,18 @@ def test_groupby_head_tail(self):
assert_frame_equal(df_as, g_as.head(7)) # contains all
assert_frame_equal(df_as, g_as.tail(7))
+ # test with selection
+ assert_frame_equal(g_as[[]].head(1), df_as.loc[[0,2], []])
+ assert_frame_equal(g_as[['A']].head(1), df_as.loc[[0,2], ['A']])
+ assert_frame_equal(g_as[['B']].head(1), df_as.loc[[0,2], ['B']])
+ assert_frame_equal(g_as[['A', 'B']].head(1), df_as.loc[[0,2]])
+
+ assert_frame_equal(g_not_as[[]].head(1), df_as.loc[[0,2], []])
+ assert_frame_equal(g_not_as[['A']].head(1), df_as.loc[[0,2], ['A']])
+ assert_frame_equal(g_not_as[['B']].head(1), df_as.loc[[0,2], ['B']])
+ assert_frame_equal(g_not_as[['A', 'B']].head(1), df_as.loc[[0,2]])
+
+
def test_groupby_multiple_key(self):
df = tm.makeTimeDataFrame()
grouped = df.groupby([lambda x: x.year,
| BUG/API groupby head and tail act like filter, since they dont aggregage fixes column selection
Breaking API change to groupby head and tail, these were never aggregated output, so should not have the group labels as the index, it should always filter. (It was a legacy from when this was `g.apply(lambda x: x.head(n))`.)
```
as_index : boolean, default True
For aggregated output, return object with group labels as the
index. Only relevant for DataFrame input. as_index=False is
effectively "SQL-style" grouped output
```
Also fixes the column selection for head and tail
part of #5755
related #6524
part of #5264.
cc @jreback @TomAugspurger
| https://api.github.com/repos/pandas-dev/pandas/pulls/6533 | 2014-03-03T23:54:07Z | 2014-03-06T00:21:26Z | 2014-03-06T00:21:26Z | 2014-06-27T15:35:00Z |
BUG/TST: fix several issues with slice bound checking code | diff --git a/doc/source/release.rst b/doc/source/release.rst
index f4f376026225e..1819272c59243 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -108,6 +108,9 @@ API Changes
- Slicing and advanced/boolean indexing operations on ``Index`` classes will no
longer change type of the resulting index (:issue:`6440`).
- ``set_index`` no longer converts MultiIndexes to an Index of tuples (:issue:`6459`).
+- Slicing with negative start, stop & step values handles corner cases better (:issue:`6531`):
+ - ``df.iloc[:-len(df)]`` is now empty
+ - ``df.iloc[len(df)::-1]`` now enumerates all elements in reverse
Experimental Features
~~~~~~~~~~~~~~~~~~~~~
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 05f7785a401f8..4c02c8abab353 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1867,11 +1867,6 @@ def eval(self, expr, **kwargs):
kwargs['resolvers'] = kwargs.get('resolvers', ()) + resolvers
return _eval(expr, **kwargs)
- def _slice(self, slobj, axis=0, raise_on_error=False, typ=None):
- axis = self._get_block_manager_axis(axis)
- new_data = self._data.get_slice(
- slobj, axis=axis, raise_on_error=raise_on_error)
- return self._constructor(new_data)
def _box_item_values(self, key, values):
items = self.columns[self.columns.get_loc(key)]
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 8ca397eda17e9..120e03e9962d8 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -1079,6 +1079,16 @@ def _clear_item_cache(self, i=None):
else:
self._item_cache.clear()
+ def _slice(self, slobj, axis=0, typ=None):
+ """
+ Construct a slice of this container.
+
+ typ parameter is maintained for compatibility with Series slicing.
+
+ """
+ axis = self._get_block_manager_axis(axis)
+ return self._constructor(self._data.get_slice(slobj, axis=axis))
+
def _set_item(self, key, value):
self._data.set(key, value)
self._clear_item_cache()
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index c7970309a6558..e3cbddebb6643 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -91,32 +91,8 @@ def _get_label(self, label, axis=0):
def _get_loc(self, key, axis=0):
return self.obj._ixs(key, axis=axis)
- def _slice(self, obj, axis=0, raise_on_error=False, typ=None):
-
- # make out-of-bounds into bounds of the object
- if typ == 'iloc':
- ax = self.obj._get_axis(axis)
- l = len(ax)
- start = obj.start
- stop = obj.stop
- step = obj.step
- if start is not None:
- # degenerate to return nothing
- if start >= l:
- return self._getitem_axis(tuple(),axis=axis)
-
- # equiv to a null slice
- elif start <= -l:
- start = None
- if stop is not None:
- if stop > l:
- stop = None
- elif stop <= -l:
- stop = None
- obj = slice(start,stop,step)
-
- return self.obj._slice(obj, axis=axis, raise_on_error=raise_on_error,
- typ=typ)
+ def _slice(self, obj, axis=0, typ=None):
+ return self.obj._slice(obj, axis=axis, typ=typ)
def __setitem__(self, key, value):
@@ -1343,8 +1319,7 @@ def _get_slice_axis(self, slice_obj, axis=0):
return obj
if isinstance(slice_obj, slice):
- return self._slice(slice_obj, axis=axis, raise_on_error=True,
- typ='iloc')
+ return self._slice(slice_obj, axis=axis, typ='iloc')
else:
return self.obj.take(slice_obj, axis=axis, convert=False)
@@ -1647,18 +1622,6 @@ def _need_slice(obj):
(obj.step is not None and obj.step != 1))
-def _check_slice_bounds(slobj, values):
- l = len(values)
- start = slobj.start
- if start is not None:
- if start < -l or start > l - 1:
- raise IndexError("out-of-bounds on slice (start)")
- stop = slobj.stop
- if stop is not None:
- if stop < -l - 1 or stop > l:
- raise IndexError("out-of-bounds on slice (end)")
-
-
def _maybe_droplevels(index, key):
# drop levels
original_index = index
diff --git a/pandas/core/internals.py b/pandas/core/internals.py
index e3deed52f4b3f..39eb03eebdb8c 100644
--- a/pandas/core/internals.py
+++ b/pandas/core/internals.py
@@ -14,8 +14,7 @@
_values_from_object, _is_null_datelike_scalar)
from pandas.core.index import (Index, MultiIndex, _ensure_index,
_handle_legacy_indexes)
-from pandas.core.indexing import (_check_slice_bounds, _maybe_convert_indices,
- _length_of_indexer)
+from pandas.core.indexing import (_maybe_convert_indices, _length_of_indexer)
import pandas.core.common as com
from pandas.sparse.array import _maybe_to_sparse, SparseArray
import pandas.lib as lib
@@ -2669,12 +2668,9 @@ def combine(self, blocks):
new_axes[0] = new_items
return self.__class__(new_blocks, new_axes, do_integrity_check=False)
- def get_slice(self, slobj, axis=0, raise_on_error=False):
+ def get_slice(self, slobj, axis=0):
new_axes = list(self.axes)
- if raise_on_error:
- _check_slice_bounds(slobj, new_axes[axis])
-
new_axes[axis] = new_axes[axis][slobj]
if axis == 0:
@@ -3739,9 +3735,7 @@ def _delete_from_block(self, i, item):
)
self._values = self._block.values
- def get_slice(self, slobj, raise_on_error=False):
- if raise_on_error:
- _check_slice_bounds(slobj, self.index)
+ def get_slice(self, slobj):
return self.__class__(self._block._slice(slobj),
self.index[slobj], fastpath=True)
diff --git a/pandas/core/panel.py b/pandas/core/panel.py
index eba526f574375..2bf50bb1bf142 100644
--- a/pandas/core/panel.py
+++ b/pandas/core/panel.py
@@ -539,12 +539,6 @@ def _box_item_values(self, key, values):
d = self._construct_axes_dict_for_slice(self._AXIS_ORDERS[1:])
return self._constructor_sliced(values, **d)
- def _slice(self, slobj, axis=0, raise_on_error=False, typ=None):
- new_data = self._data.get_slice(slobj,
- axis=axis,
- raise_on_error=raise_on_error)
- return self._constructor(new_data)
-
def __setitem__(self, key, value):
shape = tuple(self.shape)
if isinstance(value, self._constructor_sliced):
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 9e6c0bd9305ab..4fc7ced6e8900 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -28,7 +28,7 @@
from pandas.core.index import (Index, MultiIndex, InvalidIndexError,
_ensure_index, _handle_legacy_indexes)
from pandas.core.indexing import (
- _check_bool_indexer, _check_slice_bounds,
+ _check_bool_indexer,
_is_index_slice, _maybe_convert_indices)
from pandas.core import generic, base
from pandas.core.internals import SingleBlockManager
@@ -469,9 +469,7 @@ def _ixs(self, i, axis=0):
def _is_mixed_type(self):
return False
- def _slice(self, slobj, axis=0, raise_on_error=False, typ=None):
- if raise_on_error:
- _check_slice_bounds(slobj, self.values)
+ def _slice(self, slobj, axis=0, typ=None):
slobj = self.index._convert_slice_indexer(slobj, typ=typ or 'getitem')
return self._get_values(slobj)
diff --git a/pandas/sparse/frame.py b/pandas/sparse/frame.py
index 6e76155619c09..a69c07494af8a 100644
--- a/pandas/sparse/frame.py
+++ b/pandas/sparse/frame.py
@@ -13,7 +13,7 @@
from pandas.core.common import (isnull, notnull, _pickle_array,
_unpickle_array, _try_sort)
from pandas.core.index import Index, MultiIndex, _ensure_index
-from pandas.core.indexing import _check_slice_bounds, _maybe_convert_indices
+from pandas.core.indexing import _maybe_convert_indices
from pandas.core.series import Series
from pandas.core.frame import (DataFrame, extract_index, _prep_ndarray,
_default_index)
@@ -379,15 +379,11 @@ def set_value(self, index, col, value, takeable=False):
return dense.to_sparse(kind=self._default_kind,
fill_value=self._default_fill_value)
- def _slice(self, slobj, axis=0, raise_on_error=False, typ=None):
+ def _slice(self, slobj, axis=0, typ=None):
if axis == 0:
- if raise_on_error:
- _check_slice_bounds(slobj, self.index)
new_index = self.index[slobj]
new_columns = self.columns
else:
- if raise_on_error:
- _check_slice_bounds(slobj, self.columns)
new_index = self.index
new_columns = self.columns[slobj]
diff --git a/pandas/sparse/panel.py b/pandas/sparse/panel.py
index 86dcf97c8bd3d..20bbc58cc908f 100644
--- a/pandas/sparse/panel.py
+++ b/pandas/sparse/panel.py
@@ -187,7 +187,7 @@ def _ixs(self, i, axis=0):
return self.xs(key, axis=axis)
- def _slice(self, slobj, axis=0, raise_on_error=False, typ=None):
+ def _slice(self, slobj, axis=0, typ=None):
"""
for compat as we don't support Block Manager here
"""
diff --git a/pandas/tests/test_indexing.py b/pandas/tests/test_indexing.py
index 1d033782a0175..325d770fb62c9 100644
--- a/pandas/tests/test_indexing.py
+++ b/pandas/tests/test_indexing.py
@@ -393,12 +393,36 @@ def test_iloc_exceeds_bounds(self):
self.assertRaises(IndexError, lambda : df.iloc[-30])
# slices are ok
- result = df.iloc[:,4:10]
+ result = df.iloc[:,4:10] # 0 < start < len < stop
expected = df.iloc[:,4:]
assert_frame_equal(result,expected)
- result = df.iloc[:,-4:-10]
- expected = df.iloc[:,-4:]
+ result = df.iloc[:,-4:-10] # stop < 0 < start < len
+ expected = df.iloc[:,:0]
+ assert_frame_equal(result,expected)
+
+ result = df.iloc[:,10:4:-1] # 0 < stop < len < start (down)
+ expected = df.iloc[:,:4:-1]
+ assert_frame_equal(result,expected)
+
+ result = df.iloc[:,4:-10:-1] # stop < 0 < start < len (down)
+ expected = df.iloc[:,4::-1]
+ assert_frame_equal(result,expected)
+
+ result = df.iloc[:,-10:4] # start < 0 < stop < len
+ expected = df.iloc[:,:4]
+ assert_frame_equal(result,expected)
+
+ result = df.iloc[:,10:4] # 0 < stop < len < start
+ expected = df.iloc[:,:0]
+ assert_frame_equal(result,expected)
+
+ result = df.iloc[:,-10:-11:-1] # stop < start < 0 < len (down)
+ expected = df.iloc[:,:0]
+ assert_frame_equal(result,expected)
+
+ result = df.iloc[:,10:11] # 0 < len < start < stop
+ expected = df.iloc[:,:0]
assert_frame_equal(result,expected)
# slice bounds exceeding is ok
@@ -406,6 +430,14 @@ def test_iloc_exceeds_bounds(self):
expected = s.iloc[18:]
assert_series_equal(result,expected)
+ result = s.iloc[30:]
+ expected = s.iloc[:0]
+ assert_series_equal(result,expected)
+
+ result = s.iloc[30::-1]
+ expected = s.iloc[::-1]
+ assert_series_equal(result,expected)
+
# doc example
def check(result,expected):
str(result)
| This patch removes more of what's left after removing pandas-specific customizations to slice indexing.
BUG/TST: `obj.iloc[:,-4:-10]` should return empty slice (because slice.step > 0 and slice.start > slice.stop)
There's no way to describe this by setting stop to a value in `[0; len]` interval, it should remain negative (see [this ticket in python bugtracker](http://bugs.python.org/issue11842)]. Proposed fix to this issue is to remove the custom logic altogether. A side-effect of that is correct handling of negative steps in presence of out-of-bounds slices, e.g. `obj.iloc[:,10:4:-1]` would've incorrectly returned empty slice.
BUG: fix exception raised by `Series([1,2,3]).iloc[10:]`.
After I've cleaned up suspicious code that handled empty-sequence keys in #6440, this piece of code started causing trouble:
``` python
if start >= l:
return self._getitem_axis(tuple(),axis=axis)
```
CLN: #6299 & #6443 rendered `core.indexing._check_slice_bounds` function useless and it's now gone. Next step would be to drop unused `raise_on_error` parameter in slice-related functions.
Not sure, how do I put down all these relations into changelog, advice on that is welcome.
| https://api.github.com/repos/pandas-dev/pandas/pulls/6531 | 2014-03-03T17:04:55Z | 2014-03-05T11:20:16Z | 2014-03-05T11:20:16Z | 2014-06-12T19:22:01Z |
BUG: Regression from 0.13 in the treatment of numpy datetime64 non-ns dtypes in Series creation (GH6429) | diff --git a/doc/source/release.rst b/doc/source/release.rst
index 49955ec79e9f3..ae31f1e7fc495 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -195,6 +195,7 @@ Bug Fixes
fail (:issue:`6445`).
- Bug in multi-axis indexing using ``.loc`` on non-unique indices (:issue:`6504`)
- Bug that caused _ref_locs corruption when slice indexing across columns axis of a DataFrame (:issue:`6525`)
+- Regression from 0.13 in the treatmenet of numpy ``datetime64`` non-ns dtypes in Series creation (:issue:`6529`)
pandas 0.13.1
-------------
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 69addea1c4188..eb3c159ae916d 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -124,7 +124,7 @@ def isnull(obj):
See also
--------
- pandas.notnull: boolean inverse of pandas.isnull
+ pandas.notnull: boolean inverse of pandas.isnull
"""
return _isnull(obj)
@@ -272,7 +272,7 @@ def notnull(obj):
isnulled : array-like of bool or bool
Array or bool indicating whether an object is *not* null or if an array
is given which of the element is *not* null.
-
+
See also
--------
pandas.isnull : boolean inverse of pandas.notnull
@@ -1727,10 +1727,7 @@ def _possibly_cast_to_datetime(value, dtype, coerce=False):
dtype = value.dtype
if dtype.kind == 'M' and dtype != _NS_DTYPE:
- try:
- value = tslib.array_to_datetime(value)
- except:
- raise
+ value = value.astype(_NS_DTYPE)
elif dtype.kind == 'm' and dtype != _TD_DTYPE:
from pandas.tseries.timedeltas import \
diff --git a/pandas/tests/test_series.py b/pandas/tests/test_series.py
index bae4036a68b37..faf5341276ae5 100644
--- a/pandas/tests/test_series.py
+++ b/pandas/tests/test_series.py
@@ -600,6 +600,25 @@ def test_constructor_dtype_datetime64(self):
self.assertEqual(result['a'], Timestamp('20130101'))
self.assertEqual(result['b'], 1)
+ # GH6529
+ # coerce datetime64 non-ns properly
+ dates = date_range('01-Jan-2015', '01-Dec-2015', freq='M')
+ values2 = dates.view(np.ndarray).astype('datetime64[ns]')
+ expected = Series(values2, dates)
+
+ # numpy < 1.7 is very odd about astyping
+ if not _np_version_under1p7:
+ for dtype in ['s','D','ms','us','ns']:
+ values1 = dates.view(np.ndarray).astype('M8[{0}]'.format(dtype))
+ result = Series(values1, dates)
+ assert_series_equal(result,expected)
+
+ # leave datetime.date alone
+ dates2 = np.array([ d.date() for d in dates.to_pydatetime() ],dtype=object)
+ series1 = Series(dates2, dates)
+ self.assert_numpy_array_equal(series1.values,dates2)
+ self.assertEqual(series1.dtype,object)
+
def test_constructor_dict(self):
d = {'a': 0., 'b': 1., 'c': 2.}
result = Series(d, index=['b', 'c', 'd', 'a'])
| closes #6529
| https://api.github.com/repos/pandas-dev/pandas/pulls/6530 | 2014-03-03T16:53:04Z | 2014-03-03T19:13:31Z | 2014-03-03T19:13:31Z | 2014-06-27T23:40:56Z |
BUG: fix DataFarame column slice indexer | diff --git a/doc/source/release.rst b/doc/source/release.rst
index 08bfcbe42ad5b..49955ec79e9f3 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -194,6 +194,7 @@ Bug Fixes
- Bug in ``read_html`` tests where redirected invalid URLs would make one test
fail (:issue:`6445`).
- Bug in multi-axis indexing using ``.loc`` on non-unique indices (:issue:`6504`)
+- Bug that caused _ref_locs corruption when slice indexing across columns axis of a DataFrame (:issue:`6525`)
pandas 0.13.1
-------------
diff --git a/pandas/core/internals.py b/pandas/core/internals.py
index 74a8ce0118d88..6d2b2933eb597 100644
--- a/pandas/core/internals.py
+++ b/pandas/core/internals.py
@@ -133,6 +133,12 @@ def take_ref_locs(self, indexer):
tindexer[indexer] = False
tindexer = tindexer.astype(int).cumsum()[indexer]
ref_locs = ref_locs[indexer]
+
+ # Make sure the result is a copy, or otherwise self._ref_locs will be
+ # updated.
+ if ref_locs.base is not None:
+ ref_locs = ref_locs.copy()
+
ref_locs -= tindexer
return ref_locs
diff --git a/pandas/tests/test_frame.py b/pandas/tests/test_frame.py
index 3c39d610c1b88..a36b3c5b15384 100644
--- a/pandas/tests/test_frame.py
+++ b/pandas/tests/test_frame.py
@@ -12267,6 +12267,19 @@ def test_empty_frame_dtypes_ftypes(self):
('b', 'bool:dense'),
('c', 'float64:dense')])))
+ def test_dtypes_are_correct_after_column_slice(self):
+ # GH6525
+ df = pd.DataFrame(index=range(5), columns=list("abc"), dtype=np.float_)
+ odict = OrderedDict
+ assert_series_equal(df.dtypes,
+ pd.Series(odict([('a', np.float_), ('b', np.float_),
+ ('c', np.float_),])))
+ assert_series_equal(df.iloc[:,2:].dtypes,
+ pd.Series(odict([('c', np.float_)])))
+ assert_series_equal(df.dtypes,
+ pd.Series(odict([('a', np.float_), ('b', np.float_),
+ ('c', np.float_),])))
+
def skip_if_no_ne(engine='numexpr'):
if engine == 'numexpr':
| The code pulled in in #6123 didn't account for slice indexers which return views, not copies in `take_ref_locs` function. As a result, slice across columns corrupted `_ref_locs` of the parent block (provided `_ref_locs` existed). This PR should fix that.
``` python
In [1]: df = pd.DataFrame(np.random.rand(5,3))
In [2]: df.dtypes
Out[2]:
0 float64
1 float64
2 float64
dtype: object
In [3]: df.iloc[:,2:]
Out[3]:
2
0 0.524160
1 0.072608
2 0.289047
3 0.494401
4 0.235275
[5 rows x 1 columns]
In [4]: _3.dtypes
Out[4]:
2 float64
dtype: object
In [5]: df.dtypes
Out[5]:
0 float64
1 float64
2 None
dtype: object
In [6]: pd.__version__
Out[6]: '0.13.1-346-g30d3cba'
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/6525 | 2014-03-03T12:36:45Z | 2014-03-03T14:10:37Z | 2014-03-03T14:10:37Z | 2014-06-14T08:38:16Z |
DOC: Add common error message to byte-ordering gotcha. | diff --git a/doc/source/gotchas.rst b/doc/source/gotchas.rst
index 97699aa32890d..49d463d07e75e 100644
--- a/doc/source/gotchas.rst
+++ b/doc/source/gotchas.rst
@@ -533,7 +533,15 @@ parse HTML tables in the top-level pandas io function ``read_html``.
Byte-Ordering Issues
--------------------
Occasionally you may have to deal with data that were created on a machine with
-a different byte order than the one on which you are running Python. To deal
+a different byte order than the one on which you are running Python. A common symptom of this issue is an error like
+
+.. code-block:: python
+
+ Traceback
+ ...
+ ValueError: Big-endian buffer not supported on little-endian compiler
+
+To deal
with this issue you should convert the underlying NumPy array to the native
system byte order *before* passing it to Series/DataFrame/Panel constructors
using something similar to the following:
| A friend of mine got tripped up by [this gotcha](http://pandas.pydata.org/pandas-docs/stable/gotchas.html#byte-ordering-issues). We document it well, but Googling the error message doesn't turn up our documentation, so it took him a lot of digging to get there.
This commit adds an example error message that byte-ordering issues raise, in hopes of making this easier to Google.
| https://api.github.com/repos/pandas-dev/pandas/pulls/6521 | 2014-03-02T20:32:18Z | 2014-03-02T20:53:43Z | 2014-03-02T20:53:43Z | 2014-06-26T12:43:08Z |
[BUG]: Fix ValueError in concat() when at least one Index has duplicates | diff --git a/asv_bench/benchmarks/algorithms.py b/asv_bench/benchmarks/algorithms.py
index 65e52e03c43c7..03480ae198345 100644
--- a/asv_bench/benchmarks/algorithms.py
+++ b/asv_bench/benchmarks/algorithms.py
@@ -5,6 +5,7 @@
from pandas._libs import lib
import pandas as pd
+from pandas.core.algorithms import make_duplicates_of_left_unique_in_right
from .pandas_vb_common import tm
@@ -174,4 +175,15 @@ def time_argsort(self, N):
self.array.argsort()
+class RemoveDuplicates:
+ def setup(self):
+ N = 10 ** 5
+ na = np.arange(int(N / 2))
+ self.left = np.concatenate([na[: int(N / 4)], na[: int(N / 4)]])
+ self.right = np.concatenate([na, na])
+
+ def time_make_duplicates_of_left_unique_in_right(self):
+ make_duplicates_of_left_unique_in_right(self.left, self.right)
+
+
from .pandas_vb_common import setup # noqa: F401 isort:skip
diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index f37552d193f96..20e16ca558d9e 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -708,6 +708,7 @@ Reshaping
- Bug in :meth:`DataFrame.combine_first()` caused wrong alignment with dtype ``string`` and one level of ``MultiIndex`` containing only ``NA`` (:issue:`37591`)
- Fixed regression in :func:`merge` on merging DatetimeIndex with empty DataFrame (:issue:`36895`)
- Bug in :meth:`DataFrame.apply` not setting index of return value when ``func`` return type is ``dict`` (:issue:`37544`)
+- Bug in :func:`concat` resulting in a ``ValueError`` when at least one of both inputs had a non-unique index (:issue:`36263`)
Sparse
^^^^^^
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 2e6b801db109a..ca878d3293c57 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -2150,3 +2150,24 @@ def _sort_tuples(values: np.ndarray[tuple]):
arrays, _ = to_arrays(values, None)
indexer = lexsort_indexer(arrays, orders=True)
return values[indexer]
+
+
+def make_duplicates_of_left_unique_in_right(
+ left: np.ndarray, right: np.ndarray
+) -> np.ndarray:
+ """
+ If left has duplicates, which are also duplicated in right, this duplicated values
+ are dropped from right, meaning that every duplicate value from left exists only
+ once in right.
+
+ Parameters
+ ----------
+ left: ndarray
+ right: ndarray
+
+ Returns
+ -------
+ Duplicates of left are unique in right
+ """
+ left_duplicates = unique(left[duplicated(left)])
+ return right[~(duplicated(right) & isin(right, left_duplicates))]
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index 77b1076920f20..ee54b06f5bceb 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -13,6 +13,7 @@
from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
from pandas.core.dtypes.missing import isna
+import pandas.core.algorithms as algos
from pandas.core.arrays.categorical import (
factorize_from_iterable,
factorize_from_iterables,
@@ -501,6 +502,13 @@ def get_result(self):
# 1-ax to convert BlockManager axis to DataFrame axis
obj_labels = obj.axes[1 - ax]
if not new_labels.equals(obj_labels):
+ # We have to remove the duplicates from obj_labels
+ # in new labels to make them unique, otherwise we would
+ # duplicate or duplicates again
+ if not obj_labels.is_unique:
+ new_labels = algos.make_duplicates_of_left_unique_in_right(
+ np.asarray(obj_labels), np.asarray(new_labels)
+ )
indexers[ax] = obj_labels.reindex(new_labels)[1]
mgrs_indexers.append((obj._mgr, indexers))
diff --git a/pandas/tests/reshape/concat/test_dataframe.py b/pandas/tests/reshape/concat/test_dataframe.py
index 295846ee1b264..babc8124877e9 100644
--- a/pandas/tests/reshape/concat/test_dataframe.py
+++ b/pandas/tests/reshape/concat/test_dataframe.py
@@ -167,3 +167,14 @@ def test_concat_dataframe_keys_bug(self, sort):
# it works
result = concat([t1, t2], axis=1, keys=["t1", "t2"], sort=sort)
assert list(result.columns) == [("t1", "value"), ("t2", "value")]
+
+ def test_concat_duplicate_indexes(self):
+ # GH#36263 ValueError with non unique indexes
+ df1 = DataFrame([1, 2, 3, 4], index=[0, 1, 1, 4], columns=["a"])
+ df2 = DataFrame([6, 7, 8, 9], index=[0, 0, 1, 3], columns=["b"])
+ result = concat([df1, df2], axis=1)
+ expected = DataFrame(
+ {"a": [1, 1, 2, 3, np.nan, 4], "b": [6, 7, 8, 8, 9, np.nan]},
+ index=Index([0, 0, 1, 1, 3, 4]),
+ )
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index 34b7d0e73e914..3c8f5b7385fcb 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -2356,3 +2356,15 @@ def test_diff_ea_axis(self):
msg = "cannot diff DatetimeArray on axis=1"
with pytest.raises(ValueError, match=msg):
algos.diff(dta, 1, axis=1)
+
+
+@pytest.mark.parametrize(
+ "left_values", [[0, 1, 1, 4], [0, 1, 1, 4, 4], [0, 1, 1, 1, 4]]
+)
+def test_make_duplicates_of_left_unique_in_right(left_values):
+ # GH#36263
+ left = np.array(left_values)
+ right = np.array([0, 0, 1, 1, 4])
+ result = algos.make_duplicates_of_left_unique_in_right(left, right)
+ expected = np.array([0, 0, 1, 4])
+ tm.assert_numpy_array_equal(result, expected)
| - [x] closes #36263
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
If obj_labes Index has duplicates and they are not removed from new_labels before redindexing, they are multiplied. So we would get a way too big index. | https://api.github.com/repos/pandas-dev/pandas/pulls/36290 | 2020-09-11T15:27:36Z | 2020-11-19T19:01:09Z | 2020-11-19T19:01:09Z | 2020-12-24T15:09:44Z |
ENH: support of pandas.DataFrame.hist for datetime data | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index b30e4177270b8..d67e5c1a3fd40 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -165,6 +165,7 @@ Other enhancements
- :meth:`DataFrame.applymap` now supports ``na_action`` (:issue:`23803`)
- :class:`Index` with object dtype supports division and multiplication (:issue:`34160`)
- :meth:`DataFrame.explode` and :meth:`Series.explode` now support exploding of sets (:issue:`35614`)
+- :meth:`DataFrame.hist` now supports time series (datetime) data (:issue:`32590`)
- ``Styler`` now allows direct CSS class name addition to individual data cells (:issue:`36159`)
- :meth:`Rolling.mean()` and :meth:`Rolling.sum()` use Kahan summation to calculate the mean to avoid numerical problems (:issue:`10319`, :issue:`11645`, :issue:`13254`, :issue:`32761`, :issue:`36031`)
- :meth:`DatetimeIndex.searchsorted`, :meth:`TimedeltaIndex.searchsorted`, :meth:`PeriodIndex.searchsorted`, and :meth:`Series.searchsorted` with datetimelike dtypes will now try to cast string arguments (listlike and scalar) to the matching datetimelike type (:issue:`36346`)
diff --git a/pandas/plotting/_matplotlib/hist.py b/pandas/plotting/_matplotlib/hist.py
index 89035552d4309..6d22d2ffe4a51 100644
--- a/pandas/plotting/_matplotlib/hist.py
+++ b/pandas/plotting/_matplotlib/hist.py
@@ -417,11 +417,16 @@ def hist_frame(
if not isinstance(column, (list, np.ndarray, ABCIndexClass)):
column = [column]
data = data[column]
- data = data._get_numeric_data()
+ # GH32590
+ data = data.select_dtypes(
+ include=(np.number, "datetime64", "datetimetz"), exclude="timedelta"
+ )
naxes = len(data.columns)
if naxes == 0:
- raise ValueError("hist method requires numerical columns, nothing to plot.")
+ raise ValueError(
+ "hist method requires numerical or datetime columns, nothing to plot."
+ )
fig, axes = create_subplots(
naxes=naxes,
diff --git a/pandas/tests/plotting/common.py b/pandas/tests/plotting/common.py
index 9301a29933d45..2a6bd97c93b8e 100644
--- a/pandas/tests/plotting/common.py
+++ b/pandas/tests/plotting/common.py
@@ -10,7 +10,7 @@
from pandas.core.dtypes.api import is_list_like
import pandas as pd
-from pandas import DataFrame, Series
+from pandas import DataFrame, Series, to_datetime
import pandas._testing as tm
@@ -28,6 +28,9 @@ def setup_method(self, method):
mpl.rcdefaults()
+ self.start_date_to_int64 = 812419200000000000
+ self.end_date_to_int64 = 819331200000000000
+
self.mpl_ge_2_2_3 = compat.mpl_ge_2_2_3()
self.mpl_ge_3_0_0 = compat.mpl_ge_3_0_0()
self.mpl_ge_3_1_0 = compat.mpl_ge_3_1_0()
@@ -50,6 +53,14 @@ def setup_method(self, method):
"height": random.normal(66, 4, size=n),
"weight": random.normal(161, 32, size=n),
"category": random.randint(4, size=n),
+ "datetime": to_datetime(
+ random.randint(
+ self.start_date_to_int64,
+ self.end_date_to_int64,
+ size=n,
+ dtype=np.int64,
+ )
+ ),
}
)
diff --git a/pandas/tests/plotting/test_hist_method.py b/pandas/tests/plotting/test_hist_method.py
index 34c881855d16a..d9a58e808661b 100644
--- a/pandas/tests/plotting/test_hist_method.py
+++ b/pandas/tests/plotting/test_hist_method.py
@@ -6,7 +6,7 @@
import pandas.util._test_decorators as td
-from pandas import DataFrame, Index, Series
+from pandas import DataFrame, Index, Series, to_datetime
import pandas._testing as tm
from pandas.tests.plotting.common import TestPlotBase, _check_plot_works
@@ -163,17 +163,34 @@ def test_hist_df_legacy(self):
_check_plot_works(self.hist_df.hist)
# make sure layout is handled
- df = DataFrame(randn(100, 3))
+ df = DataFrame(randn(100, 2))
+ df[2] = to_datetime(
+ np.random.randint(
+ self.start_date_to_int64,
+ self.end_date_to_int64,
+ size=100,
+ dtype=np.int64,
+ )
+ )
with tm.assert_produces_warning(UserWarning):
axes = _check_plot_works(df.hist, grid=False)
self._check_axes_shape(axes, axes_num=3, layout=(2, 2))
assert not axes[1, 1].get_visible()
+ _check_plot_works(df[[2]].hist)
df = DataFrame(randn(100, 1))
_check_plot_works(df.hist)
# make sure layout is handled
- df = DataFrame(randn(100, 6))
+ df = DataFrame(randn(100, 5))
+ df[5] = to_datetime(
+ np.random.randint(
+ self.start_date_to_int64,
+ self.end_date_to_int64,
+ size=100,
+ dtype=np.int64,
+ )
+ )
with tm.assert_produces_warning(UserWarning):
axes = _check_plot_works(df.hist, layout=(4, 2))
self._check_axes_shape(axes, axes_num=6, layout=(4, 2))
@@ -225,18 +242,42 @@ def test_hist_df_legacy(self):
ser.hist(foo="bar")
@pytest.mark.slow
- def test_hist_non_numerical_raises(self):
- # gh-10444
- df = DataFrame(np.random.rand(10, 2))
+ def test_hist_non_numerical_or_datetime_raises(self):
+ # gh-10444, GH32590
+ df = DataFrame(
+ {
+ "a": np.random.rand(10),
+ "b": np.random.randint(0, 10, 10),
+ "c": to_datetime(
+ np.random.randint(
+ 1582800000000000000, 1583500000000000000, 10, dtype=np.int64
+ )
+ ),
+ "d": to_datetime(
+ np.random.randint(
+ 1582800000000000000, 1583500000000000000, 10, dtype=np.int64
+ ),
+ utc=True,
+ ),
+ }
+ )
df_o = df.astype(object)
- msg = "hist method requires numerical columns, nothing to plot."
+ msg = "hist method requires numerical or datetime columns, nothing to plot."
with pytest.raises(ValueError, match=msg):
df_o.hist()
@pytest.mark.slow
def test_hist_layout(self):
- df = DataFrame(randn(100, 3))
+ df = DataFrame(randn(100, 2))
+ df[2] = to_datetime(
+ np.random.randint(
+ self.start_date_to_int64,
+ self.end_date_to_int64,
+ size=100,
+ dtype=np.int64,
+ )
+ )
layout_to_expected_size = (
{"layout": None, "expected_size": (2, 2)}, # default is 2x2
@@ -268,7 +309,15 @@ def test_hist_layout(self):
@pytest.mark.slow
# GH 9351
def test_tight_layout(self):
- df = DataFrame(randn(100, 3))
+ df = DataFrame(np.random.randn(100, 2))
+ df[2] = to_datetime(
+ np.random.randint(
+ self.start_date_to_int64,
+ self.end_date_to_int64,
+ size=100,
+ dtype=np.int64,
+ )
+ )
_check_plot_works(df.hist)
self.plt.tight_layout()
@@ -355,7 +404,15 @@ def test_grouped_hist_legacy(self):
from pandas.plotting._matplotlib.hist import _grouped_hist
- df = DataFrame(randn(500, 2), columns=["A", "B"])
+ df = DataFrame(randn(500, 1), columns=["A"])
+ df["B"] = to_datetime(
+ np.random.randint(
+ self.start_date_to_int64,
+ self.end_date_to_int64,
+ size=500,
+ dtype=np.int64,
+ )
+ )
df["C"] = np.random.randint(0, 4, 500)
df["D"] = ["X"] * 500
| - [x] closes #32590
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
# Update
```
import numpy as np
from pandas import DataFrame, to_datetime
from datetime import timedelta
df = DataFrame(
{
"a": np.random.rand(10),
"b": [timedelta(np.random.randn()) for _ in range(10)],
"c": to_datetime(
np.random.randint(
1582800000000000000, 1583500000000000000, 10, dtype=np.int64
)
),
"d": to_datetime(
np.random.randint(
1582800000000000000, 1583500000000000000, 10, dtype=np.int64
),
utc=True
),
}
)
df.dtypes
a float64
b timedelta64[ns]
c datetime64[ns]
d datetime64[ns, UTC]
dtype: object
df.hist(xrot=90, figsize=(9, 6))
array([[<AxesSubplot:title={'center':'a'}>,
<AxesSubplot:title={'center':'c'}>],
[<AxesSubplot:title={'center':'d'}>, <AxesSubplot:>]], dtype=object)
```
# ~~WIP~~
Since there's no response for several days in https://github.com/pandas-dev/pandas/issues/32590, I decide to open this PR for further discussion.
There's two feasible options:
Plan A:
As is shown in the files changed, `data._get_numeric_data()` is modified to `data._get_numeric_or_datetime_data()`, and I will work on related tests as the next step.
Plan B, this may be a fotfix according to https://github.com/pandas-dev/pandas/issues/32590#issuecomment-687477764:
```
column_dt = data.select_dtypes(include='datetime64[ns]')
if len(column_dt) > 0:
data[column_dt] = data[column_dt].astype(np.int64)
data = data._get_numeric_data()
if len(column_dt) > 0:
data[column_dt] = data[column_dt].astype('datetime64[ns]')
```
Also, related tests will be modified.
Any comment / thought is welcomed. | https://api.github.com/repos/pandas-dev/pandas/pulls/36287 | 2020-09-11T10:04:07Z | 2020-10-10T23:07:42Z | 2020-10-10T23:07:42Z | 2020-10-10T23:07:49Z |
DOC: Fixed type hints for GroupBy.{any, all} | diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 8340f964fb44b..54d52b1e79da3 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -1371,7 +1371,9 @@ def any(self, skipna: bool = True):
Returns
-------
- bool
+ Series or DataFrame
+ DataFrame or Series of boolean values, where a value is True if any element
+ is True within its respective group, False otherwise.
"""
return self._bool_agg("any", skipna)
@@ -1388,7 +1390,9 @@ def all(self, skipna: bool = True):
Returns
-------
- bool
+ Series or DataFrame
+ DataFrame or Series of boolean values, where a value is True if all elements
+ are True within its respective group, False otherwise.
"""
return self._bool_agg("all", skipna)
| The current documentation says the return value of GroupBy.all and GroupBy.any is `bool`.
```
def any(self, skipna: bool = True):
"""
Return True if any value in the group is truthful, else False.
Parameters
----------
skipna : bool, default True
Flag to ignore nan values during truth testing.
Returns
-------
bool
"""
```
However, the actual returned type is DataFrame or Series (with the same shape as `GroupBy.sum()`).
```
In [25]: df
Out[25]:
0 1 2 3
0 1.0 0.0 0.0 0.0
1 0.0 1.0 0.0 0.0
2 0.0 0.0 1.0 0.0
3 0.0 0.0 0.0 1.0
In [26]: df.groupby(0).any()
Out[26]:
1 2 3
0
0.0 True True True
1.0 False False False
In [27]: type(df.groupby(0).any())
Out[27]: pandas.core.frame.DataFrame
```
This PR fixes the wrong type hints for `GroupBy.{any, all}`.
- [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36284 | 2020-09-11T07:08:35Z | 2020-10-09T01:47:41Z | 2020-10-09T01:47:40Z | 2020-10-09T01:50:00Z |
TST: #31922 assert no segmentation fault with numpy.array.__contains__ | diff --git a/pandas/tests/scalar/test_na_scalar.py b/pandas/tests/scalar/test_na_scalar.py
index 5c4d7e191d1bb..10d366fe485da 100644
--- a/pandas/tests/scalar/test_na_scalar.py
+++ b/pandas/tests/scalar/test_na_scalar.py
@@ -305,3 +305,11 @@ def test_pickle_roundtrip_containers(as_frame, values, dtype):
s = s.to_frame(name="A")
result = tm.round_trip_pickle(s)
tm.assert_equal(result, s)
+
+
+@pytest.mark.parametrize("array", [np.array(["a"], dtype=object), ["a"]])
+def test_array_contains_na(array):
+ # GH 31922
+ msg = "boolean value of NA is ambiguous"
+ with pytest.raises(TypeError, match=msg):
+ NA in array
| - [ ] closes #31922
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] new test cases
| https://api.github.com/repos/pandas-dev/pandas/pulls/36283 | 2020-09-11T06:03:39Z | 2020-09-19T22:07:25Z | 2020-09-19T22:07:24Z | 2020-11-19T00:34:52Z |
REF: de-duplicate _wrap_joined_index | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 67456096e8681..5d15d33e7e215 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -3877,7 +3877,7 @@ def _join_monotonic(self, other, how="left", return_indexers=False):
def _wrap_joined_index(self, joined, other):
name = get_op_result_name(self, other)
- return Index(joined, name=name)
+ return self._constructor(joined, name=name)
# --------------------------------------------------------------------
# Uncategorized Methods
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 7509cb35069e8..98ef473a13348 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -767,7 +767,8 @@ def _wrap_joined_index(
self, joined: np.ndarray, other: "CategoricalIndex"
) -> "CategoricalIndex":
name = get_op_result_name(self, other)
- return self._create_from_codes(joined, name=name)
+ cat = self._data._from_backing_data(joined)
+ return type(self)._simple_new(cat, name=name)
CategoricalIndex._add_logical_methods_disabled()
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 54c8ed60b6097..13236f8488ecb 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -603,7 +603,9 @@ def _wrap_joined_index(self, joined: np.ndarray, other):
else:
self = cast(DatetimeTimedeltaMixin, self)
freq = self.freq if self._can_fast_union(other) else None
- new_data = type(self._data)._simple_new(joined, dtype=self.dtype, freq=freq)
+
+ new_data = self._data._from_backing_data(joined)
+ new_data._freq = freq
return type(self)._simple_new(new_data, name=name)
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index deeb7ff50b88c..7aceb898f5ccf 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -3637,7 +3637,7 @@ def delete(self, loc):
def _wrap_joined_index(self, joined, other):
names = self.names if self.names == other.names else None
- return MultiIndex.from_tuples(joined, names=names)
+ return self._constructor(joined, names=names)
@doc(Index.isin)
def isin(self, values, level=None):
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index 125602ef2054a..e8b7efeee8852 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -33,7 +33,6 @@
from pandas.core import algorithms
import pandas.core.common as com
from pandas.core.indexes.base import Index, maybe_extract_name
-from pandas.core.ops import get_op_result_name
_num_index_shared_docs = dict()
@@ -262,10 +261,6 @@ class Int64Index(IntegerIndex):
_engine_type = libindex.Int64Engine
_default_dtype = np.dtype(np.int64)
- def _wrap_joined_index(self, joined, other):
- name = get_op_result_name(self, other)
- return Int64Index(joined, name=name)
-
@classmethod
def _assert_safe_casting(cls, data, subarr):
"""
@@ -324,10 +319,6 @@ def _convert_index_indexer(self, keyarr):
# ----------------------------------------------------------------
- def _wrap_joined_index(self, joined, other):
- name = get_op_result_name(self, other)
- return UInt64Index(joined, name=name)
-
@classmethod
def _assert_safe_casting(cls, data, subarr):
"""
| https://api.github.com/repos/pandas-dev/pandas/pulls/36282 | 2020-09-11T02:47:46Z | 2020-09-12T20:31:30Z | 2020-09-12T20:31:30Z | 2020-09-12T20:57:10Z | |
PERF: CategoricalDtype.__eq__ | diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index e321fdd9b3a9b..2e5dc15131e70 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -375,12 +375,30 @@ def __eq__(self, other: Any) -> bool:
# but same order is not necessary. There is no distinction between
# ordered=False and ordered=None: CDT(., False) and CDT(., None)
# will be equal if they have the same categories.
- if (
- self.categories.dtype == other.categories.dtype
- and self.categories.equals(other.categories)
- ):
+ left = self.categories
+ right = other.categories
+
+ # GH#36280 the ordering of checks here is for performance
+ if not left.dtype == right.dtype:
+ return False
+
+ if len(left) != len(right):
+ return False
+
+ if self.categories.equals(other.categories):
# Check and see if they happen to be identical categories
return True
+
+ if left.dtype != object:
+ # Faster than calculating hash
+ indexer = left.get_indexer(right)
+ # Because left and right have the same length and are unique,
+ # `indexer` not having any -1s implies that there is a
+ # bijection between `left` and `right`.
+ return (indexer != -1).all()
+
+ # With object-dtype we need a comparison that identifies
+ # e.g. int(2) as distinct from float(2)
return hash(self) == hash(other)
def __repr__(self) -> str_type:
| Three special cases where we can get better performance
1) categories have different lengths --> never equal
2) categories have different dtypes --> never equal
3) categories are not object-dtype --> can use use get_indexer instead of hashing
```
import pandas as pd
import numpy as np
dti = pd.date_range("2016-01-01", periods=10000, tz="US/Pacific")
dti2 = type(dti)(dti._data.copy())
np.random.shuffle(dti._data._data)
assert not dti.equals(dti2)
cd1 = pd.CategoricalDtype(dti)
cd2 = pd.CategoricalDtype(dti2)
cd3 = pd.CategoricalDtype(dti2[:-1])
cd4 = pd.CategoricalDtype(pd.Index(range(len(dti))))
In [5]: %timeit cd1 == cd2
548 µs ± 3.94 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) # <-- master
239 µs ± 1.04 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) # <-- PR
In [6]: %timeit cd1 == cd3
543 µs ± 4.05 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) # <-- master
5.05 µs ± 257 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) # <-- PR
In [7]: %timeit cd1 == cd4
389 µs ± 13.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) # <-- master
2.17 µs ± 63.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) # <-- PR
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/36280 | 2020-09-11T01:52:01Z | 2020-09-13T12:29:32Z | 2020-09-13T12:29:32Z | 2020-09-13T15:03:54Z |
Concatenating rows with Int64 datatype coerces to object | diff --git a/pandas/tests/reshape/test_concat.py b/pandas/tests/reshape/test_concat.py
index 90705f827af25..7d6611722d8b5 100644
--- a/pandas/tests/reshape/test_concat.py
+++ b/pandas/tests/reshape/test_concat.py
@@ -2918,3 +2918,12 @@ def test_concat_frame_axis0_extension_dtypes():
result = pd.concat([df2, df1], ignore_index=True)
expected = pd.DataFrame({"a": [4, 5, 6, 1, 2, 3]}, dtype="Int64")
tm.assert_frame_equal(result, expected)
+
+
+def test_concat_preserves_extension_int64_dtype():
+ # GH 24768
+ df_a = pd.DataFrame({"a": [-1]}, dtype="Int64")
+ df_b = pd.DataFrame({"b": [1]}, dtype="Int64")
+ result = pd.concat([df_a, df_b], ignore_index=True)
+ expected = pd.DataFrame({"a": [-1, None], "b": [None, 1]}, dtype="Int64")
+ tm.assert_frame_equal(result, expected)
| - [x] closes #24768
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
Issue was fixed in the past.
| https://api.github.com/repos/pandas-dev/pandas/pulls/36278 | 2020-09-10T21:46:06Z | 2020-09-13T23:25:30Z | 2020-09-13T23:25:29Z | 2020-09-13T23:54:12Z |
CLN: typo cleanups | diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index 569562f5b5037..8155e7e6c074a 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -260,7 +260,7 @@ cdef class IndexEngine:
def get_indexer_non_unique(self, targets):
"""
Return an indexer suitable for taking from a non unique index
- return the labels in the same order ast the target
+ return the labels in the same order as the target
and a missing indexer into the targets (which correspond
to the -1 indices in the results
"""
diff --git a/pandas/tests/arrays/categorical/test_indexing.py b/pandas/tests/arrays/categorical/test_indexing.py
index abfae189bb4d7..ab8606ef9258d 100644
--- a/pandas/tests/arrays/categorical/test_indexing.py
+++ b/pandas/tests/arrays/categorical/test_indexing.py
@@ -183,7 +183,7 @@ def test_get_indexer_non_unique(self, idx_values, key_values, key_class):
# GH 21448
key = key_class(key_values, categories=range(1, 5))
# Test for flat index and CategoricalIndex with same/different cats:
- for dtype in None, "category", key.dtype:
+ for dtype in [None, "category", key.dtype]:
idx = Index(idx_values, dtype=dtype)
expected, exp_miss = idx.get_indexer_non_unique(key_values)
result, res_miss = idx.get_indexer_non_unique(key)
diff --git a/scripts/validate_unwanted_patterns.py b/scripts/validate_unwanted_patterns.py
index 1a6d8cc8b9914..2add2b8c62a4e 100755
--- a/scripts/validate_unwanted_patterns.py
+++ b/scripts/validate_unwanted_patterns.py
@@ -357,9 +357,9 @@ def main(
output_format : str
Output format of the error message.
file_extensions_to_check : str
- Coma seperated values of what file extensions to check.
+ Comma separated values of what file extensions to check.
excluded_file_paths : str
- Coma seperated values of what file paths to exclude during the check.
+ Comma separated values of what file paths to exclude during the check.
Returns
-------
@@ -444,7 +444,7 @@ def main(
parser.add_argument(
"--included-file-extensions",
default="py,pyx,pxd,pxi",
- help="Coma seperated file extensions to check.",
+ help="Comma separated file extensions to check.",
)
parser.add_argument(
"--excluded-file-paths",
| https://api.github.com/repos/pandas-dev/pandas/pulls/36276 | 2020-09-10T20:50:05Z | 2020-09-12T01:00:16Z | 2020-09-12T01:00:15Z | 2020-09-12T01:00:19Z | |
REF: implement Categorical._validate_listlike | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 81f9456502bf0..363873be87899 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1716,6 +1716,35 @@ def _box_func(self, i: int):
return np.NaN
return self.categories[i]
+ def _validate_listlike(self, target: ArrayLike) -> np.ndarray:
+ """
+ Extract integer codes we can use for comparison.
+
+ Notes
+ -----
+ If a value in target is not present, it gets coded as -1.
+ """
+
+ if isinstance(target, Categorical):
+ # Indexing on codes is more efficient if categories are the same,
+ # so we can apply some optimizations based on the degree of
+ # dtype-matching.
+ if self.categories.equals(target.categories):
+ # We use the same codes, so can go directly to the engine
+ codes = target.codes
+ elif self.is_dtype_equal(target):
+ # We have the same categories up to a reshuffling of codes.
+ codes = recode_for_categories(
+ target.codes, target.categories, self.categories
+ )
+ else:
+ code_indexer = self.categories.get_indexer(target.categories)
+ codes = take_1d(code_indexer, target.codes, fill_value=-1)
+ else:
+ codes = self.categories.get_indexer(target)
+
+ return codes
+
# ------------------------------------------------------------------
def take_nd(self, indexer, allow_fill: bool = False, fill_value=None):
@@ -1890,11 +1919,8 @@ def _validate_setitem_value(self, value):
"Cannot set a Categorical with another, "
"without identical categories"
)
- if not self.categories.equals(value.categories):
- new_codes = recode_for_categories(
- value.codes, value.categories, self.categories
- )
- value = Categorical.from_codes(new_codes, dtype=self.dtype)
+ new_codes = self._validate_listlike(value)
+ value = Categorical.from_codes(new_codes, dtype=self.dtype)
rvalue = value if is_list_like(value) else [value]
@@ -2164,13 +2190,7 @@ def equals(self, other: object) -> bool:
if not isinstance(other, Categorical):
return False
elif self.is_dtype_equal(other):
- if self.categories.equals(other.categories):
- # fastpath to avoid re-coding
- other_codes = other._codes
- else:
- other_codes = recode_for_categories(
- other.codes, other.categories, self.categories
- )
+ other_codes = self._validate_listlike(other)
return np.array_equal(self._codes, other_codes)
return False
diff --git a/pandas/core/dtypes/concat.py b/pandas/core/dtypes/concat.py
index dd005752a4832..1ea4ff117f209 100644
--- a/pandas/core/dtypes/concat.py
+++ b/pandas/core/dtypes/concat.py
@@ -310,14 +310,8 @@ def _maybe_unwrap(x):
categories = first.categories
ordered = first.ordered
- if all(first.categories.equals(other.categories) for other in to_union[1:]):
- new_codes = np.concatenate([c.codes for c in to_union])
- else:
- codes = [first.codes] + [
- recode_for_categories(other.codes, other.categories, first.categories)
- for other in to_union[1:]
- ]
- new_codes = np.concatenate(codes)
+ all_codes = [first._validate_listlike(x) for x in to_union]
+ new_codes = np.concatenate(all_codes)
if sort_categories and not ignore_order and ordered:
raise TypeError("Cannot use sort_categories=True with ordered Categoricals")
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 7509cb35069e8..a450e3b9fdee7 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -23,8 +23,7 @@
from pandas.core.dtypes.missing import is_valid_nat_for_dtype, notna
from pandas.core import accessor
-from pandas.core.algorithms import take_1d
-from pandas.core.arrays.categorical import Categorical, contains, recode_for_categories
+from pandas.core.arrays.categorical import Categorical, contains
import pandas.core.common as com
from pandas.core.construction import extract_array
import pandas.core.indexes.base as ibase
@@ -558,21 +557,7 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
"method='nearest' not implemented yet for CategoricalIndex"
)
- if isinstance(target, CategoricalIndex) and self._values.is_dtype_equal(target):
- if self._values.equals(target._values):
- # we have the same codes
- codes = target.codes
- else:
- codes = recode_for_categories(
- target.codes, target.categories, self._values.categories
- )
- else:
- if isinstance(target, CategoricalIndex):
- code_indexer = self.categories.get_indexer(target.categories)
- codes = take_1d(code_indexer, target.codes, fill_value=-1)
- else:
- codes = self.categories.get_indexer(target)
-
+ codes = self._values._validate_listlike(target._values)
indexer, _ = self._engine.get_indexer_non_unique(codes)
return ensure_platform_int(indexer)
@@ -580,15 +565,7 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
def get_indexer_non_unique(self, target):
target = ibase.ensure_index(target)
- if isinstance(target, CategoricalIndex):
- # Indexing on codes is more efficient if categories are the same:
- if target.categories is self.categories:
- target = target.codes
- indexer, missing = self._engine.get_indexer_non_unique(target)
- return ensure_platform_int(indexer), missing
- target = target._values
-
- codes = self.categories.get_indexer(target)
+ codes = self._values._validate_listlike(target._values)
indexer, missing = self._engine.get_indexer_non_unique(codes)
return ensure_platform_int(indexer), missing
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 9f19ea9aefe09..d95355589fd0c 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -43,7 +43,6 @@
from pandas import Categorical, Index, MultiIndex
from pandas.core import groupby
import pandas.core.algorithms as algos
-from pandas.core.arrays.categorical import recode_for_categories
import pandas.core.common as com
from pandas.core.construction import extract_array
from pandas.core.frame import _merge_doc
@@ -1936,12 +1935,8 @@ def _factorize_keys(
):
assert isinstance(lk, Categorical)
assert isinstance(rk, Categorical)
- if lk.categories.equals(rk.categories):
- # if we exactly match in categories, allow us to factorize on codes
- rk = rk.codes
- else:
- # Same categories in different orders -> recode
- rk = recode_for_categories(rk.codes, rk.categories, lk.categories)
+ # Cast rk to encoding so we can compare codes with lk
+ rk = lk._validate_listlike(rk)
lk = ensure_int64(lk.codes)
rk = ensure_int64(rk)
| I found it really confusing why we used slightly different dtype-comparisons in a bunch of different places (e.g CategoricalIndex.get_indexer vs CategoricalIndex.get_indexer_non_unique). AFAICT It's just a matter of optimizations accruing over time without a helper method to keep them in sync. | https://api.github.com/repos/pandas-dev/pandas/pulls/36274 | 2020-09-10T18:21:12Z | 2020-09-12T21:13:32Z | 2020-09-12T21:13:32Z | 2020-09-12T21:19:38Z |
CI: xfail failing parquet test | diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index 15f9837176315..35a400cba8671 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -8,6 +8,7 @@
import numpy as np
import pytest
+from pandas.compat import PY38
import pandas.util._test_decorators as td
import pandas as pd
@@ -564,8 +565,19 @@ def test_s3_roundtrip(self, df_compat, s3_resource, pa, s3so):
write_kwargs=s3so,
)
- @td.skip_if_no("s3fs")
- @pytest.mark.parametrize("partition_col", [["A"], []])
+ @td.skip_if_no("s3fs") # also requires flask
+ @pytest.mark.parametrize(
+ "partition_col",
+ [
+ pytest.param(
+ ["A"],
+ marks=pytest.mark.xfail(
+ PY38, reason="Getting back empty DataFrame", raises=AssertionError,
+ ),
+ ),
+ [],
+ ],
+ )
def test_s3_roundtrip_for_dir(
self, df_compat, s3_resource, pa, partition_col, s3so
):
| https://api.github.com/repos/pandas-dev/pandas/pulls/36272 | 2020-09-10T18:15:21Z | 2020-09-11T19:18:24Z | 2020-09-11T19:18:24Z | 2020-09-15T16:09:48Z | |
CLN: pandas/io/parsers.py | diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index 4c619a636f057..b963d5be69b5f 100644
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -421,10 +421,6 @@ def _read(filepath_or_buffer: FilePathOrBuffer, kwds):
kwds["encoding"] = encoding
compression = kwds.get("compression", "infer")
- # TODO: get_filepath_or_buffer could return
- # Union[FilePathOrBuffer, s3fs.S3File, gcsfs.GCSFile]
- # though mypy handling of conditional imports is difficult.
- # See https://github.com/python/mypy/issues/1297
ioargs = get_filepath_or_buffer(
filepath_or_buffer, encoding, compression, storage_options=storage_options
)
@@ -914,7 +910,6 @@ def __init__(self, f, engine=None, **kwds):
# miscellanea
self.engine = engine
- self._engine = None
self._currow = 0
options = self._get_options_with_defaults(engine)
@@ -923,14 +918,13 @@ def __init__(self, f, engine=None, **kwds):
self.nrows = options.pop("nrows", None)
self.squeeze = options.pop("squeeze", False)
- # might mutate self.engine
- self.engine = self._check_file_or_buffer(f, engine)
+ self._check_file_or_buffer(f, engine)
self.options, self.engine = self._clean_options(options, engine)
if "has_index_names" in kwds:
self.options["has_index_names"] = kwds["has_index_names"]
- self._make_engine(self.engine)
+ self._engine = self._make_engine(self.engine)
def close(self):
self._engine.close()
@@ -987,24 +981,21 @@ def _check_file_or_buffer(self, f, engine):
msg = "The 'python' engine cannot iterate through this file buffer."
raise ValueError(msg)
- return engine
-
def _clean_options(self, options, engine):
result = options.copy()
engine_specified = self._engine_specified
fallback_reason = None
- sep = options["delimiter"]
- delim_whitespace = options["delim_whitespace"]
-
# C engine not supported yet
if engine == "c":
if options["skipfooter"] > 0:
fallback_reason = "the 'c' engine does not support skipfooter"
engine = "python"
- encoding = sys.getfilesystemencoding() or "utf-8"
+ sep = options["delimiter"]
+ delim_whitespace = options["delim_whitespace"]
+
if sep is None and not delim_whitespace:
if engine == "c":
fallback_reason = (
@@ -1029,6 +1020,7 @@ def _clean_options(self, options, engine):
result["delimiter"] = r"\s+"
elif sep is not None:
encodeable = True
+ encoding = sys.getfilesystemencoding() or "utf-8"
try:
if len(sep.encode(encoding)) > 1:
encodeable = False
@@ -1161,29 +1153,26 @@ def __next__(self):
raise
def _make_engine(self, engine="c"):
- if engine == "c":
- self._engine = CParserWrapper(self.f, **self.options)
+ mapping = {
+ "c": CParserWrapper,
+ "python": PythonParser,
+ "python-fwf": FixedWidthFieldParser,
+ }
+ try:
+ klass = mapping[engine]
+ except KeyError:
+ raise ValueError(
+ f"Unknown engine: {engine} (valid options are {mapping.keys()})"
+ )
else:
- if engine == "python":
- klass = PythonParser
- elif engine == "python-fwf":
- klass = FixedWidthFieldParser
- else:
- raise ValueError(
- f"Unknown engine: {engine} (valid options "
- 'are "c", "python", or "python-fwf")'
- )
- self._engine = klass(self.f, **self.options)
+ return klass(self.f, **self.options)
def _failover_to_python(self):
raise AbstractMethodError(self)
def read(self, nrows=None):
nrows = validate_integer("nrows", nrows)
- ret = self._engine.read(nrows)
-
- # May alter columns / col_dict
- index, columns, col_dict = self._create_index(ret)
+ index, columns, col_dict = self._engine.read(nrows)
if index is None:
if col_dict:
@@ -1203,10 +1192,6 @@ def read(self, nrows=None):
return df[df.columns[0]].copy()
return df
- def _create_index(self, ret):
- index, columns, col_dict = ret
- return index, columns, col_dict
-
def get_chunk(self, size=None):
if size is None:
size = self.chunksize
| - [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
Slight clean-up of ``pandas/io/parsers.py``. | https://api.github.com/repos/pandas-dev/pandas/pulls/36269 | 2020-09-10T16:26:00Z | 2020-09-12T20:54:23Z | 2020-09-12T20:54:23Z | 2020-09-12T20:54:28Z |
BUG: fix isin with nans and large arrays | diff --git a/doc/source/whatsnew/v1.1.3.rst b/doc/source/whatsnew/v1.1.3.rst
index 8ead78a17e9c2..603cfc38bbbbd 100644
--- a/doc/source/whatsnew/v1.1.3.rst
+++ b/doc/source/whatsnew/v1.1.3.rst
@@ -30,6 +30,7 @@ Bug fixes
- Bug in :meth:`Series.str.startswith` and :meth:`Series.str.endswith` with ``category`` dtype not propagating ``na`` parameter (:issue:`36241`)
- Bug in :class:`Series` constructor where integer overflow would occur for sufficiently large scalar inputs when an index was provided (:issue:`36291`)
- Bug in :meth:`DataFrame.stack` raising a ``ValueError`` when stacking :class:`MultiIndex` columns based on position when the levels had duplicate names (:issue:`36353`)
+- Bug in :meth:`Series.isin` and :meth:`DataFrame.isin` when using ``NaN`` and a row length above 1,000,000 (:issue:`22205`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 2ce3f2d9a7bfa..50d1810fee30d 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -440,7 +440,12 @@ def isin(comps: AnyArrayLike, values: AnyArrayLike) -> np.ndarray:
# GH16012
# Ensure np.in1d doesn't get object types or it *may* throw an exception
if len(comps) > 1_000_000 and not is_object_dtype(comps):
- f = np.in1d
+ # If the the values include nan we need to check for nan explicitly
+ # since np.nan it not equal to np.nan
+ if np.isnan(values).any():
+ f = lambda c, v: np.logical_or(np.in1d(c, v), np.isnan(c))
+ else:
+ f = np.in1d
elif is_integer_dtype(comps):
try:
values = values.astype("int64", copy=False)
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index a2c2ae22a0b62..6102f43f4db6a 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -801,7 +801,6 @@ def test_i8(self):
tm.assert_numpy_array_equal(result, expected)
def test_large(self):
-
s = pd.date_range("20000101", periods=2000000, freq="s").values
result = algos.isin(s, s[0:2])
expected = np.zeros(len(s), dtype=bool)
@@ -841,6 +840,23 @@ def test_same_nan_is_in(self):
result = algos.isin(comps, values)
tm.assert_numpy_array_equal(expected, result)
+ def test_same_nan_is_in_large(self):
+ # https://github.com/pandas-dev/pandas/issues/22205
+ s = np.tile(1.0, 1_000_001)
+ s[0] = np.nan
+ result = algos.isin(s, [np.nan, 1])
+ expected = np.ones(len(s), dtype=bool)
+ tm.assert_numpy_array_equal(result, expected)
+
+ def test_same_nan_is_in_large_series(self):
+ # https://github.com/pandas-dev/pandas/issues/22205
+ s = np.tile(1.0, 1_000_001)
+ series = pd.Series(s)
+ s[0] = np.nan
+ result = series.isin([np.nan, 1])
+ expected = pd.Series(np.ones(len(s), dtype=bool))
+ tm.assert_series_equal(result, expected)
+
def test_same_object_is_in(self):
# GH 22160
# there could be special treatment for nans
| Does a np.isnan if nan is given to isin and we have a large enough array to trigger the `np.in1d` path
- [x] closes #22205
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36266 | 2020-09-10T11:40:06Z | 2020-09-19T02:14:26Z | 2020-09-19T02:14:25Z | 2020-09-24T20:20:07Z |
Resample fix dst transition | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index 2aac2596c18cb..b04f5964e861e 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -307,6 +307,7 @@ Groupby/resample/rolling
- Bug in :meth:`DataFrameGroupBy.count` and :meth:`SeriesGroupBy.sum` returning ``NaN`` for missing categories when grouped on multiple ``Categoricals``. Now returning ``0`` (:issue:`35028`)
- Bug in :meth:`DataFrameGroupBy.apply` that would some times throw an erroneous ``ValueError`` if the grouping axis had duplicate entries (:issue:`16646`)
+- Bug in :meth:`DataFrame.resample(...)` that would throw a ``ValueError`` when resampling from "D" to "24H" over a transition into daylight savings time (DST) (:issue:`35219`)
- Bug when combining methods :meth:`DataFrame.groupby` with :meth:`DataFrame.resample` and :meth:`DataFrame.interpolate` raising an ``TypeError`` (:issue:`35325`)
- Bug in :meth:`DataFrameGroupBy.apply` where a non-nuisance grouping column would be dropped from the output columns if another groupby method was called before ``.apply()`` (:issue:`34656`)
- Bug in :meth:`DataFrameGroupby.apply` would drop a :class:`CategoricalIndex` when grouped on. (:issue:`35792`)
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 7b5154756e613..a2bf631959dd1 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -1087,7 +1087,11 @@ def _upsample(self, method, limit=None, fill_value=None):
res_index = self._adjust_binner_for_upsample(binner)
# if we have the same frequency as our axis, then we are equal sampling
- if limit is None and to_offset(ax.inferred_freq) == self.freq:
+ if (
+ limit is None
+ and to_offset(ax.inferred_freq) == self.freq
+ and len(obj) == len(res_index)
+ ):
result = obj.copy()
result.index = res_index
else:
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 59a0183304c76..9475dcc6981ff 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -1740,3 +1740,50 @@ def test_resample_apply_product():
columns=["A", "B"],
)
tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "first,last,freq_in,freq_out,exp_last",
+ [
+ (
+ "2020-03-28",
+ "2020-03-31",
+ "D",
+ "24H",
+ "2020-03-30 01:00",
+ ), # includes transition into DST
+ (
+ "2020-03-28",
+ "2020-10-27",
+ "D",
+ "24H",
+ "2020-10-27 00:00",
+ ), # includes transition into and out of DST
+ (
+ "2020-10-25",
+ "2020-10-27",
+ "D",
+ "24H",
+ "2020-10-26 23:00",
+ ), # includes transition out of DST
+ (
+ "2020-03-28",
+ "2020-03-31",
+ "24H",
+ "D",
+ "2020-03-30 00:00",
+ ), # same as above, but from 24H to D
+ ("2020-03-28", "2020-10-27", "24H", "D", "2020-10-27 00:00"),
+ ("2020-10-25", "2020-10-27", "24H", "D", "2020-10-26 00:00"),
+ ],
+)
+def test_resample_calendar_day_with_dst(
+ first: str, last: str, freq_in: str, freq_out: str, exp_last: str
+):
+ # GH 35219
+ ts = pd.Series(1.0, pd.date_range(first, last, freq=freq_in, tz="Europe/Amsterdam"))
+ result = ts.resample(freq_out).pad()
+ expected = pd.Series(
+ 1.0, pd.date_range(first, exp_last, freq=freq_out, tz="Europe/Amsterdam")
+ )
+ tm.assert_series_equal(result, expected)
| Fix bug when resampling with DST transition.
- [x] closes #35219
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36264 | 2020-09-10T07:48:04Z | 2020-09-12T21:07:53Z | 2020-09-12T21:07:53Z | 2020-09-12T21:08:11Z |
ENH: consistently cast strings for DTA/TDA/PA.__setitem__ | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index 00cbb248e4690..119b34afdb69a 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -230,6 +230,8 @@ Datetimelike
- Bug in :meth:`DatetimeIndex.get_slice_bound` where ``datetime.date`` objects were not accepted or naive :class:`Timestamp` with a tz-aware :class:`DatetimeIndex` (:issue:`35690`)
- Bug in :meth:`DatetimeIndex.slice_locs` where ``datetime.date`` objects were not accepted (:issue:`34077`)
- Bug in :meth:`DatetimeIndex.searchsorted`, :meth:`TimedeltaIndex.searchsorted`, :meth:`PeriodIndex.searchsorted`, and :meth:`Series.searchsorted` with ``datetime64``, ``timedelta64`` or ``Period`` dtype placement of ``NaT`` values being inconsistent with ``NumPy`` (:issue:`36176`,:issue:`36254`)
+- Inconsistency in :class:`DatetimeArray`, :class:`TimedeltaArray`, and :class:`PeriodArray` setitem casting arrays of strings to datetimelike scalars but not scalar strings (:issue:`36261`)
+-
Timedelta
^^^^^^^^^
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index b013246e724de..6f0e2a6a598fc 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -875,8 +875,7 @@ def _validate_setitem_value(self, value):
if is_list_like(value):
value = self._validate_listlike(value, "setitem", cast_str=True)
else:
- # TODO: cast_str for consistency?
- value = self._validate_scalar(value, msg, cast_str=False)
+ value = self._validate_scalar(value, msg, cast_str=True)
return self._unbox(value, setitem=True)
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 624335fd78b0f..0ae6b5bde5297 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -2,6 +2,7 @@
import numpy as np
import pytest
+import pytz
from pandas._libs import OutOfBoundsDatetime
from pandas.compat.numpy import np_version_under1p18
@@ -282,15 +283,35 @@ def test_setitem(self):
expected[:2] = expected[-2:]
tm.assert_numpy_array_equal(arr.asi8, expected)
- def test_setitem_str_array(self, arr1d):
- if isinstance(arr1d, DatetimeArray) and arr1d.tz is not None:
- pytest.xfail(reason="timezone comparisons inconsistent")
+ def test_setitem_strs(self, arr1d):
+ # Check that we parse strs in both scalar and listlike
+ if isinstance(arr1d, DatetimeArray):
+ tz = arr1d.tz
+ if (
+ tz is not None
+ and tz is not pytz.UTC
+ and not isinstance(tz, pytz._FixedOffset)
+ ):
+ # If we have e.g. tzutc(), when we cast to string and parse
+ # back we get pytz.UTC, and then consider them different timezones
+ # so incorrectly raise.
+ pytest.xfail(reason="timezone comparisons inconsistent")
+
+ # Setting list-like of strs
expected = arr1d.copy()
expected[[0, 1]] = arr1d[-2:]
- arr1d[:2] = [str(x) for x in arr1d[-2:]]
+ result = arr1d.copy()
+ result[:2] = [str(x) for x in arr1d[-2:]]
+ tm.assert_equal(result, expected)
- tm.assert_equal(arr1d, expected)
+ # Same thing but now for just a scalar str
+ expected = arr1d.copy()
+ expected[0] = arr1d[-1]
+
+ result = arr1d.copy()
+ result[0] = str(arr1d[-1])
+ tm.assert_equal(result, expected)
@pytest.mark.parametrize("as_index", [True, False])
def test_setitem_categorical(self, arr1d, as_index):
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 804654451a6d9..53f26de09f94e 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -197,6 +197,29 @@ def test_tz_setter_raises(self):
with pytest.raises(AttributeError, match="tz_localize"):
arr.tz = "UTC"
+ def test_setitem_str_impute_tz(self, tz_naive_fixture):
+ # Like for getitem, if we are passed a naive-like string, we impute
+ # our own timezone.
+ tz = tz_naive_fixture
+
+ data = np.array([1, 2, 3], dtype="M8[ns]")
+ dtype = data.dtype if tz is None else DatetimeTZDtype(tz=tz)
+ arr = DatetimeArray(data, dtype=dtype)
+ expected = arr.copy()
+
+ ts = pd.Timestamp("2020-09-08 16:50").tz_localize(tz)
+ setter = str(ts.tz_localize(None))
+
+ # Setting a scalar tznaive string
+ expected[0] = ts
+ arr[0] = setter
+ tm.assert_equal(arr, expected)
+
+ # Setting a listlike of tznaive strings
+ expected[1] = ts
+ arr[:2] = [setter, setter]
+ tm.assert_equal(arr, expected)
+
def test_setitem_different_tz_raises(self):
data = np.array([1, 2, 3], dtype="M8[ns]")
arr = DatetimeArray(data, copy=False, dtype=DatetimeTZDtype(tz="US/Central"))
| - [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
ATM we cast strings for listlike inputs but not for scalars.
| https://api.github.com/repos/pandas-dev/pandas/pulls/36261 | 2020-09-10T00:59:20Z | 2020-09-12T23:24:34Z | 2020-09-12T23:24:34Z | 2020-09-12T23:41:15Z |
CLN: _wrap_applied_output | diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index e870187fc7952..1552256468ad2 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -1203,16 +1203,27 @@ def _wrap_applied_output(self, keys, values, not_indexed_same=False):
values = [x if (x is not None) else backup for x in values]
- v = values[0]
-
- if not isinstance(v, (np.ndarray, Index, Series)) and self.as_index:
+ if isinstance(first_not_none, (np.ndarray, Index)):
+ # GH#1738: values is list of arrays of unequal lengths
+ # fall through to the outer else clause
+ # TODO: sure this is right? we used to do this
+ # after raising AttributeError above
+ return self.obj._constructor_sliced(
+ values, index=key_index, name=self._selection_name
+ )
+ elif not isinstance(first_not_none, Series):
# values are not series or array-like but scalars
# self._selection_name not passed through to Series as the
# result should not take the name of original selection
# of columns
- return self.obj._constructor_sliced(values, index=key_index)
+ if self.as_index:
+ return self.obj._constructor_sliced(values, index=key_index)
+ else:
+ result = DataFrame(values, index=key_index, columns=[self._selection])
+ self._insert_inaxis_grouper_inplace(result)
+ return result
- if isinstance(v, Series):
+ else:
all_indexed_same = all_indexes_same((x.index for x in values))
# GH3596
@@ -1253,31 +1264,19 @@ def _wrap_applied_output(self, keys, values, not_indexed_same=False):
if self.axis == 0:
index = key_index
- columns = v.index.copy()
+ columns = first_not_none.index.copy()
if columns.name is None:
# GH6124 - propagate name of Series when it's consistent
names = {v.name for v in values}
if len(names) == 1:
columns.name = list(names)[0]
else:
- index = v.index
+ index = first_not_none.index
columns = key_index
stacked_values = stacked_values.T
result = self.obj._constructor(stacked_values, index=index, columns=columns)
- elif not self.as_index:
- # We add grouping column below, so create a frame here
- result = DataFrame(values, index=key_index, columns=[self._selection])
- else:
- # GH#1738: values is list of arrays of unequal lengths
- # fall through to the outer else clause
- # TODO: sure this is right? we used to do this
- # after raising AttributeError above
- return self.obj._constructor_sliced(
- values, index=key_index, name=self._selection_name
- )
-
# if we have date/time like in the original, then coerce dates
# as we are stacking can easily have object dtypes here
so = self._selected_obj
diff --git a/pandas/tests/groupby/test_apply.py b/pandas/tests/groupby/test_apply.py
index 3183305fe2933..db5c4af9c6f53 100644
--- a/pandas/tests/groupby/test_apply.py
+++ b/pandas/tests/groupby/test_apply.py
@@ -381,6 +381,16 @@ def test_apply_frame_to_series(df):
tm.assert_numpy_array_equal(result.values, expected.values)
+def test_apply_frame_not_as_index_column_name(df):
+ # GH 35964 - path within _wrap_applied_output not hit by a test
+ grouped = df.groupby(["A", "B"], as_index=False)
+ result = grouped.apply(len)
+ expected = grouped.count().rename(columns={"C": np.nan}).drop(columns="D")
+ # TODO: Use assert_frame_equal when column name is not np.nan (GH 36306)
+ tm.assert_index_equal(result.index, expected.index)
+ tm.assert_numpy_array_equal(result.values, expected.values)
+
+
def test_apply_frame_concat_series():
def trans(group):
return group.groupby("B")["C"].sum().sort_values()[:2]
| - [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36260 | 2020-09-10T00:25:23Z | 2020-09-12T21:12:43Z | 2020-09-12T21:12:43Z | 2020-09-12T21:15:53Z |
de-privatize imported names | diff --git a/pandas/compat/numpy/function.py b/pandas/compat/numpy/function.py
index d7a14c28cc9ca..5f627aeade47c 100644
--- a/pandas/compat/numpy/function.py
+++ b/pandas/compat/numpy/function.py
@@ -21,7 +21,7 @@
from distutils.version import LooseVersion
from typing import Any, Dict, Optional, Union
-from numpy import __version__ as _np_version, ndarray
+from numpy import __version__, ndarray
from pandas._libs.lib import is_bool, is_integer
from pandas.errors import UnsupportedFunctionCall
@@ -122,7 +122,7 @@ def validate_argmax_with_skipna(skipna, args, kwargs):
ARGSORT_DEFAULTS["kind"] = "quicksort"
ARGSORT_DEFAULTS["order"] = None
-if LooseVersion(_np_version) >= LooseVersion("1.17.0"):
+if LooseVersion(__version__) >= LooseVersion("1.17.0"):
# GH-26361. NumPy added radix sort and changed default to None.
ARGSORT_DEFAULTS["kind"] = None
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 57e63daff29e4..872c51c7dfa75 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -262,7 +262,7 @@ def _get_values_for_rank(values):
return values
-def _get_data_algo(values):
+def get_data_algo(values):
values = _get_values_for_rank(values)
ndtype = _check_object_for_strings(values)
@@ -491,7 +491,7 @@ def factorize_array(
codes : ndarray
uniques : ndarray
"""
- hash_klass, values = _get_data_algo(values)
+ hash_klass, values = get_data_algo(values)
table = hash_klass(size_hint or len(values))
uniques, codes = table.factorize(
@@ -2086,7 +2086,7 @@ def sort_mixed(values):
if sorter is None:
# mixed types
- hash_klass, values = _get_data_algo(values)
+ hash_klass, values = get_data_algo(values)
t = hash_klass(len(values))
t.map_locations(values)
sorter = ensure_platform_int(t.lookup(ordered))
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 81f9456502bf0..e73a1404c6434 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -43,7 +43,7 @@
from pandas.core import ops
from pandas.core.accessor import PandasDelegate, delegate_names
import pandas.core.algorithms as algorithms
-from pandas.core.algorithms import _get_data_algo, factorize, take_1d, unique1d
+from pandas.core.algorithms import factorize, get_data_algo, take_1d, unique1d
from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
from pandas.core.base import ExtensionArray, NoNewAttributesMixin, PandasObject
import pandas.core.common as com
@@ -2531,8 +2531,8 @@ def _get_codes_for_values(values, categories):
# Only hit here when we've already coerced to object dtypee.
- hash_klass, vals = _get_data_algo(values)
- _, cats = _get_data_algo(categories)
+ hash_klass, vals = get_data_algo(values)
+ _, cats = get_data_algo(categories)
t = hash_klass(len(cats))
t.map_locations(cats)
return coerce_indexer_dtype(t.lookup(vals), cats)
diff --git a/pandas/core/ops/__init__.py b/pandas/core/ops/__init__.py
index 8fcbee6a20ac3..6763db1e2b138 100644
--- a/pandas/core/ops/__init__.py
+++ b/pandas/core/ops/__init__.py
@@ -324,12 +324,12 @@ def _align_method_SERIES(left: "Series", right, align_asobject: bool = False):
return left, right
-def _arith_method_SERIES(cls, op, special):
+def arith_method_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
- assert special # non-special uses _flex_method_SERIES
+ assert special # non-special uses flex_method_SERIES
op_name = _get_op_name(op, special)
@unpack_zerodim_and_defer(op_name)
@@ -348,12 +348,12 @@ def wrapper(left, right):
return wrapper
-def _comp_method_SERIES(cls, op, special):
+def comp_method_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
- assert special # non-special uses _flex_method_SERIES
+ assert special # non-special uses flex_method_SERIES
op_name = _get_op_name(op, special)
@unpack_zerodim_and_defer(op_name)
@@ -375,12 +375,12 @@ def wrapper(self, other):
return wrapper
-def _bool_method_SERIES(cls, op, special):
+def bool_method_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
- assert special # non-special uses _flex_method_SERIES
+ assert special # non-special uses flex_method_SERIES
op_name = _get_op_name(op, special)
@unpack_zerodim_and_defer(op_name)
@@ -398,7 +398,7 @@ def wrapper(self, other):
return wrapper
-def _flex_method_SERIES(cls, op, special):
+def flex_method_SERIES(cls, op, special):
assert not special # "special" also means "not flex"
name = _get_op_name(op, special)
doc = _make_flex_doc(name, "series")
@@ -614,7 +614,7 @@ def _maybe_align_series_as_frame(frame: "DataFrame", series: "Series", axis: int
return type(frame)(rvalues, index=frame.index, columns=frame.columns)
-def _arith_method_FRAME(cls: Type["DataFrame"], op, special: bool):
+def arith_method_FRAME(cls: Type["DataFrame"], op, special: bool):
# This is the only function where `special` can be either True or False
op_name = _get_op_name(op, special)
default_axis = _get_frame_op_default_axis(op_name)
@@ -666,7 +666,7 @@ def f(self, other, axis=default_axis, level=None, fill_value=None):
return f
-def _flex_comp_method_FRAME(cls: Type["DataFrame"], op, special: bool):
+def flex_comp_method_FRAME(cls: Type["DataFrame"], op, special: bool):
assert not special # "special" also means "not flex"
op_name = _get_op_name(op, special)
default_axis = _get_frame_op_default_axis(op_name)
@@ -690,7 +690,7 @@ def f(self, other, axis=default_axis, level=None):
return f
-def _comp_method_FRAME(cls: Type["DataFrame"], op, special: bool):
+def comp_method_FRAME(cls: Type["DataFrame"], op, special: bool):
assert special # "special" also means "not flex"
op_name = _get_op_name(op, special)
diff --git a/pandas/core/ops/methods.py b/pandas/core/ops/methods.py
index a4694a6e5134f..e04db92b58c36 100644
--- a/pandas/core/ops/methods.py
+++ b/pandas/core/ops/methods.py
@@ -44,28 +44,28 @@ def _get_method_wrappers(cls):
# TODO: make these non-runtime imports once the relevant functions
# are no longer in __init__
from pandas.core.ops import (
- _arith_method_FRAME,
- _arith_method_SERIES,
- _bool_method_SERIES,
- _comp_method_FRAME,
- _comp_method_SERIES,
- _flex_comp_method_FRAME,
- _flex_method_SERIES,
+ arith_method_FRAME,
+ arith_method_SERIES,
+ bool_method_SERIES,
+ comp_method_FRAME,
+ comp_method_SERIES,
+ flex_comp_method_FRAME,
+ flex_method_SERIES,
)
if issubclass(cls, ABCSeries):
# Just Series
- arith_flex = _flex_method_SERIES
- comp_flex = _flex_method_SERIES
- arith_special = _arith_method_SERIES
- comp_special = _comp_method_SERIES
- bool_special = _bool_method_SERIES
+ arith_flex = flex_method_SERIES
+ comp_flex = flex_method_SERIES
+ arith_special = arith_method_SERIES
+ comp_special = comp_method_SERIES
+ bool_special = bool_method_SERIES
elif issubclass(cls, ABCDataFrame):
- arith_flex = _arith_method_FRAME
- comp_flex = _flex_comp_method_FRAME
- arith_special = _arith_method_FRAME
- comp_special = _comp_method_FRAME
- bool_special = _arith_method_FRAME
+ arith_flex = arith_method_FRAME
+ comp_flex = flex_comp_method_FRAME
+ arith_special = arith_method_FRAME
+ comp_special = comp_method_FRAME
+ bool_special = arith_method_FRAME
return arith_flex, comp_flex, arith_special, comp_special, bool_special
diff --git a/pandas/io/excel/__init__.py b/pandas/io/excel/__init__.py
index d035223957a76..3bad493dee388 100644
--- a/pandas/io/excel/__init__.py
+++ b/pandas/io/excel/__init__.py
@@ -1,9 +1,9 @@
from pandas.io.excel._base import ExcelFile, ExcelWriter, read_excel
-from pandas.io.excel._odswriter import _ODSWriter
-from pandas.io.excel._openpyxl import _OpenpyxlWriter
+from pandas.io.excel._odswriter import ODSWriter as _ODSWriter
+from pandas.io.excel._openpyxl import OpenpyxlWriter as _OpenpyxlWriter
from pandas.io.excel._util import register_writer
-from pandas.io.excel._xlsxwriter import _XlsxWriter
-from pandas.io.excel._xlwt import _XlwtWriter
+from pandas.io.excel._xlsxwriter import XlsxWriter as _XlsxWriter
+from pandas.io.excel._xlwt import XlwtWriter as _XlwtWriter
__all__ = ["read_excel", "ExcelWriter", "ExcelFile"]
diff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py
index d597731ed0ac4..e9634ff0e9a05 100644
--- a/pandas/io/excel/_base.py
+++ b/pandas/io/excel/_base.py
@@ -844,16 +844,16 @@ class ExcelFile:
- ``pyxlsb`` supports Binary Excel files.
"""
- from pandas.io.excel._odfreader import _ODFReader
- from pandas.io.excel._openpyxl import _OpenpyxlReader
- from pandas.io.excel._pyxlsb import _PyxlsbReader
- from pandas.io.excel._xlrd import _XlrdReader
+ from pandas.io.excel._odfreader import ODFReader
+ from pandas.io.excel._openpyxl import OpenpyxlReader
+ from pandas.io.excel._pyxlsb import PyxlsbReader
+ from pandas.io.excel._xlrd import XlrdReader
_engines: Mapping[str, Any] = {
- "xlrd": _XlrdReader,
- "openpyxl": _OpenpyxlReader,
- "odf": _ODFReader,
- "pyxlsb": _PyxlsbReader,
+ "xlrd": XlrdReader,
+ "openpyxl": OpenpyxlReader,
+ "odf": ODFReader,
+ "pyxlsb": PyxlsbReader,
}
def __init__(
diff --git a/pandas/io/excel/_odfreader.py b/pandas/io/excel/_odfreader.py
index 02575ab878f6e..ffb599cdfaaf8 100644
--- a/pandas/io/excel/_odfreader.py
+++ b/pandas/io/excel/_odfreader.py
@@ -10,7 +10,7 @@
from pandas.io.excel._base import BaseExcelReader
-class _ODFReader(BaseExcelReader):
+class ODFReader(BaseExcelReader):
"""
Read tables out of OpenDocument formatted files.
diff --git a/pandas/io/excel/_odswriter.py b/pandas/io/excel/_odswriter.py
index e7684012c1d4c..cbac60dfabaa7 100644
--- a/pandas/io/excel/_odswriter.py
+++ b/pandas/io/excel/_odswriter.py
@@ -9,7 +9,7 @@
from pandas.io.formats.excel import ExcelCell
-class _ODSWriter(ExcelWriter):
+class ODSWriter(ExcelWriter):
engine = "odf"
supported_extensions = (".ods",)
diff --git a/pandas/io/excel/_openpyxl.py b/pandas/io/excel/_openpyxl.py
index f395127902101..a5cadf4d93389 100644
--- a/pandas/io/excel/_openpyxl.py
+++ b/pandas/io/excel/_openpyxl.py
@@ -12,7 +12,7 @@
from openpyxl.descriptors.serialisable import Serialisable
-class _OpenpyxlWriter(ExcelWriter):
+class OpenpyxlWriter(ExcelWriter):
engine = "openpyxl"
supported_extensions = (".xlsx", ".xlsm")
@@ -438,7 +438,7 @@ def write_cells(
setattr(xcell, k, v)
-class _OpenpyxlReader(BaseExcelReader):
+class OpenpyxlReader(BaseExcelReader):
def __init__(
self,
filepath_or_buffer: FilePathOrBuffer,
diff --git a/pandas/io/excel/_pyxlsb.py b/pandas/io/excel/_pyxlsb.py
index 069c3a2eaa643..ac94f4dd3df74 100644
--- a/pandas/io/excel/_pyxlsb.py
+++ b/pandas/io/excel/_pyxlsb.py
@@ -6,7 +6,7 @@
from pandas.io.excel._base import BaseExcelReader
-class _PyxlsbReader(BaseExcelReader):
+class PyxlsbReader(BaseExcelReader):
def __init__(
self,
filepath_or_buffer: FilePathOrBuffer,
diff --git a/pandas/io/excel/_xlrd.py b/pandas/io/excel/_xlrd.py
index 9057106fb08e5..dfd5dde0329ae 100644
--- a/pandas/io/excel/_xlrd.py
+++ b/pandas/io/excel/_xlrd.py
@@ -8,7 +8,7 @@
from pandas.io.excel._base import BaseExcelReader
-class _XlrdReader(BaseExcelReader):
+class XlrdReader(BaseExcelReader):
def __init__(self, filepath_or_buffer, storage_options: StorageOptions = None):
"""
Reader using xlrd engine.
diff --git a/pandas/io/excel/_xlsxwriter.py b/pandas/io/excel/_xlsxwriter.py
index 53f0c94d12e4c..16c4d377d7610 100644
--- a/pandas/io/excel/_xlsxwriter.py
+++ b/pandas/io/excel/_xlsxwriter.py
@@ -158,7 +158,7 @@ def convert(cls, style_dict, num_format_str=None):
return props
-class _XlsxWriter(ExcelWriter):
+class XlsxWriter(ExcelWriter):
engine = "xlsxwriter"
supported_extensions = (".xlsx",)
diff --git a/pandas/io/excel/_xlwt.py b/pandas/io/excel/_xlwt.py
index faebe526d17bd..3592c2684f5a5 100644
--- a/pandas/io/excel/_xlwt.py
+++ b/pandas/io/excel/_xlwt.py
@@ -9,7 +9,7 @@
from xlwt import XFStyle
-class _XlwtWriter(ExcelWriter):
+class XlwtWriter(ExcelWriter):
engine = "xlwt"
supported_extensions = (".xls",)
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index e9deaf3fe67de..0e8f6b933cd97 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -33,7 +33,6 @@ def test_foo():
from pandas.compat import IS64, is_platform_windows
from pandas.compat._optional import import_optional_dependency
-from pandas.compat.numpy import _np_version
from pandas.core.computation.expressions import NUMEXPR_INSTALLED, USE_NUMEXPR
@@ -205,7 +204,9 @@ def skip_if_no(package: str, min_version: Optional[str] = None):
def skip_if_np_lt(ver_str: str, *args, reason: Optional[str] = None):
if reason is None:
reason = f"NumPy {ver_str} or greater required"
- return pytest.mark.skipif(_np_version < LooseVersion(ver_str), *args, reason=reason)
+ return pytest.mark.skipif(
+ np.__version__ < LooseVersion(ver_str), *args, reason=reason
+ )
def parametrize_fixture_doc(*args):
| After this we're down to ~5 i think | https://api.github.com/repos/pandas-dev/pandas/pulls/36259 | 2020-09-09T23:49:42Z | 2020-09-11T20:51:55Z | 2020-09-11T20:51:55Z | 2020-09-11T21:51:23Z |
searchsorted numpy compat for Period dtype | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index bce6a735b7b07..888658eb5ed18 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -228,7 +228,7 @@ Datetimelike
- Bug in :class:`DateOffset` where attributes reconstructed from pickle files differ from original objects when input values exceed normal ranges (e.g months=12) (:issue:`34511`)
- Bug in :meth:`DatetimeIndex.get_slice_bound` where ``datetime.date`` objects were not accepted or naive :class:`Timestamp` with a tz-aware :class:`DatetimeIndex` (:issue:`35690`)
- Bug in :meth:`DatetimeIndex.slice_locs` where ``datetime.date`` objects were not accepted (:issue:`34077`)
-- Bug in :meth:`DatetimeIndex.searchsorted`, :meth:`TimedeltaIndex.searchsorted`, and :meth:`Series.searchsorted` with ``datetime64`` or ``timedelta64`` dtype placement of ``NaT`` values being inconsistent with ``NumPy`` (:issue:`36176`)
+- Bug in :meth:`DatetimeIndex.searchsorted`, :meth:`TimedeltaIndex.searchsorted`, :meth:`PeriodIndex.searchsorted`, and :meth:`Series.searchsorted` with ``datetime64``, ``timedelta64`` or ``Period`` dtype placement of ``NaT`` values being inconsistent with ``NumPy`` (:issue:`36176`,:issue:`36254`)
Timedelta
^^^^^^^^^
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 865b1680c008a..44c0455018a42 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -587,6 +587,13 @@ def astype(self, dtype, copy: bool = True):
return self.asfreq(dtype.freq)
return super().astype(dtype, copy=copy)
+ def searchsorted(self, value, side="left", sorter=None):
+ value = self._validate_searchsorted_value(value).view("M8[ns]")
+
+ # Cast to M8 to get datetime-like NaT placement
+ m8arr = self._ndarray.view("M8[ns]")
+ return m8arr.searchsorted(value, side=side, sorter=sorter)
+
# ------------------------------------------------------------------
# Arithmetic Methods
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index 9d316c38082af..624335fd78b0f 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -244,7 +244,7 @@ def test_searchsorted(self):
# GH#29884 match numpy convention on whether NaT goes
# at the end or the beginning
result = arr.searchsorted(pd.NaT)
- if np_version_under1p18 or self.array_cls is PeriodArray:
+ if np_version_under1p18:
# Following numpy convention, NaT goes at the beginning
# (unlike NaN which goes at the end)
assert result == 0
diff --git a/pandas/tests/indexes/period/test_searchsorted.py b/pandas/tests/indexes/period/test_searchsorted.py
index f5a2583bf2e10..f2950b9f6065c 100644
--- a/pandas/tests/indexes/period/test_searchsorted.py
+++ b/pandas/tests/indexes/period/test_searchsorted.py
@@ -2,6 +2,7 @@
import pytest
from pandas._libs.tslibs import IncompatibleFrequency
+from pandas.compat.numpy import np_version_under1p18
from pandas import NaT, Period, PeriodIndex, Series, array
import pandas._testing as tm
@@ -21,7 +22,13 @@ def test_searchsorted(self, freq):
p2 = Period("2014-01-04", freq=freq)
assert pidx.searchsorted(p2) == 3
- assert pidx.searchsorted(NaT) == 0
+ if np_version_under1p18:
+ # GH#36254
+ # Following numpy convention, NaT goes at the beginning
+ # (unlike NaN which goes at the end)
+ assert pidx.searchsorted(NaT) == 0
+ else:
+ assert pidx.searchsorted(NaT) == 5
msg = "Input has different freq=H from PeriodArray"
with pytest.raises(IncompatibleFrequency, match=msg):
| - [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36254 | 2020-09-09T19:44:52Z | 2020-09-12T21:15:13Z | 2020-09-12T21:15:13Z | 2020-09-12T21:17:52Z |
CLN: simplify Categorical comparisons | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index a2b5b54c55490..fdc77c488e87f 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -80,17 +80,9 @@ def func(self, other):
# the same (maybe up to ordering, depending on ordered)
msg = "Categoricals can only be compared if 'categories' are the same."
- if len(self.categories) != len(other.categories):
- raise TypeError(msg + " Categories are different lengths")
- elif self.ordered and not (self.categories == other.categories).all():
- raise TypeError(msg)
- elif not set(self.categories) == set(other.categories):
+ if not self.is_dtype_equal(other):
raise TypeError(msg)
- if not (self.ordered == other.ordered):
- raise TypeError(
- "Categoricals can only be compared if 'ordered' is the same"
- )
if not self.ordered and not self.categories.equals(other.categories):
# both unordered and different order
other_codes = _get_codes_for_values(other, self.categories)
diff --git a/pandas/tests/arrays/categorical/test_operators.py b/pandas/tests/arrays/categorical/test_operators.py
index bc5fb51883b3d..9d118f1ed8753 100644
--- a/pandas/tests/arrays/categorical/test_operators.py
+++ b/pandas/tests/arrays/categorical/test_operators.py
@@ -79,10 +79,6 @@ def test_comparisons(self):
cat_rev_base2 = Categorical(["b", "b", "b"], categories=["c", "b", "a", "d"])
- msg = (
- "Categoricals can only be compared if 'categories' are the same. "
- "Categories are different lengths"
- )
with pytest.raises(TypeError, match=msg):
cat_rev > cat_rev_base2
@@ -90,7 +86,6 @@ def test_comparisons(self):
cat_unorderd = cat.set_ordered(False)
assert not (cat > cat).any()
- msg = "Categoricals can only be compared if 'ordered' is the same"
with pytest.raises(TypeError, match=msg):
cat > cat_unorderd
@@ -321,7 +316,7 @@ def test_compare_different_lengths(self):
c1 = Categorical([], categories=["a", "b"])
c2 = Categorical([], categories=["a"])
- msg = "Categories are different lengths"
+ msg = "Categoricals can only be compared if 'categories' are the same."
with pytest.raises(TypeError, match=msg):
c1 == c2
diff --git a/pandas/tests/indexes/categorical/test_category.py b/pandas/tests/indexes/categorical/test_category.py
index b325edb321ed4..a3a06338a0277 100644
--- a/pandas/tests/indexes/categorical/test_category.py
+++ b/pandas/tests/indexes/categorical/test_category.py
@@ -402,15 +402,7 @@ def test_equals_categorical(self):
with pytest.raises(ValueError, match="Lengths must match"):
ci1 == Index(["a", "b", "c"])
- msg = (
- "categorical index comparisons must have the same categories "
- "and ordered attributes"
- "|"
- "Categoricals can only be compared if 'categories' are the same. "
- "Categories are different lengths"
- "|"
- "Categoricals can only be compared if 'ordered' is the same"
- )
+ msg = "Categoricals can only be compared if 'categories' are the same"
with pytest.raises(TypeError, match=msg):
ci1 == ci2
with pytest.raises(TypeError, match=msg):
| We have way too many ways of comparing Categorical dtypes.
| https://api.github.com/repos/pandas-dev/pandas/pulls/36250 | 2020-09-09T17:45:09Z | 2020-09-12T21:14:36Z | 2020-09-12T21:14:36Z | 2020-09-12T21:18:29Z |
BUG: na parameter for str.startswith and str.endswith not propagating for Series with categorical dtype | diff --git a/doc/source/whatsnew/v1.1.3.rst b/doc/source/whatsnew/v1.1.3.rst
index e3161012da5d1..c06990e3f2051 100644
--- a/doc/source/whatsnew/v1.1.3.rst
+++ b/doc/source/whatsnew/v1.1.3.rst
@@ -22,7 +22,7 @@ Fixed regressions
Bug fixes
~~~~~~~~~
--
+- Bug in :meth:`Series.str.startswith` and :meth:`Series.str.endswith` with ``category`` dtype not propagating ``na`` parameter (:issue:`36241`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/strings.py b/pandas/core/strings.py
index 6702bf519c52e..4decd86764ccc 100644
--- a/pandas/core/strings.py
+++ b/pandas/core/strings.py
@@ -2050,7 +2050,7 @@ def wrapper2(self, pat, flags=0, **kwargs):
@forbid_nonstring_types(forbidden_types, name=name)
def wrapper3(self, pat, na=np.nan):
result = f(self._parent, pat, na=na)
- return self._wrap_result(result, returns_string=returns_string)
+ return self._wrap_result(result, returns_string=returns_string, fill_value=na)
wrapper = wrapper3 if na else wrapper2 if flags else wrapper1
diff --git a/pandas/tests/test_strings.py b/pandas/tests/test_strings.py
index d9396d70f9112..c792a48d3ef08 100644
--- a/pandas/tests/test_strings.py
+++ b/pandas/tests/test_strings.py
@@ -29,6 +29,8 @@ def assert_series_or_index_equal(left, right):
("decode", ("UTF-8",), {}),
("encode", ("UTF-8",), {}),
("endswith", ("a",), {}),
+ ("endswith", ("a",), {"na": True}),
+ ("endswith", ("a",), {"na": False}),
("extract", ("([a-z]*)",), {"expand": False}),
("extract", ("([a-z]*)",), {"expand": True}),
("extractall", ("([a-z]*)",), {}),
@@ -58,6 +60,8 @@ def assert_series_or_index_equal(left, right):
("split", (" ",), {"expand": False}),
("split", (" ",), {"expand": True}),
("startswith", ("a",), {}),
+ ("startswith", ("a",), {"na": True}),
+ ("startswith", ("a",), {"na": False}),
# translating unicode points of "a" to "d"
("translate", ({97: 100},), {}),
("wrap", (2,), {}),
@@ -838,15 +842,23 @@ def test_contains_for_object_category(self):
expected = Series([True, False, False, True, False])
tm.assert_series_equal(result, expected)
- def test_startswith(self):
- values = Series(["om", np.nan, "foo_nom", "nom", "bar_foo", np.nan, "foo"])
+ @pytest.mark.parametrize("dtype", [None, "category"])
+ @pytest.mark.parametrize("null_value", [None, np.nan, pd.NA])
+ @pytest.mark.parametrize("na", [True, False])
+ def test_startswith(self, dtype, null_value, na):
+ # add category dtype parametrizations for GH-36241
+ values = Series(
+ ["om", null_value, "foo_nom", "nom", "bar_foo", null_value, "foo"],
+ dtype=dtype,
+ )
result = values.str.startswith("foo")
exp = Series([False, np.nan, True, False, False, np.nan, True])
tm.assert_series_equal(result, exp)
- result = values.str.startswith("foo", na=True)
- tm.assert_series_equal(result, exp.fillna(True).astype(bool))
+ result = values.str.startswith("foo", na=na)
+ exp = Series([False, na, True, False, False, na, True])
+ tm.assert_series_equal(result, exp)
# mixed
mixed = np.array(
@@ -867,15 +879,23 @@ def test_startswith(self):
)
tm.assert_series_equal(rs, xp)
- def test_endswith(self):
- values = Series(["om", np.nan, "foo_nom", "nom", "bar_foo", np.nan, "foo"])
+ @pytest.mark.parametrize("dtype", [None, "category"])
+ @pytest.mark.parametrize("null_value", [None, np.nan, pd.NA])
+ @pytest.mark.parametrize("na", [True, False])
+ def test_endswith(self, dtype, null_value, na):
+ # add category dtype parametrizations for GH-36241
+ values = Series(
+ ["om", null_value, "foo_nom", "nom", "bar_foo", null_value, "foo"],
+ dtype=dtype,
+ )
result = values.str.endswith("foo")
exp = Series([False, np.nan, False, False, True, np.nan, True])
tm.assert_series_equal(result, exp)
- result = values.str.endswith("foo", na=False)
- tm.assert_series_equal(result, exp.fillna(False).astype(bool))
+ result = values.str.endswith("foo", na=na)
+ exp = Series([False, na, False, False, True, na, True])
+ tm.assert_series_equal(result, exp)
# mixed
mixed = np.array(
@@ -3552,6 +3572,10 @@ def test_string_array(any_string_method):
assert result.dtype == "boolean"
result = result.astype(object)
+ elif expected.dtype == "bool":
+ assert result.dtype == "boolean"
+ result = result.astype("bool")
+
elif expected.dtype == "float" and expected.isna().any():
assert result.dtype == "Int64"
result = result.astype("float")
| - [x] closes #36241
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
I parametrized dtype in existing tests. Should I create a separate test instead? | https://api.github.com/repos/pandas-dev/pandas/pulls/36249 | 2020-09-09T16:31:45Z | 2020-09-12T21:17:49Z | 2020-09-12T21:17:49Z | 2020-09-13T12:25:48Z |
DOC: Fixed a broken JSON Table Schema link | diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index 43030d76d945a..bf6575a8836f5 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -2412,7 +2412,7 @@ indicate missing values and the subsequent read cannot distinguish the intent.
os.remove('test.json')
-.. _Table Schema: https://specs.frictionlessdata.io/json-table-schema/
+.. _Table Schema: https://specs.frictionlessdata.io/table-schema/
HTML
----
| Fixed a link to JSON Table Schema specification hosted on https://specs.frictionlessdata.io/table-schema/
- [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `black pandas`
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36246 | 2020-09-09T14:57:05Z | 2020-09-09T15:12:06Z | 2020-09-09T15:12:05Z | 2020-09-09T15:12:12Z |
Backport PR #36183 on branch 1.1.x (DOC: Start 1.1.3) | diff --git a/doc/source/whatsnew/index.rst b/doc/source/whatsnew/index.rst
index 1b5e63dfcf359..33c0750c1dc16 100644
--- a/doc/source/whatsnew/index.rst
+++ b/doc/source/whatsnew/index.rst
@@ -16,6 +16,7 @@ Version 1.1
.. toctree::
:maxdepth: 2
+ v1.1.3
v1.1.2
v1.1.1
v1.1.0
diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index c6a08f4fb852a..81b8e7df11625 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -61,4 +61,4 @@ Other
Contributors
~~~~~~~~~~~~
-.. contributors:: v1.1.1..v1.1.2|HEAD
+.. contributors:: v1.1.1..v1.1.2
diff --git a/doc/source/whatsnew/v1.1.3.rst b/doc/source/whatsnew/v1.1.3.rst
new file mode 100644
index 0000000000000..e3161012da5d1
--- /dev/null
+++ b/doc/source/whatsnew/v1.1.3.rst
@@ -0,0 +1,42 @@
+.. _whatsnew_113:
+
+What's new in 1.1.3 (??)
+------------------------
+
+These are the changes in pandas 1.1.3. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_113.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_113.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_113.other:
+
+Other
+~~~~~
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_113.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.1.2..v1.1.3|HEAD
| Backport PR #36183: DOC: Start 1.1.3 | https://api.github.com/repos/pandas-dev/pandas/pulls/36242 | 2020-09-09T08:32:45Z | 2020-09-09T09:28:47Z | 2020-09-09T09:28:47Z | 2020-09-09T09:28:47Z |
PERF: Allow groupby transform with numba engine to be fully parallelizable | diff --git a/asv_bench/benchmarks/groupby.py b/asv_bench/benchmarks/groupby.py
index 5ffda03fad80f..bda3ab71d1a00 100644
--- a/asv_bench/benchmarks/groupby.py
+++ b/asv_bench/benchmarks/groupby.py
@@ -627,33 +627,42 @@ def time_first(self):
class TransformEngine:
- def setup(self):
+
+ param_names = ["parallel"]
+ params = [[True, False]]
+
+ def setup(self, parallel):
N = 10 ** 3
data = DataFrame(
{0: [str(i) for i in range(100)] * N, 1: list(range(100)) * N},
columns=[0, 1],
)
+ self.parallel = parallel
self.grouper = data.groupby(0)
- def time_series_numba(self):
+ def time_series_numba(self, parallel):
def function(values, index):
return values * 5
- self.grouper[1].transform(function, engine="numba")
+ self.grouper[1].transform(
+ function, engine="numba", engine_kwargs={"parallel": self.parallel}
+ )
- def time_series_cython(self):
+ def time_series_cython(self, parallel):
def function(values):
return values * 5
self.grouper[1].transform(function, engine="cython")
- def time_dataframe_numba(self):
+ def time_dataframe_numba(self, parallel):
def function(values, index):
return values * 5
- self.grouper.transform(function, engine="numba")
+ self.grouper.transform(
+ function, engine="numba", engine_kwargs={"parallel": self.parallel}
+ )
- def time_dataframe_cython(self):
+ def time_dataframe_cython(self, parallel):
def function(values):
return values * 5
@@ -661,15 +670,20 @@ def function(values):
class AggEngine:
- def setup(self):
+
+ param_names = ["parallel"]
+ params = [[True, False]]
+
+ def setup(self, parallel):
N = 10 ** 3
data = DataFrame(
{0: [str(i) for i in range(100)] * N, 1: list(range(100)) * N},
columns=[0, 1],
)
+ self.parallel = parallel
self.grouper = data.groupby(0)
- def time_series_numba(self):
+ def time_series_numba(self, parallel):
def function(values, index):
total = 0
for i, value in enumerate(values):
@@ -679,9 +693,11 @@ def function(values, index):
total += value * 2
return total
- self.grouper[1].agg(function, engine="numba")
+ self.grouper[1].agg(
+ function, engine="numba", engine_kwargs={"parallel": self.parallel}
+ )
- def time_series_cython(self):
+ def time_series_cython(self, parallel):
def function(values):
total = 0
for i, value in enumerate(values):
@@ -693,7 +709,7 @@ def function(values):
self.grouper[1].agg(function, engine="cython")
- def time_dataframe_numba(self):
+ def time_dataframe_numba(self, parallel):
def function(values, index):
total = 0
for i, value in enumerate(values):
@@ -703,9 +719,11 @@ def function(values, index):
total += value * 2
return total
- self.grouper.agg(function, engine="numba")
+ self.grouper.agg(
+ function, engine="numba", engine_kwargs={"parallel": self.parallel}
+ )
- def time_dataframe_cython(self):
+ def time_dataframe_cython(self, parallel):
def function(values):
total = 0
for i, value in enumerate(values):
diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index e577a8f26bd12..c2bfb2f72326a 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -207,7 +207,7 @@ Performance improvements
- Performance improvements when creating Series with dtype `str` or :class:`StringDtype` from array with many string elements (:issue:`36304`)
- Performance improvement in :meth:`GroupBy.agg` with the ``numba`` engine (:issue:`35759`)
--
+- Performance improvement in :meth:`GroupBy.transform` with the ``numba`` engine (:issue:`36240`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 1552256468ad2..ffd756bed43b6 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -226,10 +226,6 @@ def apply(self, func, *args, **kwargs):
def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs):
if maybe_use_numba(engine):
- if not callable(func):
- raise NotImplementedError(
- "Numba engine can only be used with a single function."
- )
with group_selection_context(self):
data = self._selected_obj
result, index = self._aggregate_with_numba(
@@ -489,12 +485,21 @@ def _aggregate_named(self, func, *args, **kwargs):
@Substitution(klass="Series")
@Appender(_transform_template)
def transform(self, func, *args, engine=None, engine_kwargs=None, **kwargs):
+
+ if maybe_use_numba(engine):
+ with group_selection_context(self):
+ data = self._selected_obj
+ result = self._transform_with_numba(
+ data.to_frame(), func, *args, engine_kwargs=engine_kwargs, **kwargs
+ )
+ return self.obj._constructor(
+ result.ravel(), index=data.index, name=data.name
+ )
+
func = self._get_cython_func(func) or func
if not isinstance(func, str):
- return self._transform_general(
- func, *args, engine=engine, engine_kwargs=engine_kwargs, **kwargs
- )
+ return self._transform_general(func, *args, **kwargs)
elif func not in base.transform_kernel_allowlist:
msg = f"'{func}' is not a valid function name for transform(name)"
@@ -938,10 +943,6 @@ class DataFrameGroupBy(GroupBy[DataFrame]):
def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs):
if maybe_use_numba(engine):
- if not callable(func):
- raise NotImplementedError(
- "Numba engine can only be used with a single function."
- )
with group_selection_context(self):
data = self._selected_obj
result, index = self._aggregate_with_numba(
@@ -1290,42 +1291,25 @@ def _wrap_applied_output(self, keys, values, not_indexed_same=False):
return self._reindex_output(result)
- def _transform_general(
- self, func, *args, engine="cython", engine_kwargs=None, **kwargs
- ):
+ def _transform_general(self, func, *args, **kwargs):
from pandas.core.reshape.concat import concat
applied = []
obj = self._obj_with_exclusions
gen = self.grouper.get_iterator(obj, axis=self.axis)
- if maybe_use_numba(engine):
- numba_func, cache_key = generate_numba_func(
- func, engine_kwargs, kwargs, "groupby_transform"
- )
- else:
- fast_path, slow_path = self._define_paths(func, *args, **kwargs)
+ fast_path, slow_path = self._define_paths(func, *args, **kwargs)
for name, group in gen:
object.__setattr__(group, "name", name)
- if maybe_use_numba(engine):
- values, index = split_for_numba(group)
- res = numba_func(values, index, *args)
- if cache_key not in NUMBA_FUNC_CACHE:
- NUMBA_FUNC_CACHE[cache_key] = numba_func
- # Return the result as a DataFrame for concatenation later
- res = self.obj._constructor(
- res, index=group.index, columns=group.columns
- )
- else:
- # Try slow path and fast path.
- try:
- path, res = self._choose_path(fast_path, slow_path, group)
- except TypeError:
- return self._transform_item_by_item(obj, fast_path)
- except ValueError as err:
- msg = "transform must return a scalar value for each group"
- raise ValueError(msg) from err
+ # Try slow path and fast path.
+ try:
+ path, res = self._choose_path(fast_path, slow_path, group)
+ except TypeError:
+ return self._transform_item_by_item(obj, fast_path)
+ except ValueError as err:
+ msg = "transform must return a scalar value for each group"
+ raise ValueError(msg) from err
if isinstance(res, Series):
@@ -1361,13 +1345,19 @@ def _transform_general(
@Appender(_transform_template)
def transform(self, func, *args, engine=None, engine_kwargs=None, **kwargs):
+ if maybe_use_numba(engine):
+ with group_selection_context(self):
+ data = self._selected_obj
+ result = self._transform_with_numba(
+ data, func, *args, engine_kwargs=engine_kwargs, **kwargs
+ )
+ return self.obj._constructor(result, index=data.index, columns=data.columns)
+
# optimized transforms
func = self._get_cython_func(func) or func
if not isinstance(func, str):
- return self._transform_general(
- func, *args, engine=engine, engine_kwargs=engine_kwargs, **kwargs
- )
+ return self._transform_general(func, *args, **kwargs)
elif func not in base.transform_kernel_allowlist:
msg = f"'{func}' is not a valid function name for transform(name)"
@@ -1393,9 +1383,7 @@ def transform(self, func, *args, engine=None, engine_kwargs=None, **kwargs):
):
return self._transform_fast(result)
- return self._transform_general(
- func, engine=engine, engine_kwargs=engine_kwargs, *args, **kwargs
- )
+ return self._transform_general(func, *args, **kwargs)
def _transform_fast(self, result: DataFrame) -> DataFrame:
"""
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 8a55d438cf8d4..30bd53a3ddff1 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -1056,6 +1056,41 @@ def _cython_agg_general(
return self._wrap_aggregated_output(output, index=self.grouper.result_index)
+ def _transform_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs):
+ """
+ Perform groupby transform routine with the numba engine.
+
+ This routine mimics the data splitting routine of the DataSplitter class
+ to generate the indices of each group in the sorted data and then passes the
+ data and indices into a Numba jitted function.
+ """
+ if not callable(func):
+ raise NotImplementedError(
+ "Numba engine can only be used with a single function."
+ )
+ group_keys = self.grouper._get_group_keys()
+ labels, _, n_groups = self.grouper.group_info
+ sorted_index = get_group_index_sorter(labels, n_groups)
+ sorted_labels = algorithms.take_nd(labels, sorted_index, allow_fill=False)
+ sorted_data = data.take(sorted_index, axis=self.axis).to_numpy()
+ starts, ends = lib.generate_slices(sorted_labels, n_groups)
+ cache_key = (func, "groupby_transform")
+ if cache_key in NUMBA_FUNC_CACHE:
+ numba_transform_func = NUMBA_FUNC_CACHE[cache_key]
+ else:
+ numba_transform_func = numba_.generate_numba_transform_func(
+ tuple(args), kwargs, func, engine_kwargs
+ )
+ result = numba_transform_func(
+ sorted_data, sorted_index, starts, ends, len(group_keys), len(data.columns)
+ )
+ if cache_key not in NUMBA_FUNC_CACHE:
+ NUMBA_FUNC_CACHE[cache_key] = numba_transform_func
+
+ # result values needs to be resorted to their original positions since we
+ # evaluated the data sorted by group
+ return result.take(np.argsort(sorted_index), axis=0)
+
def _aggregate_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs):
"""
Perform groupby aggregation routine with the numba engine.
@@ -1064,6 +1099,10 @@ def _aggregate_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs)
to generate the indices of each group in the sorted data and then passes the
data and indices into a Numba jitted function.
"""
+ if not callable(func):
+ raise NotImplementedError(
+ "Numba engine can only be used with a single function."
+ )
group_keys = self.grouper._get_group_keys()
labels, _, n_groups = self.grouper.group_info
sorted_index = get_group_index_sorter(labels, n_groups)
@@ -1072,7 +1111,6 @@ def _aggregate_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs)
starts, ends = lib.generate_slices(sorted_labels, n_groups)
cache_key = (func, "groupby_agg")
if cache_key in NUMBA_FUNC_CACHE:
- # Return an already compiled version of roll_apply if available
numba_agg_func = NUMBA_FUNC_CACHE[cache_key]
else:
numba_agg_func = numba_.generate_numba_agg_func(
diff --git a/pandas/core/groupby/numba_.py b/pandas/core/groupby/numba_.py
index aebe60f797fcd..a2dfcd7bddd53 100644
--- a/pandas/core/groupby/numba_.py
+++ b/pandas/core/groupby/numba_.py
@@ -153,7 +153,7 @@ def generate_numba_agg_func(
loop_range = range
@numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
- def group_apply(
+ def group_agg(
values: np.ndarray,
index: np.ndarray,
begin: np.ndarray,
@@ -169,4 +169,69 @@ def group_apply(
result[i, j] = numba_func(group, group_index, *args)
return result
- return group_apply
+ return group_agg
+
+
+def generate_numba_transform_func(
+ args: Tuple,
+ kwargs: Dict[str, Any],
+ func: Callable[..., Scalar],
+ engine_kwargs: Optional[Dict[str, bool]],
+) -> Callable[[np.ndarray, np.ndarray, np.ndarray, np.ndarray, int, int], np.ndarray]:
+ """
+ Generate a numba jitted transform function specified by values from engine_kwargs.
+
+ 1. jit the user's function
+ 2. Return a groupby agg function with the jitted function inline
+
+ Configurations specified in engine_kwargs apply to both the user's
+ function _AND_ the rolling apply function.
+
+ Parameters
+ ----------
+ args : tuple
+ *args to be passed into the function
+ kwargs : dict
+ **kwargs to be passed into the function
+ func : function
+ function to be applied to each window and will be JITed
+ engine_kwargs : dict
+ dictionary of arguments to be passed into numba.jit
+
+ Returns
+ -------
+ Numba function
+ """
+ nopython, nogil, parallel = get_jit_arguments(engine_kwargs)
+
+ check_kwargs_and_nopython(kwargs, nopython)
+
+ validate_udf(func)
+
+ numba_func = jit_user_function(func, nopython, nogil, parallel)
+
+ numba = import_optional_dependency("numba")
+
+ if parallel:
+ loop_range = numba.prange
+ else:
+ loop_range = range
+
+ @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+ def group_transform(
+ values: np.ndarray,
+ index: np.ndarray,
+ begin: np.ndarray,
+ end: np.ndarray,
+ num_groups: int,
+ num_columns: int,
+ ) -> np.ndarray:
+ result = np.empty((len(values), num_columns))
+ for i in loop_range(num_groups):
+ group_index = index[begin[i] : end[i]]
+ for j in loop_range(num_columns):
+ group = values[begin[i] : end[i], j]
+ result[begin[i] : end[i], j] = numba_func(group, group_index, *args)
+ return result
+
+ return group_transform
diff --git a/pandas/tests/groupby/transform/test_numba.py b/pandas/tests/groupby/transform/test_numba.py
index 87723cd7c8f50..fcaa5ab13599a 100644
--- a/pandas/tests/groupby/transform/test_numba.py
+++ b/pandas/tests/groupby/transform/test_numba.py
@@ -127,3 +127,19 @@ def func_1(values, index):
with option_context("compute.use_numba", True):
result = grouped.transform(func_1, engine=None)
tm.assert_frame_equal(expected, result)
+
+
+@td.skip_if_no("numba", "0.46.0")
+@pytest.mark.parametrize(
+ "agg_func", [["min", "max"], "min", {"B": ["min", "max"], "C": "sum"}],
+)
+def test_multifunc_notimplimented(agg_func):
+ data = DataFrame(
+ {0: ["a", "a", "b", "b", "a"], 1: [1.0, 2.0, 3.0, 4.0, 5.0]}, columns=[0, 1]
+ )
+ grouped = data.groupby(0)
+ with pytest.raises(NotImplementedError, match="Numba engine can"):
+ grouped.transform(agg_func, engine="numba")
+
+ with pytest.raises(NotImplementedError, match="Numba engine can"):
+ grouped[1].transform(agg_func, engine="numba")
| - [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
New performance comparison with 10k groups
```
In [1]: df_g = pd.DataFrame({'a': range(10**4), 'b': range(10**4), 'c': range(10**4)})
In [2]: df_g.groupby('a').transform(lambda x: x + 1)
Out[2]:
b c
0 1 1
1 2 2
2 3 3
3 4 4
4 5 5
... ... ...
9995 9996 9996
9996 9997 9997
9997 9998 9998
9998 9999 9999
9999 10000 10000
[10000 rows x 2 columns]
In [3]: %timeit df_g.groupby('a').transform(lambda x: x + 1)
9.48 s ± 885 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [4]: def f(values, index):
...: return values + 1
...:
In [5]: df_g.groupby('a').transform(f, engine='numba', engine_kwargs={'parallel': True})
Out[5]:
b c
0 1.0 1.0
1 2.0 2.0
2 3.0 3.0
3 4.0 4.0
4 5.0 5.0
... ... ...
9995 9996.0 9996.0
9996 9997.0 9997.0
9997 9998.0 9998.0
9998 9999.0 9999.0
9999 10000.0 10000.0
[10000 rows x 2 columns]
In [6]: %timeit df_g.groupby('a').transform(f, engine='numba', engine_kwargs={'parallel': True})
4.41 ms ± 34.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) | https://api.github.com/repos/pandas-dev/pandas/pulls/36240 | 2020-09-09T04:03:17Z | 2020-09-13T13:13:54Z | 2020-09-13T13:13:54Z | 2020-09-13T17:25:07Z |
DOC: Improve Index docstrings | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 8014b16d07b01..67456096e8681 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -195,7 +195,7 @@ def _new_Index(cls, d):
class Index(IndexOpsMixin, PandasObject):
"""
- Immutable ndarray implementing an ordered, sliceable set. The basic object
+ Immutable sequence used for indexing and alignment. The basic object
storing axis labels for all pandas objects.
Parameters
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index 079f43cb2c66b..125602ef2054a 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -189,7 +189,7 @@ def _union(self, other, sort):
_num_index_shared_docs[
"class_descr"
] = """
- Immutable ndarray implementing an ordered, sliceable set. The basic object
+ Immutable sequence used for indexing and alignment. The basic object
storing axis labels for all pandas objects. %(klass)s is a special case
of `Index` with purely %(ltype)s labels. %(extra)s.
| Index is now described as List instead of Set
- [x] closes #36170
- [ ] tests added / passed
- [ ] passes `black pandas`
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36239 | 2020-09-09T03:33:22Z | 2020-09-09T22:25:32Z | 2020-09-09T22:25:32Z | 2020-09-09T22:25:46Z |
DOC: Update groupby.rst | diff --git a/doc/source/user_guide/groupby.rst b/doc/source/user_guide/groupby.rst
index ddba3dc452e28..f745dab00bab8 100644
--- a/doc/source/user_guide/groupby.rst
+++ b/doc/source/user_guide/groupby.rst
@@ -87,11 +87,9 @@ The mapping can be specified many different ways:
* A Python function, to be called on each of the axis labels.
* A list or NumPy array of the same length as the selected axis.
* A dict or ``Series``, providing a ``label -> group name`` mapping.
-* For ``DataFrame`` objects, a string indicating a column to be used to group.
- Of course ``df.groupby('A')`` is just syntactic sugar for
- ``df.groupby(df['A'])``, but it makes life simpler.
-* For ``DataFrame`` objects, a string indicating an index level to be used to
- group.
+* For ``DataFrame`` objects, a string indicating either a column name or
+ an index level name to be used to group.
+* ``df.groupby('A')`` is just syntactic sugar for ``df.groupby(df['A'])``.
* A list of any of the above things.
Collectively we refer to the grouping objects as the **keys**. For example,
| The previous description still had a conflict between the column name and index level
- [x] closes #16870
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36238 | 2020-09-09T03:09:02Z | 2020-09-11T16:47:14Z | 2020-09-11T16:47:14Z | 2020-09-11T16:47:21Z |
CLN: simplify Categorical comparisons | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index a2b5b54c55490..0209ef5046645 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -63,6 +63,7 @@
def _cat_compare_op(op):
opname = f"__{op.__name__}__"
+ fill_value = True if op is operator.ne else False
@unpack_zerodim_and_defer(opname)
def func(self, other):
@@ -97,26 +98,23 @@ def func(self, other):
else:
other_codes = other._codes
- f = getattr(self._codes, opname)
- ret = f(other_codes)
+ ret = op(self._codes, other_codes)
mask = (self._codes == -1) | (other_codes == -1)
if mask.any():
- # In other series, the leads to False, so do that here too
- if opname == "__ne__":
- ret[(self._codes == -1) & (other_codes == -1)] = True
- else:
- ret[mask] = False
+ ret[mask] = fill_value
return ret
if is_scalar(other):
if other in self.categories:
i = self.categories.get_loc(other)
- ret = getattr(self._codes, opname)(i)
+ ret = op(self._codes, i)
if opname not in {"__eq__", "__ge__", "__gt__"}:
- # check for NaN needed if we are not equal or larger
+ # GH#29820 performance trick; get_loc will always give i>=0,
+ # so in the cases (__ne__, __le__, __lt__) the setting
+ # here is a no-op, so can be skipped.
mask = self._codes == -1
- ret[mask] = False
+ ret[mask] = fill_value
return ret
else:
return ops.invalid_comparison(self, other, op)
| Not as much as I had hoped, but not nothing. | https://api.github.com/repos/pandas-dev/pandas/pulls/36237 | 2020-09-09T02:47:03Z | 2020-09-11T13:12:12Z | 2020-09-11T13:12:12Z | 2020-09-11T14:34:57Z |
TST: add test case for sort_index on multiindexed Frame with sparse cols | diff --git a/pandas/tests/frame/methods/test_sort_index.py b/pandas/tests/frame/methods/test_sort_index.py
index dcc33428d18a5..a106702aff807 100644
--- a/pandas/tests/frame/methods/test_sort_index.py
+++ b/pandas/tests/frame/methods/test_sort_index.py
@@ -739,3 +739,18 @@ def test_changes_length_raises(self):
df = pd.DataFrame({"A": [1, 2, 3]})
with pytest.raises(ValueError, match="change the shape"):
df.sort_index(key=lambda x: x[:1])
+
+ def test_sort_index_multiindex_sparse_column(self):
+ # GH 29735, testing that sort_index on a multiindexed frame with sparse
+ # columns fills with 0.
+ expected = pd.DataFrame(
+ {
+ i: pd.array([0.0, 0.0, 0.0, 0.0], dtype=pd.SparseDtype("float64", 0.0))
+ for i in range(0, 4)
+ },
+ index=pd.MultiIndex.from_product([[1, 2], [1, 2]]),
+ )
+
+ result = expected.sort_index(level=0)
+
+ tm.assert_frame_equal(result, expected)
| - [ ] closes #29735
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] add test case for sort_index on multiindexed Frame with sparse cols
| https://api.github.com/repos/pandas-dev/pandas/pulls/36236 | 2020-09-09T00:33:24Z | 2020-09-12T21:23:21Z | 2020-09-12T21:23:21Z | 2020-09-12T21:23:25Z |
STY: De-privatize imported names | diff --git a/pandas/_libs/interval.pyx b/pandas/_libs/interval.pyx
index 931ad8326c371..f8bcbcfb158b5 100644
--- a/pandas/_libs/interval.pyx
+++ b/pandas/_libs/interval.pyx
@@ -46,7 +46,7 @@ from pandas._libs.tslibs.util cimport (
is_timedelta64_object,
)
-_VALID_CLOSED = frozenset(['left', 'right', 'both', 'neither'])
+VALID_CLOSED = frozenset(['left', 'right', 'both', 'neither'])
cdef class IntervalMixin:
@@ -318,7 +318,7 @@ cdef class Interval(IntervalMixin):
self._validate_endpoint(left)
self._validate_endpoint(right)
- if closed not in _VALID_CLOSED:
+ if closed not in VALID_CLOSED:
raise ValueError(f"invalid option for 'closed': {closed}")
if not left <= right:
raise ValueError("left side of interval must be <= right side")
diff --git a/pandas/core/arrays/_arrow_utils.py b/pandas/core/arrays/_arrow_utils.py
index 4a33e0e841f7f..c89f5554d0715 100644
--- a/pandas/core/arrays/_arrow_utils.py
+++ b/pandas/core/arrays/_arrow_utils.py
@@ -4,7 +4,7 @@
import numpy as np
import pyarrow
-from pandas.core.arrays.interval import _VALID_CLOSED
+from pandas.core.arrays.interval import VALID_CLOSED
_pyarrow_version_ge_015 = LooseVersion(pyarrow.__version__) >= LooseVersion("0.15")
@@ -83,7 +83,7 @@ class ArrowIntervalType(pyarrow.ExtensionType):
def __init__(self, subtype, closed):
# attributes need to be set first before calling
# super init (as that calls serialize)
- assert closed in _VALID_CLOSED
+ assert closed in VALID_CLOSED
self._closed = closed
if not isinstance(subtype, pyarrow.DataType):
subtype = pyarrow.type_for_alias(str(subtype))
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index d76e0fd628a48..1dbd3cfc6dca6 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -5,7 +5,12 @@
from pandas._config import get_option
-from pandas._libs.interval import Interval, IntervalMixin, intervals_to_interval_bounds
+from pandas._libs.interval import (
+ VALID_CLOSED,
+ Interval,
+ IntervalMixin,
+ intervals_to_interval_bounds,
+)
from pandas.compat.numpy import function as nv
from pandas.util._decorators import Appender
@@ -42,7 +47,6 @@
from pandas.core.indexers import check_array_indexer
from pandas.core.indexes.base import ensure_index
-_VALID_CLOSED = {"left", "right", "both", "neither"}
_interval_shared_docs = {}
_shared_docs_kwargs = dict(
@@ -475,7 +479,7 @@ def _validate(self):
* left and right have the same missing values
* left is always below right
"""
- if self.closed not in _VALID_CLOSED:
+ if self.closed not in VALID_CLOSED:
msg = f"invalid option for 'closed': {self.closed}"
raise ValueError(msg)
if len(self.left) != len(self.right):
@@ -1012,7 +1016,7 @@ def closed(self):
)
)
def set_closed(self, closed):
- if closed not in _VALID_CLOSED:
+ if closed not in VALID_CLOSED:
msg = f"invalid option for 'closed': {closed}"
raise ValueError(msg)
diff --git a/pandas/core/arrays/sparse/__init__.py b/pandas/core/arrays/sparse/__init__.py
index e928db499a771..e9ff4b7d4ffc2 100644
--- a/pandas/core/arrays/sparse/__init__.py
+++ b/pandas/core/arrays/sparse/__init__.py
@@ -5,6 +5,6 @@
BlockIndex,
IntIndex,
SparseArray,
- _make_index,
+ make_sparse_index,
)
from pandas.core.arrays.sparse.dtype import SparseDtype
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 47c960dc969d6..853f7bb0b0d81 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -1556,7 +1556,7 @@ def make_sparse(arr: np.ndarray, kind="block", fill_value=None, dtype=None, copy
else:
indices = mask.nonzero()[0].astype(np.int32)
- index = _make_index(length, indices, kind)
+ index = make_sparse_index(length, indices, kind)
sparsified_values = arr[mask]
if dtype is not None:
sparsified_values = astype_nansafe(sparsified_values, dtype=dtype)
@@ -1564,7 +1564,7 @@ def make_sparse(arr: np.ndarray, kind="block", fill_value=None, dtype=None, copy
return sparsified_values, index, fill_value
-def _make_index(length, indices, kind):
+def make_sparse_index(length, indices, kind):
if kind == "block" or isinstance(kind, BlockIndex):
locs, lens = splib.get_blocks(indices)
diff --git a/pandas/core/computation/engines.py b/pandas/core/computation/engines.py
index 0cdc0f530a7f3..77a378369ca34 100644
--- a/pandas/core/computation/engines.py
+++ b/pandas/core/computation/engines.py
@@ -130,7 +130,7 @@ def _evaluate(self) -> None:
pass
-_engines: Dict[str, Type[AbstractEngine]] = {
+ENGINES: Dict[str, Type[AbstractEngine]] = {
"numexpr": NumExprEngine,
"python": PythonEngine,
}
diff --git a/pandas/core/computation/eval.py b/pandas/core/computation/eval.py
index f6a7935142a32..630606b4d8111 100644
--- a/pandas/core/computation/eval.py
+++ b/pandas/core/computation/eval.py
@@ -9,8 +9,8 @@
from pandas._libs.lib import no_default
from pandas.util._validators import validate_bool_kwarg
-from pandas.core.computation.engines import _engines
-from pandas.core.computation.expr import Expr, _parsers
+from pandas.core.computation.engines import ENGINES
+from pandas.core.computation.expr import PARSERS, Expr
from pandas.core.computation.parsing import tokenize_string
from pandas.core.computation.scope import ensure_scope
@@ -43,8 +43,8 @@ def _check_engine(engine: Optional[str]) -> str:
if engine is None:
engine = "numexpr" if NUMEXPR_INSTALLED else "python"
- if engine not in _engines:
- valid_engines = list(_engines.keys())
+ if engine not in ENGINES:
+ valid_engines = list(ENGINES.keys())
raise KeyError(
f"Invalid engine '{engine}' passed, valid engines are {valid_engines}"
)
@@ -75,9 +75,9 @@ def _check_parser(parser: str):
KeyError
* If an invalid parser is passed
"""
- if parser not in _parsers:
+ if parser not in PARSERS:
raise KeyError(
- f"Invalid parser '{parser}' passed, valid parsers are {_parsers.keys()}"
+ f"Invalid parser '{parser}' passed, valid parsers are {PARSERS.keys()}"
)
@@ -341,7 +341,7 @@ def eval(
parsed_expr = Expr(expr, engine=engine, parser=parser, env=env)
# construct the engine and evaluate the parsed expression
- eng = _engines[engine]
+ eng = ENGINES[engine]
eng_inst = eng(parsed_expr)
ret = eng_inst.evaluate()
diff --git a/pandas/core/computation/expr.py b/pandas/core/computation/expr.py
index 8cff6abc071ca..f5897277d83bf 100644
--- a/pandas/core/computation/expr.py
+++ b/pandas/core/computation/expr.py
@@ -782,7 +782,7 @@ def __init__(
self.env = env or Scope(level=level + 1)
self.engine = engine
self.parser = parser
- self._visitor = _parsers[parser](self.env, self.engine, self.parser)
+ self._visitor = PARSERS[parser](self.env, self.engine, self.parser)
self.terms = self.parse()
@property
@@ -814,4 +814,4 @@ def names(self):
return frozenset(term.name for term in com.flatten(self.terms))
-_parsers = {"python": PythonExprVisitor, "pandas": PandasExprVisitor}
+PARSERS = {"python": PythonExprVisitor, "pandas": PandasExprVisitor}
diff --git a/pandas/core/config_init.py b/pandas/core/config_init.py
index 0c23f1b4bcdf2..bfe20551cbcfc 100644
--- a/pandas/core/config_init.py
+++ b/pandas/core/config_init.py
@@ -314,9 +314,9 @@ def use_numba_cb(key):
def table_schema_cb(key):
- from pandas.io.formats.printing import _enable_data_resource_formatter
+ from pandas.io.formats.printing import enable_data_resource_formatter
- _enable_data_resource_formatter(cf.get_option(key))
+ enable_data_resource_formatter(cf.get_option(key))
def is_terminal() -> bool:
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 72003eab24b29..e870187fc7952 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -70,9 +70,9 @@
GroupBy,
_agg_template,
_apply_docs,
- _group_selection_context,
_transform_template,
get_groupby,
+ group_selection_context,
)
from pandas.core.groupby.numba_ import generate_numba_func, split_for_numba
from pandas.core.indexes.api import Index, MultiIndex, all_indexes_same
@@ -230,7 +230,7 @@ def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs)
raise NotImplementedError(
"Numba engine can only be used with a single function."
)
- with _group_selection_context(self):
+ with group_selection_context(self):
data = self._selected_obj
result, index = self._aggregate_with_numba(
data.to_frame(), func, *args, engine_kwargs=engine_kwargs, **kwargs
@@ -685,7 +685,7 @@ def value_counts(
self, normalize=False, sort=True, ascending=False, bins=None, dropna=True
):
- from pandas.core.reshape.merge import _get_join_indexers
+ from pandas.core.reshape.merge import get_join_indexers
from pandas.core.reshape.tile import cut
if bins is not None and not np.iterable(bins):
@@ -787,7 +787,7 @@ def value_counts(
right = [diff.cumsum() - 1, codes[-1]]
- _, idx = _get_join_indexers(left, right, sort=False, how="left")
+ _, idx = get_join_indexers(left, right, sort=False, how="left")
out = np.where(idx != -1, out[idx], 0)
if sort:
@@ -942,7 +942,7 @@ def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs)
raise NotImplementedError(
"Numba engine can only be used with a single function."
)
- with _group_selection_context(self):
+ with group_selection_context(self):
data = self._selected_obj
result, index = self._aggregate_with_numba(
data, func, *args, engine_kwargs=engine_kwargs, **kwargs
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 6ef2e67030881..1e3e56f4ff09f 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -459,9 +459,9 @@ def f(self):
@contextmanager
-def _group_selection_context(groupby: "_GroupBy"):
+def group_selection_context(groupby: "_GroupBy"):
"""
- Set / reset the _group_selection_context.
+ Set / reset the group_selection_context.
"""
groupby._set_group_selection()
try:
@@ -737,7 +737,7 @@ def pipe(self, func, *args, **kwargs):
def _make_wrapper(self, name: str) -> Callable:
assert name in self._apply_allowlist
- with _group_selection_context(self):
+ with group_selection_context(self):
# need to setup the selection
# as are not passed directly but in the grouper
f = getattr(self._obj_with_exclusions, name)
@@ -868,7 +868,7 @@ def f(g):
# fails on *some* columns, e.g. a numeric operation
# on a string grouper column
- with _group_selection_context(self):
+ with group_selection_context(self):
return self._python_apply_general(f, self._selected_obj)
return result
@@ -994,7 +994,7 @@ def _agg_general(
alias: str,
npfunc: Callable,
):
- with _group_selection_context(self):
+ with group_selection_context(self):
# try a cython aggregation if we can
try:
return self._cython_agg_general(
@@ -1499,7 +1499,7 @@ def var(self, ddof: int = 1):
)
else:
func = lambda x: x.var(ddof=ddof)
- with _group_selection_context(self):
+ with group_selection_context(self):
return self._python_agg_general(func)
@Substitution(name="groupby")
@@ -1658,7 +1658,7 @@ def ohlc(self) -> DataFrame:
@doc(DataFrame.describe)
def describe(self, **kwargs):
- with _group_selection_context(self):
+ with group_selection_context(self):
result = self.apply(lambda x: x.describe(**kwargs))
if self.axis == 1:
return result.T
@@ -1963,7 +1963,7 @@ def nth(self, n: Union[int, List[int]], dropna: Optional[str] = None) -> DataFra
nth_values = list(set(n))
nth_array = np.array(nth_values, dtype=np.intp)
- with _group_selection_context(self):
+ with group_selection_context(self):
mask_left = np.in1d(self._cumcount_array(), nth_array)
mask_right = np.in1d(
@@ -2226,7 +2226,7 @@ def ngroup(self, ascending: bool = True):
5 0
dtype: int64
"""
- with _group_selection_context(self):
+ with group_selection_context(self):
index = self._selected_obj.index
result = self._obj_1d_constructor(self.grouper.group_info[0], index)
if not ascending:
@@ -2287,7 +2287,7 @@ def cumcount(self, ascending: bool = True):
5 0
dtype: int64
"""
- with _group_selection_context(self):
+ with group_selection_context(self):
index = self._selected_obj.index
cumcounts = self._cumcount_array(ascending=ascending)
return self._obj_1d_constructor(cumcounts, index)
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 526dae7e256b7..8014b16d07b01 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -3660,7 +3660,7 @@ def _join_multi(self, other, how, return_indexers=True):
return result
def _join_non_unique(self, other, how="left", return_indexers=False):
- from pandas.core.reshape.merge import _get_join_indexers
+ from pandas.core.reshape.merge import get_join_indexers
# We only get here if dtypes match
assert self.dtype == other.dtype
@@ -3668,7 +3668,7 @@ def _join_non_unique(self, other, how="left", return_indexers=False):
lvalues = self._get_engine_target()
rvalues = other._get_engine_target()
- left_idx, right_idx = _get_join_indexers(
+ left_idx, right_idx = get_join_indexers(
[lvalues], [rvalues], how=how, sort=True
)
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 3f72577c9420e..154f41bf07928 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -59,7 +59,6 @@
if TYPE_CHECKING:
from pandas import CategoricalIndex # noqa:F401
-_VALID_CLOSED = {"left", "right", "both", "neither"}
_index_doc_kwargs = dict(ibase._index_doc_kwargs)
_index_doc_kwargs.update(
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 030dec369c2be..9f19ea9aefe09 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -859,7 +859,7 @@ def _maybe_add_join_keys(self, result, left_indexer, right_indexer):
def _get_join_indexers(self):
""" return the join indexers """
- return _get_join_indexers(
+ return get_join_indexers(
self.left_join_keys, self.right_join_keys, sort=self.sort, how=self.how
)
@@ -1298,7 +1298,7 @@ def _validate(self, validate: str):
raise ValueError("Not a valid argument for validate")
-def _get_join_indexers(
+def get_join_indexers(
left_keys, right_keys, sort: bool = False, how: str = "inner", **kwargs
):
"""
diff --git a/pandas/io/formats/printing.py b/pandas/io/formats/printing.py
index edc6fbfff61d7..0d2ca83f1012e 100644
--- a/pandas/io/formats/printing.py
+++ b/pandas/io/formats/printing.py
@@ -243,7 +243,7 @@ def pprint_thing_encoded(
return value.encode(encoding, errors)
-def _enable_data_resource_formatter(enable: bool) -> None:
+def enable_data_resource_formatter(enable: bool) -> None:
if "IPython" not in sys.modules:
# definitely not in IPython
return
diff --git a/pandas/tests/arrays/sparse/test_libsparse.py b/pandas/tests/arrays/sparse/test_libsparse.py
index a2f861d378e67..2d6e657debdb2 100644
--- a/pandas/tests/arrays/sparse/test_libsparse.py
+++ b/pandas/tests/arrays/sparse/test_libsparse.py
@@ -8,7 +8,7 @@
from pandas import Series
import pandas._testing as tm
-from pandas.core.arrays.sparse import BlockIndex, IntIndex, _make_index
+from pandas.core.arrays.sparse import BlockIndex, IntIndex, make_sparse_index
TEST_LENGTH = 20
@@ -273,41 +273,43 @@ def test_intersect_identical(self):
class TestSparseIndexCommon:
def test_int_internal(self):
- idx = _make_index(4, np.array([2, 3], dtype=np.int32), kind="integer")
+ idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind="integer")
assert isinstance(idx, IntIndex)
assert idx.npoints == 2
tm.assert_numpy_array_equal(idx.indices, np.array([2, 3], dtype=np.int32))
- idx = _make_index(4, np.array([], dtype=np.int32), kind="integer")
+ idx = make_sparse_index(4, np.array([], dtype=np.int32), kind="integer")
assert isinstance(idx, IntIndex)
assert idx.npoints == 0
tm.assert_numpy_array_equal(idx.indices, np.array([], dtype=np.int32))
- idx = _make_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind="integer")
+ idx = make_sparse_index(
+ 4, np.array([0, 1, 2, 3], dtype=np.int32), kind="integer"
+ )
assert isinstance(idx, IntIndex)
assert idx.npoints == 4
tm.assert_numpy_array_equal(idx.indices, np.array([0, 1, 2, 3], dtype=np.int32))
def test_block_internal(self):
- idx = _make_index(4, np.array([2, 3], dtype=np.int32), kind="block")
+ idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind="block")
assert isinstance(idx, BlockIndex)
assert idx.npoints == 2
tm.assert_numpy_array_equal(idx.blocs, np.array([2], dtype=np.int32))
tm.assert_numpy_array_equal(idx.blengths, np.array([2], dtype=np.int32))
- idx = _make_index(4, np.array([], dtype=np.int32), kind="block")
+ idx = make_sparse_index(4, np.array([], dtype=np.int32), kind="block")
assert isinstance(idx, BlockIndex)
assert idx.npoints == 0
tm.assert_numpy_array_equal(idx.blocs, np.array([], dtype=np.int32))
tm.assert_numpy_array_equal(idx.blengths, np.array([], dtype=np.int32))
- idx = _make_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind="block")
+ idx = make_sparse_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind="block")
assert isinstance(idx, BlockIndex)
assert idx.npoints == 4
tm.assert_numpy_array_equal(idx.blocs, np.array([0], dtype=np.int32))
tm.assert_numpy_array_equal(idx.blengths, np.array([4], dtype=np.int32))
- idx = _make_index(4, np.array([0, 2, 3], dtype=np.int32), kind="block")
+ idx = make_sparse_index(4, np.array([0, 2, 3], dtype=np.int32), kind="block")
assert isinstance(idx, BlockIndex)
assert idx.npoints == 3
tm.assert_numpy_array_equal(idx.blocs, np.array([0, 2], dtype=np.int32))
@@ -315,7 +317,7 @@ def test_block_internal(self):
def test_lookup(self):
for kind in ["integer", "block"]:
- idx = _make_index(4, np.array([2, 3], dtype=np.int32), kind=kind)
+ idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind=kind)
assert idx.lookup(-1) == -1
assert idx.lookup(0) == -1
assert idx.lookup(1) == -1
@@ -323,12 +325,14 @@ def test_lookup(self):
assert idx.lookup(3) == 1
assert idx.lookup(4) == -1
- idx = _make_index(4, np.array([], dtype=np.int32), kind=kind)
+ idx = make_sparse_index(4, np.array([], dtype=np.int32), kind=kind)
for i in range(-1, 5):
assert idx.lookup(i) == -1
- idx = _make_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind=kind)
+ idx = make_sparse_index(
+ 4, np.array([0, 1, 2, 3], dtype=np.int32), kind=kind
+ )
assert idx.lookup(-1) == -1
assert idx.lookup(0) == 0
assert idx.lookup(1) == 1
@@ -336,7 +340,7 @@ def test_lookup(self):
assert idx.lookup(3) == 3
assert idx.lookup(4) == -1
- idx = _make_index(4, np.array([0, 2, 3], dtype=np.int32), kind=kind)
+ idx = make_sparse_index(4, np.array([0, 2, 3], dtype=np.int32), kind=kind)
assert idx.lookup(-1) == -1
assert idx.lookup(0) == 0
assert idx.lookup(1) == -1
@@ -346,7 +350,7 @@ def test_lookup(self):
def test_lookup_array(self):
for kind in ["integer", "block"]:
- idx = _make_index(4, np.array([2, 3], dtype=np.int32), kind=kind)
+ idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind=kind)
res = idx.lookup_array(np.array([-1, 0, 2], dtype=np.int32))
exp = np.array([-1, -1, 0], dtype=np.int32)
@@ -356,11 +360,13 @@ def test_lookup_array(self):
exp = np.array([-1, 0, -1, 1], dtype=np.int32)
tm.assert_numpy_array_equal(res, exp)
- idx = _make_index(4, np.array([], dtype=np.int32), kind=kind)
+ idx = make_sparse_index(4, np.array([], dtype=np.int32), kind=kind)
res = idx.lookup_array(np.array([-1, 0, 2, 4], dtype=np.int32))
exp = np.array([-1, -1, -1, -1], dtype=np.int32)
- idx = _make_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind=kind)
+ idx = make_sparse_index(
+ 4, np.array([0, 1, 2, 3], dtype=np.int32), kind=kind
+ )
res = idx.lookup_array(np.array([-1, 0, 2], dtype=np.int32))
exp = np.array([-1, 0, 2], dtype=np.int32)
tm.assert_numpy_array_equal(res, exp)
@@ -369,7 +375,7 @@ def test_lookup_array(self):
exp = np.array([-1, 2, 1, 3], dtype=np.int32)
tm.assert_numpy_array_equal(res, exp)
- idx = _make_index(4, np.array([0, 2, 3], dtype=np.int32), kind=kind)
+ idx = make_sparse_index(4, np.array([0, 2, 3], dtype=np.int32), kind=kind)
res = idx.lookup_array(np.array([2, 1, 3, 0], dtype=np.int32))
exp = np.array([1, -1, 2, 0], dtype=np.int32)
tm.assert_numpy_array_equal(res, exp)
@@ -402,25 +408,25 @@ def _check(index):
class TestBlockIndex:
def test_block_internal(self):
- idx = _make_index(4, np.array([2, 3], dtype=np.int32), kind="block")
+ idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind="block")
assert isinstance(idx, BlockIndex)
assert idx.npoints == 2
tm.assert_numpy_array_equal(idx.blocs, np.array([2], dtype=np.int32))
tm.assert_numpy_array_equal(idx.blengths, np.array([2], dtype=np.int32))
- idx = _make_index(4, np.array([], dtype=np.int32), kind="block")
+ idx = make_sparse_index(4, np.array([], dtype=np.int32), kind="block")
assert isinstance(idx, BlockIndex)
assert idx.npoints == 0
tm.assert_numpy_array_equal(idx.blocs, np.array([], dtype=np.int32))
tm.assert_numpy_array_equal(idx.blengths, np.array([], dtype=np.int32))
- idx = _make_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind="block")
+ idx = make_sparse_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind="block")
assert isinstance(idx, BlockIndex)
assert idx.npoints == 4
tm.assert_numpy_array_equal(idx.blocs, np.array([0], dtype=np.int32))
tm.assert_numpy_array_equal(idx.blengths, np.array([4], dtype=np.int32))
- idx = _make_index(4, np.array([0, 2, 3], dtype=np.int32), kind="block")
+ idx = make_sparse_index(4, np.array([0, 2, 3], dtype=np.int32), kind="block")
assert isinstance(idx, BlockIndex)
assert idx.npoints == 3
tm.assert_numpy_array_equal(idx.blocs, np.array([0, 2], dtype=np.int32))
@@ -428,7 +434,7 @@ def test_block_internal(self):
def test_make_block_boundary(self):
for i in [5, 10, 100, 101]:
- idx = _make_index(i, np.arange(0, i, 2, dtype=np.int32), kind="block")
+ idx = make_sparse_index(i, np.arange(0, i, 2, dtype=np.int32), kind="block")
exp = np.arange(0, i, 2, dtype=np.int32)
tm.assert_numpy_array_equal(idx.blocs, exp)
@@ -514,17 +520,19 @@ def test_check_integrity(self):
IntIndex(length=5, indices=[1, 3, 3])
def test_int_internal(self):
- idx = _make_index(4, np.array([2, 3], dtype=np.int32), kind="integer")
+ idx = make_sparse_index(4, np.array([2, 3], dtype=np.int32), kind="integer")
assert isinstance(idx, IntIndex)
assert idx.npoints == 2
tm.assert_numpy_array_equal(idx.indices, np.array([2, 3], dtype=np.int32))
- idx = _make_index(4, np.array([], dtype=np.int32), kind="integer")
+ idx = make_sparse_index(4, np.array([], dtype=np.int32), kind="integer")
assert isinstance(idx, IntIndex)
assert idx.npoints == 0
tm.assert_numpy_array_equal(idx.indices, np.array([], dtype=np.int32))
- idx = _make_index(4, np.array([0, 1, 2, 3], dtype=np.int32), kind="integer")
+ idx = make_sparse_index(
+ 4, np.array([0, 1, 2, 3], dtype=np.int32), kind="integer"
+ )
assert isinstance(idx, IntIndex)
assert idx.npoints == 4
tm.assert_numpy_array_equal(idx.indices, np.array([0, 1, 2, 3], dtype=np.int32))
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index d2d3766959fbf..9d316c38082af 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -244,7 +244,7 @@ def test_searchsorted(self):
# GH#29884 match numpy convention on whether NaT goes
# at the end or the beginning
result = arr.searchsorted(pd.NaT)
- if _np_version_under1p18 or self.array_cls is PeriodArray:
+ if np_version_under1p18 or self.array_cls is PeriodArray:
# Following numpy convention, NaT goes at the beginning
# (unlike NaN which goes at the end)
assert result == 0
diff --git a/pandas/tests/computation/test_compat.py b/pandas/tests/computation/test_compat.py
index ead102f532a20..9fc3ed4800d09 100644
--- a/pandas/tests/computation/test_compat.py
+++ b/pandas/tests/computation/test_compat.py
@@ -5,7 +5,7 @@
from pandas.compat._optional import VERSIONS
import pandas as pd
-from pandas.core.computation.engines import _engines
+from pandas.core.computation.engines import ENGINES
import pandas.core.computation.expr as expr
@@ -26,8 +26,8 @@ def test_compat():
pytest.skip("not testing numexpr version compat")
-@pytest.mark.parametrize("engine", _engines)
-@pytest.mark.parametrize("parser", expr._parsers)
+@pytest.mark.parametrize("engine", ENGINES)
+@pytest.mark.parametrize("parser", expr.PARSERS)
def test_invalid_numexpr_version(engine, parser):
def testit():
a, b = 1, 2 # noqa
diff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py
index 72dc04e68c154..cca64a6bf487c 100644
--- a/pandas/tests/computation/test_eval.py
+++ b/pandas/tests/computation/test_eval.py
@@ -19,7 +19,7 @@
import pandas._testing as tm
from pandas.core.computation import pytables
from pandas.core.computation.check import NUMEXPR_VERSION
-from pandas.core.computation.engines import NumExprClobberingError, _engines
+from pandas.core.computation.engines import ENGINES, NumExprClobberingError
import pandas.core.computation.expr as expr
from pandas.core.computation.expr import (
BaseExprVisitor,
@@ -46,14 +46,14 @@
f"installed->{NUMEXPR_INSTALLED}",
),
)
- for engine in _engines
+ for engine in ENGINES
)
) # noqa
def engine(request):
return request.param
-@pytest.fixture(params=expr._parsers)
+@pytest.fixture(params=expr.PARSERS)
def parser(request):
return request.param
@@ -77,7 +77,7 @@ def unary_fns_for_ne():
def engine_has_neg_frac(engine):
- return _engines[engine].has_neg_frac
+ return ENGINES[engine].has_neg_frac
def _eval_single_bin(lhs, cmp1, rhs, engine):
@@ -168,7 +168,7 @@ def setup_ops(self):
def setup_method(self, method):
self.setup_ops()
self.setup_data()
- self.current_engines = (engine for engine in _engines if engine != self.engine)
+ self.current_engines = (engine for engine in ENGINES if engine != self.engine)
def teardown_method(self, method):
del self.lhses, self.rhses, self.scalar_rhses, self.scalar_lhses
@@ -1921,7 +1921,7 @@ def test_invalid_parser():
}
-@pytest.mark.parametrize("engine", _engines)
+@pytest.mark.parametrize("engine", ENGINES)
@pytest.mark.parametrize("parser", _parsers)
def test_disallowed_nodes(engine, parser):
VisitorClass = _parsers[parser]
| Getting close to the end on these. | https://api.github.com/repos/pandas-dev/pandas/pulls/36235 | 2020-09-08T23:38:09Z | 2020-09-09T01:33:42Z | 2020-09-09T01:33:42Z | 2020-09-09T01:58:31Z |
REF: pass setitem to unbox_scalar to de-duplicate validation | diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index ba5bfc108f16b..bb40cf78ea006 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -183,7 +183,7 @@ def _rebox_native(cls, value: int) -> Union[int, np.datetime64, np.timedelta64]:
"""
raise AbstractMethodError(cls)
- def _unbox_scalar(self, value: DTScalarOrNaT) -> int:
+ def _unbox_scalar(self, value: DTScalarOrNaT, setitem: bool = False) -> int:
"""
Unbox the integer value of a scalar `value`.
@@ -191,6 +191,8 @@ def _unbox_scalar(self, value: DTScalarOrNaT) -> int:
----------
value : Period, Timestamp, Timedelta, or NaT
Depending on subclass.
+ setitem : bool, default False
+ Whether to check compatiblity with setitem strictness.
Returns
-------
@@ -841,6 +843,7 @@ def _validate_listlike(
if is_dtype_equal(value.categories.dtype, self.dtype):
# TODO: do we need equal dtype or just comparable?
value = value._internal_get_values()
+ value = extract_array(value, extract_numpy=True)
if allow_object and is_object_dtype(value.dtype):
pass
@@ -875,8 +878,7 @@ def _validate_setitem_value(self, value):
# TODO: cast_str for consistency?
value = self._validate_scalar(value, msg, cast_str=False)
- self._check_compatible_with(value, setitem=True)
- return self._unbox(value)
+ return self._unbox(value, setitem=True)
def _validate_insert_value(self, value):
msg = f"cannot insert {type(self).__name__} with incompatible label"
@@ -886,6 +888,8 @@ def _validate_insert_value(self, value):
# TODO: if we dont have compat, should we raise or astype(object)?
# PeriodIndex does astype(object)
return value
+ # Note: we do not unbox here because the caller needs boxed value
+ # to check for freq.
def _validate_where_value(self, other):
msg = f"Where requires matching dtype, not {type(other)}"
@@ -893,20 +897,18 @@ def _validate_where_value(self, other):
other = self._validate_scalar(other, msg)
else:
other = self._validate_listlike(other, "where")
- self._check_compatible_with(other, setitem=True)
- self._check_compatible_with(other, setitem=True)
- return self._unbox(other)
+ return self._unbox(other, setitem=True)
- def _unbox(self, other) -> Union[np.int64, np.ndarray]:
+ def _unbox(self, other, setitem: bool = False) -> Union[np.int64, np.ndarray]:
"""
Unbox either a scalar with _unbox_scalar or an instance of our own type.
"""
if lib.is_scalar(other):
- other = self._unbox_scalar(other)
+ other = self._unbox_scalar(other, setitem=setitem)
else:
# same type as self
- self._check_compatible_with(other)
+ self._check_compatible_with(other, setitem=setitem)
other = other.view("i8")
return other
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 9f10cc84dcfcc..56e0a9861548f 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -451,11 +451,11 @@ def _generate_range(
def _rebox_native(cls, value: int) -> np.datetime64:
return np.int64(value).view("M8[ns]")
- def _unbox_scalar(self, value):
+ def _unbox_scalar(self, value, setitem: bool = False):
if not isinstance(value, self._scalar_type) and value is not NaT:
raise ValueError("'value' should be a Timestamp.")
if not isna(value):
- self._check_compatible_with(value)
+ self._check_compatible_with(value, setitem=setitem)
return value.value
def _scalar_from_string(self, value):
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index eea11bde77030..865b1680c008a 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -257,11 +257,13 @@ def _generate_range(cls, start, end, periods, freq, fields):
def _rebox_native(cls, value: int) -> np.int64:
return np.int64(value)
- def _unbox_scalar(self, value: Union[Period, NaTType]) -> int:
+ def _unbox_scalar(
+ self, value: Union[Period, NaTType], setitem: bool = False
+ ) -> int:
if value is NaT:
return value.value
elif isinstance(value, self._scalar_type):
- self._check_compatible_with(value)
+ self._check_compatible_with(value, setitem=setitem)
return value.ordinal
else:
raise ValueError(f"'value' should be a Period. Got '{value}' instead.")
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 5e3c0f2b8d876..3eaf428bc64b2 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -283,10 +283,10 @@ def _generate_range(cls, start, end, periods, freq, closed=None):
def _rebox_native(cls, value: int) -> np.timedelta64:
return np.int64(value).view("m8[ns]")
- def _unbox_scalar(self, value):
+ def _unbox_scalar(self, value, setitem: bool = False):
if not isinstance(value, self._scalar_type) and value is not NaT:
raise ValueError("'value' should be a Timedelta.")
- self._check_compatible_with(value)
+ self._check_compatible_with(value, setitem=setitem)
return value.value
def _scalar_from_string(self, value):
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index d2d3766959fbf..9d316c38082af 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -244,7 +244,7 @@ def test_searchsorted(self):
# GH#29884 match numpy convention on whether NaT goes
# at the end or the beginning
result = arr.searchsorted(pd.NaT)
- if _np_version_under1p18 or self.array_cls is PeriodArray:
+ if np_version_under1p18 or self.array_cls is PeriodArray:
# Following numpy convention, NaT goes at the beginning
# (unlike NaN which goes at the end)
assert result == 0
| Also fixes a test that is failing on master because _np_version_under_118 is no longer defined. | https://api.github.com/repos/pandas-dev/pandas/pulls/36234 | 2020-09-08T23:34:30Z | 2020-09-09T00:55:22Z | 2020-09-09T00:55:22Z | 2020-09-09T00:58:12Z |
BUG: Fix unintentionally added suffix in DataFrame.apply/agg and Series.apply/agg | diff --git a/doc/source/whatsnew/v1.1.3.rst b/doc/source/whatsnew/v1.1.3.rst
index 2457d00eb2173..d789518f93f6d 100644
--- a/doc/source/whatsnew/v1.1.3.rst
+++ b/doc/source/whatsnew/v1.1.3.rst
@@ -14,6 +14,7 @@ including other versions of pandas.
Fixed regressions
~~~~~~~~~~~~~~~~~
+- Fixed regression in :meth:`DataFrame.agg`, :meth:`DataFrame.apply`, :meth:`Series.agg`, and :meth:`Series.apply` where internal suffix is exposed to the users when no relabelling is applied (:issue:`36189`)
- Fixed regression in :class:`IntegerArray` unary plus and minus operations raising a ``TypeError`` (:issue:`36063`)
- Fixed regression in :meth:`Series.__getitem__` incorrectly raising when the input was a tuple (:issue:`35534`)
- Fixed regression in :meth:`Series.__getitem__` incorrectly raising when the input was a frozenset (:issue:`35747`)
diff --git a/pandas/core/aggregation.py b/pandas/core/aggregation.py
index 8b74fe01d0dc0..c123156495924 100644
--- a/pandas/core/aggregation.py
+++ b/pandas/core/aggregation.py
@@ -63,7 +63,7 @@ def reconstruct_func(
Examples
--------
>>> reconstruct_func(None, **{"foo": ("col", "min")})
- (True, defaultdict(None, {'col': ['min']}), ('foo',), array([0]))
+ (True, defaultdict(<class 'list'>, {'col': ['min']}), ('foo',), array([0]))
>>> reconstruct_func("min")
(False, 'min', None, None)
@@ -87,7 +87,6 @@ def reconstruct_func(
if relabeling:
func, columns, order = normalize_keyword_aggregation(kwargs)
- func = maybe_mangle_lambdas(func)
return relabeling, func, columns, order
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 1552256468ad2..f327f45647df6 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -950,6 +950,7 @@ def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs)
return self.obj._constructor(result, index=index, columns=data.columns)
relabeling, func, columns, order = reconstruct_func(func, **kwargs)
+ func = maybe_mangle_lambdas(func)
result, how = self._aggregate(func, *args, **kwargs)
if how is None:
diff --git a/pandas/tests/frame/apply/test_frame_apply.py b/pandas/tests/frame/apply/test_frame_apply.py
index 1662f9e2fff56..cdf8a841fd098 100644
--- a/pandas/tests/frame/apply/test_frame_apply.py
+++ b/pandas/tests/frame/apply/test_frame_apply.py
@@ -1519,3 +1519,14 @@ def test_apply_empty_list_reduce():
result = df.apply(lambda x: [], result_type="reduce")
expected = pd.Series({"a": [], "b": []}, dtype=object)
tm.assert_series_equal(result, expected)
+
+
+def test_apply_no_suffix_index():
+ # GH36189
+ pdf = pd.DataFrame([[4, 9]] * 3, columns=["A", "B"])
+ result = pdf.apply(["sum", lambda x: x.sum(), lambda x: x.sum()])
+ expected = pd.DataFrame(
+ {"A": [12, 12, 12], "B": [27, 27, 27]}, index=["sum", "<lambda>", "<lambda>"]
+ )
+
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py
index 8fe450fe6abfc..c96333bc48dd4 100644
--- a/pandas/tests/groupby/aggregate/test_aggregate.py
+++ b/pandas/tests/groupby/aggregate/test_aggregate.py
@@ -1153,3 +1153,18 @@ def test_nonagg_agg():
expected = g.agg("cumsum")
tm.assert_frame_equal(result, expected)
+
+
+def test_agg_no_suffix_index():
+ # GH36189
+ df = pd.DataFrame([[4, 9]] * 3, columns=["A", "B"])
+ result = df.agg(["sum", lambda x: x.sum(), lambda x: x.sum()])
+ expected = pd.DataFrame(
+ {"A": [12, 12, 12], "B": [27, 27, 27]}, index=["sum", "<lambda>", "<lambda>"]
+ )
+ tm.assert_frame_equal(result, expected)
+
+ # test Series case
+ result = df["A"].agg(["sum", lambda x: x.sum(), lambda x: x.sum()])
+ expected = pd.Series([12, 12, 12], index=["sum", "<lambda>", "<lambda>"], name="A")
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/apply/test_series_apply.py b/pandas/tests/series/apply/test_series_apply.py
index 827f466e23106..ce8759c4ba76d 100644
--- a/pandas/tests/series/apply/test_series_apply.py
+++ b/pandas/tests/series/apply/test_series_apply.py
@@ -445,6 +445,14 @@ def test_agg_cython_table_raises(self, series, func, expected):
# e.g. Series('a b'.split()).cumprod() will raise
series.agg(func)
+ def test_series_apply_no_suffix_index(self):
+ # GH36189
+ s = pd.Series([4] * 3)
+ result = s.apply(["sum", lambda x: x.sum(), lambda x: x.sum()])
+ expected = pd.Series([12, 12, 12], index=["sum", "<lambda>", "<lambda>"])
+
+ tm.assert_series_equal(result, expected)
+
class TestSeriesMap:
def test_map(self, datetime_series):
| - [x] closes #36189
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36231 | 2020-09-08T21:26:39Z | 2020-09-13T15:53:38Z | 2020-09-13T15:53:38Z | 2020-09-14T09:54:41Z |
CLN: re-use invalid_comparison in Categorical comparisons | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index b732db4c66003..e0cec7a3270e7 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -119,15 +119,7 @@ def func(self, other):
ret[mask] = False
return ret
else:
- if opname == "__eq__":
- return np.zeros(len(self), dtype=bool)
- elif opname == "__ne__":
- return np.ones(len(self), dtype=bool)
- else:
- raise TypeError(
- f"Cannot compare a Categorical for op {opname} with a "
- "scalar, which is not a category."
- )
+ return ops.invalid_comparison(self, other, op)
else:
# allow categorical vs object dtype array comparisons for equality
# these are only positional comparisons
diff --git a/pandas/tests/arrays/categorical/test_operators.py b/pandas/tests/arrays/categorical/test_operators.py
index 6ea003c122eea..bc5fb51883b3d 100644
--- a/pandas/tests/arrays/categorical/test_operators.py
+++ b/pandas/tests/arrays/categorical/test_operators.py
@@ -171,17 +171,14 @@ def test_comparison_with_unknown_scalars(self):
# for unequal comps, but not for equal/not equal
cat = Categorical([1, 2, 3], ordered=True)
- msg = (
- "Cannot compare a Categorical for op __{}__ with a scalar, "
- "which is not a category"
- )
- with pytest.raises(TypeError, match=msg.format("lt")):
+ msg = "Invalid comparison between dtype=category and int"
+ with pytest.raises(TypeError, match=msg):
cat < 4
- with pytest.raises(TypeError, match=msg.format("gt")):
+ with pytest.raises(TypeError, match=msg):
cat > 4
- with pytest.raises(TypeError, match=msg.format("gt")):
+ with pytest.raises(TypeError, match=msg):
4 < cat
- with pytest.raises(TypeError, match=msg.format("lt")):
+ with pytest.raises(TypeError, match=msg):
4 > cat
tm.assert_numpy_array_equal(cat == 4, np.array([False, False, False]))
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index ef2bafd4ea2ad..c937e357b9dbc 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -501,7 +501,7 @@ def test_unequal_categorical_comparison_raises_type_error(self):
# for unequal comps, but not for equal/not equal
cat = Series(Categorical(list("abc"), ordered=True))
- msg = "Cannot compare a Categorical for op.+with a scalar"
+ msg = "Invalid comparison between dtype=category and str"
with pytest.raises(TypeError, match=msg):
cat < "d"
with pytest.raises(TypeError, match=msg):
| https://api.github.com/repos/pandas-dev/pandas/pulls/36229 | 2020-09-08T21:12:00Z | 2020-09-08T22:53:04Z | 2020-09-08T22:53:04Z | 2020-09-08T23:10:03Z | |
Change default of float_precision for read_csv and read_table to "high" | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index bce6a735b7b07..ee53b83c1764c 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -96,6 +96,19 @@ For example:
buffer = io.BytesIO()
data.to_csv(buffer, mode="w+b", encoding="utf-8", compression="gzip")
+:.. _whatsnew_read_csv_table_precision_default:
+
+Change in default floating precision for ``read_csv`` and ``read_table``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+For the C parsing engine, the methods :meth:`read_csv` and :meth:`read_table` previously defaulted to a parser that
+could read floating point numbers slightly incorrectly with respect to the last bit in precision.
+The option ``floating_precision="high"`` has always been available to avoid this issue.
+Beginning with this version, the default is now to use the more accurate parser by making
+``floating_precision=None`` correspond to the high precision parser, and the new option
+``floating_precision="legacy"`` to use the legacy parser. The change to using the higher precision
+parser by default should have no impact on performance. (:issue:`17154`)
+
.. _whatsnew_120.enhancements.other:
Other enhancements
diff --git a/pandas/_libs/parsers.pyx b/pandas/_libs/parsers.pyx
index 811e28b830921..b87e46f9b6648 100644
--- a/pandas/_libs/parsers.pyx
+++ b/pandas/_libs/parsers.pyx
@@ -476,10 +476,13 @@ cdef class TextReader:
if float_precision == "round_trip":
# see gh-15140
self.parser.double_converter = round_trip
- elif float_precision == "high":
+ elif float_precision == "legacy":
+ self.parser.double_converter = xstrtod
+ elif float_precision == "high" or float_precision is None:
self.parser.double_converter = precise_xstrtod
else:
- self.parser.double_converter = xstrtod
+ raise ValueError(f'Unrecognized float_precision option: '
+ f'{float_precision}')
if isinstance(dtype, dict):
dtype = {k: pandas_dtype(dtype[k])
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index 4c619a636f057..fe94a722f2ec8 100644
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -338,9 +338,9 @@
option can improve performance because there is no longer any I/O overhead.
float_precision : str, optional
Specifies which converter the C engine should use for floating-point
- values. The options are `None` for the ordinary converter,
- `high` for the high-precision converter, and `round_trip` for the
- round-trip converter.
+ values. The options are `None` or `high` for the ordinary converter,
+ `legacy` for the original lower precision pandas converter, and
+ `round_trip` for the round-trip converter.
Returns
-------
@@ -2299,6 +2299,7 @@ def TextParser(*args, **kwds):
values. The options are None for the ordinary converter,
'high' for the high-precision converter, and 'round_trip' for the
round-trip converter.
+ .. versionchanged:: 1.2
"""
kwds["engine"] = "python"
return TextFileReader(*args, **kwds)
diff --git a/pandas/tests/io/parser/test_c_parser_only.py b/pandas/tests/io/parser/test_c_parser_only.py
index 50d5fb3e49c2a..7c58afe867440 100644
--- a/pandas/tests/io/parser/test_c_parser_only.py
+++ b/pandas/tests/io/parser/test_c_parser_only.py
@@ -160,7 +160,9 @@ def test_precise_conversion(c_parser_only):
# 25 decimal digits of precision
text = f"a\n{num:.25}"
- normal_val = float(parser.read_csv(StringIO(text))["a"][0])
+ normal_val = float(
+ parser.read_csv(StringIO(text), float_precision="legacy")["a"][0]
+ )
precise_val = float(
parser.read_csv(StringIO(text), float_precision="high")["a"][0]
)
@@ -608,7 +610,7 @@ def test_unix_style_breaks(c_parser_only):
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("float_precision", [None, "high", "round_trip"])
+@pytest.mark.parametrize("float_precision", [None, "legacy", "high", "round_trip"])
@pytest.mark.parametrize(
"data,thousands,decimal",
[
@@ -646,7 +648,7 @@ def test_1000_sep_with_decimal(
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("float_precision", [None, "high", "round_trip"])
+@pytest.mark.parametrize("float_precision", [None, "legacy", "high", "round_trip"])
@pytest.mark.parametrize(
"value,expected",
[
@@ -702,3 +704,22 @@ def test_1000_sep_decimal_float_precision(
)
val = df.iloc[0, 0]
assert val == expected
+
+
+def test_float_precision_options(c_parser_only):
+ # GH 17154, 36228
+ parser = c_parser_only
+ s = "foo\n243.164\n"
+ df = parser.read_csv(StringIO(s))
+ df2 = parser.read_csv(StringIO(s), float_precision="high")
+
+ tm.assert_frame_equal(df, df2)
+
+ df3 = parser.read_csv(StringIO(s), float_precision="legacy")
+
+ assert not df.iloc[0, 0] == df3.iloc[0, 0]
+
+ msg = "Unrecognized float_precision option: junk"
+
+ with pytest.raises(ValueError, match=msg):
+ parser.read_csv(StringIO(s), float_precision="junk")
| - [x] closes #17154
- [x] tests added / passed
- modified `tests/io/parser/test_c_parser.py` to make sure all 4 options are tested
- added `tests/io/parser/test_c_parser.py:test_high_is_default`
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
- for version 1.2
See discussion at bottom of #36149 for the performance tests. Added `float_precision="legacy"` so people can pick up the old parser. Can't change default to "high" because of incompatibility with python parser
| https://api.github.com/repos/pandas-dev/pandas/pulls/36228 | 2020-09-08T19:35:57Z | 2020-09-13T22:54:42Z | 2020-09-13T22:54:41Z | 2020-09-18T11:35:31Z |
BUG: GH36212 DataFrame agg() raises error when DataFrame column name is `name` | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index bce6a735b7b07..fdc7a5b796685 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -323,6 +323,7 @@ Reshaping
- Bug in :meth:`DataFrame.pivot_table` with ``aggfunc='count'`` or ``aggfunc='sum'`` returning ``NaN`` for missing categories when pivoted on a ``Categorical``. Now returning ``0`` (:issue:`31422`)
- Bug in :func:`union_indexes` where input index names are not preserved in some cases. Affects :func:`concat` and :class:`DataFrame` constructor (:issue:`13475`)
- Bug in func :meth:`crosstab` when using multiple columns with ``margins=True`` and ``normalize=True`` (:issue:`35144`)
+- Bug in :meth:`DataFrame.agg` with ``func={'name':<FUNC>}`` incorrectly raising ``TypeError`` when ``DataFrame.columns==['Name']`` (:issue:`36212`)
-
Sparse
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 1926803d8f04b..7bcce695d999e 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -470,9 +470,12 @@ def is_any_frame() -> bool:
try:
result = DataFrame(result)
except ValueError:
-
# we have a dict of scalars
- result = Series(result, name=getattr(self, "name", None))
+
+ # GH 36212 use name only if self is a series
+ name = self.name if (self.ndim == 1) else None
+
+ result = Series(result, name=name)
return result, True
elif is_list_like(arg):
diff --git a/pandas/tests/frame/apply/test_frame_apply.py b/pandas/tests/frame/apply/test_frame_apply.py
index 1662f9e2fff56..f75d7c13665f9 100644
--- a/pandas/tests/frame/apply/test_frame_apply.py
+++ b/pandas/tests/frame/apply/test_frame_apply.py
@@ -1147,6 +1147,21 @@ def test_demo(self):
)
tm.assert_frame_equal(result.reindex_like(expected), expected)
+ def test_agg_with_name_as_column_name(self):
+ # GH 36212 - Column name is "name"
+ data = {"name": ["foo", "bar"]}
+ df = pd.DataFrame(data)
+
+ # result's name should be None
+ result = df.agg({"name": "count"})
+ expected = pd.Series({"name": 2})
+ tm.assert_series_equal(result, expected)
+
+ # Check if name is still preserved when aggregating series instead
+ result = df["name"].agg({"name": "count"})
+ expected = pd.Series({"name": 2}, name="name")
+ tm.assert_series_equal(result, expected)
+
def test_agg_multiple_mixed_no_warning(self):
# GH 20909
mdf = pd.DataFrame(
| - [x] closes #36212
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry | https://api.github.com/repos/pandas-dev/pandas/pulls/36224 | 2020-09-08T17:07:18Z | 2020-09-13T13:15:08Z | 2020-09-13T13:15:07Z | 2020-09-13T13:15:12Z |
CLN: w3 formatting | diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 023557dd6494d..b27a4e036e137 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -327,7 +327,7 @@ def format_attr(pair):
colspan = col_lengths.get((r, c), 0)
if colspan > 1:
es["attributes"] = [
- format_attr({"key": "colspan", "value": colspan})
+ format_attr({"key": "colspan", "value": f'"{colspan}"'})
]
row_es.append(es)
head.append(row_es)
diff --git a/pandas/tests/io/formats/test_style.py b/pandas/tests/io/formats/test_style.py
index 6025649e9dbec..de549ec3eb75e 100644
--- a/pandas/tests/io/formats/test_style.py
+++ b/pandas/tests/io/formats/test_style.py
@@ -1691,6 +1691,12 @@ def test_no_cell_ids(self):
s = styler.render() # render twice to ensure ctx is not updated
assert s.find('<td class="data row0 col0" >') != -1
+ def test_colspan_w3(self):
+ # GH 36223
+ df = pd.DataFrame(data=[[1, 2]], columns=[["l0", "l0"], ["l1a", "l1b"]])
+ s = Styler(df, uuid="_", cell_ids=False)
+ assert '<th class="col_heading level0 col0" colspan="2">l0</th>' in s.render()
+
@td.skip_if_no_mpl
class TestStylerMatplotlibDep:
| - [x] closes #35706
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
Cleans a very minor formatting error to be consistent with w3schools specification.
`colspan=2 ---> colspan="2"`
Note this generally has no effect in browsers parsing HTML. | https://api.github.com/repos/pandas-dev/pandas/pulls/36223 | 2020-09-08T16:14:42Z | 2020-09-08T23:56:47Z | 2020-09-08T23:56:47Z | 2020-09-09T05:11:04Z |
CLN remove trailing commas | diff --git a/pandas/tests/io/pytables/test_timezones.py b/pandas/tests/io/pytables/test_timezones.py
index 38d32b0bdc8a3..1c29928991cde 100644
--- a/pandas/tests/io/pytables/test_timezones.py
+++ b/pandas/tests/io/pytables/test_timezones.py
@@ -110,7 +110,7 @@ def test_append_with_timezones_dateutil(setup_path):
dti = dti._with_freq(None) # freq doesnt round-trip
# GH 4098 example
- df = DataFrame(dict(A=Series(range(3), index=dti,)))
+ df = DataFrame(dict(A=Series(range(3), index=dti)))
_maybe_remove(store, "df")
store.put("df", df)
@@ -197,7 +197,7 @@ def test_append_with_timezones_pytz(setup_path):
dti = dti._with_freq(None) # freq doesnt round-trip
# GH 4098 example
- df = DataFrame(dict(A=Series(range(3), index=dti,)))
+ df = DataFrame(dict(A=Series(range(3), index=dti)))
_maybe_remove(store, "df")
store.put("df", df)
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
index a8a5c8f00e6bf..c1e63f512b53e 100644
--- a/pandas/tests/io/test_feather.py
+++ b/pandas/tests/io/test_feather.py
@@ -76,7 +76,7 @@ def test_basic(self):
pd.Timestamp("20130103"),
],
"dtns": pd.DatetimeIndex(
- list(pd.date_range("20130101", periods=3, freq="ns")), freq=None,
+ list(pd.date_range("20130101", periods=3, freq="ns")), freq=None
),
}
)
diff --git a/pandas/tests/io/test_s3.py b/pandas/tests/io/test_s3.py
index a137e76b1696b..0ee6cb0796644 100644
--- a/pandas/tests/io/test_s3.py
+++ b/pandas/tests/io/test_s3.py
@@ -43,6 +43,6 @@ def test_read_with_creds_from_pub_bucket():
os.environ.setdefault("AWS_ACCESS_KEY_ID", "foobar_key")
os.environ.setdefault("AWS_SECRET_ACCESS_KEY", "foobar_secret")
df = read_csv(
- "s3://gdelt-open-data/events/1981.csv", nrows=5, sep="\t", header=None,
+ "s3://gdelt-open-data/events/1981.csv", nrows=5, sep="\t", header=None
)
assert len(df) == 5
| #35925
From this set of 10 files, only the first 3 needed changes to comply if the new version of black:
- [x] pandas/tests/io/pytables/test_timezones.py
- [x] pandas/tests/io/test_feather.py
- [x] pandas/tests/io/test_s3.py
- [ ] pandas/tests/io/test_sql.py
- [ ] pandas/tests/io/test_stata.py
- [ ] pandas/tests/plotting/test_frame.py
- [ ] pandas/tests/resample/test_datetime_index.py
- [ ] pandas/tests/reshape/merge/test_merge_index_as_string.py
- [ ] pandas/tests/reshape/test_crosstab.py
- [ ] pandas/tests/reshape/test_get_dummies.py | https://api.github.com/repos/pandas-dev/pandas/pulls/36222 | 2020-09-08T14:10:59Z | 2020-09-08T15:28:22Z | 2020-09-08T15:28:22Z | 2020-09-08T15:28:25Z |
Backport PR #36141 on branch 1.1.x (BUG: copying series into empty dataframe does not preserve dataframe index name) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index a214ad9762733..c6a08f4fb852a 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -43,6 +43,7 @@ Bug fixes
- Bug in :class:`DataFrame` indexing returning an incorrect :class:`Series` in some cases when the series has been altered and a cache not invalidated (:issue:`33675`)
- Bug in :meth:`DataFrame.corr` causing subsequent indexing lookups to be incorrect (:issue:`35882`)
- Bug in :meth:`import_optional_dependency` returning incorrect package names in cases where package name is different from import name (:issue:`35948`)
+- Bug when setting empty :class:`DataFrame` column to a :class:`Series` in preserving name of index in frame (:issue:`31368`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 041121d60ad33..9af9c19392ef7 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3170,9 +3170,11 @@ def _ensure_valid_index(self, value):
"and a value that cannot be converted to a Series"
) from err
- self._mgr = self._mgr.reindex_axis(
- value.index.copy(), axis=1, fill_value=np.nan
- )
+ # GH31368 preserve name of index
+ index_copy = value.index.copy()
+ index_copy.name = self.index.name
+
+ self._mgr = self._mgr.reindex_axis(index_copy, axis=1, fill_value=np.nan)
def _box_col_values(self, values, loc: int) -> Series:
"""
diff --git a/pandas/tests/indexing/test_partial.py b/pandas/tests/indexing/test_partial.py
index 350f86b4e9fd0..7afbbc2b9ab2b 100644
--- a/pandas/tests/indexing/test_partial.py
+++ b/pandas/tests/indexing/test_partial.py
@@ -660,3 +660,15 @@ def test_indexing_timeseries_regression(self):
expected = Series(rng, index=rng)
tm.assert_series_equal(result, expected)
+
+ def test_index_name_empty(self):
+ # GH 31368
+ df = pd.DataFrame({}, index=pd.RangeIndex(0, name="df_index"))
+ series = pd.Series(1.23, index=pd.RangeIndex(4, name="series_index"))
+
+ df["series"] = series
+ expected = pd.DataFrame(
+ {"series": [1.23] * 4}, index=pd.RangeIndex(4, name="df_index")
+ )
+
+ tm.assert_frame_equal(df, expected)
| Backport PR #36141: BUG: copying series into empty dataframe does not preserve dataframe index name | https://api.github.com/repos/pandas-dev/pandas/pulls/36221 | 2020-09-08T14:06:41Z | 2020-09-08T14:55:07Z | 2020-09-08T14:55:07Z | 2020-09-08T14:55:08Z |
TST: skip test_groupby_rolling_index_changed on 32bit | diff --git a/pandas/tests/window/test_grouper.py b/pandas/tests/window/test_grouper.py
index 97f3e50edf211..806c22c60b48f 100644
--- a/pandas/tests/window/test_grouper.py
+++ b/pandas/tests/window/test_grouper.py
@@ -384,6 +384,7 @@ def test_groupby_subset_rolling_subset_with_closed(self):
)
tm.assert_series_equal(result, expected)
+ @pytest.mark.xfail(not compat.IS64, reason="GH-35294")
@pytest.mark.parametrize("func", ["max", "min"])
def test_groupby_rolling_index_changed(self, func):
# GH: #36018 nlevels of MultiIndex changed
| this is against 1.1.x directly. see https://github.com/pandas-dev/pandas/issues/35831#issuecomment-688862692 | https://api.github.com/repos/pandas-dev/pandas/pulls/36220 | 2020-09-08T13:32:35Z | 2020-09-08T14:20:27Z | 2020-09-08T14:20:27Z | 2020-09-08T14:22:22Z |
REF: eliminate method _write() in json writers | diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index 3cf3c2e7fd91d..288bc0adc5162 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -1,15 +1,21 @@
+from abc import ABC, abstractmethod
from collections import abc
import functools
from io import BytesIO, StringIO
from itertools import islice
import os
-from typing import IO, Any, Callable, List, Optional, Tuple, Type
+from typing import IO, Any, Callable, List, Mapping, Optional, Tuple, Type, Union
import numpy as np
import pandas._libs.json as json
from pandas._libs.tslibs import iNaT
-from pandas._typing import CompressionOptions, JSONSerializable, StorageOptions
+from pandas._typing import (
+ CompressionOptions,
+ IndexLabel,
+ JSONSerializable,
+ StorageOptions,
+)
from pandas.errors import AbstractMethodError
from pandas.util._decorators import deprecate_kwarg, deprecate_nonkeyword_arguments
@@ -17,6 +23,7 @@
from pandas import DataFrame, MultiIndex, Series, isna, to_datetime
from pandas.core.construction import create_series_with_explicit_dtype
+from pandas.core.generic import NDFrame
from pandas.core.reshape.concat import concat
from pandas.io.common import get_compression_method, get_filepath_or_buffer, get_handle
@@ -33,7 +40,7 @@
# interface to/from
def to_json(
path_or_buf,
- obj,
+ obj: NDFrame,
orient: Optional[str] = None,
date_format: str = "epoch",
double_precision: int = 10,
@@ -110,7 +117,7 @@ def to_json(
path_or_buf.close()
-class Writer:
+class Writer(ABC):
_default_orient: str
def __init__(
@@ -146,75 +153,52 @@ def _format_axes(self):
raise AbstractMethodError(self)
def write(self):
- return self._write(
- self.obj,
- self.orient,
- self.double_precision,
- self.ensure_ascii,
- self.date_unit,
- self.date_format == "iso",
- self.default_handler,
- self.indent,
- )
-
- def _write(
- self,
- obj,
- orient: Optional[str],
- double_precision: int,
- ensure_ascii: bool,
- date_unit: str,
- iso_dates: bool,
- default_handler: Optional[Callable[[Any], JSONSerializable]],
- indent: int,
- ):
+ iso_dates = self.date_format == "iso"
return dumps(
- obj,
- orient=orient,
- double_precision=double_precision,
- ensure_ascii=ensure_ascii,
- date_unit=date_unit,
+ self.obj_to_write,
+ orient=self.orient,
+ double_precision=self.double_precision,
+ ensure_ascii=self.ensure_ascii,
+ date_unit=self.date_unit,
iso_dates=iso_dates,
- default_handler=default_handler,
- indent=indent,
+ default_handler=self.default_handler,
+ indent=self.indent,
)
+ @property
+ @abstractmethod
+ def obj_to_write(self) -> Union[NDFrame, Mapping[IndexLabel, Any]]:
+ """Object to write in JSON format."""
+ pass
+
class SeriesWriter(Writer):
_default_orient = "index"
+ @property
+ def obj_to_write(self) -> Union[NDFrame, Mapping[IndexLabel, Any]]:
+ if not self.index and self.orient == "split":
+ return {"name": self.obj.name, "data": self.obj.values}
+ else:
+ return self.obj
+
def _format_axes(self):
if not self.obj.index.is_unique and self.orient == "index":
raise ValueError(f"Series index must be unique for orient='{self.orient}'")
- def _write(
- self,
- obj,
- orient: Optional[str],
- double_precision: int,
- ensure_ascii: bool,
- date_unit: str,
- iso_dates: bool,
- default_handler: Optional[Callable[[Any], JSONSerializable]],
- indent: int,
- ):
- if not self.index and orient == "split":
- obj = {"name": obj.name, "data": obj.values}
- return super()._write(
- obj,
- orient,
- double_precision,
- ensure_ascii,
- date_unit,
- iso_dates,
- default_handler,
- indent,
- )
-
class FrameWriter(Writer):
_default_orient = "columns"
+ @property
+ def obj_to_write(self) -> Union[NDFrame, Mapping[IndexLabel, Any]]:
+ if not self.index and self.orient == "split":
+ obj_to_write = self.obj.to_dict(orient="split")
+ del obj_to_write["index"]
+ else:
+ obj_to_write = self.obj
+ return obj_to_write
+
def _format_axes(self):
"""
Try to format axes if they are datelike.
@@ -232,31 +216,6 @@ def _format_axes(self):
f"DataFrame columns must be unique for orient='{self.orient}'."
)
- def _write(
- self,
- obj,
- orient: Optional[str],
- double_precision: int,
- ensure_ascii: bool,
- date_unit: str,
- iso_dates: bool,
- default_handler: Optional[Callable[[Any], JSONSerializable]],
- indent: int,
- ):
- if not self.index and orient == "split":
- obj = obj.to_dict(orient="split")
- del obj["index"]
- return super()._write(
- obj,
- orient,
- double_precision,
- ensure_ascii,
- date_unit,
- iso_dates,
- default_handler,
- indent,
- )
-
class JSONTableWriter(FrameWriter):
_default_orient = "records"
@@ -331,30 +290,9 @@ def __init__(
self.orient = "records"
self.index = index
- def _write(
- self,
- obj,
- orient,
- double_precision,
- ensure_ascii,
- date_unit,
- iso_dates,
- default_handler,
- indent,
- ):
- table_obj = {"schema": self.schema, "data": obj}
- serialized = super()._write(
- table_obj,
- orient,
- double_precision,
- ensure_ascii,
- date_unit,
- iso_dates,
- default_handler,
- indent,
- )
-
- return serialized
+ @property
+ def obj_to_write(self) -> Union[NDFrame, Mapping[IndexLabel, Any]]:
+ return {"schema": self.schema, "data": self.obj}
@deprecate_kwarg(old_arg_name="numpy", new_arg_name=None)
| - [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
Attempted to figure out what is wrong with the issue https://github.com/pandas-dev/pandas/issues/36211.
I noticed that the private methods ``_write`` are defined in each child of class ``Writer``, which simply re-define ``obj`` and call the parent ``_write`` method.
It turns out that the source of the recursion does not lie there, but I refactored the module slightly by removing the mediator ``_write`` method. Instead I put the differences between the writers into their ``__init__`` method.
It seems that source of the problem with the recursion mentioned in the bug report is in ``pandas/_libs/src/ujson/python/objToJSON.c``. | https://api.github.com/repos/pandas-dev/pandas/pulls/36218 | 2020-09-08T12:09:13Z | 2020-10-22T19:36:59Z | 2020-10-22T19:36:59Z | 2020-11-06T15:35:25Z |
Backport PR #36182 on branch 1.1.x (DOC: release date for 1.1.2) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index 0e4a88f3ee56b..a214ad9762733 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -1,7 +1,7 @@
.. _whatsnew_112:
-What's new in 1.1.2 (??)
-------------------------
+What's new in 1.1.2 (September 8, 2020)
+---------------------------------------
These are the changes in pandas 1.1.2. See :ref:`release` for a full changelog
including other versions of pandas.
| Backport PR #36182: DOC: release date for 1.1.2 | https://api.github.com/repos/pandas-dev/pandas/pulls/36217 | 2020-09-08T11:50:25Z | 2020-09-08T12:34:57Z | 2020-09-08T12:34:57Z | 2020-09-08T12:34:57Z |
Backport PR #36205 on branch 1.1.x (DOC: doc fix) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index 28ce49c11b3f0..331650b7073f5 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -51,7 +51,7 @@ Bug fixes
Other
~~~~~
- :meth:`factorize` now supports ``na_sentinel=None`` to include NaN in the uniques of the values and remove ``dropna`` keyword which was unintentionally exposed to public facing API in 1.1 version from :meth:`factorize` (:issue:`35667`)
-- :meth:`DataFrame.plot` and meth:`Series.plot` raise ``UserWarning`` about usage of FixedFormatter and FixedLocator (:issue:`35684` and :issue:`35945`)
+- :meth:`DataFrame.plot` and :meth:`Series.plot` raise ``UserWarning`` about usage of ``FixedFormatter`` and ``FixedLocator`` (:issue:`35684` and :issue:`35945`)
.. ---------------------------------------------------------------------------
| Backport PR #36205: DOC: doc fix | https://api.github.com/repos/pandas-dev/pandas/pulls/36215 | 2020-09-08T10:22:30Z | 2020-09-08T11:05:52Z | 2020-09-08T11:05:52Z | 2020-09-08T11:05:52Z |
Backport PR #36208 on branch 1.1.x (BUG: GroupbyRolling with an empty frame) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index 28ce49c11b3f0..f13d38d1f8f76 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -24,7 +24,7 @@ Fixed regressions
- Fix regression in pickle roundtrip of the ``closed`` attribute of :class:`IntervalIndex` (:issue:`35658`)
- Fixed regression in :meth:`DataFrameGroupBy.agg` where a ``ValueError: buffer source array is read-only`` would be raised when the underlying array is read-only (:issue:`36014`)
- Fixed regression in :meth:`Series.groupby.rolling` number of levels of :class:`MultiIndex` in input was compressed to one (:issue:`36018`)
--
+- Fixed regression in :class:`DataFrameGroupBy` on an empty :class:`DataFrame` (:issue:`36197`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index 0c940e5d1b82d..f7bcd1e795fd3 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -2226,10 +2226,12 @@ def _create_blocks(self, obj: FrameOrSeries):
"""
# Ensure the object we're rolling over is monotonically sorted relative
# to the groups
- groupby_order = np.concatenate(
- list(self._groupby.grouper.indices.values())
- ).astype(np.int64)
- obj = obj.take(groupby_order)
+ # GH 36197
+ if not obj.empty:
+ groupby_order = np.concatenate(
+ list(self._groupby.grouper.indices.values())
+ ).astype(np.int64)
+ obj = obj.take(groupby_order)
return super()._create_blocks(obj)
def _get_cython_func_type(self, func: str) -> Callable:
diff --git a/pandas/tests/window/test_grouper.py b/pandas/tests/window/test_grouper.py
index a46a72bde8d6d..97f3e50edf211 100644
--- a/pandas/tests/window/test_grouper.py
+++ b/pandas/tests/window/test_grouper.py
@@ -404,3 +404,15 @@ def test_groupby_rolling_index_changed(self, func):
name="a",
)
tm.assert_series_equal(result, expected)
+
+ def test_groupby_rolling_empty_frame(self):
+ # GH 36197
+ expected = pd.DataFrame({"s1": []})
+ result = expected.groupby("s1").rolling(window=1).sum()
+ expected.index = pd.MultiIndex.from_tuples([], names=["s1", None])
+ tm.assert_frame_equal(result, expected)
+
+ expected = pd.DataFrame({"s1": [], "s2": []})
+ result = expected.groupby(["s1", "s2"]).rolling(window=1).sum()
+ expected.index = pd.MultiIndex.from_tuples([], names=["s1", "s2", None])
+ tm.assert_frame_equal(result, expected)
| Backport PR #36208: BUG: GroupbyRolling with an empty frame | https://api.github.com/repos/pandas-dev/pandas/pulls/36213 | 2020-09-08T09:53:16Z | 2020-09-08T10:49:23Z | 2020-09-08T10:49:23Z | 2020-09-08T10:49:23Z |
REF: share more EA methods | diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index 8b79f8ce66756..e9d8671b69c78 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -6,7 +6,7 @@
from pandas.errors import AbstractMethodError
from pandas.util._decorators import cache_readonly, doc
-from pandas.core.algorithms import searchsorted, take, unique
+from pandas.core.algorithms import take, unique
from pandas.core.array_algos.transforms import shift
from pandas.core.arrays.base import ExtensionArray
@@ -102,6 +102,9 @@ def T(self: _T) -> _T:
# ------------------------------------------------------------------------
+ def _values_for_argsort(self):
+ return self._ndarray
+
def copy(self: _T) -> _T:
new_data = self._ndarray.copy()
return self._from_backing_data(new_data)
@@ -135,7 +138,11 @@ def _concat_same_type(cls, to_concat, axis: int = 0):
@doc(ExtensionArray.searchsorted)
def searchsorted(self, value, side="left", sorter=None):
- return searchsorted(self._ndarray, value, side=side, sorter=sorter)
+ value = self._validate_searchsorted_value(value)
+ return self._ndarray.searchsorted(value, side=side, sorter=sorter)
+
+ def _validate_searchsorted_value(self, value):
+ return value
@doc(ExtensionArray.shift)
def shift(self, periods=1, fill_value=None, axis=0):
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index a2b5b54c55490..66d917b07305c 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -12,7 +12,7 @@
from pandas._libs import NaT, algos as libalgos, hashtable as htable, lib
from pandas._typing import ArrayLike, Dtype, Ordered, Scalar
from pandas.compat.numpy import function as nv
-from pandas.util._decorators import cache_readonly, deprecate_kwarg, doc
+from pandas.util._decorators import cache_readonly, deprecate_kwarg
from pandas.util._validators import validate_bool_kwarg, validate_fillna_kwargs
from pandas.core.dtypes.cast import (
@@ -45,12 +45,7 @@
import pandas.core.algorithms as algorithms
from pandas.core.algorithms import _get_data_algo, factorize, take_1d, unique1d
from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
-from pandas.core.base import (
- ExtensionArray,
- NoNewAttributesMixin,
- PandasObject,
- _shared_docs,
-)
+from pandas.core.base import ExtensionArray, NoNewAttributesMixin, PandasObject
import pandas.core.common as com
from pandas.core.construction import array, extract_array, sanitize_array
from pandas.core.indexers import check_array_indexer, deprecate_ndim_indexing
@@ -1315,11 +1310,6 @@ def memory_usage(self, deep=False):
"""
return self._codes.nbytes + self.dtype.categories.memory_usage(deep=deep)
- @doc(_shared_docs["searchsorted"], klass="Categorical")
- def searchsorted(self, value, side="left", sorter=None):
- value = self._validate_searchsorted_value(value)
- return self.codes.searchsorted(value, side=side, sorter=sorter)
-
def isna(self):
"""
Detect missing values
@@ -1428,9 +1418,6 @@ def check_for_ordered(self, op):
"Categorical to an ordered one\n"
)
- def _values_for_argsort(self):
- return self._codes
-
def argsort(self, ascending=True, kind="quicksort", **kwargs):
"""
Return the indices that would sort the Categorical.
@@ -1879,7 +1866,7 @@ def __getitem__(self, key):
if result.ndim > 1:
deprecate_ndim_indexing(result)
return result
- return self._constructor(result, dtype=self.dtype, fastpath=True)
+ return self._from_backing_data(result)
def __setitem__(self, key, value):
"""
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index bb40cf78ea006..6302b48cb1978 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -545,15 +545,18 @@ def __getitem__(self, key):
result = self._ndarray[key]
if self.ndim == 1:
return self._box_func(result)
- return self._simple_new(result, dtype=self.dtype)
+ return self._from_backing_data(result)
key = self._validate_getitem_key(key)
result = self._ndarray[key]
if lib.is_scalar(result):
return self._box_func(result)
+ result = self._from_backing_data(result)
+
freq = self._get_getitem_freq(key)
- return self._simple_new(result, dtype=self.dtype, freq=freq)
+ result._freq = freq
+ return result
def _validate_getitem_key(self, key):
if com.is_bool_indexer(key):
@@ -714,9 +717,6 @@ def _values_for_factorize(self):
def _from_factorized(cls, values, original):
return cls(values, dtype=original.dtype)
- def _values_for_argsort(self):
- return self._ndarray
-
# ------------------------------------------------------------------
# Validation Methods
# TODO: try to de-duplicate these, ensure identical behavior
@@ -917,34 +917,6 @@ def _unbox(self, other, setitem: bool = False) -> Union[np.int64, np.ndarray]:
# These are not part of the EA API, but we implement them because
# pandas assumes they're there.
- def searchsorted(self, value, side="left", sorter=None):
- """
- Find indices where elements should be inserted to maintain order.
-
- Find the indices into a sorted array `self` such that, if the
- corresponding elements in `value` were inserted before the indices,
- the order of `self` would be preserved.
-
- Parameters
- ----------
- value : array_like
- Values to insert into `self`.
- side : {'left', 'right'}, optional
- If 'left', the index of the first suitable location found is given.
- If 'right', return the last such index. If there is no suitable
- index, return either 0 or N (where N is the length of `self`).
- sorter : 1-D array_like, optional
- Optional array of integer indices that sort `self` into ascending
- order. They are typically the result of ``np.argsort``.
-
- Returns
- -------
- indices : array of ints
- Array of insertion points with the same shape as `value`.
- """
- value = self._validate_searchsorted_value(value)
- return self._data.searchsorted(value, side=side, sorter=sorter)
-
def value_counts(self, dropna=False):
"""
Return a Series containing counts of unique values.
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index 588d68514649a..d3fa87d5ea7ff 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -260,15 +260,19 @@ def __getitem__(self, item):
return result
def __setitem__(self, key, value) -> None:
- value = extract_array(value, extract_numpy=True)
+ key = self._validate_setitem_key(key)
+ value = self._validate_setitem_value(value)
+ self._ndarray[key] = value
- key = check_array_indexer(self, key)
- scalar_value = lib.is_scalar(value)
+ def _validate_setitem_value(self, value):
+ value = extract_array(value, extract_numpy=True)
- if not scalar_value:
+ if not lib.is_scalar(value):
value = np.asarray(value, dtype=self._ndarray.dtype)
+ return value
- self._ndarray[key] = value
+ def _validate_setitem_key(self, key):
+ return check_array_indexer(self, key)
def isna(self) -> np.ndarray:
return isna(self._ndarray)
@@ -308,9 +312,6 @@ def _validate_fill_value(self, fill_value):
fill_value = self.dtype.na_value
return fill_value
- def _values_for_argsort(self) -> np.ndarray:
- return self._ndarray
-
def _values_for_factorize(self) -> Tuple[np.ndarray, int]:
return self._ndarray, -1
| https://api.github.com/repos/pandas-dev/pandas/pulls/36209 | 2020-09-08T02:37:54Z | 2020-09-11T13:04:38Z | 2020-09-11T13:04:38Z | 2020-09-11T14:36:10Z | |
BUG: GroupbyRolling with an empty frame | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index 28ce49c11b3f0..f13d38d1f8f76 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -24,7 +24,7 @@ Fixed regressions
- Fix regression in pickle roundtrip of the ``closed`` attribute of :class:`IntervalIndex` (:issue:`35658`)
- Fixed regression in :meth:`DataFrameGroupBy.agg` where a ``ValueError: buffer source array is read-only`` would be raised when the underlying array is read-only (:issue:`36014`)
- Fixed regression in :meth:`Series.groupby.rolling` number of levels of :class:`MultiIndex` in input was compressed to one (:issue:`36018`)
--
+- Fixed regression in :class:`DataFrameGroupBy` on an empty :class:`DataFrame` (:issue:`36197`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index 235bd5364af02..9466ada3f4578 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -2240,10 +2240,12 @@ def _create_blocks(self, obj: FrameOrSeriesUnion):
"""
# Ensure the object we're rolling over is monotonically sorted relative
# to the groups
- groupby_order = np.concatenate(
- list(self._groupby.grouper.indices.values())
- ).astype(np.int64)
- obj = obj.take(groupby_order)
+ # GH 36197
+ if not obj.empty:
+ groupby_order = np.concatenate(
+ list(self._groupby.grouper.indices.values())
+ ).astype(np.int64)
+ obj = obj.take(groupby_order)
return super()._create_blocks(obj)
def _get_cython_func_type(self, func: str) -> Callable:
diff --git a/pandas/tests/window/test_grouper.py b/pandas/tests/window/test_grouper.py
index cb85ad7584da7..786cf68d28871 100644
--- a/pandas/tests/window/test_grouper.py
+++ b/pandas/tests/window/test_grouper.py
@@ -393,3 +393,15 @@ def test_groupby_rolling_index_changed(self, func):
name="a",
)
tm.assert_series_equal(result, expected)
+
+ def test_groupby_rolling_empty_frame(self):
+ # GH 36197
+ expected = pd.DataFrame({"s1": []})
+ result = expected.groupby("s1").rolling(window=1).sum()
+ expected.index = pd.MultiIndex.from_tuples([], names=["s1", None])
+ tm.assert_frame_equal(result, expected)
+
+ expected = pd.DataFrame({"s1": [], "s2": []})
+ result = expected.groupby(["s1", "s2"]).rolling(window=1).sum()
+ expected.index = pd.MultiIndex.from_tuples([], names=["s1", "s2", None])
+ tm.assert_frame_equal(result, expected)
| - [x] closes #36197
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36208 | 2020-09-08T02:01:13Z | 2020-09-08T09:51:21Z | 2020-09-08T09:51:21Z | 2020-11-12T05:15:26Z |
Fixed pandas.json_normalize doctests errors | diff --git a/pandas/io/json/_normalize.py b/pandas/io/json/_normalize.py
index 2e1fc57e88ed1..3ed0b5851b395 100644
--- a/pandas/io/json/_normalize.py
+++ b/pandas/io/json/_normalize.py
@@ -163,11 +163,11 @@ def _json_normalize(
>>> data = [{'id': 1, 'name': {'first': 'Coleen', 'last': 'Volk'}},
... {'name': {'given': 'Mose', 'family': 'Regner'}},
... {'id': 2, 'name': 'Faye Raker'}]
- >>> pandas.json_normalize(data)
- id name name.family name.first name.given name.last
- 0 1.0 NaN NaN Coleen NaN Volk
- 1 NaN NaN Regner NaN Mose NaN
- 2 2.0 Faye Raker NaN NaN NaN NaN
+ >>> pd.json_normalize(data)
+ id name.first name.last name.given name.family name
+ 0 1.0 Coleen Volk NaN NaN NaN
+ 1 NaN NaN NaN Mose Regner NaN
+ 2 2.0 NaN NaN NaN NaN Faye Raker
>>> data = [{'id': 1,
... 'name': "Cole Volk",
@@ -176,11 +176,11 @@ def _json_normalize(
... 'fitness': {'height': 130, 'weight': 60}},
... {'id': 2, 'name': 'Faye Raker',
... 'fitness': {'height': 130, 'weight': 60}}]
- >>> pandas.json_normalize(data, max_level=0)
- fitness id name
- 0 {'height': 130, 'weight': 60} 1.0 Cole Volk
- 1 {'height': 130, 'weight': 60} NaN Mose Reg
- 2 {'height': 130, 'weight': 60} 2.0 Faye Raker
+ >>> pd.json_normalize(data, max_level=0)
+ id name fitness
+ 0 1.0 Cole Volk {'height': 130, 'weight': 60}
+ 1 NaN Mose Reg {'height': 130, 'weight': 60}
+ 2 2.0 Faye Raker {'height': 130, 'weight': 60}
Normalizes nested data up to level 1.
@@ -191,11 +191,11 @@ def _json_normalize(
... 'fitness': {'height': 130, 'weight': 60}},
... {'id': 2, 'name': 'Faye Raker',
... 'fitness': {'height': 130, 'weight': 60}}]
- >>> pandas.json_normalize(data, max_level=1)
- fitness.height fitness.weight id name
- 0 130 60 1.0 Cole Volk
- 1 130 60 NaN Mose Reg
- 2 130 60 2.0 Faye Raker
+ >>> pd.json_normalize(data, max_level=1)
+ id name fitness.height fitness.weight
+ 0 1.0 Cole Volk 130 60
+ 1 NaN Mose Reg 130 60
+ 2 2.0 Faye Raker 130 60
>>> data = [{'state': 'Florida',
... 'shortname': 'FL',
@@ -208,7 +208,7 @@ def _json_normalize(
... 'info': {'governor': 'John Kasich'},
... 'counties': [{'name': 'Summit', 'population': 1234},
... {'name': 'Cuyahoga', 'population': 1337}]}]
- >>> result = pandas.json_normalize(data, 'counties', ['state', 'shortname',
+ >>> result = pd.json_normalize(data, 'counties', ['state', 'shortname',
... ['info', 'governor']])
>>> result
name population state shortname info.governor
@@ -219,7 +219,7 @@ def _json_normalize(
4 Cuyahoga 1337 Ohio OH John Kasich
>>> data = {'A': [1, 2]}
- >>> pandas.json_normalize(data, 'A', record_prefix='Prefix.')
+ >>> pd.json_normalize(data, 'A', record_prefix='Prefix.')
Prefix.0
0 1
1 2
| - [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] Changed `pandas.` to `pd.` in the docstring of `pandas.json_normalize`. Fixed the expected results.
| https://api.github.com/repos/pandas-dev/pandas/pulls/36207 | 2020-09-08T01:52:16Z | 2020-09-08T13:01:44Z | 2020-09-08T13:01:43Z | 2020-09-08T23:15:16Z |
REF: implement Categorical._box_func, make _box_func a method | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index b732db4c66003..f20d3d5e316f8 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1734,6 +1734,11 @@ def _ndarray(self) -> np.ndarray:
def _from_backing_data(self, arr: np.ndarray) -> "Categorical":
return self._constructor(arr, dtype=self.dtype, fastpath=True)
+ def _box_func(self, i: int):
+ if i == -1:
+ return np.NaN
+ return self.categories[i]
+
# ------------------------------------------------------------------
def take_nd(self, indexer, allow_fill: bool = False, fill_value=None):
@@ -1874,10 +1879,7 @@ def __getitem__(self, key):
"""
if isinstance(key, (int, np.integer)):
i = self._codes[key]
- if i == -1:
- return np.nan
- else:
- return self.categories[i]
+ return self._box_func(i)
key = check_array_indexer(self, key)
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 6477b94a823ce..ba5bfc108f16b 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -478,8 +478,7 @@ def _from_backing_data(self: _T, arr: np.ndarray) -> _T:
# ------------------------------------------------------------------
- @property
- def _box_func(self):
+ def _box_func(self, x):
"""
box function to get object from internal representation
"""
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index d913e7be9ae5f..9f10cc84dcfcc 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -7,6 +7,7 @@
from pandas._libs import lib, tslib
from pandas._libs.tslibs import (
NaT,
+ NaTType,
Resolution,
Timestamp,
conversion,
@@ -475,9 +476,8 @@ def _maybe_clear_freq(self):
# -----------------------------------------------------------------
# Descriptive Properties
- @property
- def _box_func(self):
- return lambda x: Timestamp(x, freq=self.freq, tz=self.tz)
+ def _box_func(self, x) -> Union[Timestamp, NaTType]:
+ return Timestamp(x, freq=self.freq, tz=self.tz)
@property
def dtype(self) -> Union[np.dtype, DatetimeTZDtype]:
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index c3a9430736969..eea11bde77030 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -484,9 +484,8 @@ def _time_shift(self, periods, freq=None):
values[self._isnan] = iNaT
return type(self)(values, freq=self.freq)
- @property
- def _box_func(self):
- return lambda x: Period._from_ordinal(ordinal=x, freq=self.freq)
+ def _box_func(self, x) -> Union[Period, NaTType]:
+ return Period._from_ordinal(ordinal=x, freq=self.freq)
def asfreq(self, freq=None, how: str = "E") -> "PeriodArray":
"""
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 485ebb49a376d..5e3c0f2b8d876 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -1,10 +1,19 @@
from datetime import timedelta
-from typing import List
+from typing import List, Union
import numpy as np
from pandas._libs import lib, tslibs
-from pandas._libs.tslibs import NaT, Period, Tick, Timedelta, Timestamp, iNaT, to_offset
+from pandas._libs.tslibs import (
+ NaT,
+ NaTType,
+ Period,
+ Tick,
+ Timedelta,
+ Timestamp,
+ iNaT,
+ to_offset,
+)
from pandas._libs.tslibs.conversion import precision_from_unit
from pandas._libs.tslibs.fields import get_timedelta_field
from pandas._libs.tslibs.timedeltas import array_to_timedelta64, parse_timedelta_unit
@@ -108,9 +117,8 @@ class TimedeltaArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps):
# Note: ndim must be defined to ensure NaT.__richcmp(TimedeltaArray)
# operates pointwise.
- @property
- def _box_func(self):
- return lambda x: Timedelta(x, unit="ns")
+ def _box_func(self, x) -> Union[Timedelta, NaTType]:
+ return Timedelta(x, unit="ns")
@property
def dtype(self):
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index e7e93068d9175..54c8ed60b6097 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -81,7 +81,7 @@ def wrapper(left, right):
DatetimeLikeArrayMixin,
cache=True,
)
-@inherit_names(["mean", "asi8", "freq", "freqstr", "_box_func"], DatetimeLikeArrayMixin)
+@inherit_names(["mean", "asi8", "freq", "freqstr"], DatetimeLikeArrayMixin)
class DatetimeIndexOpsMixin(ExtensionIndex):
"""
Common ops mixin to support a unified interface datetimelike Index.
@@ -244,7 +244,7 @@ def min(self, axis=None, skipna=True, *args, **kwargs):
# quick check
if len(i8) and self.is_monotonic:
if i8[0] != iNaT:
- return self._box_func(i8[0])
+ return self._data._box_func(i8[0])
if self.hasnans:
if skipna:
@@ -253,7 +253,7 @@ def min(self, axis=None, skipna=True, *args, **kwargs):
return self._na_value
else:
min_stamp = i8.min()
- return self._box_func(min_stamp)
+ return self._data._box_func(min_stamp)
except ValueError:
return self._na_value
@@ -301,7 +301,7 @@ def max(self, axis=None, skipna=True, *args, **kwargs):
# quick check
if len(i8) and self.is_monotonic:
if i8[-1] != iNaT:
- return self._box_func(i8[-1])
+ return self._data._box_func(i8[-1])
if self.hasnans:
if skipna:
@@ -310,7 +310,7 @@ def max(self, axis=None, skipna=True, *args, **kwargs):
return self._na_value
else:
max_stamp = i8.max()
- return self._box_func(max_stamp)
+ return self._data._box_func(max_stamp)
except ValueError:
return self._na_value
| Defining `_box_func` on `Categorical` is to facilitate more code sharing with datetimelike. Also there are a bunch of places that do something _similar_ but slightly different that I want to standardize within `Categorical`.
Changing `_box_func` from a property-lambda to a method on the datetimelike arrays gives a slight perf boost:
```
In [1]: import pandas as pd
In [2]: dti = pd.date_range("2016-01-01", periods=3)
In [3]: %timeit dti[1]
8.73 µs ± 50.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) # <-- master
8.08 µs ± 119 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) # <-- PR
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/36206 | 2020-09-08T00:50:57Z | 2020-09-08T22:24:55Z | 2020-09-08T22:24:55Z | 2020-09-08T23:10:51Z |
DOC: doc fix | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index 28ce49c11b3f0..331650b7073f5 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -51,7 +51,7 @@ Bug fixes
Other
~~~~~
- :meth:`factorize` now supports ``na_sentinel=None`` to include NaN in the uniques of the values and remove ``dropna`` keyword which was unintentionally exposed to public facing API in 1.1 version from :meth:`factorize` (:issue:`35667`)
-- :meth:`DataFrame.plot` and meth:`Series.plot` raise ``UserWarning`` about usage of FixedFormatter and FixedLocator (:issue:`35684` and :issue:`35945`)
+- :meth:`DataFrame.plot` and :meth:`Series.plot` raise ``UserWarning`` about usage of ``FixedFormatter`` and ``FixedLocator`` (:issue:`35684` and :issue:`35945`)
.. ---------------------------------------------------------------------------
| https://github.com/pandas-dev/pandas/issues/35831#issuecomment-688518465 | https://api.github.com/repos/pandas-dev/pandas/pulls/36205 | 2020-09-07T22:06:54Z | 2020-09-08T10:22:20Z | 2020-09-08T10:22:20Z | 2020-09-08T10:23:17Z |
Backport PR #36152 on branch 1.1.x (Fix compressed multiindex for output of groupby.rolling) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index e9cba3de56920..28ce49c11b3f0 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -23,6 +23,7 @@ Fixed regressions
- Regression in :meth:`DataFrame.replace` where a ``TypeError`` would be raised when attempting to replace elements of type :class:`Interval` (:issue:`35931`)
- Fix regression in pickle roundtrip of the ``closed`` attribute of :class:`IntervalIndex` (:issue:`35658`)
- Fixed regression in :meth:`DataFrameGroupBy.agg` where a ``ValueError: buffer source array is read-only`` would be raised when the underlying array is read-only (:issue:`36014`)
+- Fixed regression in :meth:`Series.groupby.rolling` number of levels of :class:`MultiIndex` in input was compressed to one (:issue:`36018`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index d727881f8285a..0c940e5d1b82d 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -2197,17 +2197,17 @@ def _apply(
# Compose MultiIndex result from grouping levels then rolling level
# Aggregate the MultiIndex data as tuples then the level names
grouped_object_index = self.obj.index
- grouped_index_name = [grouped_object_index.name]
+ grouped_index_name = [*grouped_object_index.names]
groupby_keys = [grouping.name for grouping in self._groupby.grouper._groupings]
result_index_names = groupby_keys + grouped_index_name
result_index_data = []
for key, values in self._groupby.grouper.indices.items():
for value in values:
- if not is_list_like(key):
- data = [key, grouped_object_index[value]]
- else:
- data = [*key, grouped_object_index[value]]
+ data = [
+ *com.maybe_make_list(key),
+ *com.maybe_make_list(grouped_object_index[value]),
+ ]
result_index_data.append(tuple(data))
result_index = MultiIndex.from_tuples(
diff --git a/pandas/tests/window/test_grouper.py b/pandas/tests/window/test_grouper.py
index d0a62374d0888..a46a72bde8d6d 100644
--- a/pandas/tests/window/test_grouper.py
+++ b/pandas/tests/window/test_grouper.py
@@ -383,3 +383,24 @@ def test_groupby_subset_rolling_subset_with_closed(self):
name="column1",
)
tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize("func", ["max", "min"])
+ def test_groupby_rolling_index_changed(self, func):
+ # GH: #36018 nlevels of MultiIndex changed
+ ds = Series(
+ [1, 2, 2],
+ index=pd.MultiIndex.from_tuples(
+ [("a", "x"), ("a", "y"), ("c", "z")], names=["1", "2"]
+ ),
+ name="a",
+ )
+
+ result = getattr(ds.groupby(ds).rolling(2), func)()
+ expected = Series(
+ [np.nan, np.nan, 2.0],
+ index=pd.MultiIndex.from_tuples(
+ [(1, "a", "x"), (2, "a", "y"), (2, "c", "z")], names=["a", "1", "2"]
+ ),
+ name="a",
+ )
+ tm.assert_series_equal(result, expected)
| Backport PR #36152: Fix compressed multiindex for output of groupby.rolling | https://api.github.com/repos/pandas-dev/pandas/pulls/36203 | 2020-09-07T21:13:12Z | 2020-09-07T22:10:03Z | 2020-09-07T22:10:03Z | 2020-09-07T22:10:03Z |
TST: DataFrame.replace: TypeError: Cannot compare types 'ndarray(dtype=int64)' and 'unicode' | diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index ea2488dfc0877..a77753ed9f9d0 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -1599,3 +1599,11 @@ def test_replace_intervals(self):
result = df.replace({"a": {pd.Interval(0, 1): "x"}})
expected = pd.DataFrame({"a": ["x", "x"]})
tm.assert_frame_equal(result, expected)
+
+ def test_replace_unicode(self):
+ # GH: 16784
+ columns_values_map = {"positive": {"正面": 1, "中立": 1, "负面": 0}}
+ df1 = pd.DataFrame({"positive": np.ones(3)})
+ result = df1.replace(columns_values_map)
+ expected = pd.DataFrame({"positive": np.ones(3)})
+ tm.assert_frame_equal(result, expected)
| - [x] closes #16784
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
Thanks @jbrockmendel for fixing my related issue | https://api.github.com/repos/pandas-dev/pandas/pulls/36202 | 2020-09-07T19:54:48Z | 2020-09-07T21:11:30Z | 2020-09-07T21:11:29Z | 2020-09-07T21:13:36Z |
Backport PR #36191 on branch 1.1.x (TST: update test_series_factorize_na_sentinel_none for 32bit) | diff --git a/pandas/tests/base/test_factorize.py b/pandas/tests/base/test_factorize.py
index 9fad9856d53cc..f8cbadb987d29 100644
--- a/pandas/tests/base/test_factorize.py
+++ b/pandas/tests/base/test_factorize.py
@@ -34,7 +34,7 @@ def test_series_factorize_na_sentinel_none():
ser = pd.Series(values)
codes, uniques = ser.factorize(na_sentinel=None)
- expected_codes = np.array([0, 1, 0, 2], dtype="int64")
+ expected_codes = np.array([0, 1, 0, 2], dtype=np.intp)
expected_uniques = pd.Index([1.0, 2.0, np.nan])
tm.assert_numpy_array_equal(codes, expected_codes)
| Backport PR #36191: TST: update test_series_factorize_na_sentinel_none for 32bit | https://api.github.com/repos/pandas-dev/pandas/pulls/36200 | 2020-09-07T19:41:11Z | 2020-09-07T20:35:06Z | 2020-09-07T20:35:06Z | 2020-09-07T20:35:07Z |
Backport PR #36134: BUG: shows correct package name when import_optional_dependency is ca… | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index 8a4574af8f6a9..e9cba3de56920 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -41,6 +41,7 @@ Bug fixes
- Bug in :meth:`Series.dt.isocalendar` and :meth:`DatetimeIndex.isocalendar` that returned incorrect year for certain dates (:issue:`36032`)
- Bug in :class:`DataFrame` indexing returning an incorrect :class:`Series` in some cases when the series has been altered and a cache not invalidated (:issue:`33675`)
- Bug in :meth:`DataFrame.corr` causing subsequent indexing lookups to be incorrect (:issue:`35882`)
+- Bug in :meth:`import_optional_dependency` returning incorrect package names in cases where package name is different from import name (:issue:`35948`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/compat/_optional.py b/pandas/compat/_optional.py
index 6423064732def..9a5e54dd31171 100644
--- a/pandas/compat/_optional.py
+++ b/pandas/compat/_optional.py
@@ -33,6 +33,19 @@
"numba": "0.46.0",
}
+# A mapping from import name to package name (on PyPI) for packages where
+# these two names are different.
+
+INSTALL_MAPPING = {
+ "bs4": "beautifulsoup4",
+ "bottleneck": "Bottleneck",
+ "lxml.etree": "lxml",
+ "odf": "odfpy",
+ "pandas_gbq": "pandas-gbq",
+ "sqlalchemy": "SQLAlchemy",
+ "jinja2": "Jinja2",
+}
+
def _get_version(module: types.ModuleType) -> str:
version = getattr(module, "__version__", None)
@@ -82,9 +95,13 @@ def import_optional_dependency(
is False, or when the package's version is too old and `on_version`
is ``'warn'``.
"""
+
+ package_name = INSTALL_MAPPING.get(name)
+ install_name = package_name if package_name is not None else name
+
msg = (
- f"Missing optional dependency '{name}'. {extra} "
- f"Use pip or conda to install {name}."
+ f"Missing optional dependency '{install_name}'. {extra} "
+ f"Use pip or conda to install {install_name}."
)
try:
module = importlib.import_module(name)
| xref #36134 | https://api.github.com/repos/pandas-dev/pandas/pulls/36199 | 2020-09-07T19:30:17Z | 2020-09-07T20:35:19Z | 2020-09-07T20:35:19Z | 2020-09-07T20:51:23Z |
CLN: remove unused return value in _create_blocks | diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index 9466ada3f4578..5a7482076903c 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -234,7 +234,7 @@ def _validate_get_window_bounds_signature(window: BaseIndexer) -> None:
f"get_window_bounds"
)
- def _create_blocks(self, obj: FrameOrSeriesUnion):
+ def _create_data(self, obj: FrameOrSeries) -> FrameOrSeries:
"""
Split data into blocks & return conformed data.
"""
@@ -242,9 +242,8 @@ def _create_blocks(self, obj: FrameOrSeriesUnion):
if self.on is not None and not isinstance(self.on, Index):
if obj.ndim == 2:
obj = obj.reindex(columns=obj.columns.difference([self.on]), copy=False)
- blocks = obj._to_dict_of_blocks(copy=False).values()
- return blocks, obj
+ return obj
def _gotitem(self, key, ndim, subset=None):
"""
@@ -333,7 +332,7 @@ def __repr__(self) -> str:
def __iter__(self):
window = self._get_window(win_type=None)
- _, obj = self._create_blocks(self._selected_obj)
+ obj = self._create_data(self._selected_obj)
index = self._get_window_indexer(window=window)
start, end = index.get_window_bounds(
@@ -469,7 +468,7 @@ def _apply_series(self, homogeneous_func: Callable[..., ArrayLike]) -> "Series":
"""
Series version of _apply_blockwise
"""
- _, obj = self._create_blocks(self._selected_obj)
+ obj = self._create_data(self._selected_obj)
try:
values = self._prep_values(obj.values)
@@ -489,7 +488,7 @@ def _apply_blockwise(
if self._selected_obj.ndim == 1:
return self._apply_series(homogeneous_func)
- _, obj = self._create_blocks(self._selected_obj)
+ obj = self._create_data(self._selected_obj)
mgr = obj._mgr
def hfunc(bvalues: ArrayLike) -> ArrayLike:
@@ -1268,7 +1267,7 @@ def count(self):
# implementations shouldn't end up here
assert not isinstance(self.window, BaseIndexer)
- _, obj = self._create_blocks(self._selected_obj)
+ obj = self._create_data(self._selected_obj)
def hfunc(values: np.ndarray) -> np.ndarray:
result = notna(values)
@@ -2234,7 +2233,7 @@ def _apply(
def _constructor(self):
return Rolling
- def _create_blocks(self, obj: FrameOrSeriesUnion):
+ def _create_data(self, obj: FrameOrSeries) -> FrameOrSeries:
"""
Split data into blocks & return conformed data.
"""
@@ -2246,7 +2245,7 @@ def _create_blocks(self, obj: FrameOrSeriesUnion):
list(self._groupby.grouper.indices.values())
).astype(np.int64)
obj = obj.take(groupby_order)
- return super()._create_blocks(obj)
+ return super()._create_data(obj)
def _get_cython_func_type(self, func: str) -> Callable:
"""
| The blocks are made unnecessary by the recent changes to use BlockManager.apply | https://api.github.com/repos/pandas-dev/pandas/pulls/36196 | 2020-09-07T17:38:01Z | 2020-09-08T15:29:03Z | 2020-09-08T15:29:03Z | 2020-09-08T15:31:24Z |
pandas docs json_normalize example | diff --git a/pandas/io/json/_normalize.py b/pandas/io/json/_normalize.py
index 44765dbe74b46..2e1fc57e88ed1 100644
--- a/pandas/io/json/_normalize.py
+++ b/pandas/io/json/_normalize.py
@@ -176,7 +176,7 @@ def _json_normalize(
... 'fitness': {'height': 130, 'weight': 60}},
... {'id': 2, 'name': 'Faye Raker',
... 'fitness': {'height': 130, 'weight': 60}}]
- >>> json_normalize(data, max_level=0)
+ >>> pandas.json_normalize(data, max_level=0)
fitness id name
0 {'height': 130, 'weight': 60} 1.0 Cole Volk
1 {'height': 130, 'weight': 60} NaN Mose Reg
@@ -191,7 +191,7 @@ def _json_normalize(
... 'fitness': {'height': 130, 'weight': 60}},
... {'id': 2, 'name': 'Faye Raker',
... 'fitness': {'height': 130, 'weight': 60}}]
- >>> json_normalize(data, max_level=1)
+ >>> pandas.json_normalize(data, max_level=1)
fitness.height fitness.weight id name
0 130 60 1.0 Cole Volk
1 130 60 NaN Mose Reg
@@ -208,7 +208,7 @@ def _json_normalize(
... 'info': {'governor': 'John Kasich'},
... 'counties': [{'name': 'Summit', 'population': 1234},
... {'name': 'Cuyahoga', 'population': 1337}]}]
- >>> result = json_normalize(data, 'counties', ['state', 'shortname',
+ >>> result = pandas.json_normalize(data, 'counties', ['state', 'shortname',
... ['info', 'governor']])
>>> result
name population state shortname info.governor
@@ -219,7 +219,7 @@ def _json_normalize(
4 Cuyahoga 1337 Ohio OH John Kasich
>>> data = {'A': [1, 2]}
- >>> json_normalize(data, 'A', record_prefix='Prefix.')
+ >>> pandas.json_normalize(data, 'A', record_prefix='Prefix.')
Prefix.0
0 1
1 2
| - [x] closes #36184
- [x] Inserted " pandas. " preceding the json_normalize() method in the example cells where it was missing.
Documentation Location : [https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.json_normalize.html](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.json_normalize.html) | https://api.github.com/repos/pandas-dev/pandas/pulls/36194 | 2020-09-07T16:00:38Z | 2020-09-08T00:30:20Z | 2020-09-08T00:30:20Z | 2020-09-08T03:37:02Z |
CLN: remove unnecessary trailing commas on issues #35925 | diff --git a/pandas/tests/arrays/categorical/test_replace.py b/pandas/tests/arrays/categorical/test_replace.py
index b9ac3ce9a37ae..8b784fde1d3c5 100644
--- a/pandas/tests/arrays/categorical/test_replace.py
+++ b/pandas/tests/arrays/categorical/test_replace.py
@@ -43,9 +43,5 @@ def test_replace(to_replace, value, expected, flip_categories):
# the replace call loses categorical dtype
expected = pd.Series(np.asarray(expected))
- tm.assert_series_equal(
- expected, result, check_category_order=False,
- )
- tm.assert_series_equal(
- expected, s, check_category_order=False,
- )
+ tm.assert_series_equal(expected, result, check_category_order=False)
+ tm.assert_series_equal(expected, s, check_category_order=False)
diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index a0525aa511ee2..304e1c80a3f77 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -35,7 +35,7 @@
np.dtype("float32"),
PandasArray(np.array([1.0, 2.0], dtype=np.dtype("float32"))),
),
- (np.array([1, 2], dtype="int64"), None, IntegerArray._from_sequence([1, 2]),),
+ (np.array([1, 2], dtype="int64"), None, IntegerArray._from_sequence([1, 2])),
# String alias passes through to NumPy
([1, 2], "float32", PandasArray(np.array([1, 2], dtype="float32"))),
# Period alias
@@ -120,10 +120,10 @@
(pd.Series([1, 2]), None, PandasArray(np.array([1, 2], dtype=np.int64))),
# String
(["a", None], "string", StringArray._from_sequence(["a", None])),
- (["a", None], pd.StringDtype(), StringArray._from_sequence(["a", None]),),
+ (["a", None], pd.StringDtype(), StringArray._from_sequence(["a", None])),
# Boolean
([True, None], "boolean", BooleanArray._from_sequence([True, None])),
- ([True, None], pd.BooleanDtype(), BooleanArray._from_sequence([True, None]),),
+ ([True, None], pd.BooleanDtype(), BooleanArray._from_sequence([True, None])),
# Index
(pd.Index([1, 2]), None, PandasArray(np.array([1, 2], dtype=np.int64))),
# Series[EA] returns the EA
@@ -174,7 +174,7 @@ def test_array_copy():
period_array(["2000", "2001"], freq="D"),
),
# interval
- ([pd.Interval(0, 1), pd.Interval(1, 2)], IntervalArray.from_breaks([0, 1, 2]),),
+ ([pd.Interval(0, 1), pd.Interval(1, 2)], IntervalArray.from_breaks([0, 1, 2])),
# datetime
(
[pd.Timestamp("2000"), pd.Timestamp("2001")],
diff --git a/pandas/tests/arrays/test_timedeltas.py b/pandas/tests/arrays/test_timedeltas.py
index c86b4f71ee592..a32529cb58ba3 100644
--- a/pandas/tests/arrays/test_timedeltas.py
+++ b/pandas/tests/arrays/test_timedeltas.py
@@ -46,7 +46,7 @@ def test_incorrect_dtype_raises(self):
TimedeltaArray(np.array([1, 2, 3], dtype="i8"), dtype="category")
with pytest.raises(
- ValueError, match=r"dtype int64 cannot be converted to timedelta64\[ns\]",
+ ValueError, match=r"dtype int64 cannot be converted to timedelta64\[ns\]"
):
TimedeltaArray(np.array([1, 2, 3], dtype="i8"), dtype=np.dtype("int64"))
diff --git a/pandas/tests/base/test_conversion.py b/pandas/tests/base/test_conversion.py
index b688a048cbe8e..b5595ba220a15 100644
--- a/pandas/tests/base/test_conversion.py
+++ b/pandas/tests/base/test_conversion.py
@@ -183,7 +183,7 @@ def test_iter_box(self):
PeriodArray,
pd.core.dtypes.dtypes.PeriodDtype("A-DEC"),
),
- (pd.IntervalIndex.from_breaks([0, 1, 2]), IntervalArray, "interval",),
+ (pd.IntervalIndex.from_breaks([0, 1, 2]), IntervalArray, "interval"),
# This test is currently failing for datetime64[ns] and timedelta64[ns].
# The NumPy type system is sufficient for representing these types, so
# we just use NumPy for Series / DataFrame columns of these types (so
@@ -285,10 +285,7 @@ def test_array_multiindex_raises():
pd.core.arrays.period_array(["2000", "2001"], freq="D"),
np.array([pd.Period("2000", freq="D"), pd.Period("2001", freq="D")]),
),
- (
- pd.core.arrays.integer_array([0, np.nan]),
- np.array([0, pd.NA], dtype=object),
- ),
+ (pd.core.arrays.integer_array([0, np.nan]), np.array([0, pd.NA], dtype=object)),
(
IntervalArray.from_breaks([0, 1, 2]),
np.array([pd.Interval(0, 1), pd.Interval(1, 2)], dtype=object),
diff --git a/pandas/tests/dtypes/test_missing.py b/pandas/tests/dtypes/test_missing.py
index 04dde08de082d..a642b23379c6f 100644
--- a/pandas/tests/dtypes/test_missing.py
+++ b/pandas/tests/dtypes/test_missing.py
@@ -373,7 +373,7 @@ def test_array_equivalent(dtype_equal):
)
# The rest are not dtype_equal
assert not array_equivalent(
- DatetimeIndex([0, np.nan]), DatetimeIndex([0, np.nan], tz="US/Eastern"),
+ DatetimeIndex([0, np.nan]), DatetimeIndex([0, np.nan], tz="US/Eastern")
)
assert not array_equivalent(
DatetimeIndex([0, np.nan], tz="CET"),
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index 5e1cf30efd534..23e20a2c0903a 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -92,18 +92,14 @@ def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting, na_valu
assert data_missing_for_sorting.argmax() == 0
assert data_missing_for_sorting.argmin() == 2
- @pytest.mark.parametrize(
- "method", ["argmax", "argmin"],
- )
+ @pytest.mark.parametrize("method", ["argmax", "argmin"])
def test_argmin_argmax_empty_array(self, method, data):
# GH 24382
err_msg = "attempt to get"
with pytest.raises(ValueError, match=err_msg):
getattr(data[:0], method)()
- @pytest.mark.parametrize(
- "method", ["argmax", "argmin"],
- )
+ @pytest.mark.parametrize("method", ["argmax", "argmin"])
def test_argmin_argmax_all_na(self, method, data, na_value):
# all missing with skipna=True is the same as emtpy
err_msg = "attempt to get"
diff --git a/pandas/tests/extension/test_sparse.py b/pandas/tests/extension/test_sparse.py
index b411ca1c482a4..d11cfd219a443 100644
--- a/pandas/tests/extension/test_sparse.py
+++ b/pandas/tests/extension/test_sparse.py
@@ -316,9 +316,7 @@ def test_shift_0_periods(self, data):
data._sparse_values[0] = data._sparse_values[1]
assert result._sparse_values[0] != result._sparse_values[1]
- @pytest.mark.parametrize(
- "method", ["argmax", "argmin"],
- )
+ @pytest.mark.parametrize("method", ["argmax", "argmin"])
def test_argmin_argmax_all_na(self, method, data, na_value):
# overriding because Sparse[int64, 0] cannot handle na_value
self._check_unsupported(data)
diff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py
index c5945edfd3127..8313ab0b99bac 100644
--- a/pandas/tests/frame/indexing/test_setitem.py
+++ b/pandas/tests/frame/indexing/test_setitem.py
@@ -108,7 +108,7 @@ def test_setitem_timestamp_empty_columns(self):
df["now"] = Timestamp("20130101", tz="UTC")
expected = DataFrame(
- [[Timestamp("20130101", tz="UTC")]] * 3, index=[0, 1, 2], columns=["now"],
+ [[Timestamp("20130101", tz="UTC")]] * 3, index=[0, 1, 2], columns=["now"]
)
tm.assert_frame_equal(df, expected)
@@ -158,11 +158,7 @@ def test_setitem_dict_preserves_dtypes(self):
}
)
for idx, b in enumerate([1, 2, 3]):
- df.loc[df.shape[0]] = {
- "a": int(idx),
- "b": float(b),
- "c": float(b),
- }
+ df.loc[df.shape[0]] = {"a": int(idx), "b": float(b), "c": float(b)}
tm.assert_frame_equal(df, expected)
@pytest.mark.parametrize(
| #35925
- pandas/tests/arrays/categorical/test_replace.py
- pandas/tests/arrays/sparse/test_array.py
- pandas/tests/arrays/test_array.py
- pandas/tests/arrays/test_timedeltas.py
- pandas/tests/base/test_conversion.py
- pandas/tests/dtypes/test_missing.py
- pandas/tests/extension/base/methods.py
- pandas/tests/extension/test_sparse.py
- pandas/tests/frame/indexing/test_setitem.py
please give me a feedback if there is something that I have to change.. thank you before | https://api.github.com/repos/pandas-dev/pandas/pulls/36193 | 2020-09-07T15:40:32Z | 2020-09-09T13:24:15Z | 2020-09-09T13:24:15Z | 2020-09-09T13:24:19Z |
TST: test_datetime64_factorize on 32bit | diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index ec7413514d430..a2c2ae22a0b62 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -256,7 +256,7 @@ def test_datetime64_factorize(self, writable):
# GH35650 Verify whether read-only datetime64 array can be factorized
data = np.array([np.datetime64("2020-01-01T00:00:00.000")])
data.setflags(write=writable)
- expected_codes = np.array([0], dtype=np.int64)
+ expected_codes = np.array([0], dtype=np.intp)
expected_uniques = np.array(
["2020-01-01T00:00:00.000000000"], dtype="datetime64[ns]"
)
| - [ ] closes #35921
- [ ] tests added / passed
- [ ] passes `black pandas`
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36192 | 2020-09-07T12:16:13Z | 2020-09-07T19:05:51Z | 2020-09-07T19:05:51Z | 2020-09-07T19:07:35Z |
TST: update test_series_factorize_na_sentinel_none for 32bit | diff --git a/pandas/tests/base/test_factorize.py b/pandas/tests/base/test_factorize.py
index 9fad9856d53cc..f8cbadb987d29 100644
--- a/pandas/tests/base/test_factorize.py
+++ b/pandas/tests/base/test_factorize.py
@@ -34,7 +34,7 @@ def test_series_factorize_na_sentinel_none():
ser = pd.Series(values)
codes, uniques = ser.factorize(na_sentinel=None)
- expected_codes = np.array([0, 1, 0, 2], dtype="int64")
+ expected_codes = np.array([0, 1, 0, 2], dtype=np.intp)
expected_uniques = pd.Index([1.0, 2.0, np.nan])
tm.assert_numpy_array_equal(codes, expected_codes)
| xref https://github.com/pandas-dev/pandas/issues/35831#issuecomment-688163069
(I've not tested this locally, after backport can retrigger https://github.com/MacPython/pandas-wheels/pull/97 to check) | https://api.github.com/repos/pandas-dev/pandas/pulls/36191 | 2020-09-07T12:11:14Z | 2020-09-07T19:39:16Z | 2020-09-07T19:39:16Z | 2020-09-07T19:41:30Z |
Backport PR #35882 on branch 1.1.x (BUG: item_cache invalidation in get_numeric_data) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index a0e57eb1729e1..8a4574af8f6a9 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -40,6 +40,7 @@ Bug fixes
- Bug in :class:`Series` constructor incorrectly raising a ``TypeError`` when passed an ordered set (:issue:`36044`)
- Bug in :meth:`Series.dt.isocalendar` and :meth:`DatetimeIndex.isocalendar` that returned incorrect year for certain dates (:issue:`36032`)
- Bug in :class:`DataFrame` indexing returning an incorrect :class:`Series` in some cases when the series has been altered and a cache not invalidated (:issue:`33675`)
+- Bug in :meth:`DataFrame.corr` causing subsequent indexing lookups to be incorrect (:issue:`35882`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index c4a866edba490..3f3f0c68cb1ed 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -732,7 +732,6 @@ def get_numeric_data(self, copy: bool = False) -> "BlockManager":
copy : bool, default False
Whether to copy the blocks
"""
- self._consolidate_inplace()
return self._combine([b for b in self.blocks if b.is_numeric], copy)
def _combine(self, blocks: List[Block], copy: bool = True) -> "BlockManager":
diff --git a/pandas/tests/frame/methods/test_cov_corr.py b/pandas/tests/frame/methods/test_cov_corr.py
index d3548b639572d..f307acd8c2178 100644
--- a/pandas/tests/frame/methods/test_cov_corr.py
+++ b/pandas/tests/frame/methods/test_cov_corr.py
@@ -191,6 +191,23 @@ def test_corr_nullable_integer(self, nullable_column, other_column, method):
expected = pd.DataFrame(np.ones((2, 2)), columns=["a", "b"], index=["a", "b"])
tm.assert_frame_equal(result, expected)
+ def test_corr_item_cache(self):
+ # Check that corr does not lead to incorrect entries in item_cache
+
+ df = pd.DataFrame({"A": range(10)})
+ df["B"] = range(10)[::-1]
+
+ ser = df["A"] # populate item_cache
+ assert len(df._mgr.blocks) == 2
+
+ _ = df.corr()
+
+ # Check that the corr didnt break link between ser and df
+ ser.values[0] = 99
+ assert df.loc[0, "A"] == 99
+ assert df["A"] is ser
+ assert df.values[0, 0] == 99
+
class TestDataFrameCorrWith:
def test_corrwith(self, datetime_frame):
| Backport PR #35882: BUG: item_cache invalidation in get_numeric_data | https://api.github.com/repos/pandas-dev/pandas/pulls/36188 | 2020-09-07T11:34:34Z | 2020-09-07T19:06:15Z | 2020-09-07T19:06:15Z | 2020-09-07T19:06:15Z |
DOC: move release note for #36155 | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index da261907565a1..e9cba3de56920 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -50,6 +50,7 @@ Bug fixes
Other
~~~~~
- :meth:`factorize` now supports ``na_sentinel=None`` to include NaN in the uniques of the values and remove ``dropna`` keyword which was unintentionally exposed to public facing API in 1.1 version from :meth:`factorize` (:issue:`35667`)
+- :meth:`DataFrame.plot` and meth:`Series.plot` raise ``UserWarning`` about usage of FixedFormatter and FixedLocator (:issue:`35684` and :issue:`35945`)
.. ---------------------------------------------------------------------------
diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index 9a778acba4764..ccaae9f996425 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -300,7 +300,6 @@ Plotting
^^^^^^^^
- Bug in :meth:`DataFrame.plot` where a marker letter in the ``style`` keyword sometimes causes a ``ValueError`` (:issue:`21003`)
-- meth:`DataFrame.plot` and meth:`Series.plot` raise ``UserWarning`` about usage of FixedFormatter and FixedLocator (:issue:`35684` and :issue:`35945`)
Groupby/resample/rolling
^^^^^^^^^^^^^^^^^^^^^^^^
| xref https://github.com/pandas-dev/pandas/pull/36155#issuecomment-687846461
does not need backport. release note already in 1.1.2 on backport branch | https://api.github.com/repos/pandas-dev/pandas/pulls/36187 | 2020-09-07T11:28:54Z | 2020-09-07T19:41:43Z | 2020-09-07T19:41:42Z | 2020-09-07T19:44:44Z |
BUG: pandas.DataFrame().stack() raise an error, while expected is empty | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index 6f046d3a9379d..f9e348b04e318 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -727,6 +727,8 @@ Reshaping
- Bug in :meth:`DataFrame.pivot_table` with ``aggfunc='count'`` or ``aggfunc='sum'`` returning ``NaN`` for missing categories when pivoted on a ``Categorical``. Now returning ``0`` (:issue:`31422`)
- Bug in :func:`concat` and :class:`DataFrame` constructor where input index names are not preserved in some cases (:issue:`13475`)
- Bug in func :meth:`crosstab` when using multiple columns with ``margins=True`` and ``normalize=True`` (:issue:`35144`)
+- Bug in :meth:`DataFrame.stack` where an empty DataFrame.stack would raise an error (:issue:`36113`). Now returning an empty Series with empty MultiIndex.
+- Bug in :meth:`Series.unstack`. Now a Series with single level of Index trying to unstack would raise a ValueError. (:issue:`36113`)
- Bug in :meth:`DataFrame.agg` with ``func={'name':<FUNC>}`` incorrectly raising ``TypeError`` when ``DataFrame.columns==['Name']`` (:issue:`36212`)
- Bug in :meth:`Series.transform` would give incorrect results or raise when the argument ``func`` was a dictionary (:issue:`35811`)
- Bug in :meth:`DataFrame.pivot` did not preserve :class:`MultiIndex` level names for columns when rows and columns are both multiindexed (:issue:`36360`)
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index 44e165b2d06ee..c197e142fecbc 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -399,6 +399,7 @@ def _unstack_multiple(data, clocs, fill_value=None):
def unstack(obj, level, fill_value=None):
+
if isinstance(level, (tuple, list)):
if len(level) != 1:
# _unstack_multiple only handles MultiIndexes,
@@ -416,6 +417,13 @@ def unstack(obj, level, fill_value=None):
return _unstack_frame(obj, level, fill_value=fill_value)
else:
return obj.T.stack(dropna=False)
+ elif not isinstance(obj.index, MultiIndex):
+ # GH 36113
+ # Give nicer error messages when unstack a Series whose
+ # Index is not a MultiIndex.
+ raise ValueError(
+ f"index must be a MultiIndex to unstack, {type(obj.index)} was passed"
+ )
else:
if is_extension_array_dtype(obj.dtype):
return _unstack_extension_series(obj, level, fill_value)
@@ -513,7 +521,7 @@ def factorize(index):
verify_integrity=False,
)
- if frame._is_homogeneous_type:
+ if not frame.empty and frame._is_homogeneous_type:
# For homogeneous EAs, frame._values will coerce to object. So
# we concatenate instead.
dtypes = list(frame.dtypes._values)
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
index 2a0da8b0fb35c..729f517c789a7 100644
--- a/pandas/core/sorting.py
+++ b/pandas/core/sorting.py
@@ -610,7 +610,7 @@ def compress_group_index(group_index, sort: bool = True):
if sort and len(obs_group_ids) > 0:
obs_group_ids, comp_ids = _reorder_by_uniques(obs_group_ids, comp_ids)
- return comp_ids, obs_group_ids
+ return ensure_int64(comp_ids), ensure_int64(obs_group_ids)
def _reorder_by_uniques(uniques, labels):
diff --git a/pandas/tests/frame/test_stack_unstack.py b/pandas/tests/frame/test_stack_unstack.py
index 3fa17c1764de3..c70bfc4a3602b 100644
--- a/pandas/tests/frame/test_stack_unstack.py
+++ b/pandas/tests/frame/test_stack_unstack.py
@@ -1175,6 +1175,32 @@ def test_stack_timezone_aware_values():
tm.assert_series_equal(result, expected)
+@pytest.mark.parametrize("dropna", [True, False])
+def test_stack_empty_frame(dropna):
+ # GH 36113
+ expected = Series(index=MultiIndex([[], []], [[], []]), dtype=np.float64)
+ result = DataFrame(dtype=np.float64).stack(dropna=dropna)
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+@pytest.mark.parametrize("fill_value", [None, 0])
+def test_stack_unstack_empty_frame(dropna, fill_value):
+ # GH 36113
+ result = (
+ DataFrame(dtype=np.int64).stack(dropna=dropna).unstack(fill_value=fill_value)
+ )
+ expected = DataFrame(dtype=np.int64)
+ tm.assert_frame_equal(result, expected)
+
+
+def test_unstack_single_index_series():
+ # GH 36113
+ msg = r"index must be a MultiIndex to unstack.*"
+ with pytest.raises(ValueError, match=msg):
+ Series(dtype=np.int64).unstack()
+
+
def test_unstacking_multi_index_df():
# see gh-30740
df = DataFrame(
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 5a28cd5c418f0..f9b2a02920841 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -4,8 +4,6 @@
import numpy as np
import pytest
-from pandas.compat import IS64
-
import pandas as pd
from pandas import (
Categorical,
@@ -2102,7 +2100,6 @@ def test_pivot_duplicates(self):
with pytest.raises(ValueError, match="duplicate entries"):
data.pivot("a", "b", "c")
- @pytest.mark.xfail(not IS64, reason="GH 36579: fail on 32-bit system")
def test_pivot_empty(self):
df = DataFrame(columns=["a", "b", "c"])
result = df.pivot("a", "b", "c")
| - [ ] closes #36113
- [ ] tests added / passed
- [ ] passes `black pandas`
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36185 | 2020-09-07T10:07:24Z | 2020-11-26T15:54:44Z | 2020-11-26T15:54:44Z | 2020-11-27T07:29:39Z |
DOC: Start 1.1.3 | diff --git a/doc/source/whatsnew/index.rst b/doc/source/whatsnew/index.rst
index 1827d151579a1..933ed3cb8babf 100644
--- a/doc/source/whatsnew/index.rst
+++ b/doc/source/whatsnew/index.rst
@@ -24,6 +24,7 @@ Version 1.1
.. toctree::
:maxdepth: 2
+ v1.1.3
v1.1.2
v1.1.1
v1.1.0
diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index 1e946d325ace1..5b692e0077452 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -57,4 +57,4 @@ Other
Contributors
~~~~~~~~~~~~
-.. contributors:: v1.1.1..v1.1.2|HEAD
+.. contributors:: v1.1.1..v1.1.2
diff --git a/doc/source/whatsnew/v1.1.3.rst b/doc/source/whatsnew/v1.1.3.rst
new file mode 100644
index 0000000000000..e3161012da5d1
--- /dev/null
+++ b/doc/source/whatsnew/v1.1.3.rst
@@ -0,0 +1,42 @@
+.. _whatsnew_113:
+
+What's new in 1.1.3 (??)
+------------------------
+
+These are the changes in pandas 1.1.3. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_113.regressions:
+
+Fixed regressions
+~~~~~~~~~~~~~~~~~
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_113.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_113.other:
+
+Other
+~~~~~
+-
+
+.. ---------------------------------------------------------------------------
+
+.. _whatsnew_113.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v1.1.2..v1.1.3|HEAD
| pr for tomorrow | https://api.github.com/repos/pandas-dev/pandas/pulls/36183 | 2020-09-07T09:10:51Z | 2020-09-08T22:43:53Z | 2020-09-08T22:43:53Z | 2020-09-09T08:37:11Z |
DOC: release date for 1.1.2 | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index 0e4a88f3ee56b..a214ad9762733 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -1,7 +1,7 @@
.. _whatsnew_112:
-What's new in 1.1.2 (??)
-------------------------
+What's new in 1.1.2 (September 8, 2020)
+---------------------------------------
These are the changes in pandas 1.1.2. See :ref:`release` for a full changelog
including other versions of pandas.
| pr for tomorrow | https://api.github.com/repos/pandas-dev/pandas/pulls/36182 | 2020-09-07T09:03:18Z | 2020-09-08T11:50:14Z | 2020-09-08T11:50:14Z | 2020-09-09T08:46:02Z |
REF: use _validate_foo pattern in Categorical | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 02305479bef67..228e630f95863 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1192,6 +1192,26 @@ def map(self, mapper):
__le__ = _cat_compare_op(operator.le)
__ge__ = _cat_compare_op(operator.ge)
+ def _validate_insert_value(self, value) -> int:
+ code = self.categories.get_indexer([value])
+ if (code == -1) and not (is_scalar(value) and isna(value)):
+ raise TypeError(
+ "cannot insert an item into a CategoricalIndex "
+ "that is not already an existing category"
+ )
+ return code[0]
+
+ def _validate_searchsorted_value(self, value):
+ # searchsorted is very performance sensitive. By converting codes
+ # to same dtype as self.codes, we get much faster performance.
+ if is_scalar(value):
+ codes = self.categories.get_loc(value)
+ codes = self.codes.dtype.type(codes)
+ else:
+ locs = [self.categories.get_loc(x) for x in value]
+ codes = np.array(locs, dtype=self.codes.dtype)
+ return codes
+
def _validate_fill_value(self, fill_value):
"""
Convert a user-facing fill_value to a representation to use with our
@@ -1299,15 +1319,8 @@ def memory_usage(self, deep=False):
@doc(_shared_docs["searchsorted"], klass="Categorical")
def searchsorted(self, value, side="left", sorter=None):
- # searchsorted is very performance sensitive. By converting codes
- # to same dtype as self.codes, we get much faster performance.
- if is_scalar(value):
- codes = self.categories.get_loc(value)
- codes = self.codes.dtype.type(codes)
- else:
- locs = [self.categories.get_loc(x) for x in value]
- codes = np.array(locs, dtype=self.codes.dtype)
- return self.codes.searchsorted(codes, side=side, sorter=sorter)
+ value = self._validate_searchsorted_value(value)
+ return self.codes.searchsorted(value, side=side, sorter=sorter)
def isna(self):
"""
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index cbb30763797d1..d38f77aaceb01 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -20,7 +20,7 @@
pandas_dtype,
)
from pandas.core.dtypes.dtypes import CategoricalDtype
-from pandas.core.dtypes.missing import is_valid_nat_for_dtype, isna, notna
+from pandas.core.dtypes.missing import is_valid_nat_for_dtype, notna
from pandas.core import accessor
from pandas.core.algorithms import take_1d
@@ -734,15 +734,10 @@ def insert(self, loc: int, item):
ValueError if the item is not in the categories
"""
- code = self.categories.get_indexer([item])
- if (code == -1) and not (is_scalar(item) and isna(item)):
- raise TypeError(
- "cannot insert an item into a CategoricalIndex "
- "that is not already an existing category"
- )
+ code = self._data._validate_insert_value(item)
codes = self.codes
- codes = np.concatenate((codes[:loc], code, codes[loc:]))
+ codes = np.concatenate((codes[:loc], [code], codes[loc:]))
return self._create_from_codes(codes)
def _concat(self, to_concat, name):
| Similar to how we did it in datetimelike, eventually these validator methods are going to end up sharing most of their code | https://api.github.com/repos/pandas-dev/pandas/pulls/36181 | 2020-09-07T02:57:23Z | 2020-09-07T19:56:19Z | 2020-09-07T19:56:18Z | 2020-09-07T20:10:41Z |
REF: implement Categorical._validate_setitem_value | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 58847528d2183..b732db4c66003 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -9,7 +9,7 @@
from pandas._config import get_option
-from pandas._libs import NaT, algos as libalgos, hashtable as htable
+from pandas._libs import NaT, algos as libalgos, hashtable as htable, lib
from pandas._typing import ArrayLike, Dtype, Ordered, Scalar
from pandas.compat.numpy import function as nv
from pandas.util._decorators import cache_readonly, deprecate_kwarg, doc
@@ -1868,14 +1868,6 @@ def __repr__(self) -> str:
# ------------------------------------------------------------------
- def _maybe_coerce_indexer(self, indexer):
- """
- return an indexer coerced to the codes dtype
- """
- if isinstance(indexer, np.ndarray) and indexer.dtype.kind == "i":
- indexer = indexer.astype(self._codes.dtype)
- return indexer
-
def __getitem__(self, key):
"""
Return an item.
@@ -1905,6 +1897,11 @@ def __setitem__(self, key, value):
If (one or more) Value is not in categories or if a assigned
`Categorical` does not have the same categories
"""
+ key = self._validate_setitem_key(key)
+ value = self._validate_setitem_value(value)
+ self._ndarray[key] = value
+
+ def _validate_setitem_value(self, value):
value = extract_array(value, extract_numpy=True)
# require identical categories set
@@ -1934,12 +1931,19 @@ def __setitem__(self, key, value):
"category, set the categories first"
)
- # set by position
- if isinstance(key, (int, np.integer)):
+ lindexer = self.categories.get_indexer(rvalue)
+ if isinstance(lindexer, np.ndarray) and lindexer.dtype.kind == "i":
+ lindexer = lindexer.astype(self._ndarray.dtype)
+
+ return lindexer
+
+ def _validate_setitem_key(self, key):
+ if lib.is_integer(key):
+ # set by position
pass
- # tuple of indexers (dataframe)
elif isinstance(key, tuple):
+ # tuple of indexers (dataframe)
# only allow 1 dimensional slicing, but can
# in a 2-d case be passed (slice(None),....)
if len(key) == 2:
@@ -1951,17 +1955,14 @@ def __setitem__(self, key, value):
else:
raise AssertionError("invalid slicing for a 1-ndim categorical")
- # slicing in Series or Categorical
elif isinstance(key, slice):
+ # slicing in Series or Categorical
pass
# else: array of True/False in Series or Categorical
- lindexer = self.categories.get_indexer(rvalue)
- lindexer = self._maybe_coerce_indexer(lindexer)
-
key = check_array_indexer(self, key)
- self._codes[key] = lindexer
+ return key
def _reverse_indexer(self) -> Dict[Hashable, np.ndarray]:
"""
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index a218745db0a44..2626890c2dbe5 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -546,6 +546,15 @@ def __getitem__(self, key):
return self._box_func(result)
return self._simple_new(result, dtype=self.dtype)
+ key = self._validate_getitem_key(key)
+ result = self._ndarray[key]
+ if lib.is_scalar(result):
+ return self._box_func(result)
+
+ freq = self._get_getitem_freq(key)
+ return self._simple_new(result, dtype=self.dtype, freq=freq)
+
+ def _validate_getitem_key(self, key):
if com.is_bool_indexer(key):
# first convert to boolean, because check_array_indexer doesn't
# allow object dtype
@@ -560,12 +569,7 @@ def __getitem__(self, key):
pass
else:
key = check_array_indexer(self, key)
-
- freq = self._get_getitem_freq(key)
- result = self._ndarray[key]
- if lib.is_scalar(result):
- return self._box_func(result)
- return self._simple_new(result, dtype=self.dtype, freq=freq)
+ return key
def _get_getitem_freq(self, key):
"""
| Moving towards sharing more methods | https://api.github.com/repos/pandas-dev/pandas/pulls/36180 | 2020-09-07T02:28:46Z | 2020-09-07T22:41:00Z | 2020-09-07T22:41:00Z | 2020-09-08T00:12:46Z |
DEPR: string indexing along index for datetimes | diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index 32f0cac3f81e2..868bf5a1672ff 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -579,7 +579,12 @@ This type of slicing will work on a ``DataFrame`` with a ``DatetimeIndex`` as we
partial string selection is a form of label slicing, the endpoints **will be** included. This
would include matching times on an included date:
+.. warning::
+
+ Indexing ``DataFrame`` rows with strings is deprecated in pandas 1.2.0 and will be removed in a future version. Use ``frame.loc[dtstring]`` instead.
+
.. ipython:: python
+ :okwarning:
dft = pd.DataFrame(np.random.randn(100000, 1), columns=['A'],
index=pd.date_range('20130101', periods=100000, freq='T'))
@@ -590,24 +595,28 @@ This starts on the very first time in the month, and includes the last date and
time for the month:
.. ipython:: python
+ :okwarning:
dft['2013-1':'2013-2']
This specifies a stop time **that includes all of the times on the last day**:
.. ipython:: python
+ :okwarning:
dft['2013-1':'2013-2-28']
This specifies an **exact** stop time (and is not the same as the above):
.. ipython:: python
+ :okwarning:
dft['2013-1':'2013-2-28 00:00:00']
We are stopping on the included end-point as it is part of the index:
.. ipython:: python
+ :okwarning:
dft['2013-1-15':'2013-1-15 12:30:00']
@@ -631,6 +640,7 @@ We are stopping on the included end-point as it is part of the index:
Slicing with string indexing also honors UTC offset.
.. ipython:: python
+ :okwarning:
df = pd.DataFrame([0], index=pd.DatetimeIndex(['2019-01-01'], tz='US/Pacific'))
df
@@ -681,6 +691,7 @@ If index resolution is second, then the minute-accurate timestamp gives a
If the timestamp string is treated as a slice, it can be used to index ``DataFrame`` with ``[]`` as well.
.. ipython:: python
+ :okwarning:
dft_minute = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]},
index=series_minute.index)
@@ -2027,6 +2038,7 @@ You can pass in dates and strings to ``Series`` and ``DataFrame`` with ``PeriodI
Passing a string representing a lower frequency than ``PeriodIndex`` returns partial sliced data.
.. ipython:: python
+ :okwarning:
ps['2011']
diff --git a/doc/source/whatsnew/v0.11.0.rst b/doc/source/whatsnew/v0.11.0.rst
index 6c13a125a4e54..c0bc74c9ff036 100644
--- a/doc/source/whatsnew/v0.11.0.rst
+++ b/doc/source/whatsnew/v0.11.0.rst
@@ -367,6 +367,7 @@ Enhancements
- You can now select with a string from a DataFrame with a datelike index, in a similar way to a Series (:issue:`3070`)
.. ipython:: python
+ :okwarning:
idx = pd.date_range("2001-10-1", periods=5, freq='M')
ts = pd.Series(np.random.rand(len(idx)), index=idx)
diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index 7ba64f57be136..782e7fe16a2dc 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -213,6 +213,7 @@ Deprecations
- Date parser functions :func:`~pandas.io.date_converters.parse_date_time`, :func:`~pandas.io.date_converters.parse_date_fields`, :func:`~pandas.io.date_converters.parse_all_fields` and :func:`~pandas.io.date_converters.generic_parser` from ``pandas.io.date_converters`` are deprecated and will be removed in a future version; use :func:`to_datetime` instead (:issue:`35741`)
- :meth:`DataFrame.lookup` is deprecated and will be removed in a future version, use :meth:`DataFrame.melt` and :meth:`DataFrame.loc` instead (:issue:`18682`)
- The :meth:`Index.to_native_types` is deprecated. Use ``.astype(str)`` instead (:issue:`28867`)
+- Deprecated indexing :class:`DataFrame` rows with datetime-like strings ``df[string]``, use ``df.loc[string]`` instead (:issue:`36179`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 5f57fe1c9a56a..8aef150078e5b 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -1,4 +1,5 @@
from typing import TYPE_CHECKING, Hashable, List, Tuple, Union
+import warnings
import numpy as np
@@ -2191,7 +2192,15 @@ def convert_to_index_sliceable(obj: "DataFrame", key):
# slice here via partial string indexing
if idx._supports_partial_string_indexing:
try:
- return idx._get_string_slice(key)
+ res = idx._get_string_slice(key)
+ warnings.warn(
+ "Indexing on datetimelike rows with `frame[string]` is "
+ "deprecated and will be removed in a future version. "
+ "Use `frame.loc[string]` instead.",
+ FutureWarning,
+ stacklevel=3,
+ )
+ return res
except (KeyError, ValueError, NotImplementedError):
return None
diff --git a/pandas/tests/indexes/datetimes/test_partial_slicing.py b/pandas/tests/indexes/datetimes/test_partial_slicing.py
index 635470b930252..57dc46e1fb415 100644
--- a/pandas/tests/indexes/datetimes/test_partial_slicing.py
+++ b/pandas/tests/indexes/datetimes/test_partial_slicing.py
@@ -228,7 +228,9 @@ def test_partial_slicing_dataframe(self):
tm.assert_series_equal(result, expected)
# Frame should return slice as well
- result = df[ts_string]
+ with tm.assert_produces_warning(FutureWarning):
+ # GH#36179 deprecated this indexing
+ result = df[ts_string]
expected = df[theslice]
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/series/indexing/test_datetime.py b/pandas/tests/series/indexing/test_datetime.py
index 088f8681feb99..b7fbed2b325b3 100644
--- a/pandas/tests/series/indexing/test_datetime.py
+++ b/pandas/tests/series/indexing/test_datetime.py
@@ -1,3 +1,6 @@
+"""
+Also test support for datetime64[ns] in Series / DataFrame
+"""
from datetime import datetime, timedelta
import re
@@ -11,10 +14,6 @@
from pandas import DataFrame, DatetimeIndex, NaT, Series, Timestamp, date_range
import pandas._testing as tm
-"""
-Also test support for datetime64[ns] in Series / DataFrame
-"""
-
def test_fancy_getitem():
dti = date_range(
@@ -605,7 +604,9 @@ def test_indexing():
expected.name = "A"
df = DataFrame(dict(A=ts))
- result = df["2001"]["A"]
+ with tm.assert_produces_warning(FutureWarning):
+ # GH#36179 string indexing on rows for DataFrame deprecated
+ result = df["2001"]["A"]
tm.assert_series_equal(expected, result)
# setting
@@ -615,7 +616,9 @@ def test_indexing():
df.loc["2001", "A"] = 1
- result = df["2001"]["A"]
+ with tm.assert_produces_warning(FutureWarning):
+ # GH#36179 string indexing on rows for DataFrame deprecated
+ result = df["2001"]["A"]
tm.assert_series_equal(expected, result)
# GH3546 (not including times on the last day)
| - [x] closes #31476
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Let's get ourselves one less special case to worry about | https://api.github.com/repos/pandas-dev/pandas/pulls/36179 | 2020-09-07T02:21:18Z | 2020-09-24T19:57:39Z | 2020-09-24T19:57:39Z | 2020-09-27T01:04:33Z |
STY: de-privatize names imported across modules | diff --git a/pandas/__init__.py b/pandas/__init__.py
index 2737bcd8f9ccf..70bb0c8a2cb51 100644
--- a/pandas/__init__.py
+++ b/pandas/__init__.py
@@ -20,9 +20,9 @@
# numpy compat
from pandas.compat.numpy import (
- _np_version_under1p17,
- _np_version_under1p18,
- _is_numpy_dev,
+ np_version_under1p17 as _np_version_under1p17,
+ np_version_under1p18 as _np_version_under1p18,
+ is_numpy_dev as _is_numpy_dev,
)
try:
diff --git a/pandas/_testing.py b/pandas/_testing.py
index 7dba578951deb..9db0c3496e290 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing.py
@@ -2713,7 +2713,7 @@ def use_numexpr(use, min_elements=None):
if min_elements is None:
min_elements = expr._MIN_ELEMENTS
- olduse = expr._USE_NUMEXPR
+ olduse = expr.USE_NUMEXPR
oldmin = expr._MIN_ELEMENTS
expr.set_use_numexpr(use)
expr._MIN_ELEMENTS = min_elements
diff --git a/pandas/compat/numpy/__init__.py b/pandas/compat/numpy/__init__.py
index 08d06da93bb45..a2444b7ba5a0d 100644
--- a/pandas/compat/numpy/__init__.py
+++ b/pandas/compat/numpy/__init__.py
@@ -8,11 +8,11 @@
# numpy versioning
_np_version = np.__version__
_nlv = LooseVersion(_np_version)
-_np_version_under1p17 = _nlv < LooseVersion("1.17")
-_np_version_under1p18 = _nlv < LooseVersion("1.18")
+np_version_under1p17 = _nlv < LooseVersion("1.17")
+np_version_under1p18 = _nlv < LooseVersion("1.18")
_np_version_under1p19 = _nlv < LooseVersion("1.19")
_np_version_under1p20 = _nlv < LooseVersion("1.20")
-_is_numpy_dev = ".dev" in str(_nlv)
+is_numpy_dev = ".dev" in str(_nlv)
_min_numpy_ver = "1.16.5"
@@ -65,6 +65,6 @@ def np_array_datetime64_compat(arr, *args, **kwargs):
__all__ = [
"np",
"_np_version",
- "_np_version_under1p17",
- "_is_numpy_dev",
+ "np_version_under1p17",
+ "is_numpy_dev",
]
diff --git a/pandas/core/array_algos/masked_reductions.py b/pandas/core/array_algos/masked_reductions.py
index 1b9ed014f27b7..3f4625e2b712a 100644
--- a/pandas/core/array_algos/masked_reductions.py
+++ b/pandas/core/array_algos/masked_reductions.py
@@ -8,7 +8,7 @@
import numpy as np
from pandas._libs import missing as libmissing
-from pandas.compat.numpy import _np_version_under1p17
+from pandas.compat.numpy import np_version_under1p17
from pandas.core.nanops import check_below_min_count
@@ -46,7 +46,7 @@ def _sumprod(
if check_below_min_count(values.shape, mask, min_count):
return libmissing.NA
- if _np_version_under1p17:
+ if np_version_under1p17:
return func(values[~mask])
else:
return func(values, where=~mask)
diff --git a/pandas/core/arrays/sparse/accessor.py b/pandas/core/arrays/sparse/accessor.py
index da8d695c59b9e..ec4b0fd89860c 100644
--- a/pandas/core/arrays/sparse/accessor.py
+++ b/pandas/core/arrays/sparse/accessor.py
@@ -88,9 +88,9 @@ def from_coo(cls, A, dense_index=False):
dtype: Sparse[float64, nan]
"""
from pandas import Series
- from pandas.core.arrays.sparse.scipy_sparse import _coo_to_sparse_series
+ from pandas.core.arrays.sparse.scipy_sparse import coo_to_sparse_series
- result = _coo_to_sparse_series(A, dense_index=dense_index)
+ result = coo_to_sparse_series(A, dense_index=dense_index)
result = Series(result.array, index=result.index, copy=False)
return result
@@ -168,9 +168,9 @@ def to_coo(self, row_levels=(0,), column_levels=(1,), sort_labels=False):
>>> columns
[('a', 0), ('a', 1), ('b', 0), ('b', 1)]
"""
- from pandas.core.arrays.sparse.scipy_sparse import _sparse_series_to_coo
+ from pandas.core.arrays.sparse.scipy_sparse import sparse_series_to_coo
- A, rows, columns = _sparse_series_to_coo(
+ A, rows, columns = sparse_series_to_coo(
self._parent, row_levels, column_levels, sort_labels=sort_labels
)
return A, rows, columns
diff --git a/pandas/core/arrays/sparse/scipy_sparse.py b/pandas/core/arrays/sparse/scipy_sparse.py
index eafd782dc9b9c..56c678c88b9c7 100644
--- a/pandas/core/arrays/sparse/scipy_sparse.py
+++ b/pandas/core/arrays/sparse/scipy_sparse.py
@@ -85,7 +85,7 @@ def _get_index_subset_to_coord_dict(index, subset, sort_labels=False):
return values, i_coord, j_coord, i_labels, j_labels
-def _sparse_series_to_coo(ss, row_levels=(0,), column_levels=(1,), sort_labels=False):
+def sparse_series_to_coo(ss, row_levels=(0,), column_levels=(1,), sort_labels=False):
"""
Convert a sparse Series to a scipy.sparse.coo_matrix using index
levels row_levels, column_levels as the row and column
@@ -113,7 +113,7 @@ def _sparse_series_to_coo(ss, row_levels=(0,), column_levels=(1,), sort_labels=F
return sparse_matrix, rows, columns
-def _coo_to_sparse_series(A, dense_index: bool = False):
+def coo_to_sparse_series(A, dense_index: bool = False):
"""
Convert a scipy.sparse.coo_matrix to a SparseSeries.
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 279d512e5a046..968fb180abcd0 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -16,7 +16,7 @@
from pandas._libs import lib, tslibs
from pandas._typing import AnyArrayLike, Scalar, T
-from pandas.compat.numpy import _np_version_under1p18
+from pandas.compat.numpy import np_version_under1p18
from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
from pandas.core.dtypes.common import (
@@ -425,7 +425,7 @@ def random_state(state=None):
if (
is_integer(state)
or is_array_like(state)
- or (not _np_version_under1p18 and isinstance(state, np.random.BitGenerator))
+ or (not np_version_under1p18 and isinstance(state, np.random.BitGenerator))
):
return np.random.RandomState(state)
elif isinstance(state, np.random.RandomState):
diff --git a/pandas/core/computation/engines.py b/pandas/core/computation/engines.py
index 9c5388faae1bd..0cdc0f530a7f3 100644
--- a/pandas/core/computation/engines.py
+++ b/pandas/core/computation/engines.py
@@ -6,11 +6,11 @@
from typing import Dict, Type
from pandas.core.computation.align import align_terms, reconstruct_object
-from pandas.core.computation.ops import _mathops, _reductions
+from pandas.core.computation.ops import MATHOPS, REDUCTIONS
import pandas.io.formats.printing as printing
-_ne_builtins = frozenset(_mathops + _reductions)
+_ne_builtins = frozenset(MATHOPS + REDUCTIONS)
class NumExprClobberingError(NameError):
diff --git a/pandas/core/computation/expr.py b/pandas/core/computation/expr.py
index df71b4fe415f8..8cff6abc071ca 100644
--- a/pandas/core/computation/expr.py
+++ b/pandas/core/computation/expr.py
@@ -12,7 +12,13 @@
import pandas.core.common as com
from pandas.core.computation.ops import (
- _LOCAL_TAG,
+ ARITH_OPS_SYMS,
+ BOOL_OPS_SYMS,
+ CMP_OPS_SYMS,
+ LOCAL_TAG,
+ MATHOPS,
+ REDUCTIONS,
+ UNARY_OPS_SYMS,
BinOp,
Constant,
Div,
@@ -21,12 +27,6 @@
Term,
UnaryOp,
UndefinedVariableError,
- _arith_ops_syms,
- _bool_ops_syms,
- _cmp_ops_syms,
- _mathops,
- _reductions,
- _unary_ops_syms,
is_term,
)
from pandas.core.computation.parsing import clean_backtick_quoted_toks, tokenize_string
@@ -101,7 +101,7 @@ def _replace_locals(tok: Tuple[int, str]) -> Tuple[int, str]:
"""
toknum, tokval = tok
if toknum == tokenize.OP and tokval == "@":
- return tokenize.OP, _LOCAL_TAG
+ return tokenize.OP, LOCAL_TAG
return toknum, tokval
@@ -338,7 +338,7 @@ class BaseExprVisitor(ast.NodeVisitor):
const_type: Type[Term] = Constant
term_type = Term
- binary_ops = _cmp_ops_syms + _bool_ops_syms + _arith_ops_syms
+ binary_ops = CMP_OPS_SYMS + BOOL_OPS_SYMS + ARITH_OPS_SYMS
binary_op_nodes = (
"Gt",
"Lt",
@@ -362,7 +362,7 @@ class BaseExprVisitor(ast.NodeVisitor):
)
binary_op_nodes_map = dict(zip(binary_ops, binary_op_nodes))
- unary_ops = _unary_ops_syms
+ unary_ops = UNARY_OPS_SYMS
unary_op_nodes = "UAdd", "USub", "Invert", "Not"
unary_op_nodes_map = {k: v for k, v in zip(unary_ops, unary_op_nodes)}
@@ -494,7 +494,7 @@ def _maybe_evaluate_binop(
if self.engine != "pytables":
if (
- res.op in _cmp_ops_syms
+ res.op in CMP_OPS_SYMS
and getattr(lhs, "is_datetime", False)
or getattr(rhs, "is_datetime", False)
):
@@ -726,7 +726,7 @@ def visitor(x, y):
_python_not_supported = frozenset(["Dict", "BoolOp", "In", "NotIn"])
-_numexpr_supported_calls = frozenset(_reductions + _mathops)
+_numexpr_supported_calls = frozenset(REDUCTIONS + MATHOPS)
@disallow(
diff --git a/pandas/core/computation/expressions.py b/pandas/core/computation/expressions.py
index d2c08c343ab4b..0032fe97b8b33 100644
--- a/pandas/core/computation/expressions.py
+++ b/pandas/core/computation/expressions.py
@@ -23,7 +23,7 @@
_TEST_MODE = None
_TEST_RESULT: List[bool] = list()
-_USE_NUMEXPR = NUMEXPR_INSTALLED
+USE_NUMEXPR = NUMEXPR_INSTALLED
_evaluate = None
_where = None
@@ -39,21 +39,21 @@
def set_use_numexpr(v=True):
# set/unset to use numexpr
- global _USE_NUMEXPR
+ global USE_NUMEXPR
if NUMEXPR_INSTALLED:
- _USE_NUMEXPR = v
+ USE_NUMEXPR = v
# choose what we are going to do
global _evaluate, _where
- _evaluate = _evaluate_numexpr if _USE_NUMEXPR else _evaluate_standard
- _where = _where_numexpr if _USE_NUMEXPR else _where_standard
+ _evaluate = _evaluate_numexpr if USE_NUMEXPR else _evaluate_standard
+ _where = _where_numexpr if USE_NUMEXPR else _where_standard
def set_numexpr_threads(n=None):
# if we are using numexpr, set the threads to n
# otherwise reset
- if NUMEXPR_INSTALLED and _USE_NUMEXPR:
+ if NUMEXPR_INSTALLED and USE_NUMEXPR:
if n is None:
n = ne.detect_number_of_cores()
ne.set_num_threads(n)
diff --git a/pandas/core/computation/ops.py b/pandas/core/computation/ops.py
index 1fb3910b8577d..5759cd17476d6 100644
--- a/pandas/core/computation/ops.py
+++ b/pandas/core/computation/ops.py
@@ -16,11 +16,11 @@
import pandas.core.common as com
from pandas.core.computation.common import ensure_decoded, result_type_many
-from pandas.core.computation.scope import _DEFAULT_GLOBALS
+from pandas.core.computation.scope import DEFAULT_GLOBALS
from pandas.io.formats.printing import pprint_thing, pprint_thing_encoded
-_reductions = ("sum", "prod")
+REDUCTIONS = ("sum", "prod")
_unary_math_ops = (
"sin",
@@ -46,10 +46,10 @@
)
_binary_math_ops = ("arctan2",)
-_mathops = _unary_math_ops + _binary_math_ops
+MATHOPS = _unary_math_ops + _binary_math_ops
-_LOCAL_TAG = "__pd_eval_local_"
+LOCAL_TAG = "__pd_eval_local_"
class UndefinedVariableError(NameError):
@@ -80,13 +80,13 @@ def __init__(self, name, env, side=None, encoding=None):
self.env = env
self.side = side
tname = str(name)
- self.is_local = tname.startswith(_LOCAL_TAG) or tname in _DEFAULT_GLOBALS
+ self.is_local = tname.startswith(LOCAL_TAG) or tname in DEFAULT_GLOBALS
self._value = self._resolve_name()
self.encoding = encoding
@property
def local_name(self) -> str:
- return self.name.replace(_LOCAL_TAG, "")
+ return self.name.replace(LOCAL_TAG, "")
def __repr__(self) -> str:
return pprint_thing(self.name)
@@ -220,7 +220,7 @@ def __repr__(self) -> str:
@property
def return_type(self):
# clobber types to bool if the op is a boolean operator
- if self.op in (_cmp_ops_syms + _bool_ops_syms):
+ if self.op in (CMP_OPS_SYMS + BOOL_OPS_SYMS):
return np.bool_
return result_type_many(*(term.type for term in com.flatten(self)))
@@ -280,7 +280,7 @@ def _not_in(x, y):
return x not in y
-_cmp_ops_syms = (">", "<", ">=", "<=", "==", "!=", "in", "not in")
+CMP_OPS_SYMS = (">", "<", ">=", "<=", "==", "!=", "in", "not in")
_cmp_ops_funcs = (
operator.gt,
operator.lt,
@@ -291,13 +291,13 @@ def _not_in(x, y):
_in,
_not_in,
)
-_cmp_ops_dict = dict(zip(_cmp_ops_syms, _cmp_ops_funcs))
+_cmp_ops_dict = dict(zip(CMP_OPS_SYMS, _cmp_ops_funcs))
-_bool_ops_syms = ("&", "|", "and", "or")
+BOOL_OPS_SYMS = ("&", "|", "and", "or")
_bool_ops_funcs = (operator.and_, operator.or_, operator.and_, operator.or_)
-_bool_ops_dict = dict(zip(_bool_ops_syms, _bool_ops_funcs))
+_bool_ops_dict = dict(zip(BOOL_OPS_SYMS, _bool_ops_funcs))
-_arith_ops_syms = ("+", "-", "*", "/", "**", "//", "%")
+ARITH_OPS_SYMS = ("+", "-", "*", "/", "**", "//", "%")
_arith_ops_funcs = (
operator.add,
operator.sub,
@@ -307,12 +307,12 @@ def _not_in(x, y):
operator.floordiv,
operator.mod,
)
-_arith_ops_dict = dict(zip(_arith_ops_syms, _arith_ops_funcs))
+_arith_ops_dict = dict(zip(ARITH_OPS_SYMS, _arith_ops_funcs))
-_special_case_arith_ops_syms = ("**", "//", "%")
+SPECIAL_CASE_ARITH_OPS_SYMS = ("**", "//", "%")
_special_case_arith_ops_funcs = (operator.pow, operator.floordiv, operator.mod)
_special_case_arith_ops_dict = dict(
- zip(_special_case_arith_ops_syms, _special_case_arith_ops_funcs)
+ zip(SPECIAL_CASE_ARITH_OPS_SYMS, _special_case_arith_ops_funcs)
)
_binary_ops_dict = {}
@@ -530,9 +530,9 @@ def __init__(self, lhs, rhs):
_cast_inplace(com.flatten(self), acceptable_dtypes, np.float_)
-_unary_ops_syms = ("+", "-", "~", "not")
+UNARY_OPS_SYMS = ("+", "-", "~", "not")
_unary_ops_funcs = (operator.pos, operator.neg, operator.invert, operator.invert)
-_unary_ops_dict = dict(zip(_unary_ops_syms, _unary_ops_funcs))
+_unary_ops_dict = dict(zip(UNARY_OPS_SYMS, _unary_ops_funcs))
class UnaryOp(Op):
@@ -561,7 +561,7 @@ def __init__(self, op: str, operand):
except KeyError as err:
raise ValueError(
f"Invalid unary operator {repr(op)}, "
- f"valid operators are {_unary_ops_syms}"
+ f"valid operators are {UNARY_OPS_SYMS}"
) from err
def __call__(self, env):
@@ -602,7 +602,7 @@ class FuncNode:
def __init__(self, name: str):
from pandas.core.computation.check import NUMEXPR_INSTALLED, NUMEXPR_VERSION
- if name not in _mathops or (
+ if name not in MATHOPS or (
NUMEXPR_INSTALLED
and NUMEXPR_VERSION < LooseVersion("2.6.9")
and name in ("floor", "ceil")
diff --git a/pandas/core/computation/scope.py b/pandas/core/computation/scope.py
index 83bf92ad737e4..2925f583bfc56 100644
--- a/pandas/core/computation/scope.py
+++ b/pandas/core/computation/scope.py
@@ -53,7 +53,7 @@ def _raw_hex_id(obj) -> str:
return "".join(_replacer(x) for x in packed)
-_DEFAULT_GLOBALS = {
+DEFAULT_GLOBALS = {
"Timestamp": Timestamp,
"datetime": datetime.datetime,
"True": True,
@@ -114,7 +114,7 @@ def __init__(
# shallow copy because we don't want to keep filling this up with what
# was there before if there are multiple calls to Scope/_ensure_scope
- self.scope = DeepChainMap(_DEFAULT_GLOBALS.copy())
+ self.scope = DeepChainMap(DEFAULT_GLOBALS.copy())
self.target = target
if isinstance(local_dict, Scope):
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 7c5aafcbbc7e9..8f9c0cf7a01db 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -22,9 +22,9 @@
from pandas.util._validators import validate_bool_kwarg
from pandas.core.dtypes.common import (
- _POSSIBLY_CAST_DTYPES,
DT64NS_DTYPE,
INT64_DTYPE,
+ POSSIBLY_CAST_DTYPES,
TD64NS_DTYPE,
ensure_int8,
ensure_int16,
@@ -1188,7 +1188,7 @@ def maybe_castable(arr) -> bool:
elif kind == "m":
return is_timedelta64_ns_dtype(arr.dtype)
- return arr.dtype.name not in _POSSIBLY_CAST_DTYPES
+ return arr.dtype.name not in POSSIBLY_CAST_DTYPES
def maybe_infer_to_datetimelike(value, convert_dates: bool = False):
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index 6ad46eb967275..5987fdabf78bb 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -43,7 +43,7 @@
is_sequence,
)
-_POSSIBLY_CAST_DTYPES = {
+POSSIBLY_CAST_DTYPES = {
np.dtype(t).name
for t in [
"O",
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 93c945638a174..40f0c6200e835 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -102,7 +102,7 @@
import pandas.core.indexing as indexing
from pandas.core.internals import BlockManager
from pandas.core.missing import find_valid_index
-from pandas.core.ops import _align_method_FRAME
+from pandas.core.ops import align_method_FRAME
from pandas.core.shared_docs import _shared_docs
from pandas.core.window import Expanding, ExponentialMovingWindow, Rolling, Window
@@ -7402,7 +7402,7 @@ def _clip_with_one_bound(self, threshold, method, axis, inplace):
if isinstance(self, ABCSeries):
threshold = self._constructor(threshold, index=self.index)
else:
- threshold = _align_method_FRAME(self, threshold, axis, flex=None)[1]
+ threshold = align_method_FRAME(self, threshold, axis, flex=None)[1]
return self.where(subset, threshold, axis=axis, inplace=inplace)
def clip(
diff --git a/pandas/core/index.py b/pandas/core/index.py
index a315b9619b0e7..44f434e038a4b 100644
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -19,7 +19,7 @@
ensure_index_from_sequences,
get_objs_combined_axis,
)
-from pandas.core.indexes.multi import _sparsify # noqa:F401
+from pandas.core.indexes.multi import sparsify_labels # noqa:F401
# GH#30193
warnings.warn(
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index a1bc8a4659b24..526dae7e256b7 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -3586,7 +3586,7 @@ def join(self, other, how="left", level=None, return_indexers=False, sort=False)
def _join_multi(self, other, how, return_indexers=True):
from pandas.core.indexes.multi import MultiIndex
- from pandas.core.reshape.merge import _restore_dropped_levels_multijoin
+ from pandas.core.reshape.merge import restore_dropped_levels_multijoin
# figure out join names
self_names = set(com.not_none(*self.names))
@@ -3622,7 +3622,7 @@ def _join_multi(self, other, how, return_indexers=True):
# common levels, ldrop_names, rdrop_names
dropped_names = ldrop_names + rdrop_names
- levels, codes, names = _restore_dropped_levels_multijoin(
+ levels, codes, names = restore_dropped_levels_multijoin(
self, other, dropped_names, join_idx, lidx, ridx
)
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 9630e154ccd17..deeb7ff50b88c 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -1337,7 +1337,7 @@ def format(
if sparsify in [False, lib.no_default]:
sentinel = sparsify
# little bit of a kludge job for #1217
- result_levels = _sparsify(
+ result_levels = sparsify_labels(
result_levels, start=int(names), sentinel=sentinel
)
@@ -3692,7 +3692,7 @@ def _add_numeric_methods_disabled(cls):
MultiIndex._add_logical_methods_disabled()
-def _sparsify(label_list, start: int = 0, sentinel=""):
+def sparsify_labels(label_list, start: int = 0, sentinel=""):
pivoted = list(zip(*label_list))
k = len(label_list)
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index 6fdde22a1c514..64470da2fb910 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -11,7 +11,7 @@
from pandas._typing import ArrayLike, Dtype, DtypeObj, F, Scalar
from pandas.compat._optional import import_optional_dependency
-from pandas.core.dtypes.cast import _int64_max, maybe_upcast_putmask
+from pandas.core.dtypes.cast import maybe_upcast_putmask
from pandas.core.dtypes.common import (
get_dtype,
is_any_int_dtype,
@@ -185,7 +185,7 @@ def _get_fill_value(
else:
if fill_value_typ == "+inf":
# need the max int here
- return _int64_max
+ return np.iinfo(np.int64).max
else:
return iNaT
@@ -346,7 +346,7 @@ def _wrap_results(result, dtype: DtypeObj, fill_value=None):
result = np.nan
# raise if we have a timedelta64[ns] which is too large
- if np.fabs(result) > _int64_max:
+ if np.fabs(result) > np.iinfo(np.int64).max:
raise ValueError("overflow in timedelta operation")
result = Timedelta(result, unit="ns")
diff --git a/pandas/core/ops/__init__.py b/pandas/core/ops/__init__.py
index 60f3d23aaed13..8fcbee6a20ac3 100644
--- a/pandas/core/ops/__init__.py
+++ b/pandas/core/ops/__init__.py
@@ -306,7 +306,7 @@ def dispatch_to_series(left, right, func, axis: Optional[int] = None):
def _align_method_SERIES(left: "Series", right, align_asobject: bool = False):
""" align lhs and rhs Series """
- # ToDo: Different from _align_method_FRAME, list, tuple and ndarray
+ # ToDo: Different from align_method_FRAME, list, tuple and ndarray
# are not coerced here
# because Series has inconsistencies described in #13637
@@ -430,7 +430,7 @@ def flex_wrapper(self, other, level=None, fill_value=None, axis=0):
# DataFrame
-def _align_method_FRAME(
+def align_method_FRAME(
left, right, axis, flex: Optional[bool] = False, level: Level = None
):
"""
@@ -571,7 +571,7 @@ def _frame_arith_method_with_reindex(
new_right = right.iloc[:, rcols]
result = op(new_left, new_right)
- # Do the join on the columns instead of using _align_method_FRAME
+ # Do the join on the columns instead of using align_method_FRAME
# to avoid constructing two potentially large/sparse DataFrames
join_columns, _, _ = left.columns.join(
right.columns, how="outer", level=None, return_indexers=True
@@ -644,7 +644,7 @@ def f(self, other, axis=default_axis, level=None, fill_value=None):
# TODO: why are we passing flex=True instead of flex=not special?
# 15 tests fail if we pass flex=not special instead
- self, other = _align_method_FRAME(self, other, axis, flex=True, level=level)
+ self, other = align_method_FRAME(self, other, axis, flex=True, level=level)
if isinstance(other, ABCDataFrame):
# Another DataFrame
@@ -680,7 +680,7 @@ def _flex_comp_method_FRAME(cls: Type["DataFrame"], op, special: bool):
def f(self, other, axis=default_axis, level=None):
axis = self._get_axis_number(axis) if axis is not None else 1
- self, other = _align_method_FRAME(self, other, axis, flex=True, level=level)
+ self, other = align_method_FRAME(self, other, axis, flex=True, level=level)
new_data = dispatch_to_series(self, other, op, axis=axis)
return self._construct_result(new_data)
@@ -698,7 +698,7 @@ def _comp_method_FRAME(cls: Type["DataFrame"], op, special: bool):
def f(self, other):
axis = 1 # only relevant for Series other case
- self, other = _align_method_FRAME(self, other, axis, level=None, flex=False)
+ self, other = align_method_FRAME(self, other, axis, level=None, flex=False)
# See GH#4537 for discussion of scalar op behavior
new_data = dispatch_to_series(self, other, op, axis=axis)
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index f1c5486222ea1..030dec369c2be 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -1350,7 +1350,7 @@ def _get_join_indexers(
return join_func(lkey, rkey, count, **kwargs)
-def _restore_dropped_levels_multijoin(
+def restore_dropped_levels_multijoin(
left: MultiIndex,
right: MultiIndex,
dropped_level_names,
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index 623dc6e6bad91..6781d98ded41d 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -995,7 +995,7 @@ def to_html(
)
def _get_formatted_column_labels(self, frame: "DataFrame") -> List[List[str]]:
- from pandas.core.indexes.multi import _sparsify
+ from pandas.core.indexes.multi import sparsify_labels
columns = frame.columns
@@ -1021,7 +1021,7 @@ def space_format(x, y):
zip(*[[space_format(x, y) for y in x] for x in fmt_columns])
)
if self.sparsify and len(str_columns):
- str_columns = _sparsify(str_columns)
+ str_columns = sparsify_labels(str_columns)
str_columns = [list(x) for x in zip(*str_columns)]
else:
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index a4d923fdbe45a..e3000788cb33a 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -22,7 +22,7 @@
from pandas.io.common import get_compression_method, get_filepath_or_buffer, get_handle
from pandas.io.json._normalize import convert_to_line_delimits
from pandas.io.json._table_schema import build_table_schema, parse_table_schema
-from pandas.io.parsers import _validate_integer
+from pandas.io.parsers import validate_integer
loads = json.loads
dumps = json.dumps
@@ -698,11 +698,11 @@ def __init__(
self.file_handles: List[IO] = []
if self.chunksize is not None:
- self.chunksize = _validate_integer("chunksize", self.chunksize, 1)
+ self.chunksize = validate_integer("chunksize", self.chunksize, 1)
if not self.lines:
raise ValueError("chunksize can only be passed if lines=True")
if self.nrows is not None:
- self.nrows = _validate_integer("nrows", self.nrows, 0)
+ self.nrows = validate_integer("nrows", self.nrows, 0)
if not self.lines:
raise ValueError("nrows can only be passed if lines=True")
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index a0466c5ac6b57..4c619a636f057 100644
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -361,7 +361,7 @@
)
-def _validate_integer(name, val, min_val=0):
+def validate_integer(name, val, min_val=0):
"""
Checks whether the 'name' parameter for parsing is either
an integer OR float that can SAFELY be cast to an integer
@@ -436,7 +436,7 @@ def _read(filepath_or_buffer: FilePathOrBuffer, kwds):
# Extract some of the arguments (pass chunksize on).
iterator = kwds.get("iterator", False)
- chunksize = _validate_integer("chunksize", kwds.get("chunksize", None), 1)
+ chunksize = validate_integer("chunksize", kwds.get("chunksize", None), 1)
nrows = kwds.get("nrows", None)
# Check for duplicates in names.
@@ -1179,7 +1179,7 @@ def _failover_to_python(self):
raise AbstractMethodError(self)
def read(self, nrows=None):
- nrows = _validate_integer("nrows", nrows)
+ nrows = validate_integer("nrows", nrows)
ret = self._engine.read(nrows)
# May alter columns / col_dict
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index b1ab700427c28..8f1ca9a4a7a96 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -4,7 +4,7 @@
import pytest
from pandas._libs import OutOfBoundsDatetime
-from pandas.compat.numpy import _np_version_under1p18
+from pandas.compat.numpy import np_version_under1p18
import pandas as pd
import pandas._testing as tm
@@ -955,7 +955,7 @@ def test_invalid_nat_setitem_array(array, non_casting_nats):
],
)
def test_to_numpy_extra(array):
- if _np_version_under1p18:
+ if np_version_under1p18:
# np.isnan(NaT) raises, so use pandas'
isnan = pd.isna
else:
diff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py
index 49066428eb16c..72dc04e68c154 100644
--- a/pandas/tests/computation/test_eval.py
+++ b/pandas/tests/computation/test_eval.py
@@ -26,12 +26,12 @@
PandasExprVisitor,
PythonExprVisitor,
)
-from pandas.core.computation.expressions import _USE_NUMEXPR, NUMEXPR_INSTALLED
+from pandas.core.computation.expressions import NUMEXPR_INSTALLED, USE_NUMEXPR
from pandas.core.computation.ops import (
- _arith_ops_syms,
+ ARITH_OPS_SYMS,
+ SPECIAL_CASE_ARITH_OPS_SYMS,
_binary_math_ops,
_binary_ops_dict,
- _special_case_arith_ops_syms,
_unary_math_ops,
)
@@ -41,8 +41,8 @@
pytest.param(
engine,
marks=pytest.mark.skipif(
- engine == "numexpr" and not _USE_NUMEXPR,
- reason=f"numexpr enabled->{_USE_NUMEXPR}, "
+ engine == "numexpr" and not USE_NUMEXPR,
+ reason=f"numexpr enabled->{USE_NUMEXPR}, "
f"installed->{NUMEXPR_INSTALLED}",
),
)
@@ -114,7 +114,7 @@ def _is_py3_complex_incompat(result, expected):
return isinstance(expected, (complex, np.complexfloating)) and np.isnan(result)
-_good_arith_ops = set(_arith_ops_syms).difference(_special_case_arith_ops_syms)
+_good_arith_ops = set(ARITH_OPS_SYMS).difference(SPECIAL_CASE_ARITH_OPS_SYMS)
@td.skip_if_no_ne
@@ -158,10 +158,10 @@ def setup_data(self):
self.rhses = self.pandas_rhses + self.scalar_rhses
def setup_ops(self):
- self.cmp_ops = expr._cmp_ops_syms
+ self.cmp_ops = expr.CMP_OPS_SYMS
self.cmp2_ops = self.cmp_ops[::-1]
- self.bin_ops = expr._bool_ops_syms
- self.special_case_ops = _special_case_arith_ops_syms
+ self.bin_ops = expr.BOOL_OPS_SYMS
+ self.special_case_ops = SPECIAL_CASE_ARITH_OPS_SYMS
self.arith_ops = _good_arith_ops
self.unary_ops = "-", "~", "not "
@@ -774,10 +774,10 @@ def setup_class(cls):
cls.parser = "python"
def setup_ops(self):
- self.cmp_ops = [op for op in expr._cmp_ops_syms if op not in ("in", "not in")]
+ self.cmp_ops = [op for op in expr.CMP_OPS_SYMS if op not in ("in", "not in")]
self.cmp2_ops = self.cmp_ops[::-1]
- self.bin_ops = [op for op in expr._bool_ops_syms if op not in ("and", "or")]
- self.special_case_ops = _special_case_arith_ops_syms
+ self.bin_ops = [op for op in expr.BOOL_OPS_SYMS if op not in ("and", "or")]
+ self.special_case_ops = SPECIAL_CASE_ARITH_OPS_SYMS
self.arith_ops = _good_arith_ops
self.unary_ops = "+", "-", "~"
@@ -1135,7 +1135,7 @@ class TestOperationsNumExprPandas:
def setup_class(cls):
cls.engine = "numexpr"
cls.parser = "pandas"
- cls.arith_ops = expr._arith_ops_syms + expr._cmp_ops_syms
+ cls.arith_ops = expr.ARITH_OPS_SYMS + expr.CMP_OPS_SYMS
@classmethod
def teardown_class(cls):
@@ -1177,7 +1177,7 @@ def test_simple_arith_ops(self):
assert y == expec
def test_simple_bool_ops(self):
- for op, lhs, rhs in product(expr._bool_ops_syms, (True, False), (True, False)):
+ for op, lhs, rhs in product(expr.BOOL_OPS_SYMS, (True, False), (True, False)):
ex = f"{lhs} {op} {rhs}"
res = self.eval(ex)
exp = eval(ex)
@@ -1185,7 +1185,7 @@ def test_simple_bool_ops(self):
def test_bool_ops_with_constants(self):
for op, lhs, rhs in product(
- expr._bool_ops_syms, ("True", "False"), ("True", "False")
+ expr.BOOL_OPS_SYMS, ("True", "False"), ("True", "False")
):
ex = f"{lhs} {op} {rhs}"
res = self.eval(ex)
@@ -1637,7 +1637,7 @@ def setup_class(cls):
cls.parser = "python"
cls.arith_ops = [
op
- for op in expr._arith_ops_syms + expr._cmp_ops_syms
+ for op in expr.ARITH_OPS_SYMS + expr.CMP_OPS_SYMS
if op not in ("in", "not in")
]
@@ -1697,7 +1697,7 @@ def test_fails_pipe(self):
def test_bool_ops_with_constants(self):
for op, lhs, rhs in product(
- expr._bool_ops_syms, ("True", "False"), ("True", "False")
+ expr.BOOL_OPS_SYMS, ("True", "False"), ("True", "False")
):
ex = f"{lhs} {op} {rhs}"
if op in ("and", "or"):
@@ -1710,7 +1710,7 @@ def test_bool_ops_with_constants(self):
assert res == exp
def test_simple_bool_ops(self):
- for op, lhs, rhs in product(expr._bool_ops_syms, (True, False), (True, False)):
+ for op, lhs, rhs in product(expr.BOOL_OPS_SYMS, (True, False), (True, False)):
ex = f"lhs {op} rhs"
if op in ("and", "or"):
msg = "'BoolOp' nodes are not implemented"
@@ -1729,7 +1729,7 @@ def setup_class(cls):
cls.engine = cls.parser = "python"
cls.arith_ops = [
op
- for op in expr._arith_ops_syms + expr._cmp_ops_syms
+ for op in expr.ARITH_OPS_SYMS + expr.CMP_OPS_SYMS
if op not in ("in", "not in")
]
@@ -1740,7 +1740,7 @@ def setup_class(cls):
super().setup_class()
cls.engine = "python"
cls.parser = "pandas"
- cls.arith_ops = expr._arith_ops_syms + expr._cmp_ops_syms
+ cls.arith_ops = expr.ARITH_OPS_SYMS + expr.CMP_OPS_SYMS
@td.skip_if_no_ne
@@ -2020,7 +2020,7 @@ def test_equals_various(other):
df = DataFrame({"A": ["a", "b", "c"]})
result = df.eval(f"A == {other}")
expected = Series([False, False, False], name="A")
- if _USE_NUMEXPR:
+ if USE_NUMEXPR:
# https://github.com/pandas-dev/pandas/issues/10239
# lose name with numexpr engine. Remove when that's fixed.
expected.name = None
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 70d0b4e9e835c..6dd8d890e8a4b 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -1417,7 +1417,7 @@ def test_alignment_non_pandas(self):
columns = ["X", "Y", "Z"]
df = pd.DataFrame(np.random.randn(3, 3), index=index, columns=columns)
- align = pd.core.ops._align_method_FRAME
+ align = pd.core.ops.align_method_FRAME
for val in [
[1, 2, 3],
(1, 2, 3),
diff --git a/pandas/tests/generic/test_generic.py b/pandas/tests/generic/test_generic.py
index 23bb673586768..2c2584e8dee01 100644
--- a/pandas/tests/generic/test_generic.py
+++ b/pandas/tests/generic/test_generic.py
@@ -3,7 +3,7 @@
import numpy as np
import pytest
-from pandas.compat.numpy import _np_version_under1p17
+from pandas.compat.numpy import np_version_under1p17
from pandas.core.dtypes.common import is_scalar
@@ -652,12 +652,12 @@ def test_sample(sel):
pytest.param(
"np.random.MT19937",
3,
- marks=pytest.mark.skipif(_np_version_under1p17, reason="NumPy<1.17"),
+ marks=pytest.mark.skipif(np_version_under1p17, reason="NumPy<1.17"),
),
pytest.param(
"np.random.PCG64",
11,
- marks=pytest.mark.skipif(_np_version_under1p17, reason="NumPy<1.17"),
+ marks=pytest.mark.skipif(np_version_under1p17, reason="NumPy<1.17"),
),
],
)
diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py
index e95e7267f17ec..11dc232af8de4 100644
--- a/pandas/tests/indexes/common.py
+++ b/pandas/tests/indexes/common.py
@@ -5,7 +5,7 @@
import pytest
from pandas._libs import iNaT
-from pandas.compat.numpy import _is_numpy_dev
+from pandas.compat.numpy import is_numpy_dev
from pandas.errors import InvalidIndexError
from pandas.core.dtypes.common import is_datetime64tz_dtype
@@ -475,7 +475,7 @@ def test_intersection_base(self, index, request):
for case in cases:
# https://github.com/pandas-dev/pandas/issues/35481
if (
- _is_numpy_dev
+ is_numpy_dev
and isinstance(case, Series)
and isinstance(index, UInt64Index)
):
diff --git a/pandas/tests/indexes/multi/test_analytics.py b/pandas/tests/indexes/multi/test_analytics.py
index 9e4e73e793bac..d661a56311e6c 100644
--- a/pandas/tests/indexes/multi/test_analytics.py
+++ b/pandas/tests/indexes/multi/test_analytics.py
@@ -1,7 +1,7 @@
import numpy as np
import pytest
-from pandas.compat.numpy import _np_version_under1p17
+from pandas.compat.numpy import np_version_under1p17
import pandas as pd
from pandas import Index, MultiIndex, date_range, period_range
@@ -240,7 +240,7 @@ def test_numpy_ufuncs(idx, func):
# test ufuncs of numpy. see:
# https://numpy.org/doc/stable/reference/ufuncs.html
- if _np_version_under1p17:
+ if np_version_under1p17:
expected_exception = AttributeError
msg = f"'tuple' object has no attribute '{func.__name__}'"
else:
diff --git a/pandas/tests/indexes/test_numpy_compat.py b/pandas/tests/indexes/test_numpy_compat.py
index 043539c173427..a83684464caf6 100644
--- a/pandas/tests/indexes/test_numpy_compat.py
+++ b/pandas/tests/indexes/test_numpy_compat.py
@@ -1,6 +1,8 @@
import numpy as np
import pytest
+from pandas.compat.numpy import np_version_under1p17, np_version_under1p18
+
from pandas import (
DatetimeIndex,
Float64Index,
@@ -9,8 +11,6 @@
PeriodIndex,
TimedeltaIndex,
UInt64Index,
- _np_version_under1p17,
- _np_version_under1p18,
)
import pandas._testing as tm
from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
@@ -83,12 +83,12 @@ def test_numpy_ufuncs_other(index, func):
if func in [np.isfinite, np.isnan, np.isinf]:
pytest.xfail(reason="__array_ufunc__ is not defined")
- if not _np_version_under1p18 and func in [np.isfinite, np.isinf, np.isnan]:
+ if not np_version_under1p18 and func in [np.isfinite, np.isinf, np.isnan]:
# numpy 1.18(dev) changed isinf and isnan to not raise on dt64/tfd64
result = func(index)
assert isinstance(result, np.ndarray)
- elif not _np_version_under1p17 and func in [np.isfinite]:
+ elif not np_version_under1p17 and func in [np.isfinite]:
# ok under numpy >= 1.17
# Results in bool array
result = func(index)
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index e42d9679464d8..9a6f30ec920cc 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -5,7 +5,7 @@
import numpy as np
import pytest
-from pandas.compat.numpy import _is_numpy_dev
+from pandas.compat.numpy import is_numpy_dev
import pandas as pd
from pandas import DataFrame, Series, Timestamp, date_range
@@ -938,7 +938,7 @@ def test_loc_setitem_empty_append(self):
df.loc[0, "x"] = expected.loc[0, "x"]
tm.assert_frame_equal(df, expected)
- @pytest.mark.xfail(_is_numpy_dev, reason="gh-35481")
+ @pytest.mark.xfail(is_numpy_dev, reason="gh-35481")
def test_loc_setitem_empty_append_raises(self):
# GH6173, various appends to an empty dataframe
diff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py
index cb33f99d9bd91..d4d7e4b85268f 100644
--- a/pandas/tests/scalar/timedelta/test_arithmetic.py
+++ b/pandas/tests/scalar/timedelta/test_arithmetic.py
@@ -7,8 +7,10 @@
import numpy as np
import pytest
+from pandas.compat.numpy import is_numpy_dev
+
import pandas as pd
-from pandas import NaT, Timedelta, Timestamp, _is_numpy_dev, compat, offsets
+from pandas import NaT, Timedelta, Timestamp, compat, offsets
import pandas._testing as tm
from pandas.core import ops
@@ -426,7 +428,7 @@ def test_td_div_numeric_scalar(self):
np.float64("NaN"),
marks=pytest.mark.xfail(
# Works on numpy dev only in python 3.9
- _is_numpy_dev and not compat.PY39,
+ is_numpy_dev and not compat.PY39,
raises=RuntimeWarning,
reason="https://github.com/pandas-dev/pandas/issues/31992",
),
diff --git a/pandas/tests/test_common.py b/pandas/tests/test_common.py
index 3d45a1f7389b7..f7f3f1fa0c13d 100644
--- a/pandas/tests/test_common.py
+++ b/pandas/tests/test_common.py
@@ -6,7 +6,7 @@
import numpy as np
import pytest
-from pandas.compat.numpy import _np_version_under1p17
+from pandas.compat.numpy import np_version_under1p17
import pandas as pd
from pandas import Series, Timestamp
@@ -72,7 +72,7 @@ def test_random_state():
# Check BitGenerators
# GH32503
- if not _np_version_under1p17:
+ if not np_version_under1p17:
assert (
com.random_state(npr.MT19937(3)).uniform()
== npr.RandomState(npr.MT19937(3)).uniform()
diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py
index 2368e93ddc256..da7f8b9b4a721 100644
--- a/pandas/tests/test_expressions.py
+++ b/pandas/tests/test_expressions.py
@@ -35,7 +35,7 @@
)
-@pytest.mark.skipif(not expr._USE_NUMEXPR, reason="not using numexpr")
+@pytest.mark.skipif(not expr.USE_NUMEXPR, reason="not using numexpr")
class TestExpressions:
def setup_method(self, method):
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index 94c252eca1671..e9deaf3fe67de 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -35,7 +35,7 @@ def test_foo():
from pandas.compat._optional import import_optional_dependency
from pandas.compat.numpy import _np_version
-from pandas.core.computation.expressions import _USE_NUMEXPR, NUMEXPR_INSTALLED
+from pandas.core.computation.expressions import NUMEXPR_INSTALLED, USE_NUMEXPR
def safe_import(mod_name: str, min_version: Optional[str] = None):
@@ -195,8 +195,8 @@ def skip_if_no(package: str, min_version: Optional[str] = None):
_skip_if_no_scipy(), reason="Missing SciPy requirement"
)
skip_if_no_ne = pytest.mark.skipif(
- not _USE_NUMEXPR,
- reason=f"numexpr enabled->{_USE_NUMEXPR}, installed->{NUMEXPR_INSTALLED}",
+ not USE_NUMEXPR,
+ reason=f"numexpr enabled->{USE_NUMEXPR}, installed->{NUMEXPR_INSTALLED}",
)
| getting close to the end of this and enabling a code_check
| https://api.github.com/repos/pandas-dev/pandas/pulls/36178 | 2020-09-07T00:02:21Z | 2020-09-08T22:41:30Z | 2020-09-08T22:41:30Z | 2020-09-08T23:04:44Z |
Move sort index to generic | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 56dc5e54e1d59..bc0e55195fb3e 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -143,7 +143,6 @@
)
from pandas.core.reshape.melt import melt
from pandas.core.series import Series
-from pandas.core.sorting import ensure_key_mapped
from pandas.io.common import get_filepath_or_buffer
from pandas.io.formats import console, format as fmt
@@ -5448,62 +5447,17 @@ def sort_index(
C 3
d 4
"""
- # TODO: this can be combined with Series.sort_index impl as
- # almost identical
-
- inplace = validate_bool_kwarg(inplace, "inplace")
-
- axis = self._get_axis_number(axis)
- labels = self._get_axis(axis)
- labels = ensure_key_mapped(labels, key, levels=level)
-
- # make sure that the axis is lexsorted to start
- # if not we need to reconstruct to get the correct indexer
- labels = labels._sort_levels_monotonic()
- if level is not None:
- new_axis, indexer = labels.sortlevel(
- level, ascending=ascending, sort_remaining=sort_remaining
- )
-
- elif isinstance(labels, MultiIndex):
- from pandas.core.sorting import lexsort_indexer
-
- indexer = lexsort_indexer(
- labels._get_codes_for_sorting(),
- orders=ascending,
- na_position=na_position,
- )
- else:
- from pandas.core.sorting import nargsort
-
- # Check monotonic-ness before sort an index
- # GH11080
- if (ascending and labels.is_monotonic_increasing) or (
- not ascending and labels.is_monotonic_decreasing
- ):
- if inplace:
- return
- else:
- return self.copy()
-
- indexer = nargsort(
- labels, kind=kind, ascending=ascending, na_position=na_position
- )
-
- baxis = self._get_block_manager_axis(axis)
- new_data = self._mgr.take(indexer, axis=baxis, verify=False)
-
- # reconstruct axis if needed
- new_data.axes[baxis] = new_data.axes[baxis]._sort_levels_monotonic()
-
- if ignore_index:
- new_data.axes[1] = ibase.default_index(len(indexer))
-
- result = self._constructor(new_data)
- if inplace:
- return self._update_inplace(result)
- else:
- return result.__finalize__(self, method="sort_index")
+ return super().sort_index(
+ axis,
+ level,
+ ascending,
+ inplace,
+ kind,
+ na_position,
+ sort_remaining,
+ ignore_index,
+ key,
+ )
def value_counts(
self,
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 5336d0828881b..0a8dd578bf461 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -40,6 +40,7 @@
CompressionOptions,
FilePathOrBuffer,
FrameOrSeries,
+ IndexKeyFunc,
IndexLabel,
JSONSerializable,
Label,
@@ -92,6 +93,7 @@
import pandas.core.common as com
from pandas.core.construction import create_series_with_explicit_dtype
from pandas.core.flags import Flags
+from pandas.core.indexes import base as ibase
from pandas.core.indexes.api import Index, MultiIndex, RangeIndex, ensure_index
from pandas.core.indexes.datetimes import DatetimeIndex
from pandas.core.indexes.period import Period, PeriodIndex
@@ -100,6 +102,7 @@
from pandas.core.missing import find_valid_index
from pandas.core.ops import align_method_FRAME
from pandas.core.shared_docs import _shared_docs
+from pandas.core.sorting import get_indexer_indexer
from pandas.core.window import Expanding, ExponentialMovingWindow, Rolling, Window
from pandas.io.formats import format as fmt
@@ -4409,6 +4412,50 @@ def sort_values(
"""
raise AbstractMethodError(self)
+ def sort_index(
+ self,
+ axis=0,
+ level=None,
+ ascending: bool_t = True,
+ inplace: bool_t = False,
+ kind: str = "quicksort",
+ na_position: str = "last",
+ sort_remaining: bool_t = True,
+ ignore_index: bool_t = False,
+ key: IndexKeyFunc = None,
+ ):
+
+ inplace = validate_bool_kwarg(inplace, "inplace")
+ axis = self._get_axis_number(axis)
+ target = self._get_axis(axis)
+
+ indexer = get_indexer_indexer(
+ target, level, ascending, kind, na_position, sort_remaining, key
+ )
+
+ if indexer is None:
+ if inplace:
+ return
+ else:
+ return self.copy()
+
+ baxis = self._get_block_manager_axis(axis)
+ new_data = self._mgr.take(indexer, axis=baxis, verify=False)
+
+ # reconstruct axis if needed
+ new_data.axes[baxis] = new_data.axes[baxis]._sort_levels_monotonic()
+
+ if ignore_index:
+ axis = 1 if isinstance(self, ABCDataFrame) else 0
+ new_data.axes[axis] = ibase.default_index(len(indexer))
+
+ result = self._constructor(new_data)
+
+ if inplace:
+ return self._update_inplace(result)
+ else:
+ return result.__finalize__(self, method="sort_index")
+
@doc(
klass=_shared_doc_kwargs["klass"],
axes=_shared_doc_kwargs["axes"],
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 69376d8bf80d1..48fae9a0a91cd 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -3463,59 +3463,17 @@ def sort_index(
dtype: int64
"""
- # TODO: this can be combined with DataFrame.sort_index impl as
- # almost identical
- inplace = validate_bool_kwarg(inplace, "inplace")
- # Validate the axis parameter
- self._get_axis_number(axis)
- index = ensure_key_mapped(self.index, key, levels=level)
-
- if level is not None:
- new_index, indexer = index.sortlevel(
- level, ascending=ascending, sort_remaining=sort_remaining
- )
-
- elif isinstance(index, MultiIndex):
- from pandas.core.sorting import lexsort_indexer
-
- labels = index._sort_levels_monotonic()
-
- indexer = lexsort_indexer(
- labels._get_codes_for_sorting(),
- orders=ascending,
- na_position=na_position,
- )
- else:
- from pandas.core.sorting import nargsort
-
- # Check monotonic-ness before sort an index
- # GH11080
- if (ascending and index.is_monotonic_increasing) or (
- not ascending and index.is_monotonic_decreasing
- ):
- if inplace:
- return
- else:
- return self.copy()
-
- indexer = nargsort(
- index, kind=kind, ascending=ascending, na_position=na_position
- )
-
- indexer = ensure_platform_int(indexer)
- new_index = self.index.take(indexer)
- new_index = new_index._sort_levels_monotonic()
-
- new_values = self._values.take(indexer)
- result = self._constructor(new_values, index=new_index)
-
- if ignore_index:
- result.index = ibase.default_index(len(result))
-
- if inplace:
- self._update_inplace(result)
- else:
- return result.__finalize__(self, method="sort_index")
+ return super().sort_index(
+ axis,
+ level,
+ ascending,
+ inplace,
+ kind,
+ na_position,
+ sort_remaining,
+ ignore_index,
+ key,
+ )
def argsort(self, axis=0, kind="quicksort", order=None) -> "Series":
"""
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
index d03b2f29521b7..dd6aadf570baa 100644
--- a/pandas/core/sorting.py
+++ b/pandas/core/sorting.py
@@ -1,11 +1,21 @@
""" miscellaneous sorting / groupby utilities """
from collections import defaultdict
-from typing import TYPE_CHECKING, Callable, DefaultDict, Iterable, List, Optional, Tuple
+from typing import (
+ TYPE_CHECKING,
+ Callable,
+ DefaultDict,
+ Iterable,
+ List,
+ Optional,
+ Tuple,
+ Union,
+)
import numpy as np
from pandas._libs import algos, hashtable, lib
from pandas._libs.hashtable import unique_label_indices
+from pandas._typing import IndexKeyFunc
from pandas.core.dtypes.common import (
ensure_int64,
@@ -20,11 +30,64 @@
from pandas.core.construction import extract_array
if TYPE_CHECKING:
- from pandas.core.indexes.base import Index # noqa:F401
+ from pandas.core.indexes.base import Index
_INT64_MAX = np.iinfo(np.int64).max
+def get_indexer_indexer(
+ target: "Index",
+ level: Union[str, int, List[str], List[int]],
+ ascending: bool,
+ kind: str,
+ na_position: str,
+ sort_remaining: bool,
+ key: IndexKeyFunc,
+) -> Optional[np.array]:
+ """
+ Helper method that return the indexer according to input parameters for
+ the sort_index method of DataFrame and Series.
+
+ Parameters
+ ----------
+ target : Index
+ level : int or level name or list of ints or list of level names
+ ascending : bool or list of bools, default True
+ kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'
+ na_position : {'first', 'last'}, default 'last'
+ sort_remaining : bool, default True
+ key : callable, optional
+
+ Returns
+ -------
+ Optional[ndarray]
+ The indexer for the new index.
+ """
+
+ target = ensure_key_mapped(target, key, levels=level)
+ target = target._sort_levels_monotonic()
+
+ if level is not None:
+ _, indexer = target.sortlevel(
+ level, ascending=ascending, sort_remaining=sort_remaining
+ )
+ elif isinstance(target, ABCMultiIndex):
+ indexer = lexsort_indexer(
+ target._get_codes_for_sorting(), orders=ascending, na_position=na_position,
+ )
+ else:
+ # Check monotonic-ness before sort an index (GH 11080)
+ if (ascending and target.is_monotonic_increasing) or (
+ not ascending and target.is_monotonic_decreasing
+ ):
+ return None
+
+ indexer = nargsort(
+ target, kind=kind, ascending=ascending, na_position=na_position
+ )
+ return indexer
+
+
def get_group_index(labels, shape, sort: bool, xnull: bool):
"""
For the particular label_list, gets the offsets into the hypothetical list
| - [x] closes #8283
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
| https://api.github.com/repos/pandas-dev/pandas/pulls/36177 | 2020-09-06T23:57:53Z | 2020-09-15T02:11:48Z | 2020-09-15T02:11:48Z | 2020-09-15T15:14:21Z |
COMPAT: match numpy behavior for searchsorted on dt64/td64 | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index ccaae9f996425..2afa1f1a6199e 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -228,6 +228,7 @@ Datetimelike
- Bug in :class:`DateOffset` where attributes reconstructed from pickle files differ from original objects when input values exceed normal ranges (e.g months=12) (:issue:`34511`)
- Bug in :meth:`DatetimeIndex.get_slice_bound` where ``datetime.date`` objects were not accepted or naive :class:`Timestamp` with a tz-aware :class:`DatetimeIndex` (:issue:`35690`)
- Bug in :meth:`DatetimeIndex.slice_locs` where ``datetime.date`` objects were not accepted (:issue:`34077`)
+- Bug in :meth:`DatetimeIndex.searchsorted`, :meth:`TimedeltaIndex.searchsorted`, and :meth:`Series.searchsorted` with ``datetime64`` or ``timedelta64`` dtype placement of ``NaT`` values being inconsistent with ``NumPy`` (:issue:`36176`)
Timedelta
^^^^^^^^^
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index a218745db0a44..e81904713ea5b 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -858,7 +858,8 @@ def _validate_searchsorted_value(self, value):
# TODO: cast_str? we accept it for scalar
value = self._validate_listlike(value, "searchsorted")
- return self._unbox(value)
+ rv = self._unbox(value)
+ return self._rebox_native(rv)
def _validate_setitem_value(self, value):
msg = (
@@ -937,9 +938,7 @@ def searchsorted(self, value, side="left", sorter=None):
Array of insertion points with the same shape as `value`.
"""
value = self._validate_searchsorted_value(value)
-
- # TODO: Use datetime64 semantics for sorting, xref GH#29844
- return self.asi8.searchsorted(value, side=side, sorter=sorter)
+ return self._data.searchsorted(value, side=side, sorter=sorter)
def value_counts(self, dropna=False):
"""
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index b1ab700427c28..292557fc04258 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -241,10 +241,15 @@ def test_searchsorted(self):
expected = np.array([2, 3], dtype=np.intp)
tm.assert_numpy_array_equal(result, expected)
- # Following numpy convention, NaT goes at the beginning
- # (unlike NaN which goes at the end)
+ # GH#29884 match numpy convention on whether NaT goes
+ # at the end or the beginning
result = arr.searchsorted(pd.NaT)
- assert result == 0
+ if _np_version_under1p18 or self.array_cls is PeriodArray:
+ # Following numpy convention, NaT goes at the beginning
+ # (unlike NaN which goes at the end)
+ assert result == 0
+ else:
+ assert result == 10
def test_getitem_2d(self, arr1d):
# 2d slicing on a 1D array
| - [x] closes #29884
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Should whatsnew be considered a bug or breaking change? | https://api.github.com/repos/pandas-dev/pandas/pulls/36176 | 2020-09-06T23:14:17Z | 2020-09-08T00:15:52Z | 2020-09-08T00:15:51Z | 2020-09-08T00:17:02Z |
BUG: read_excel for ods files raising UnboundLocalError in certain cases | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index 2aac2596c18cb..b4289973a26cd 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -296,6 +296,7 @@ I/O
- :meth:`to_csv` did not support zip compression for binary file object not having a filename (:issue: `35058`)
- :meth:`to_csv` and :meth:`read_csv` did not honor `compression` and `encoding` for path-like objects that are internally converted to file-like objects (:issue:`35677`, :issue:`26124`, and :issue:`32392`)
- :meth:`to_picke` and :meth:`read_pickle` did not support compression for file-objects (:issue:`26237`, :issue:`29054`, and :issue:`29570`)
+- Bug in :meth:`read_excel` with `engine="odf"` caused ``UnboundLocalError`` in some cases where cells had nested child nodes (:issue:`36122`, and :issue:`35802`)
Plotting
^^^^^^^^
diff --git a/pandas/io/excel/_odfreader.py b/pandas/io/excel/_odfreader.py
index 02575ab878f6e..09a4bfb9accc3 100644
--- a/pandas/io/excel/_odfreader.py
+++ b/pandas/io/excel/_odfreader.py
@@ -197,22 +197,24 @@ def _get_cell_string_value(self, cell) -> str:
Find and decode OpenDocument text:s tags that represent
a run length encoded sequence of space characters.
"""
- from odf.element import Element, Text
+ from odf.element import Element
from odf.namespaces import TEXTNS
- from odf.text import P, S
+ from odf.text import S
- text_p = P().qname
text_s = S().qname
- p = cell.childNodes[0]
-
value = []
- if p.qname == text_p:
- for k, fragment in enumerate(p.childNodes):
- if isinstance(fragment, Text):
- value.append(fragment.data)
- elif isinstance(fragment, Element):
- if fragment.qname == text_s:
- spaces = int(fragment.attributes.get((TEXTNS, "c"), 1))
+
+ for fragment in cell.childNodes:
+ if isinstance(fragment, Element):
+ if fragment.qname == text_s:
+ spaces = int(fragment.attributes.get((TEXTNS, "c"), 1))
value.append(" " * spaces)
+ else:
+ # recursive impl needed in case of nested fragments
+ # with multiple spaces
+ # https://github.com/pandas-dev/pandas/pull/36175#discussion_r484639704
+ value.append(self._get_cell_string_value(fragment))
+ else:
+ value.append(str(fragment))
return "".join(value)
diff --git a/pandas/tests/io/data/excel/gh-35802.ods b/pandas/tests/io/data/excel/gh-35802.ods
new file mode 100755
index 0000000000000..f3ad061f1d995
Binary files /dev/null and b/pandas/tests/io/data/excel/gh-35802.ods differ
diff --git a/pandas/tests/io/data/excel/gh-36122.ods b/pandas/tests/io/data/excel/gh-36122.ods
new file mode 100755
index 0000000000000..3dfdaf976da45
Binary files /dev/null and b/pandas/tests/io/data/excel/gh-36122.ods differ
diff --git a/pandas/tests/io/excel/test_readers.py b/pandas/tests/io/excel/test_readers.py
index 431a50477fccc..33467be42dfd9 100644
--- a/pandas/tests/io/excel/test_readers.py
+++ b/pandas/tests/io/excel/test_readers.py
@@ -499,6 +499,23 @@ def test_reader_spaces(self, read_ext):
)
tm.assert_frame_equal(actual, expected)
+ # gh-36122, gh-35802
+ @pytest.mark.parametrize(
+ "basename,expected",
+ [
+ ("gh-35802", DataFrame({"COLUMN": ["Test (1)"]})),
+ ("gh-36122", DataFrame(columns=["got 2nd sa"])),
+ ],
+ )
+ def test_read_excel_ods_nested_xml(self, read_ext, basename, expected):
+ # see gh-35802
+ engine = pd.read_excel.keywords["engine"]
+ if engine != "odf":
+ pytest.skip(f"Skipped for engine: {engine}")
+
+ actual = pd.read_excel(basename + read_ext)
+ tm.assert_frame_equal(actual, expected)
+
def test_reading_all_sheets(self, read_ext):
# Test reading all sheet names by setting sheet_name to None,
# Ensure a dict is returned.
| - [x] closes #36122
- [x] closes #35802
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Need some guidance on tests here. Do we need tests for other file formats here as well? Also unsure about naming conventions.
The primary bug in this case (apart from the indentation problem in the original code) is that the code was ignoring cases where the XML of the cell had multiple child nodes that were not spaces
reverted implementation from #33233 incorporating part of its modifications. | https://api.github.com/repos/pandas-dev/pandas/pulls/36175 | 2020-09-06T22:58:37Z | 2020-09-13T22:57:45Z | 2020-09-13T22:57:45Z | 2021-01-05T09:37:02Z |
BUG: Ensure read_spss accepts pathlib Paths (GH33666) | diff --git a/doc/source/whatsnew/v1.1.3.rst b/doc/source/whatsnew/v1.1.3.rst
index 2457d00eb2173..c03a7244a6f0e 100644
--- a/doc/source/whatsnew/v1.1.3.rst
+++ b/doc/source/whatsnew/v1.1.3.rst
@@ -25,6 +25,7 @@ Fixed regressions
Bug fixes
~~~~~~~~~
+- Bug in :func:`read_spss` where passing a ``pathlib.Path`` as ``path`` would raise a ``TypeError`` (:issue:`33666`)
- Bug in :meth:`Series.str.startswith` and :meth:`Series.str.endswith` with ``category`` dtype not propagating ``na`` parameter (:issue:`36241`)
- Bug in :class:`Series` constructor where integer overflow would occur for sufficiently large scalar inputs when an index was provided (:issue:`36291`)
diff --git a/pandas/io/spss.py b/pandas/io/spss.py
index 9605faeb36590..79cdfbf15392a 100644
--- a/pandas/io/spss.py
+++ b/pandas/io/spss.py
@@ -7,6 +7,8 @@
from pandas.core.api import DataFrame
+from pandas.io.common import stringify_path
+
def read_spss(
path: Union[str, Path],
@@ -40,6 +42,6 @@ def read_spss(
usecols = list(usecols) # pyreadstat requires a list
df, _ = pyreadstat.read_sav(
- path, usecols=usecols, apply_value_formats=convert_categoricals
+ stringify_path(path), usecols=usecols, apply_value_formats=convert_categoricals
)
return df
diff --git a/pandas/tests/io/test_spss.py b/pandas/tests/io/test_spss.py
index 013f56f83c5ec..a4894ff66ab9f 100644
--- a/pandas/tests/io/test_spss.py
+++ b/pandas/tests/io/test_spss.py
@@ -1,3 +1,5 @@
+from pathlib import Path
+
import numpy as np
import pytest
@@ -7,9 +9,10 @@
pyreadstat = pytest.importorskip("pyreadstat")
-def test_spss_labelled_num(datapath):
+@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/)
- fname = datapath("io", "data", "spss", "labelled-num.sav")
+ fname = path_klass(datapath("io", "data", "spss", "labelled-num.sav"))
df = pd.read_spss(fname, convert_categoricals=True)
expected = pd.DataFrame({"VAR00002": "This is one"}, index=[0])
| - [x] closes #33666
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Wrapped the `path` passed into `pandas.io.spss.read_spss` in a `pandas.io.common.stringify_path` call prior to passing it to `pyreadstat.read_sav`. This fixes #33666. I've also included tests validating `pd.read_spss` accepts strings and `pathlib.Path`s. | https://api.github.com/repos/pandas-dev/pandas/pulls/36174 | 2020-09-06T21:28:24Z | 2020-09-13T20:29:42Z | 2020-09-13T20:29:42Z | 2020-09-13T20:33:16Z |
REF: collect methods by topic | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 228e630f95863..58847528d2183 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -393,56 +393,6 @@ def __init__(
self._dtype = self._dtype.update_dtype(dtype)
self._codes = coerce_indexer_dtype(codes, dtype.categories)
- @property
- def categories(self):
- """
- The categories of this categorical.
-
- Setting assigns new values to each category (effectively a rename of
- each individual category).
-
- The assigned value has to be a list-like object. All items must be
- unique and the number of items in the new categories must be the same
- as the number of items in the old categories.
-
- Assigning to `categories` is a inplace operation!
-
- Raises
- ------
- ValueError
- If the new categories do not validate as categories or if the
- number of new categories is unequal the number of old categories
-
- See Also
- --------
- rename_categories : Rename categories.
- reorder_categories : Reorder categories.
- add_categories : Add new categories.
- remove_categories : Remove the specified categories.
- remove_unused_categories : Remove categories which are not used.
- set_categories : Set the categories to the specified ones.
- """
- return self.dtype.categories
-
- @categories.setter
- def categories(self, categories):
- new_dtype = CategoricalDtype(categories, ordered=self.ordered)
- if self.dtype.categories is not None and len(self.dtype.categories) != len(
- new_dtype.categories
- ):
- raise ValueError(
- "new categories need to have the same number of "
- "items as the old categories!"
- )
- self._dtype = new_dtype
-
- @property
- def ordered(self) -> Ordered:
- """
- Whether the categories have an ordered relationship.
- """
- return self.dtype.ordered
-
@property
def dtype(self) -> CategoricalDtype:
"""
@@ -458,10 +408,6 @@ def _constructor(self) -> Type["Categorical"]:
def _from_sequence(cls, scalars, dtype=None, copy=False):
return Categorical(scalars, dtype=dtype)
- def _formatter(self, boxed=False):
- # Defer to CategoricalFormatter's formatter.
- return None
-
def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
"""
Coerce this type to another dtype
@@ -640,6 +586,59 @@ def from_codes(cls, codes, categories=None, ordered=None, dtype=None):
return cls(codes, dtype=dtype, fastpath=True)
+ # ------------------------------------------------------------------
+ # Categories/Codes/Ordered
+
+ @property
+ def categories(self):
+ """
+ The categories of this categorical.
+
+ Setting assigns new values to each category (effectively a rename of
+ each individual category).
+
+ The assigned value has to be a list-like object. All items must be
+ unique and the number of items in the new categories must be the same
+ as the number of items in the old categories.
+
+ Assigning to `categories` is a inplace operation!
+
+ Raises
+ ------
+ ValueError
+ If the new categories do not validate as categories or if the
+ number of new categories is unequal the number of old categories
+
+ See Also
+ --------
+ rename_categories : Rename categories.
+ reorder_categories : Reorder categories.
+ add_categories : Add new categories.
+ remove_categories : Remove the specified categories.
+ remove_unused_categories : Remove categories which are not used.
+ set_categories : Set the categories to the specified ones.
+ """
+ return self.dtype.categories
+
+ @categories.setter
+ def categories(self, categories):
+ new_dtype = CategoricalDtype(categories, ordered=self.ordered)
+ if self.dtype.categories is not None and len(self.dtype.categories) != len(
+ new_dtype.categories
+ ):
+ raise ValueError(
+ "new categories need to have the same number of "
+ "items as the old categories!"
+ )
+ self._dtype = new_dtype
+
+ @property
+ def ordered(self) -> Ordered:
+ """
+ Whether the categories have an ordered relationship.
+ """
+ return self.dtype.ordered
+
@property
def codes(self) -> np.ndarray:
"""
@@ -1104,6 +1103,8 @@ def remove_unused_categories(self, inplace=False):
if not inplace:
return cat
+ # ------------------------------------------------------------------
+
def map(self, mapper):
"""
Map categories using input correspondence (dict, Series, or function).
@@ -1192,6 +1193,9 @@ def map(self, mapper):
__le__ = _cat_compare_op(operator.le)
__ge__ = _cat_compare_op(operator.ge)
+ # -------------------------------------------------------------
+ # Validators; ideally these can be de-duplicated
+
def _validate_insert_value(self, value) -> int:
code = self.categories.get_indexer([value])
if (code == -1) and not (is_scalar(value) and isna(value)):
@@ -1241,6 +1245,8 @@ def _validate_fill_value(self, fill_value):
)
return fill_value
+ # -------------------------------------------------------------
+
def __array__(self, dtype=None) -> np.ndarray:
"""
The numpy array interface.
@@ -1758,6 +1764,10 @@ def __contains__(self, key) -> bool:
# ------------------------------------------------------------------
# Rendering Methods
+ def _formatter(self, boxed=False):
+ # Defer to CategoricalFormatter's formatter.
+ return None
+
def _tidy_repr(self, max_vals=10, footer=True) -> str:
"""
a short repr displaying only max_vals and an optional (but default
@@ -1987,7 +1997,9 @@ def _reverse_indexer(self) -> Dict[Hashable, np.ndarray]:
result = dict(zip(categories, _result))
return result
- # reduction ops #
+ # ------------------------------------------------------------------
+ # Reductions
+
def _reduce(self, name: str, skipna: bool = True, **kwargs):
func = getattr(self, name, None)
if func is None:
@@ -2090,6 +2102,9 @@ def mode(self, dropna=True):
codes = sorted(htable.mode_int64(ensure_int64(codes), dropna))
return self._constructor(values=codes, dtype=self.dtype, fastpath=True)
+ # ------------------------------------------------------------------
+ # ExtensionArray Interface
+
def unique(self):
"""
Return the ``Categorical`` which ``categories`` and ``codes`` are
@@ -2179,6 +2194,18 @@ def equals(self, other: object) -> bool:
return np.array_equal(self._codes, other_codes)
return False
+ @property
+ def _can_hold_na(self):
+ return True
+
+ @classmethod
+ def _concat_same_type(self, to_concat):
+ from pandas.core.dtypes.concat import union_categoricals
+
+ return union_categoricals(to_concat)
+
+ # ------------------------------------------------------------------
+
def is_dtype_equal(self, other):
"""
Returns True if categoricals are the same dtype
@@ -2217,17 +2244,6 @@ def describe(self):
return result
- # Implement the ExtensionArray interface
- @property
- def _can_hold_na(self):
- return True
-
- @classmethod
- def _concat_same_type(self, to_concat):
- from pandas.core.dtypes.concat import union_categoricals
-
- return union_categoricals(to_concat)
-
def isin(self, values) -> np.ndarray:
"""
Check whether `values` are contained in Categorical.
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index d38f77aaceb01..7509cb35069e8 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -433,11 +433,6 @@ def _to_safe_for_reshape(self):
""" convert to object if we are a categorical """
return self.astype("object")
- def _maybe_cast_indexer(self, key):
- code = self.categories.get_loc(key)
- code = self.codes.dtype.type(code)
- return code
-
@doc(Index.where)
def where(self, cond, other=None):
# TODO: Investigate an alternative implementation with
@@ -537,6 +532,14 @@ def _reindex_non_unique(self, target):
return new_target, indexer, new_indexer
+ # --------------------------------------------------------------------
+ # Indexing Methods
+
+ def _maybe_cast_indexer(self, key):
+ code = self.categories.get_loc(key)
+ code = self.codes.dtype.type(code)
+ return code
+
@Appender(_index_shared_docs["get_indexer"] % _index_doc_kwargs)
def get_indexer(self, target, method=None, limit=None, tolerance=None):
method = missing.clean_reindex_fill_method(method)
@@ -619,6 +622,15 @@ def _convert_arr_indexer(self, keyarr):
def _convert_index_indexer(self, keyarr):
return self._shallow_copy(keyarr)
+ @doc(Index._maybe_cast_slice_bound)
+ def _maybe_cast_slice_bound(self, label, side, kind):
+ if kind == "loc":
+ return label
+
+ return super()._maybe_cast_slice_bound(label, side, kind)
+
+ # --------------------------------------------------------------------
+
def take_nd(self, *args, **kwargs):
"""Alias for `take`"""
warnings.warn(
@@ -628,13 +640,6 @@ def take_nd(self, *args, **kwargs):
)
return self.take(*args, **kwargs)
- @doc(Index._maybe_cast_slice_bound)
- def _maybe_cast_slice_bound(self, label, side, kind):
- if kind == "loc":
- return label
-
- return super()._maybe_cast_slice_bound(label, side, kind)
-
def map(self, mapper):
"""
Map values using input correspondence (a dict, Series, or function).
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 3fd93a8159041..f0b80c2852bd5 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -509,6 +509,9 @@ def snap(self, freq="S"):
dta = DatetimeArray(snapped, dtype=self.dtype)
return DatetimeIndex._simple_new(dta, name=self.name)
+ # --------------------------------------------------------------------
+ # Indexing Methods
+
def _parsed_string_to_bounds(self, reso: Resolution, parsed: datetime):
"""
Calculate datetime bounds for parsed time string and its resolution.
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 419ff81a2a478..3f72577c9420e 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -57,7 +57,7 @@
from pandas.core.ops import get_op_result_name
if TYPE_CHECKING:
- from pandas import CategoricalIndex
+ from pandas import CategoricalIndex # noqa:F401
_VALID_CLOSED = {"left", "right", "both", "neither"}
_index_doc_kwargs = dict(ibase._index_doc_kwargs)
@@ -515,28 +515,6 @@ def is_overlapping(self) -> bool:
# GH 23309
return self._engine.is_overlapping
- def _should_fallback_to_positional(self) -> bool:
- # integer lookups in Series.__getitem__ are unambiguously
- # positional in this case
- return self.dtype.subtype.kind in ["m", "M"]
-
- def _maybe_cast_slice_bound(self, label, side, kind):
- return getattr(self, side)._maybe_cast_slice_bound(label, side, kind)
-
- @Appender(Index._convert_list_indexer.__doc__)
- def _convert_list_indexer(self, keyarr):
- """
- we are passed a list-like indexer. Return the
- indexer for matching intervals.
- """
- locs = self.get_indexer_for(keyarr)
-
- # we have missing values
- if (locs == -1).any():
- raise KeyError
-
- return locs
-
def _can_reindex(self, indexer: np.ndarray) -> None:
"""
Check if we are allowing reindexing with this particular indexer.
@@ -668,6 +646,9 @@ def _searchsorted_monotonic(self, label, side, exclude_label=False):
return sub_idx._searchsorted_monotonic(label, side)
+ # --------------------------------------------------------------------
+ # Indexing Methods
+
def get_loc(
self, key, method: Optional[str] = None, tolerance=None
) -> Union[int, slice, np.ndarray]:
@@ -885,6 +866,30 @@ def _convert_slice_indexer(self, key: slice, kind: str):
return super()._convert_slice_indexer(key, kind)
+ def _should_fallback_to_positional(self) -> bool:
+ # integer lookups in Series.__getitem__ are unambiguously
+ # positional in this case
+ return self.dtype.subtype.kind in ["m", "M"]
+
+ def _maybe_cast_slice_bound(self, label, side, kind):
+ return getattr(self, side)._maybe_cast_slice_bound(label, side, kind)
+
+ @Appender(Index._convert_list_indexer.__doc__)
+ def _convert_list_indexer(self, keyarr):
+ """
+ we are passed a list-like indexer. Return the
+ indexer for matching intervals.
+ """
+ locs = self.get_indexer_for(keyarr)
+
+ # we have missing values
+ if (locs == -1).any():
+ raise KeyError
+
+ return locs
+
+ # --------------------------------------------------------------------
+
@Appender(Index.where.__doc__)
def where(self, cond, other=None):
if other is None:
@@ -1030,6 +1035,9 @@ def equals(self, other: object) -> bool:
and self.closed == other.closed
)
+ # --------------------------------------------------------------------
+ # Set Operations
+
@Appender(Index.intersection.__doc__)
@SetopCheck(op_name="intersection")
def intersection(
@@ -1115,6 +1123,12 @@ def func(self, other, sort=sort):
return func
+ union = _setop("union")
+ difference = _setop("difference")
+ symmetric_difference = _setop("symmetric_difference")
+
+ # --------------------------------------------------------------------
+
@property
def is_all_dates(self) -> bool:
"""
@@ -1123,10 +1137,6 @@ def is_all_dates(self) -> bool:
"""
return False
- union = _setop("union")
- difference = _setop("difference")
- symmetric_difference = _setop("symmetric_difference")
-
# TODO: arithmetic operations
# GH#30817 until IntervalArray implements inequalities, get them from Index
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index e49a23935efbd..9630e154ccd17 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -3154,6 +3154,8 @@ def _update_indexer(idxr, indexer=indexer):
return indexer._values
+ # --------------------------------------------------------------------
+
def _reorder_indexer(
self,
seq: Tuple[Union[Scalar, Iterable, AnyArrayLike], ...],
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index cd3f1f51a86d2..079f43cb2c66b 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -97,6 +97,9 @@ def _validate_dtype(cls, dtype: Dtype) -> None:
f"Incorrect `dtype` passed: expected {expected}, received {dtype}"
)
+ # ----------------------------------------------------------------
+ # Indexing Methods
+
@doc(Index._maybe_cast_slice_bound)
def _maybe_cast_slice_bound(self, label, side, kind):
assert kind in ["loc", "getitem", None]
@@ -104,6 +107,8 @@ def _maybe_cast_slice_bound(self, label, side, kind):
# we will try to coerce to integers
return self._maybe_cast_indexer(label)
+ # ----------------------------------------------------------------
+
@doc(Index._shallow_copy)
def _shallow_copy(self, values=None, name: Label = lib.no_default):
if values is not None and not self._can_hold_na and values.dtype.kind == "f":
@@ -293,6 +298,9 @@ class UInt64Index(IntegerIndex):
_engine_type = libindex.UInt64Engine
_default_dtype = np.dtype(np.uint64)
+ # ----------------------------------------------------------------
+ # Indexing Methods
+
@doc(Index._convert_arr_indexer)
def _convert_arr_indexer(self, keyarr):
# Cast the indexer to uint64 if possible so that the values returned
@@ -314,6 +322,8 @@ def _convert_index_indexer(self, keyarr):
return keyarr.astype(np.uint64)
return keyarr
+ # ----------------------------------------------------------------
+
def _wrap_joined_index(self, joined, other):
name = get_op_result_name(self, other)
return UInt64Index(joined, name=name)
@@ -385,6 +395,22 @@ def _convert_slice_indexer(self, key: slice, kind: str):
# translate to locations
return self.slice_indexer(key.start, key.stop, key.step, kind=kind)
+ @doc(Index.get_loc)
+ def get_loc(self, key, method=None, tolerance=None):
+ if is_bool(key):
+ # Catch this to avoid accidentally casting to 1.0
+ raise KeyError(key)
+
+ if is_float(key) and np.isnan(key):
+ nan_idxs = self._nan_idxs
+ if not len(nan_idxs):
+ raise KeyError(key)
+ elif len(nan_idxs) == 1:
+ return nan_idxs[0]
+ return nan_idxs
+
+ return super().get_loc(key, method=method, tolerance=tolerance)
+
# ----------------------------------------------------------------
def _format_native_types(
@@ -409,22 +435,6 @@ def __contains__(self, other: Any) -> bool:
return is_float(other) and np.isnan(other) and self.hasnans
- @doc(Index.get_loc)
- def get_loc(self, key, method=None, tolerance=None):
- if is_bool(key):
- # Catch this to avoid accidentally casting to 1.0
- raise KeyError(key)
-
- if is_float(key) and np.isnan(key):
- nan_idxs = self._nan_idxs
- if not len(nan_idxs):
- raise KeyError(key)
- elif len(nan_idxs) == 1:
- return nan_idxs[0]
- return nan_idxs
-
- return super().get_loc(key, method=method, tolerance=tolerance)
-
@cache_readonly
def is_unique(self) -> bool:
return super().is_unique and self._nan_idxs.size < 2
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index cdb502199c6f1..5282b6f0154b4 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -433,6 +433,41 @@ def inferred_type(self) -> str:
# indexing
return "period"
+ def insert(self, loc, item):
+ if not isinstance(item, Period) or self.freq != item.freq:
+ return self.astype(object).insert(loc, item)
+
+ i8result = np.concatenate(
+ (self[:loc].asi8, np.array([item.ordinal]), self[loc:].asi8)
+ )
+ arr = type(self._data)._simple_new(i8result, dtype=self.dtype)
+ return type(self)._simple_new(arr, name=self.name)
+
+ def join(self, other, how="left", level=None, return_indexers=False, sort=False):
+ """
+ See Index.join
+ """
+ self._assert_can_do_setop(other)
+
+ if not isinstance(other, PeriodIndex):
+ return self.astype(object).join(
+ other, how=how, level=level, return_indexers=return_indexers, sort=sort
+ )
+
+ # _assert_can_do_setop ensures we have matching dtype
+ result = Int64Index.join(
+ self,
+ other,
+ how=how,
+ level=level,
+ return_indexers=return_indexers,
+ sort=sort,
+ )
+ return result
+
+ # ------------------------------------------------------------------------
+ # Indexing Methods
+
@Appender(_index_shared_docs["get_indexer"] % _index_doc_kwargs)
def get_indexer(self, target, method=None, limit=None, tolerance=None):
target = ensure_index(target)
@@ -607,38 +642,6 @@ def _get_string_slice(self, key: str, use_lhs: bool = True, use_rhs: bool = True
except KeyError as err:
raise KeyError(key) from err
- def insert(self, loc, item):
- if not isinstance(item, Period) or self.freq != item.freq:
- return self.astype(object).insert(loc, item)
-
- i8result = np.concatenate(
- (self[:loc].asi8, np.array([item.ordinal]), self[loc:].asi8)
- )
- arr = type(self._data)._simple_new(i8result, dtype=self.dtype)
- return type(self)._simple_new(arr, name=self.name)
-
- def join(self, other, how="left", level=None, return_indexers=False, sort=False):
- """
- See Index.join
- """
- self._assert_can_do_setop(other)
-
- if not isinstance(other, PeriodIndex):
- return self.astype(object).join(
- other, how=how, level=level, return_indexers=return_indexers, sort=sort
- )
-
- # _assert_can_do_setop ensures we have matching dtype
- result = Int64Index.join(
- self,
- other,
- how=how,
- level=level,
- return_indexers=return_indexers,
- sort=sort,
- )
- return result
-
# ------------------------------------------------------------------------
# Set Operation Methods
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index f1457a9aac62b..684691501de5c 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -338,6 +338,9 @@ def __contains__(self, key: Any) -> bool:
return False
return key in self._range
+ # --------------------------------------------------------------------
+ # Indexing Methods
+
@doc(Int64Index.get_loc)
def get_loc(self, key, method=None, tolerance=None):
if method is None and tolerance is None:
@@ -379,6 +382,8 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
locs[valid] = len(self) - 1 - locs[valid]
return ensure_platform_int(locs)
+ # --------------------------------------------------------------------
+
def tolist(self):
return list(self._range)
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 85c8396dfd1fe..df08fda78823d 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -202,6 +202,9 @@ def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
"""
return is_timedelta64_dtype(dtype)
+ # -------------------------------------------------------------------
+ # Indexing Methods
+
def get_loc(self, key, method=None, tolerance=None):
"""
Get integer location for requested label
@@ -248,6 +251,8 @@ def _maybe_cast_slice_bound(self, label, side: str, kind):
return label
+ # -------------------------------------------------------------------
+
def is_type_compatible(self, typ) -> bool:
return typ == self.inferred_type or typ == "timedelta"
| https://api.github.com/repos/pandas-dev/pandas/pulls/36173 | 2020-09-06T21:13:10Z | 2020-09-07T21:43:13Z | 2020-09-07T21:43:12Z | 2020-09-07T21:47:37Z | |
DTA/TDA/PA use self._data instead of self.asi8 for self._ndarray | diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index a5b8032974fa4..a218745db0a44 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -27,7 +27,7 @@
from pandas.compat import set_function_name
from pandas.compat.numpy import function as nv
from pandas.errors import AbstractMethodError, NullFrequencyError, PerformanceWarning
-from pandas.util._decorators import Appender, Substitution
+from pandas.util._decorators import Appender, Substitution, cache_readonly
from pandas.util._validators import validate_fillna_kwargs
from pandas.core.dtypes.common import (
@@ -175,6 +175,14 @@ def _scalar_from_string(self, value: str) -> DTScalarOrNaT:
"""
raise AbstractMethodError(self)
+ @classmethod
+ def _rebox_native(cls, value: int) -> Union[int, np.datetime64, np.timedelta64]:
+ """
+ Box an integer unboxed via _unbox_scalar into the native type for
+ the underlying ndarray.
+ """
+ raise AbstractMethodError(cls)
+
def _unbox_scalar(self, value: DTScalarOrNaT) -> int:
"""
Unbox the integer value of a scalar `value`.
@@ -458,18 +466,15 @@ class DatetimeLikeArrayMixin(
# ------------------------------------------------------------------
# NDArrayBackedExtensionArray compat
- # TODO: make this a cache_readonly; need to get around _index_data
- # kludge in libreduction
- @property
+ @cache_readonly
def _ndarray(self) -> np.ndarray:
- # NB: A bunch of Interval tests fail if we use ._data
- return self.asi8
+ return self._data
def _from_backing_data(self: _T, arr: np.ndarray) -> _T:
# Note: we do not retain `freq`
- # error: Too many arguments for "NDArrayBackedExtensionArray"
- # error: Unexpected keyword argument "dtype" for "NDArrayBackedExtensionArray"
- return type(self)(arr, dtype=self.dtype) # type: ignore[call-arg]
+ return type(self)._simple_new( # type: ignore[attr-defined]
+ arr, dtype=self.dtype
+ )
# ------------------------------------------------------------------
@@ -526,7 +531,7 @@ def __array__(self, dtype=None) -> np.ndarray:
# used for Timedelta/DatetimeArray, overwritten by PeriodArray
if is_object_dtype(dtype):
return np.array(list(self), dtype=object)
- return self._data
+ return self._ndarray
def __getitem__(self, key):
"""
@@ -536,7 +541,7 @@ def __getitem__(self, key):
if lib.is_integer(key):
# fast-path
- result = self._data[key]
+ result = self._ndarray[key]
if self.ndim == 1:
return self._box_func(result)
return self._simple_new(result, dtype=self.dtype)
@@ -557,7 +562,7 @@ def __getitem__(self, key):
key = check_array_indexer(self, key)
freq = self._get_getitem_freq(key)
- result = self._data[key]
+ result = self._ndarray[key]
if lib.is_scalar(result):
return self._box_func(result)
return self._simple_new(result, dtype=self.dtype, freq=freq)
@@ -612,7 +617,7 @@ def __setitem__(
value = self._validate_setitem_value(value)
key = check_array_indexer(self, key)
- self._data[key] = value
+ self._ndarray[key] = value
self._maybe_clear_freq()
def _maybe_clear_freq(self):
@@ -663,8 +668,8 @@ def astype(self, dtype, copy=True):
def view(self, dtype=None):
if dtype is None or dtype is self.dtype:
- return type(self)(self._data, dtype=self.dtype)
- return self._data.view(dtype=dtype)
+ return type(self)(self._ndarray, dtype=self.dtype)
+ return self._ndarray.view(dtype=dtype)
# ------------------------------------------------------------------
# ExtensionArray Interface
@@ -705,7 +710,7 @@ def _from_factorized(cls, values, original):
return cls(values, dtype=original.dtype)
def _values_for_argsort(self):
- return self._data
+ return self._ndarray
# ------------------------------------------------------------------
# Validation Methods
@@ -722,7 +727,7 @@ def _validate_fill_value(self, fill_value):
Returns
-------
- fill_value : np.int64
+ fill_value : np.int64, np.datetime64, or np.timedelta64
Raises
------
@@ -736,7 +741,8 @@ def _validate_fill_value(self, fill_value):
fill_value = self._validate_scalar(fill_value, msg)
except TypeError as err:
raise ValueError(msg) from err
- return self._unbox(fill_value)
+ rv = self._unbox(fill_value)
+ return self._rebox_native(rv)
def _validate_shift_value(self, fill_value):
# TODO(2.0): once this deprecation is enforced, use _validate_fill_value
@@ -951,9 +957,9 @@ def value_counts(self, dropna=False):
from pandas import Index, Series
if dropna:
- values = self[~self.isna()]._data
+ values = self[~self.isna()]._ndarray
else:
- values = self._data
+ values = self._ndarray
cls = type(self)
@@ -1044,9 +1050,9 @@ def fillna(self, value=None, method=None, limit=None):
else:
func = missing.backfill_1d
- values = self._data
+ values = self._ndarray
if not is_period_dtype(self.dtype):
- # For PeriodArray self._data is i8, which gets copied
+ # For PeriodArray self._ndarray is i8, which gets copied
# by `func`. Otherwise we need to make a copy manually
# to avoid modifying `self` in-place.
values = values.copy()
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 1bea3a9eb137e..d913e7be9ae5f 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -446,6 +446,10 @@ def _generate_range(
# -----------------------------------------------------------------
# DatetimeLike Interface
+ @classmethod
+ def _rebox_native(cls, value: int) -> np.datetime64:
+ return np.int64(value).view("M8[ns]")
+
def _unbox_scalar(self, value):
if not isinstance(value, self._scalar_type) and value is not NaT:
raise ValueError("'value' should be a Timestamp.")
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index cc39ffb5d1203..c3a9430736969 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -253,6 +253,10 @@ def _generate_range(cls, start, end, periods, freq, fields):
# -----------------------------------------------------------------
# DatetimeLike Interface
+ @classmethod
+ def _rebox_native(cls, value: int) -> np.int64:
+ return np.int64(value)
+
def _unbox_scalar(self, value: Union[Period, NaTType]) -> int:
if value is NaT:
return value.value
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 2d694c469b3a9..485ebb49a376d 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -271,6 +271,10 @@ def _generate_range(cls, start, end, periods, freq, closed=None):
# ----------------------------------------------------------------
# DatetimeLike Interface
+ @classmethod
+ def _rebox_native(cls, value: int) -> np.timedelta64:
+ return np.int64(value).view("m8[ns]")
+
def _unbox_scalar(self, value):
if not isinstance(value, self._scalar_type) and value is not NaT:
raise ValueError("'value' should be a Timedelta.")
diff --git a/pandas/tests/frame/indexing/test_datetime.py b/pandas/tests/frame/indexing/test_datetime.py
index 1937a4c380dc9..1866ac341def6 100644
--- a/pandas/tests/frame/indexing/test_datetime.py
+++ b/pandas/tests/frame/indexing/test_datetime.py
@@ -23,7 +23,9 @@ def test_setitem(self, timezone_frame):
b1 = df._mgr.blocks[1]
b2 = df._mgr.blocks[2]
tm.assert_extension_array_equal(b1.values, b2.values)
- assert id(b1.values._data.base) != id(b2.values._data.base)
+ b1base = b1.values._data.base
+ b2base = b2.values._data.base
+ assert b1base is None or (id(b1base) != id(b2base))
# with nan
df2 = df.copy()
| This in turn will let us share more methods with the parent class, at the cost of re-shuffling where we do some of the view-casting. | https://api.github.com/repos/pandas-dev/pandas/pulls/36171 | 2020-09-06T20:26:35Z | 2020-09-07T20:46:34Z | 2020-09-07T20:46:34Z | 2020-09-07T21:51:02Z |
Comma cleanup | diff --git a/pandas/tests/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index 4fae01ec710fd..bfb62835add93 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -56,7 +56,7 @@ def test_is_scalar_access(self):
assert ser.iloc._is_scalar_access((1,))
df = ser.to_frame()
- assert df.iloc._is_scalar_access((1, 0,))
+ assert df.iloc._is_scalar_access((1, 0))
def test_iloc_exceeds_bounds(self):
diff --git a/pandas/tests/indexing/test_indexing.py b/pandas/tests/indexing/test_indexing.py
index a080c5d169215..ca8a3ddc95575 100644
--- a/pandas/tests/indexing/test_indexing.py
+++ b/pandas/tests/indexing/test_indexing.py
@@ -1004,7 +1004,7 @@ def test_extension_array_cross_section():
def test_extension_array_cross_section_converts():
# all numeric columns -> numeric series
df = pd.DataFrame(
- {"A": pd.array([1, 2], dtype="Int64"), "B": np.array([1, 2])}, index=["a", "b"],
+ {"A": pd.array([1, 2], dtype="Int64"), "B": np.array([1, 2])}, index=["a", "b"]
)
result = df.loc["a"]
expected = pd.Series([1, 1], dtype="Int64", index=["A", "B"], name="a")
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index 193800fae751f..e42d9679464d8 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -29,13 +29,11 @@ def test_loc_getitem_label_out_of_range(self):
# out of range label
self.check_result(
- "loc", "f", typs=["ints", "uints", "labels", "mixed", "ts"], fails=KeyError,
+ "loc", "f", typs=["ints", "uints", "labels", "mixed", "ts"], fails=KeyError
)
self.check_result("loc", "f", typs=["floats"], fails=KeyError)
self.check_result("loc", "f", typs=["floats"], fails=KeyError)
- self.check_result(
- "loc", 20, typs=["ints", "uints", "mixed"], fails=KeyError,
- )
+ self.check_result("loc", 20, typs=["ints", "uints", "mixed"], fails=KeyError)
self.check_result("loc", 20, typs=["labels"], fails=KeyError)
self.check_result("loc", 20, typs=["ts"], axes=0, fails=KeyError)
self.check_result("loc", 20, typs=["floats"], axes=0, fails=KeyError)
@@ -46,26 +44,24 @@ def test_loc_getitem_label_list(self):
pass
def test_loc_getitem_label_list_with_missing(self):
+ self.check_result("loc", [0, 1, 2], typs=["empty"], fails=KeyError)
self.check_result(
- "loc", [0, 1, 2], typs=["empty"], fails=KeyError,
- )
- self.check_result(
- "loc", [0, 2, 10], typs=["ints", "uints", "floats"], axes=0, fails=KeyError,
+ "loc", [0, 2, 10], typs=["ints", "uints", "floats"], axes=0, fails=KeyError
)
self.check_result(
- "loc", [3, 6, 7], typs=["ints", "uints", "floats"], axes=1, fails=KeyError,
+ "loc", [3, 6, 7], typs=["ints", "uints", "floats"], axes=1, fails=KeyError
)
# GH 17758 - MultiIndex and missing keys
self.check_result(
- "loc", [(1, 3), (1, 4), (2, 5)], typs=["multi"], axes=0, fails=KeyError,
+ "loc", [(1, 3), (1, 4), (2, 5)], typs=["multi"], axes=0, fails=KeyError
)
def test_loc_getitem_label_list_fails(self):
# fails
self.check_result(
- "loc", [20, 30, 40], typs=["ints", "uints"], axes=1, fails=KeyError,
+ "loc", [20, 30, 40], typs=["ints", "uints"], axes=1, fails=KeyError
)
def test_loc_getitem_label_array_like(self):
@@ -95,18 +91,14 @@ def test_loc_getitem_label_slice(self):
)
self.check_result(
- "loc", slice("20130102", "20130104"), typs=["ts"], axes=1, fails=TypeError,
+ "loc", slice("20130102", "20130104"), typs=["ts"], axes=1, fails=TypeError
)
- self.check_result(
- "loc", slice(2, 8), typs=["mixed"], axes=0, fails=TypeError,
- )
- self.check_result(
- "loc", slice(2, 8), typs=["mixed"], axes=1, fails=KeyError,
- )
+ self.check_result("loc", slice(2, 8), typs=["mixed"], axes=0, fails=TypeError)
+ self.check_result("loc", slice(2, 8), typs=["mixed"], axes=1, fails=KeyError)
self.check_result(
- "loc", slice(2, 4, 2), typs=["mixed"], axes=0, fails=TypeError,
+ "loc", slice(2, 4, 2), typs=["mixed"], axes=0, fails=TypeError
)
def test_setitem_from_duplicate_axis(self):
@@ -669,8 +661,7 @@ def test_loc_setitem_with_scalar_index(self, indexer, value):
(1, ["A", "B", "C"]),
np.array([7, 8, 9], dtype=np.int64),
pd.DataFrame(
- [[1, 2, np.nan], [7, 8, 9], [5, 6, np.nan]],
- columns=["A", "B", "C"],
+ [[1, 2, np.nan], [7, 8, 9], [5, 6, np.nan]], columns=["A", "B", "C"]
),
),
(
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 06ccdd2484a2a..1d73d1e35728b 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -892,16 +892,16 @@ def assert_reindex_indexer_is_ok(mgr, axis, new_labels, indexer, fill_value):
fill_value,
)
assert_reindex_indexer_is_ok(
- mgr, ax, mgr.axes[ax][::-1], np.arange(mgr.shape[ax]), fill_value,
+ mgr, ax, mgr.axes[ax][::-1], np.arange(mgr.shape[ax]), fill_value
)
assert_reindex_indexer_is_ok(
- mgr, ax, mgr.axes[ax], np.arange(mgr.shape[ax])[::-1], fill_value,
+ mgr, ax, mgr.axes[ax], np.arange(mgr.shape[ax])[::-1], fill_value
)
assert_reindex_indexer_is_ok(
mgr, ax, pd.Index(["foo", "bar", "baz"]), [0, 0, 0], fill_value
)
assert_reindex_indexer_is_ok(
- mgr, ax, pd.Index(["foo", "bar", "baz"]), [-1, 0, -1], fill_value,
+ mgr, ax, pd.Index(["foo", "bar", "baz"]), [-1, 0, -1], fill_value
)
assert_reindex_indexer_is_ok(
mgr,
@@ -913,7 +913,7 @@ def assert_reindex_indexer_is_ok(mgr, axis, new_labels, indexer, fill_value):
if mgr.shape[ax] >= 3:
assert_reindex_indexer_is_ok(
- mgr, ax, pd.Index(["foo", "bar", "baz"]), [0, 1, 2], fill_value,
+ mgr, ax, pd.Index(["foo", "bar", "baz"]), [0, 1, 2], fill_value
)
diff --git a/pandas/tests/io/formats/test_css.py b/pandas/tests/io/formats/test_css.py
index 9383f86e335fa..785904fafd31a 100644
--- a/pandas/tests/io/formats/test_css.py
+++ b/pandas/tests/io/formats/test_css.py
@@ -99,11 +99,11 @@ def test_css_side_shorthands(shorthand, expansions):
top, right, bottom, left = expansions
assert_resolves(
- f"{shorthand}: 1pt", {top: "1pt", right: "1pt", bottom: "1pt", left: "1pt"},
+ f"{shorthand}: 1pt", {top: "1pt", right: "1pt", bottom: "1pt", left: "1pt"}
)
assert_resolves(
- f"{shorthand}: 1pt 4pt", {top: "1pt", right: "4pt", bottom: "1pt", left: "4pt"},
+ f"{shorthand}: 1pt 4pt", {top: "1pt", right: "4pt", bottom: "1pt", left: "4pt"}
)
assert_resolves(
@@ -189,9 +189,7 @@ def test_css_absolute_font_size(size, relative_to, resolved):
inherited = None
else:
inherited = {"font-size": relative_to}
- assert_resolves(
- f"font-size: {size}", {"font-size": resolved}, inherited=inherited,
- )
+ assert_resolves(f"font-size: {size}", {"font-size": resolved}, inherited=inherited)
@pytest.mark.parametrize(
@@ -225,6 +223,4 @@ def test_css_relative_font_size(size, relative_to, resolved):
inherited = None
else:
inherited = {"font-size": relative_to}
- assert_resolves(
- f"font-size: {size}", {"font-size": resolved}, inherited=inherited,
- )
+ assert_resolves(f"font-size: {size}", {"font-size": resolved}, inherited=inherited)
diff --git a/pandas/tests/io/formats/test_info.py b/pandas/tests/io/formats/test_info.py
index 877bd1650ae60..7000daeb9b575 100644
--- a/pandas/tests/io/formats/test_info.py
+++ b/pandas/tests/io/formats/test_info.py
@@ -299,7 +299,7 @@ def test_info_memory_usage():
DataFrame(1, index=["a"], columns=["A"]).memory_usage(index=True)
DataFrame(1, index=["a"], columns=["A"]).index.nbytes
df = DataFrame(
- data=1, index=MultiIndex.from_product([["a"], range(1000)]), columns=["A"],
+ data=1, index=MultiIndex.from_product([["a"], range(1000)]), columns=["A"]
)
df.index.nbytes
df.memory_usage(index=True)
@@ -336,7 +336,7 @@ def test_info_memory_usage_deep_pypy():
@pytest.mark.skipif(PYPY, reason="PyPy getsizeof() fails by design")
def test_usage_via_getsizeof():
df = DataFrame(
- data=1, index=MultiIndex.from_product([["a"], range(1000)]), columns=["A"],
+ data=1, index=MultiIndex.from_product([["a"], range(1000)]), columns=["A"]
)
mem = df.memory_usage(deep=True).sum()
# sys.getsizeof will call the .memory_usage with
@@ -359,16 +359,14 @@ def test_info_memory_usage_qualified():
buf = StringIO()
df = DataFrame(
- 1, columns=list("ab"), index=MultiIndex.from_product([range(3), range(3)]),
+ 1, columns=list("ab"), index=MultiIndex.from_product([range(3), range(3)])
)
df.info(buf=buf)
assert "+" not in buf.getvalue()
buf = StringIO()
df = DataFrame(
- 1,
- columns=list("ab"),
- index=MultiIndex.from_product([range(3), ["foo", "bar"]]),
+ 1, columns=list("ab"), index=MultiIndex.from_product([range(3), ["foo", "bar"]])
)
df.info(buf=buf)
assert "+" in buf.getvalue()
@@ -384,7 +382,7 @@ def memory_usage(f):
N = 100
M = len(uppercase)
index = MultiIndex.from_product(
- [list(uppercase), date_range("20160101", periods=N)], names=["id", "date"],
+ [list(uppercase), date_range("20160101", periods=N)], names=["id", "date"]
)
df = DataFrame({"value": np.random.randn(N * M)}, index=index)
diff --git a/pandas/tests/io/json/test_compression.py b/pandas/tests/io/json/test_compression.py
index c0e3220454bf1..a41af9886c617 100644
--- a/pandas/tests/io/json/test_compression.py
+++ b/pandas/tests/io/json/test_compression.py
@@ -45,7 +45,7 @@ def test_with_s3_url(compression, s3_resource, s3so):
s3_resource.Bucket("pandas-test").put_object(Key="test-1", Body=f)
roundtripped_df = pd.read_json(
- "s3://pandas-test/test-1", compression=compression, storage_options=s3so,
+ "s3://pandas-test/test-1", compression=compression, storage_options=s3so
)
tm.assert_frame_equal(df, roundtripped_df)
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 59d64e1a6e909..13152f01abb04 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -745,11 +745,7 @@ def test_reconstruction_index(self):
def test_path(self, float_frame, int_frame, datetime_frame):
with tm.ensure_clean("test.json") as path:
- for df in [
- float_frame,
- int_frame,
- datetime_frame,
- ]:
+ for df in [float_frame, int_frame, datetime_frame]:
df.to_json(path)
read_json(path)
@@ -1706,9 +1702,7 @@ def test_to_s3(self, s3_resource, s3so):
# GH 28375
mock_bucket_name, target_file = "pandas-test", "test.json"
df = DataFrame({"x": [1, 2, 3], "y": [2, 4, 6]})
- df.to_json(
- f"s3://{mock_bucket_name}/{target_file}", storage_options=s3so,
- )
+ df.to_json(f"s3://{mock_bucket_name}/{target_file}", storage_options=s3so)
timeout = 5
while True:
if target_file in (
diff --git a/pandas/tests/io/parser/test_c_parser_only.py b/pandas/tests/io/parser/test_c_parser_only.py
index 50179fc1ec4b8..50d5fb3e49c2a 100644
--- a/pandas/tests/io/parser/test_c_parser_only.py
+++ b/pandas/tests/io/parser/test_c_parser_only.py
@@ -646,9 +646,7 @@ def test_1000_sep_with_decimal(
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize(
- "float_precision", [None, "high", "round_trip"],
-)
+@pytest.mark.parametrize("float_precision", [None, "high", "round_trip"])
@pytest.mark.parametrize(
"value,expected",
[
diff --git a/pandas/tests/io/parser/test_parse_dates.py b/pandas/tests/io/parser/test_parse_dates.py
index ed947755e3419..833186b69c63b 100644
--- a/pandas/tests/io/parser/test_parse_dates.py
+++ b/pandas/tests/io/parser/test_parse_dates.py
@@ -1439,7 +1439,7 @@ def test_parse_timezone(all_parsers):
end="2018-01-04 09:05:00",
freq="1min",
tz=pytz.FixedOffset(540),
- ),
+ )
),
freq=None,
)
@@ -1553,5 +1553,5 @@ def test_missing_parse_dates_column_raises(
msg = f"Missing column provided to 'parse_dates': '{missing_cols}'"
with pytest.raises(ValueError, match=msg):
parser.read_csv(
- content, sep=",", names=names, usecols=usecols, parse_dates=parse_dates,
+ content, sep=",", names=names, usecols=usecols, parse_dates=parse_dates
)
diff --git a/pandas/tests/io/parser/test_usecols.py b/pandas/tests/io/parser/test_usecols.py
index d4e049cc3fcc2..7e9c9866a666d 100644
--- a/pandas/tests/io/parser/test_usecols.py
+++ b/pandas/tests/io/parser/test_usecols.py
@@ -199,7 +199,7 @@ def test_usecols_with_whitespace(all_parsers):
# Column selection by index.
([0, 1], DataFrame(data=[[1000, 2000], [4000, 5000]], columns=["2", "0"])),
# Column selection by name.
- (["0", "1"], DataFrame(data=[[2000, 3000], [5000, 6000]], columns=["0", "1"]),),
+ (["0", "1"], DataFrame(data=[[2000, 3000], [5000, 6000]], columns=["0", "1"])),
],
)
def test_usecols_with_integer_like_header(all_parsers, usecols, expected):
| - [x] pandas/tests/indexing/test_iloc.py
- [x] pandas/tests/indexing/test_indexing.py
- [x] pandas/tests/indexing/test_loc.py
- [x] pandas/tests/internals/test_internals.py
- [x] pandas/tests/io/formats/test_css.py
- [x] pandas/tests/io/formats/test_info.py
- [x] pandas/tests/io/json/test_compression.py
- [x] pandas/tests/io/json/test_pandas.py
- [x] pandas/tests/io/parser/test_c_parser_only.py
- [x] pandas/tests/io/parser/test_parse_dates.py
- [x] pandas/tests/io/parser/test_usecols.py
| https://api.github.com/repos/pandas-dev/pandas/pulls/36168 | 2020-09-06T17:10:01Z | 2020-09-07T19:04:43Z | 2020-09-07T19:04:43Z | 2020-09-07T19:04:48Z |
Backport PR #35979 on branch 1.1.x (BUG: Respect errors="ignore" during extension astype) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index dea3cb6f567ac..1c3258db28698 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -33,6 +33,7 @@ Bug fixes
- Bug in :meth:`DataFrame.eval` with ``object`` dtype column binary operations (:issue:`35794`)
- Bug in :class:`Series` constructor raising a ``TypeError`` when constructing sparse datetime64 dtypes (:issue:`35762`)
- Bug in :meth:`DataFrame.apply` with ``result_type="reduce"`` returning with incorrect index (:issue:`35683`)
+- Bug in :meth:`Series.astype` and :meth:`DataFrame.astype` not respecting the ``errors`` argument when set to ``"ignore"`` for extension dtypes (:issue:`35471`)
- Bug in :meth:`DateTimeIndex.format` and :meth:`PeriodIndex.format` with ``name=True`` setting the first item to ``"None"`` where it should be ``""`` (:issue:`35712`)
- Bug in :meth:`Float64Index.__contains__` incorrectly raising ``TypeError`` instead of returning ``False`` (:issue:`35788`)
- Bug in :class:`Series` constructor incorrectly raising a ``TypeError`` when passed an ordered set (:issue:`36044`)
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index f4f4a3666a84e..ea2b0c972d9aa 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -565,8 +565,13 @@ def astype(self, dtype, copy: bool = False, errors: str = "raise"):
# force the copy here
if self.is_extension:
- # TODO: Should we try/except this astype?
- values = self.values.astype(dtype)
+ try:
+ values = self.values.astype(dtype)
+ except (ValueError, TypeError):
+ if errors == "ignore":
+ values = self.values
+ else:
+ raise
else:
if issubclass(dtype.type, str):
diff --git a/pandas/tests/frame/methods/test_astype.py b/pandas/tests/frame/methods/test_astype.py
index b0fd0496ea81e..d3f256259b15f 100644
--- a/pandas/tests/frame/methods/test_astype.py
+++ b/pandas/tests/frame/methods/test_astype.py
@@ -8,6 +8,7 @@
CategoricalDtype,
DataFrame,
DatetimeTZDtype,
+ Interval,
IntervalDtype,
NaT,
Series,
@@ -565,3 +566,24 @@ def test_astype_empty_dtype_dict(self):
result = df.astype(dict())
tm.assert_frame_equal(result, df)
assert result is not df
+
+ @pytest.mark.parametrize(
+ "df",
+ [
+ DataFrame(Series(["x", "y", "z"], dtype="string")),
+ DataFrame(Series(["x", "y", "z"], dtype="category")),
+ DataFrame(Series(3 * [Timestamp("2020-01-01", tz="UTC")])),
+ DataFrame(Series(3 * [Interval(0, 1)])),
+ ],
+ )
+ @pytest.mark.parametrize("errors", ["raise", "ignore"])
+ def test_astype_ignores_errors_for_extension_dtypes(self, df, errors):
+ # https://github.com/pandas-dev/pandas/issues/35471
+ if errors == "ignore":
+ expected = df
+ result = df.astype(float, errors=errors)
+ tm.assert_frame_equal(result, expected)
+ else:
+ msg = "(Cannot cast)|(could not convert)"
+ with pytest.raises((ValueError, TypeError), match=msg):
+ df.astype(float, errors=errors)
diff --git a/pandas/tests/series/methods/test_astype.py b/pandas/tests/series/methods/test_astype.py
index 9fdc4179de2e1..b9d90a9fc63dd 100644
--- a/pandas/tests/series/methods/test_astype.py
+++ b/pandas/tests/series/methods/test_astype.py
@@ -1,4 +1,6 @@
-from pandas import Series, date_range
+import pytest
+
+from pandas import Interval, Series, Timestamp, date_range
import pandas._testing as tm
@@ -23,3 +25,24 @@ def test_astype_dt64tz_to_str(self):
dtype=object,
)
tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize(
+ "values",
+ [
+ Series(["x", "y", "z"], dtype="string"),
+ Series(["x", "y", "z"], dtype="category"),
+ Series(3 * [Timestamp("2020-01-01", tz="UTC")]),
+ Series(3 * [Interval(0, 1)]),
+ ],
+ )
+ @pytest.mark.parametrize("errors", ["raise", "ignore"])
+ def test_astype_ignores_errors_for_extension_dtypes(self, values, errors):
+ # https://github.com/pandas-dev/pandas/issues/35471
+ if errors == "ignore":
+ expected = values
+ result = values.astype(float, errors="ignore")
+ tm.assert_series_equal(result, expected)
+ else:
+ msg = "(Cannot cast)|(could not convert)"
+ with pytest.raises((ValueError, TypeError), match=msg):
+ values.astype(float, errors=errors)
| Backport PR #35979: BUG: Respect errors="ignore" during extension astype | https://api.github.com/repos/pandas-dev/pandas/pulls/36167 | 2020-09-06T17:07:33Z | 2020-09-06T18:06:24Z | 2020-09-06T18:06:24Z | 2020-09-06T18:06:24Z |
Backport PR #36115 on branch 1.1.x (REGR: append tz-aware DataFrame with tz-naive values) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index dea3cb6f567ac..0d3c0b203a10d 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -16,6 +16,7 @@ Fixed regressions
~~~~~~~~~~~~~~~~~
- Regression in :meth:`DatetimeIndex.intersection` incorrectly raising ``AssertionError`` when intersecting against a list (:issue:`35876`)
- Fix regression in updating a column inplace (e.g. using ``df['col'].fillna(.., inplace=True)``) (:issue:`35731`)
+- Fix regression in :meth:`DataFrame.append` mixing tz-aware and tz-naive datetime columns (:issue:`35460`)
- Performance regression for :meth:`RangeIndex.format` (:issue:`35712`)
- Regression where :meth:`MultiIndex.get_loc` would return a slice spanning the full index when passed an empty list (:issue:`35878`)
- Fix regression in invalid cache after an indexing operation; this can manifest when setting which does not update the data (:issue:`35521`)
diff --git a/pandas/core/dtypes/concat.py b/pandas/core/dtypes/concat.py
index 9902016475b22..dd005752a4832 100644
--- a/pandas/core/dtypes/concat.py
+++ b/pandas/core/dtypes/concat.py
@@ -148,15 +148,17 @@ def is_nonempty(x) -> bool:
any_ea = any(is_extension_array_dtype(x.dtype) for x in to_concat)
if any_ea:
+ # we ignore axis here, as internally concatting with EAs is always
+ # for axis=0
if not single_dtype:
target_dtype = find_common_type([x.dtype for x in to_concat])
to_concat = [_cast_to_common_type(arr, target_dtype) for arr in to_concat]
- if isinstance(to_concat[0], ExtensionArray) and axis == 0:
+ if isinstance(to_concat[0], ExtensionArray):
cls = type(to_concat[0])
return cls._concat_same_type(to_concat)
else:
- return np.concatenate(to_concat, axis=axis)
+ return np.concatenate(to_concat)
elif _contains_datetime or "timedelta" in typs:
return concat_datetime(to_concat, axis=axis, typs=typs)
diff --git a/pandas/core/internals/concat.py b/pandas/core/internals/concat.py
index 2c0d4931a7bf2..5d06cb4c48ac3 100644
--- a/pandas/core/internals/concat.py
+++ b/pandas/core/internals/concat.py
@@ -23,7 +23,7 @@
from pandas.core.dtypes.missing import isna
import pandas.core.algorithms as algos
-from pandas.core.arrays import ExtensionArray
+from pandas.core.arrays import DatetimeArray, ExtensionArray
from pandas.core.internals.blocks import make_block
from pandas.core.internals.managers import BlockManager
@@ -334,9 +334,13 @@ def _concatenate_join_units(join_units, concat_axis, copy):
# the non-EA values are 2D arrays with shape (1, n)
to_concat = [t if isinstance(t, ExtensionArray) else t[0, :] for t in to_concat]
concat_values = concat_compat(to_concat, axis=0)
- if not isinstance(concat_values, ExtensionArray):
+ if not isinstance(concat_values, ExtensionArray) or (
+ isinstance(concat_values, DatetimeArray) and concat_values.tz is None
+ ):
# if the result of concat is not an EA but an ndarray, reshape to
# 2D to put it a non-EA Block
+ # special case DatetimeArray, which *is* an EA, but is put in a
+ # consolidated 2D block
concat_values = np.atleast_2d(concat_values)
else:
concat_values = concat_compat(to_concat, axis=concat_axis,)
diff --git a/pandas/tests/reshape/test_concat.py b/pandas/tests/reshape/test_concat.py
index 0159fabd04d59..53d3a35328b68 100644
--- a/pandas/tests/reshape/test_concat.py
+++ b/pandas/tests/reshape/test_concat.py
@@ -1110,6 +1110,23 @@ def test_append_empty_frame_to_series_with_dateutil_tz(self):
result = df.append([s, s], ignore_index=True)
tm.assert_frame_equal(result, expected)
+ def test_append_empty_tz_frame_with_datetime64ns(self):
+ # https://github.com/pandas-dev/pandas/issues/35460
+ df = pd.DataFrame(columns=["a"]).astype("datetime64[ns, UTC]")
+
+ # pd.NaT gets inferred as tz-naive, so append result is tz-naive
+ result = df.append({"a": pd.NaT}, ignore_index=True)
+ expected = pd.DataFrame({"a": [pd.NaT]}).astype("datetime64[ns]")
+ tm.assert_frame_equal(result, expected)
+
+ # also test with typed value to append
+ df = pd.DataFrame(columns=["a"]).astype("datetime64[ns, UTC]")
+ result = df.append(
+ pd.Series({"a": pd.NaT}, dtype="datetime64[ns]"), ignore_index=True
+ )
+ expected = pd.DataFrame({"a": [pd.NaT]}).astype("datetime64[ns]")
+ tm.assert_frame_equal(result, expected)
+
class TestConcatenate:
def test_concat_copy(self):
| Backport PR #36115: REGR: append tz-aware DataFrame with tz-naive values | https://api.github.com/repos/pandas-dev/pandas/pulls/36166 | 2020-09-06T17:05:57Z | 2020-09-06T18:07:55Z | 2020-09-06T18:07:55Z | 2020-09-06T18:07:56Z |
TST verify groupby doesn't alter unit64s to floats #30859 | diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index e0196df7ceac0..69397228dd941 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -1183,6 +1183,18 @@ def test_groupby_dtype_inference_empty():
tm.assert_frame_equal(result, expected, by_blocks=True)
+def test_groupby_unit64_float_conversion():
+ # GH: 30859 groupby converts unit64 to floats sometimes
+ df = pd.DataFrame({"first": [1], "second": [1], "value": [16148277970000000000]})
+ result = df.groupby(["first", "second"])["value"].max()
+ expected = pd.Series(
+ [16148277970000000000],
+ pd.MultiIndex.from_product([[1], [1]], names=["first", "second"]),
+ name="value",
+ )
+ tm.assert_series_equal(result, expected)
+
+
def test_groupby_list_infer_array_like(df):
result = df.groupby(list(df["A"])).mean()
expected = df.groupby(df["A"]).mean()
| - [x] closes #30859
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
Logic of the test is to check that the value hasn't changes and that the dtype remains uint64. | https://api.github.com/repos/pandas-dev/pandas/pulls/36164 | 2020-09-06T14:12:04Z | 2020-09-07T20:47:40Z | 2020-09-07T20:47:40Z | 2020-09-07T20:47:44Z |
Backport PR #35914 on branch 1.1.x (Make MultiIndex.get_loc raise for unhashable type) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index d1a66256454ca..0fa5dd30f8cd9 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -17,6 +17,7 @@ Fixed regressions
- Regression in :meth:`DatetimeIndex.intersection` incorrectly raising ``AssertionError`` when intersecting against a list (:issue:`35876`)
- Fix regression in updating a column inplace (e.g. using ``df['col'].fillna(.., inplace=True)``) (:issue:`35731`)
- Performance regression for :meth:`RangeIndex.format` (:issue:`35712`)
+- Regression where :meth:`MultiIndex.get_loc` would return a slice spanning the full index when passed an empty list (:issue:`35878`)
- Fix regression in invalid cache after an indexing operation; this can manifest when setting which does not update the data (:issue:`35521`)
- Regression in :meth:`DataFrame.replace` where a ``TypeError`` would be raised when attempting to replace elements of type :class:`Interval` (:issue:`35931`)
- Fix regression in pickle roundtrip of the ``closed`` attribute of :class:`IntervalIndex` (:issue:`35658`)
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 235da89083d0a..09504d50bbf40 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -2681,6 +2681,8 @@ def get_loc(self, key, method=None):
"currently supported for MultiIndex"
)
+ hash(key)
+
def _maybe_to_slice(loc):
"""convert integer indexer to boolean mask or slice if possible"""
if not isinstance(loc, np.ndarray) or loc.dtype != "int64":
@@ -2695,8 +2697,7 @@ def _maybe_to_slice(loc):
mask[loc] = True
return mask
- if not isinstance(key, (tuple, list)):
- # not including list here breaks some indexing, xref #30892
+ if not isinstance(key, tuple):
loc = self._get_level_indexer(key, level=0)
return _maybe_to_slice(loc)
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index d27487dfb8aaa..e4549dfb3e68d 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -2111,7 +2111,7 @@ def test_type_error_multiindex(self):
)
dg = df.pivot_table(index="i", columns="c", values=["x", "y"])
- with pytest.raises(TypeError, match="is an invalid key"):
+ with pytest.raises(TypeError, match="unhashable type"):
dg[:, 0]
index = Index(range(2), name="i")
diff --git a/pandas/tests/indexing/multiindex/test_multiindex.py b/pandas/tests/indexing/multiindex/test_multiindex.py
index 5e5fcd3db88d8..4565d79c632de 100644
--- a/pandas/tests/indexing/multiindex/test_multiindex.py
+++ b/pandas/tests/indexing/multiindex/test_multiindex.py
@@ -1,4 +1,5 @@
import numpy as np
+import pytest
import pandas._libs.index as _index
from pandas.errors import PerformanceWarning
@@ -83,3 +84,10 @@ def test_nested_tuples_duplicates(self):
df3 = df.copy(deep=True)
df3.loc[[(dti[0], "a")], "c2"] = 1.0
tm.assert_frame_equal(df3, expected)
+
+ def test_multiindex_get_loc_list_raises(self):
+ # https://github.com/pandas-dev/pandas/issues/35878
+ idx = pd.MultiIndex.from_tuples([("a", 1), ("b", 2)])
+ msg = "unhashable type"
+ with pytest.raises(TypeError, match=msg):
+ idx.get_loc([])
diff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py
index 3463de25ad91b..593d1c78a19e2 100644
--- a/pandas/tests/series/indexing/test_setitem.py
+++ b/pandas/tests/series/indexing/test_setitem.py
@@ -1,6 +1,7 @@
import numpy as np
-from pandas import NaT, Series, date_range
+from pandas import MultiIndex, NaT, Series, date_range
+import pandas.testing as tm
class TestSetitemDT64Values:
@@ -17,3 +18,11 @@ def test_setitem_none_nan(self):
series[5:7] = np.nan
assert series[6] is NaT
+
+ def test_setitem_multiindex_empty_slice(self):
+ # https://github.com/pandas-dev/pandas/issues/35878
+ idx = MultiIndex.from_tuples([("a", 1), ("b", 2)])
+ result = Series([1, 2], index=idx)
+ expected = result.copy()
+ result.loc[[]] = 0
+ tm.assert_series_equal(result, expected)
| Backport PR #35914: Make MultiIndex.get_loc raise for unhashable type | https://api.github.com/repos/pandas-dev/pandas/pulls/36163 | 2020-09-06T13:01:29Z | 2020-09-06T15:13:33Z | 2020-09-06T15:13:33Z | 2020-09-06T15:13:33Z |
Backport PR #36054 on branch 1.1.x (BUG: Don't raise when constructing Series from ordered set) | diff --git a/doc/source/whatsnew/v1.1.2.rst b/doc/source/whatsnew/v1.1.2.rst
index d1a66256454ca..5bb0e1376fceb 100644
--- a/doc/source/whatsnew/v1.1.2.rst
+++ b/doc/source/whatsnew/v1.1.2.rst
@@ -34,6 +34,7 @@ Bug fixes
- Bug in :meth:`DataFrame.apply` with ``result_type="reduce"`` returning with incorrect index (:issue:`35683`)
- Bug in :meth:`DateTimeIndex.format` and :meth:`PeriodIndex.format` with ``name=True`` setting the first item to ``"None"`` where it should be ``""`` (:issue:`35712`)
- Bug in :meth:`Float64Index.__contains__` incorrectly raising ``TypeError`` instead of returning ``False`` (:issue:`35788`)
+- Bug in :class:`Series` constructor incorrectly raising a ``TypeError`` when passed an ordered set (:issue:`36044`)
- Bug in :meth:`Series.dt.isocalendar` and :meth:`DatetimeIndex.isocalendar` that returned incorrect year for certain dates (:issue:`36032`)
- Bug in :class:`DataFrame` indexing returning an incorrect :class:`Series` in some cases when the series has been altered and a cache not invalidated (:issue:`33675`)
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index e8c9f28e50084..d1c174d48f04b 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -437,7 +437,12 @@ def sanitize_array(
subarr = subarr.copy()
return subarr
- elif isinstance(data, (list, tuple)) and len(data) > 0:
+ elif isinstance(data, (list, tuple, abc.Set, abc.ValuesView)) and len(data) > 0:
+ if isinstance(data, set):
+ # Raise only for unordered sets, e.g., not for dict_keys
+ raise TypeError("Set type is unordered")
+ data = list(data)
+
if dtype is not None:
subarr = _try_cast(data, dtype, copy, raise_cast_failure)
else:
@@ -449,8 +454,6 @@ def sanitize_array(
# GH#16804
arr = np.arange(data.start, data.stop, data.step, dtype="int64")
subarr = _try_cast(arr, dtype, copy, raise_cast_failure)
- elif isinstance(data, abc.Set):
- raise TypeError("Set type is unordered")
elif lib.is_scalar(data) and index is not None and dtype is not None:
data = maybe_cast_to_datetime(data, dtype)
if not lib.is_scalar(data):
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index bcf7039ec9039..ce078059479b4 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -1464,3 +1464,13 @@ def test_constructor_sparse_datetime64(self, values):
arr = pd.arrays.SparseArray(values, dtype=dtype)
expected = pd.Series(arr)
tm.assert_series_equal(result, expected)
+
+ def test_construction_from_ordered_collection(self):
+ # https://github.com/pandas-dev/pandas/issues/36044
+ result = Series({"a": 1, "b": 2}.keys())
+ expected = Series(["a", "b"])
+ tm.assert_series_equal(result, expected)
+
+ result = Series({"a": 1, "b": 2}.values())
+ expected = Series([1, 2])
+ tm.assert_series_equal(result, expected)
| Backport PR #36054: BUG: Don't raise when constructing Series from ordered set | https://api.github.com/repos/pandas-dev/pandas/pulls/36162 | 2020-09-06T12:59:34Z | 2020-09-06T15:13:54Z | 2020-09-06T15:13:54Z | 2020-09-06T15:13:55Z |
BUG: Enable Series.equals to compare numpy arrays to scalars | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index bce6a735b7b07..81577d1c0205d 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -247,6 +247,7 @@ Numeric
^^^^^^^
- Bug in :func:`to_numeric` where float precision was incorrect (:issue:`31364`)
- Bug in :meth:`DataFrame.any` with ``axis=1`` and ``bool_only=True`` ignoring the ``bool_only`` keyword (:issue:`32432`)
+- Bug in :meth:`Series.equals` where a ``ValueError`` was raised when numpy arrays were compared to scalars (:issue:`35267`)
-
Conversion
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 7464fafee2b94..c24ac39becd8c 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -591,7 +591,16 @@ def array_equivalent_object(left: object[:], right: object[:]) -> bool:
if "tz-naive and tz-aware" in str(err):
return False
raise
-
+ except ValueError:
+ # Avoid raising ValueError when comparing Numpy arrays to other types
+ if cnp.PyArray_IsAnyScalar(x) != cnp.PyArray_IsAnyScalar(y):
+ # Only compare scalars to scalars and non-scalars to non-scalars
+ return False
+ elif (not (cnp.PyArray_IsPythonScalar(x) or cnp.PyArray_IsPythonScalar(y))
+ and not (isinstance(x, type(y)) or isinstance(y, type(x)))):
+ # Check if non-scalars have the same type
+ return False
+ raise
return True
diff --git a/pandas/tests/dtypes/test_missing.py b/pandas/tests/dtypes/test_missing.py
index a642b23379c6f..046b82ef3131a 100644
--- a/pandas/tests/dtypes/test_missing.py
+++ b/pandas/tests/dtypes/test_missing.py
@@ -1,3 +1,4 @@
+from contextlib import nullcontext
from datetime import datetime
from decimal import Decimal
@@ -383,6 +384,20 @@ def test_array_equivalent(dtype_equal):
assert not array_equivalent(DatetimeIndex([0, np.nan]), TimedeltaIndex([0, np.nan]))
+@pytest.mark.parametrize(
+ "val", [1, 1.1, 1 + 1j, True, "abc", [1, 2], (1, 2), {1, 2}, {"a": 1}, None]
+)
+def test_array_equivalent_series(val):
+ arr = np.array([1, 2])
+ cm = (
+ tm.assert_produces_warning(FutureWarning, check_stacklevel=False)
+ if isinstance(val, str)
+ else nullcontext()
+ )
+ with cm:
+ assert not array_equivalent(Series([arr, arr]), Series([arr, val]))
+
+
def test_array_equivalent_different_dtype_but_equal():
# Unclear if this is exposed anywhere in the public-facing API
assert array_equivalent(np.array([1, 2]), np.array([1.0, 2.0]))
diff --git a/pandas/tests/series/methods/test_equals.py b/pandas/tests/series/methods/test_equals.py
index 600154adfcda3..cf55482fefe22 100644
--- a/pandas/tests/series/methods/test_equals.py
+++ b/pandas/tests/series/methods/test_equals.py
@@ -1,7 +1,10 @@
+from contextlib import nullcontext
+
import numpy as np
import pytest
from pandas import MultiIndex, Series
+import pandas._testing as tm
@pytest.mark.parametrize(
@@ -24,16 +27,25 @@ def test_equals(arr, idx):
assert not s1.equals(s2)
-def test_equals_list_array():
+@pytest.mark.parametrize(
+ "val", [1, 1.1, 1 + 1j, True, "abc", [1, 2], (1, 2), {1, 2}, {"a": 1}, None]
+)
+def test_equals_list_array(val):
# GH20676 Verify equals operator for list of Numpy arrays
arr = np.array([1, 2])
s1 = Series([arr, arr])
s2 = s1.copy()
assert s1.equals(s2)
- # TODO: Series equals should also work between single value and list
- # s1[1] = 9
- # assert not s1.equals(s2)
+ s1[1] = val
+
+ cm = (
+ tm.assert_produces_warning(FutureWarning, check_stacklevel=False)
+ if isinstance(val, str)
+ else nullcontext()
+ )
+ with cm:
+ assert not s1.equals(s2)
def test_equals_false_negative():
| - [x] closes #35267
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/36161 | 2020-09-06T12:50:08Z | 2020-09-19T20:29:44Z | 2020-09-19T20:29:43Z | 2020-09-19T20:29:49Z |
CLN: _wrap_applied_output | diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index b855ce65f41b2..e2b847b442269 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -1192,113 +1192,104 @@ def _wrap_applied_output(self, keys, values, not_indexed_same=False):
return self.obj._constructor()
elif isinstance(first_not_none, DataFrame):
return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
- else:
- key_index = self.grouper.result_index if self.as_index else None
-
- if isinstance(first_not_none, Series):
- # this is to silence a DeprecationWarning
- # TODO: Remove when default dtype of empty Series is object
- kwargs = first_not_none._construct_axes_dict()
- backup = create_series_with_explicit_dtype(
- dtype_if_empty=object, **kwargs
- )
-
- values = [x if (x is not None) else backup for x in values]
- v = values[0]
-
- if not isinstance(v, (np.ndarray, Index, Series)) and self.as_index:
- # values are not series or array-like but scalars
- # self._selection_name not passed through to Series as the
- # result should not take the name of original selection
- # of columns
- return self.obj._constructor_sliced(values, index=key_index)
+ key_index = self.grouper.result_index if self.as_index else None
+
+ if isinstance(first_not_none, Series):
+ # this is to silence a DeprecationWarning
+ # TODO: Remove when default dtype of empty Series is object
+ kwargs = first_not_none._construct_axes_dict()
+ backup = create_series_with_explicit_dtype(dtype_if_empty=object, **kwargs)
+
+ values = [x if (x is not None) else backup for x in values]
+
+ v = values[0]
+
+ if not isinstance(v, (np.ndarray, Index, Series)) and self.as_index:
+ # values are not series or array-like but scalars
+ # self._selection_name not passed through to Series as the
+ # result should not take the name of original selection
+ # of columns
+ return self.obj._constructor_sliced(values, index=key_index)
+
+ if isinstance(v, Series):
+ all_indexed_same = all_indexes_same((x.index for x in values))
+
+ # GH3596
+ # provide a reduction (Frame -> Series) if groups are
+ # unique
+ if self.squeeze:
+ applied_index = self._selected_obj._get_axis(self.axis)
+ singular_series = len(values) == 1 and applied_index.nlevels == 1
+
+ # assign the name to this series
+ if singular_series:
+ values[0].name = keys[0]
+
+ # GH2893
+ # we have series in the values array, we want to
+ # produce a series:
+ # if any of the sub-series are not indexed the same
+ # OR we don't have a multi-index and we have only a
+ # single values
+ return self._concat_objects(
+ keys, values, not_indexed_same=not_indexed_same
+ )
+ # still a series
+ # path added as of GH 5545
+ elif all_indexed_same:
+ from pandas.core.reshape.concat import concat
+
+ return concat(values)
+
+ if not all_indexed_same:
+ # GH 8467
+ return self._concat_objects(keys, values, not_indexed_same=True)
+
+ # Combine values
+ # vstack+constructor is faster than concat and handles MI-columns
+ stacked_values = np.vstack([np.asarray(v) for v in values])
+
+ if self.axis == 0:
+ index = key_index
+ columns = v.index.copy()
+ if columns.name is None:
+ # GH6124 - propagate name of Series when it's consistent
+ names = {v.name for v in values}
+ if len(names) == 1:
+ columns.name = list(names)[0]
else:
- if isinstance(v, Series):
- all_indexed_same = all_indexes_same((x.index for x in values))
-
- # GH3596
- # provide a reduction (Frame -> Series) if groups are
- # unique
- if self.squeeze:
- applied_index = self._selected_obj._get_axis(self.axis)
- singular_series = (
- len(values) == 1 and applied_index.nlevels == 1
- )
-
- # assign the name to this series
- if singular_series:
- values[0].name = keys[0]
-
- # GH2893
- # we have series in the values array, we want to
- # produce a series:
- # if any of the sub-series are not indexed the same
- # OR we don't have a multi-index and we have only a
- # single values
- return self._concat_objects(
- keys, values, not_indexed_same=not_indexed_same
- )
-
- # still a series
- # path added as of GH 5545
- elif all_indexed_same:
- from pandas.core.reshape.concat import concat
-
- return concat(values)
-
- if not all_indexed_same:
- # GH 8467
- return self._concat_objects(keys, values, not_indexed_same=True)
-
- # Combine values
- # vstack+constructor is faster than concat and handles MI-columns
- stacked_values = np.vstack([np.asarray(v) for v in values])
-
- if self.axis == 0:
- index = key_index
- columns = v.index.copy()
- if columns.name is None:
- # GH6124 - propagate name of Series when it's consistent
- names = {v.name for v in values}
- if len(names) == 1:
- columns.name = list(names)[0]
- else:
- index = v.index
- columns = key_index
- stacked_values = stacked_values.T
-
- result = self.obj._constructor(
- stacked_values, index=index, columns=columns
- )
+ index = v.index
+ columns = key_index
+ stacked_values = stacked_values.T
- elif not self.as_index:
- # We add grouping column below, so create a frame here
- result = DataFrame(
- values, index=key_index, columns=[self._selection]
- )
- else:
- # GH#1738: values is list of arrays of unequal lengths
- # fall through to the outer else clause
- # TODO: sure this is right? we used to do this
- # after raising AttributeError above
- return self.obj._constructor_sliced(
- values, index=key_index, name=self._selection_name
- )
+ result = self.obj._constructor(stacked_values, index=index, columns=columns)
- # if we have date/time like in the original, then coerce dates
- # as we are stacking can easily have object dtypes here
- so = self._selected_obj
- if so.ndim == 2 and so.dtypes.apply(needs_i8_conversion).any():
- result = _recast_datetimelike_result(result)
- else:
- result = result._convert(datetime=True)
+ elif not self.as_index:
+ # We add grouping column below, so create a frame here
+ result = DataFrame(values, index=key_index, columns=[self._selection])
+ else:
+ # GH#1738: values is list of arrays of unequal lengths
+ # fall through to the outer else clause
+ # TODO: sure this is right? we used to do this
+ # after raising AttributeError above
+ return self.obj._constructor_sliced(
+ values, index=key_index, name=self._selection_name
+ )
+
+ # if we have date/time like in the original, then coerce dates
+ # as we are stacking can easily have object dtypes here
+ so = self._selected_obj
+ if so.ndim == 2 and so.dtypes.apply(needs_i8_conversion).any():
+ result = _recast_datetimelike_result(result)
+ else:
+ result = result._convert(datetime=True)
- if not self.as_index:
- self._insert_inaxis_grouper_inplace(result)
+ if not self.as_index:
+ self._insert_inaxis_grouper_inplace(result)
- return self._reindex_output(result)
+ return self._reindex_output(result)
def _transform_general(
self, func, *args, engine="cython", engine_kwargs=None, **kwargs
| - [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
All if statements above the changed block return, so we can remove the else's and flatten out the structure a bit. | https://api.github.com/repos/pandas-dev/pandas/pulls/36160 | 2020-09-06T12:34:00Z | 2020-09-06T17:24:04Z | 2020-09-06T17:24:04Z | 2020-09-10T00:07:20Z |
ENH: add set_td_classes method for CSS class addition to data cells | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index e577a8f26bd12..eb43ccd3429aa 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -104,7 +104,7 @@ Other enhancements
- :meth:`DataFrame.applymap` now supports ``na_action`` (:issue:`23803`)
- :class:`Index` with object dtype supports division and multiplication (:issue:`34160`)
- :meth:`DataFrame.explode` and :meth:`Series.explode` now support exploding of sets (:issue:`35614`)
--
+- `Styler` now allows direct CSS class name addition to individual data cells (:issue:`36159`)
.. _whatsnew_120.api_breaking.python:
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index b27a4e036e137..5c3a309b0e310 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -171,6 +171,8 @@ def __init__(
self.cell_ids = cell_ids
self.na_rep = na_rep
+ self.cell_context: Dict[str, Any] = {}
+
# display_funcs maps (row, col) -> formatting function
def default_display_func(x):
@@ -262,7 +264,7 @@ def format_attr(pair):
idx_lengths = _get_level_lengths(self.index)
col_lengths = _get_level_lengths(self.columns, hidden_columns)
- cell_context = dict()
+ cell_context = self.cell_context
n_rlvls = self.data.index.nlevels
n_clvls = self.data.columns.nlevels
@@ -499,6 +501,70 @@ def format(self, formatter, subset=None, na_rep: Optional[str] = None) -> "Style
self._display_funcs[(i, j)] = formatter
return self
+ def set_td_classes(self, classes: DataFrame) -> "Styler":
+ """
+ Add string based CSS class names to data cells that will appear within the
+ `Styler` HTML result. These classes are added within specified `<td>` elements.
+
+ Parameters
+ ----------
+ classes : DataFrame
+ DataFrame containing strings that will be translated to CSS classes,
+ mapped by identical column and index values that must exist on the
+ underlying `Styler` data. None, NaN values, and empty strings will
+ be ignored and not affect the rendered HTML.
+
+ Returns
+ -------
+ self : Styler
+
+ Examples
+ --------
+ >>> df = pd.DataFrame(data=[[1, 2, 3], [4, 5, 6]], columns=["A", "B", "C"])
+ >>> classes = pd.DataFrame([
+ ... ["min-val red", "", "blue"],
+ ... ["red", None, "blue max-val"]
+ ... ], index=df.index, columns=df.columns)
+ >>> df.style.set_td_classes(classes)
+
+ Using `MultiIndex` columns and a `classes` `DataFrame` as a subset of the
+ underlying,
+
+ >>> df = pd.DataFrame([[1,2],[3,4]], index=["a", "b"],
+ ... columns=[["level0", "level0"], ["level1a", "level1b"]])
+ >>> classes = pd.DataFrame(["min-val"], index=["a"],
+ ... columns=[["level0"],["level1a"]])
+ >>> df.style.set_td_classes(classes)
+
+ Form of the output with new additional css classes,
+
+ >>> df = pd.DataFrame([[1]])
+ >>> css = pd.DataFrame(["other-class"])
+ >>> s = Styler(df, uuid="_", cell_ids=False).set_td_classes(css)
+ >>> s.hide_index().render()
+ '<style type="text/css" ></style>'
+ '<table id="T__" >'
+ ' <thead>'
+ ' <tr><th class="col_heading level0 col0" >0</th></tr>'
+ ' </thead>'
+ ' <tbody>'
+ ' <tr><td class="data row0 col0 other-class" >1</td></tr>'
+ ' </tbody>'
+ '</table>'
+
+ """
+ classes = classes.reindex_like(self.data)
+
+ mask = (classes.isna()) | (classes.eq(""))
+ self.cell_context["data"] = {
+ r: {c: [str(classes.iloc[r, c])]}
+ for r, rn in enumerate(classes.index)
+ for c, cn in enumerate(classes.columns)
+ if not mask.iloc[r, c]
+ }
+
+ return self
+
def render(self, **kwargs) -> str:
"""
Render the built up styles to HTML.
@@ -609,6 +675,7 @@ def clear(self) -> None:
Returns None.
"""
self.ctx.clear()
+ self.cell_context = {}
self._todo = []
def _compute(self):
diff --git a/pandas/tests/io/formats/test_style.py b/pandas/tests/io/formats/test_style.py
index de549ec3eb75e..e7583e1ce2ce2 100644
--- a/pandas/tests/io/formats/test_style.py
+++ b/pandas/tests/io/formats/test_style.py
@@ -1691,6 +1691,27 @@ def test_no_cell_ids(self):
s = styler.render() # render twice to ensure ctx is not updated
assert s.find('<td class="data row0 col0" >') != -1
+ @pytest.mark.parametrize(
+ "classes",
+ [
+ DataFrame(
+ data=[["", "test-class"], [np.nan, None]],
+ columns=["A", "B"],
+ index=["a", "b"],
+ ),
+ DataFrame(data=[["test-class"]], columns=["B"], index=["a"]),
+ DataFrame(data=[["test-class", "unused"]], columns=["B", "C"], index=["a"]),
+ ],
+ )
+ def test_set_data_classes(self, classes):
+ # GH 36159
+ df = DataFrame(data=[[0, 1], [2, 3]], columns=["A", "B"], index=["a", "b"])
+ s = Styler(df, uuid="_", cell_ids=False).set_td_classes(classes).render()
+ assert '<td class="data row0 col0" >0</td>' in s
+ assert '<td class="data row0 col1 test-class" >1</td>' in s
+ assert '<td class="data row1 col0" >2</td>' in s
+ assert '<td class="data row1 col1" >3</td>' in s
+
def test_colspan_w3(self):
# GH 36223
df = pd.DataFrame(data=[[1, 2]], columns=[["l0", "l0"], ["l1a", "l1b"]])
| - [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Simple extension to Styler to allow cells to be assigned CSS classes from a DataFrame of strings.
Seems to be a reasonably common request.
The existing framework, i.e. the `cell_context` dictionary (which previously did nothing) is leveraged.
@TomAugspurger
| https://api.github.com/repos/pandas-dev/pandas/pulls/36159 | 2020-09-06T11:59:10Z | 2020-09-13T12:52:43Z | 2020-09-13T12:52:43Z | 2020-09-13T14:04:17Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.