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 |
|---|---|---|---|---|---|---|---|
CLN: ArrowStringArray._cmp_method - use ChunkedArray.to_numpy() | diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index e39ebd3afd2ff..eb3b3b8d29647 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -332,8 +332,11 @@ def _cmp_method(self, other, op):
else:
return NotImplemented
- # TODO(ARROW-9429): Add a .to_numpy() to ChunkedArray
- return BooleanArray._from_sequence(result.to_pandas().values)
+ if pa_version_under2p0:
+ result = result.to_pandas().values
+ else:
+ result = result.to_numpy()
+ return BooleanArray._from_sequence(result)
def insert(self, loc: int, item):
if not isinstance(item, str) and item is not libmissing.NA:
| - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
Addresses minor TODO comment in ArrowStringArray._cmp_method.
Also, better perf:
```
import numpy as np
import pyarrow as pa
ca = pa.chunked_array([
np.random.choice([0, 1], 1000),
np.random.choice([0, 1], 1000),
], type=pa.bool_())
%timeit ca.to_pandas().values
45.9 µs ± 2.75 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
%timeit ca.to_numpy()
3.8 µs ± 273 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/46417 | 2022-03-18T14:10:30Z | 2022-03-18T16:15:16Z | 2022-03-18T16:15:16Z | 2022-03-20T23:18:48Z |
TST: fix pytest collection errors with pytest-xdist | diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index bf2afe50bdb01..fd764a60d0644 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -563,9 +563,9 @@ def test_mul(self):
assert DateOffset(2) == 2 * DateOffset(1)
assert DateOffset(2) == DateOffset(1) * 2
- @pytest.mark.parametrize("relativedelta_kwd", list(liboffsets._relativedelta_kwds))
- def test_constructor(self, relativedelta_kwd, request):
- if relativedelta_kwd == "millisecond":
+ @pytest.mark.parametrize("kwd", sorted(liboffsets._relativedelta_kwds))
+ def test_constructor(self, kwd, request):
+ if kwd == "millisecond":
request.node.add_marker(
pytest.mark.xfail(
raises=NotImplementedError,
@@ -573,9 +573,9 @@ def test_constructor(self, relativedelta_kwd, request):
"yet supported.",
)
)
- offset = DateOffset(**{relativedelta_kwd: 2})
- assert offset.kwds == {relativedelta_kwd: 2}
- assert getattr(offset, relativedelta_kwd) == 2
+ offset = DateOffset(**{kwd: 2})
+ assert offset.kwds == {kwd: 2}
+ assert getattr(offset, kwd) == 2
def test_default_constructor(self):
assert (self.d + DateOffset(2)) == datetime(2008, 1, 4)
| xref https://github.com/pandas-dev/pandas/pull/43598#discussion_r829985695 | https://api.github.com/repos/pandas-dev/pandas/pulls/46416 | 2022-03-18T13:50:23Z | 2022-03-18T16:15:35Z | 2022-03-18T16:15:35Z | 2022-03-20T16:28:31Z |
REGR: Bar plot axis timestamp to string conversion error | diff --git a/pandas/tests/plotting/test_misc.py b/pandas/tests/plotting/test_misc.py
index 64c736d6314e4..656590cdb02be 100644
--- a/pandas/tests/plotting/test_misc.py
+++ b/pandas/tests/plotting/test_misc.py
@@ -8,6 +8,7 @@
from pandas import (
DataFrame,
Series,
+ Timestamp,
)
import pandas._testing as tm
from pandas.tests.plotting.common import (
@@ -549,3 +550,15 @@ def test_externally_shared_axes(self):
assert not plots[0][0].xaxis.get_label().get_visible()
assert plots[0][1].xaxis.get_label().get_visible()
assert not plots[0][2].xaxis.get_label().get_visible()
+
+ def test_plot_bar_axis_units_timestamp_conversion(self):
+ # GH 38736
+ # Ensure string x-axis from the second plot will not be converted to datetime
+ # due to axis data from first plot
+ df = DataFrame(
+ [1.0],
+ index=[Timestamp("2022-02-22 22:22:22")],
+ )
+ _check_plot_works(df.plot)
+ s = Series({"A": 1.0})
+ _check_plot_works(s.plot.bar)
| Added regression test to prevent bar plot from attempting to convert x-axis from string to timestamp due to previous plot's axis units.
Problematic example:
https://github.com/pandas-dev/pandas/blob/fb353446651067fafec03301256e93d59065c520/pandas/plotting/_matplotlib/core.py#L1433
- [x] closes #38736
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/46413 | 2022-03-18T09:16:07Z | 2022-03-20T17:43:37Z | 2022-03-20T17:43:36Z | 2022-03-20T17:44:01Z |
CI: bump mypy&pyright | diff --git a/.github/workflows/code-checks.yml b/.github/workflows/code-checks.yml
index 58bef05940af1..f32fed3b3ee68 100644
--- a/.github/workflows/code-checks.yml
+++ b/.github/workflows/code-checks.yml
@@ -74,7 +74,7 @@ jobs:
- name: Install pyright
# note: keep version in sync with .pre-commit-config.yaml
- run: npm install -g pyright@1.1.212
+ run: npm install -g pyright@1.1.230
- name: Build Pandas
id: build
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 2c58ccb52f9e5..aeb49c2b1a545 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -85,7 +85,7 @@ repos:
types: [python]
stages: [manual]
# note: keep version in sync with .github/workflows/code-checks.yml
- additional_dependencies: ['pyright@1.1.212']
+ additional_dependencies: ['pyright@1.1.230']
- repo: local
hooks:
- id: flake8-rst
diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index b1caeaf5e4726..b90a877012e6f 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -177,7 +177,7 @@ If installed, we now require:
+-----------------+-----------------+----------+---------+
| Package | Minimum Version | Required | Changed |
+=================+=================+==========+=========+
-| mypy (dev) | 0.931 | | X |
+| mypy (dev) | 0.941 | | X |
+-----------------+-----------------+----------+---------+
diff --git a/environment.yml b/environment.yml
index 2c6a6c95569d6..5402be3d4a00b 100644
--- a/environment.yml
+++ b/environment.yml
@@ -24,7 +24,7 @@ dependencies:
- flake8-bugbear=21.3.2 # used by flake8, find likely bugs
- flake8-comprehensions=3.7.0 # used by flake8, linting of unnecessary comprehensions
- isort>=5.2.1 # check that imports are in the right order
- - mypy=0.931
+ - mypy=0.941
- pre-commit>=2.9.2
- pycodestyle # used by flake8
- pyupgrade
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 15ec1006b4f80..c2a13961687fd 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -774,8 +774,7 @@ def fillna(
elif method is not None:
msg = "fillna with 'method' requires high memory usage."
warnings.warn(msg, PerformanceWarning)
- # Need type annotation for "new_values" [var-annotated]
- new_values = np.asarray(self) # type: ignore[var-annotated]
+ new_values = np.asarray(self)
# interpolate_2d modifies new_values inplace
interpolate_2d(new_values, method=method, limit=limit)
return type(self)(new_values, fill_value=self.fill_value)
diff --git a/pandas/core/computation/ops.py b/pandas/core/computation/ops.py
index 0109e0d2add11..9c54065de0353 100644
--- a/pandas/core/computation/ops.py
+++ b/pandas/core/computation/ops.py
@@ -580,7 +580,8 @@ def __init__(self, op: str, operand) -> None:
def __call__(self, env):
operand = self.operand(env)
- return self.func(operand)
+ # error: Cannot call function of unknown type
+ return self.func(operand) # type: ignore[operator]
def __repr__(self) -> str:
return pprint_thing(f"{self.op}({self.operand})")
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index d00a2778848ae..983fb8f0edf12 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -1481,9 +1481,15 @@ def equals(self, other: object) -> bool_t:
def __neg__(self):
def blk_func(values: ArrayLike):
if is_bool_dtype(values.dtype):
- return operator.inv(values)
+ # error: Argument 1 to "inv" has incompatible type "Union
+ # [ExtensionArray, ndarray[Any, Any]]"; expected
+ # "_SupportsInversion[ndarray[Any, dtype[bool_]]]"
+ return operator.inv(values) # type: ignore[arg-type]
else:
- return operator.neg(values)
+ # error: Argument 1 to "neg" has incompatible type "Union
+ # [ExtensionArray, ndarray[Any, Any]]"; expected
+ # "_SupportsNeg[ndarray[Any, dtype[Any]]]"
+ return operator.neg(values) # type: ignore[arg-type]
new_data = self._mgr.apply(blk_func)
res = self._constructor(new_data)
@@ -1495,7 +1501,10 @@ def blk_func(values: ArrayLike):
if is_bool_dtype(values.dtype):
return values.copy()
else:
- return operator.pos(values)
+ # error: Argument 1 to "pos" has incompatible type "Union
+ # [ExtensionArray, ndarray[Any, Any]]"; expected
+ # "_SupportsPos[ndarray[Any, dtype[Any]]]"
+ return operator.pos(values) # type: ignore[arg-type]
new_data = self._mgr.apply(blk_func)
res = self._constructor(new_data)
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 37fee7058f902..ab6e1c47057eb 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -4088,7 +4088,11 @@ def _get_nearest_indexer(
op = operator.lt if self.is_monotonic_increasing else operator.le
indexer = np.where(
- op(left_distances, right_distances) | (right_indexer == -1),
+ # error: Argument 1&2 has incompatible type "Union[ExtensionArray,
+ # ndarray[Any, Any]]"; expected "Union[SupportsDunderLE,
+ # SupportsDunderGE, SupportsDunderGT, SupportsDunderLT]"
+ op(left_distances, right_distances) # type: ignore[arg-type]
+ | (right_indexer == -1),
left_indexer,
right_indexer,
)
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 764787dd962e9..a3899fb880e6c 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -3875,14 +3875,22 @@ def _highlight_between(
)
g_left = (
- ops[0](data, left)
+ # error: Argument 2 to "ge" has incompatible type "Union[str, float,
+ # Period, Timedelta, Interval[Any], datetime64, timedelta64, datetime,
+ # Sequence[Any], ndarray[Any, Any], NDFrame]"; expected "Union
+ # [SupportsDunderLE, SupportsDunderGE, SupportsDunderGT, SupportsDunderLT]"
+ ops[0](data, left) # type: ignore[arg-type]
if left is not None
else np.full(data.shape, True, dtype=bool)
)
if isinstance(g_left, (DataFrame, Series)):
g_left = g_left.where(pd.notna(g_left), False)
l_right = (
- ops[1](data, right)
+ # error: Argument 2 to "le" has incompatible type "Union[str, float,
+ # Period, Timedelta, Interval[Any], datetime64, timedelta64, datetime,
+ # Sequence[Any], ndarray[Any, Any], NDFrame]"; expected "Union
+ # [SupportsDunderLE, SupportsDunderGE, SupportsDunderGT, SupportsDunderLT]"
+ ops[1](data, right) # type: ignore[arg-type]
if right is not None
else np.full(data.shape, True, dtype=bool)
)
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 94a1d344b4849..c671dc08a263e 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -12,7 +12,7 @@ flake8==4.0.1
flake8-bugbear==21.3.2
flake8-comprehensions==3.7.0
isort>=5.2.1
-mypy==0.931
+mypy==0.941
pre-commit>=2.9.2
pycodestyle
pyupgrade
| `ExtensionArray` does not implement any of the magic `<>!` methods. Might be worth adding abstract methods and force sub-classes to implement them? @jbrockmendel | https://api.github.com/repos/pandas-dev/pandas/pulls/46411 | 2022-03-18T02:29:17Z | 2022-03-18T14:33:49Z | 2022-03-18T14:33:49Z | 2022-03-18T14:33:49Z |
REF: implement get_unit_from_dtype | diff --git a/pandas/_libs/tslibs/conversion.pyx b/pandas/_libs/tslibs/conversion.pyx
index 7dce3cad9d339..0adf6f722c9ce 100644
--- a/pandas/_libs/tslibs/conversion.pyx
+++ b/pandas/_libs/tslibs/conversion.pyx
@@ -36,6 +36,7 @@ from pandas._libs.tslibs.np_datetime cimport (
dtstruct_to_dt64,
get_datetime64_unit,
get_datetime64_value,
+ get_unit_from_dtype,
npy_datetime,
npy_datetimestruct,
pandas_datetime_to_datetimestruct,
@@ -234,7 +235,9 @@ def ensure_datetime64ns(arr: ndarray, copy: bool = True):
result = result.copy()
return result
- unit = get_datetime64_unit(arr.flat[0])
+ if arr.dtype.kind != "M":
+ raise TypeError("ensure_datetime64ns arr must have datetime64 dtype")
+ unit = get_unit_from_dtype(arr.dtype)
if unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC:
# without raising explicitly here, we end up with a SystemError
# built-in function ensure_datetime64ns returned a result with an error
diff --git a/pandas/_libs/tslibs/np_datetime.pxd b/pandas/_libs/tslibs/np_datetime.pxd
index c2bbc4fe764fe..4ab10bc431d09 100644
--- a/pandas/_libs/tslibs/np_datetime.pxd
+++ b/pandas/_libs/tslibs/np_datetime.pxd
@@ -1,3 +1,4 @@
+cimport numpy as cnp
from cpython.datetime cimport (
date,
datetime,
@@ -79,3 +80,5 @@ cdef NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil
cdef int _string_to_dts(str val, npy_datetimestruct* dts,
int* out_local, int* out_tzoffset,
bint want_exc) except? -1
+
+cdef NPY_DATETIMEUNIT get_unit_from_dtype(cnp.dtype dtype)
diff --git a/pandas/_libs/tslibs/np_datetime.pyi b/pandas/_libs/tslibs/np_datetime.pyi
index db0c277b73bd5..5227de4e72f44 100644
--- a/pandas/_libs/tslibs/np_datetime.pyi
+++ b/pandas/_libs/tslibs/np_datetime.pyi
@@ -1 +1,6 @@
+import numpy as np
+
class OutOfBoundsDatetime(ValueError): ...
+
+# only exposed for testing
+def py_get_unit_from_dtype(dtype: np.dtype): ...
diff --git a/pandas/_libs/tslibs/np_datetime.pyx b/pandas/_libs/tslibs/np_datetime.pyx
index 79a58478d630a..5f4ef84a79586 100644
--- a/pandas/_libs/tslibs/np_datetime.pyx
+++ b/pandas/_libs/tslibs/np_datetime.pyx
@@ -19,6 +19,9 @@ from cpython.object cimport (
PyDateTime_IMPORT
+cimport numpy as cnp
+
+cnp.import_array()
from numpy cimport int64_t
from pandas._libs.tslibs.util cimport get_c_string_buf_and_size
@@ -42,6 +45,8 @@ cdef extern from "src/datetime/np_datetime.h":
npy_datetimestruct _NS_MIN_DTS, _NS_MAX_DTS
+ PyArray_DatetimeMetaData get_datetime_metadata_from_dtype(cnp.PyArray_Descr *dtype);
+
cdef extern from "src/datetime/np_datetime_strings.h":
int parse_iso_8601_datetime(const char *str, int len, int want_exc,
npy_datetimestruct *out,
@@ -74,6 +79,22 @@ cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil:
"""
return <NPY_DATETIMEUNIT>(<PyDatetimeScalarObject*>obj).obmeta.base
+
+cdef NPY_DATETIMEUNIT get_unit_from_dtype(cnp.dtype dtype):
+ # NB: caller is responsible for ensuring this is *some* datetime64 or
+ # timedelta64 dtype, otherwise we can segfault
+ cdef:
+ cnp.PyArray_Descr* descr = <cnp.PyArray_Descr*>dtype
+ PyArray_DatetimeMetaData meta
+ meta = get_datetime_metadata_from_dtype(descr)
+ return meta.base
+
+
+def py_get_unit_from_dtype(dtype):
+ # for testing get_unit_from_dtype; adds 896 bytes to the .so file.
+ return get_unit_from_dtype(dtype)
+
+
# ----------------------------------------------------------------------
# Comparison
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime.c b/pandas/_libs/tslibs/src/datetime/np_datetime.c
index 8f59f53a555d8..12e20df256293 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime.c
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime.c
@@ -768,3 +768,15 @@ void pandas_timedelta_to_timedeltastruct(npy_timedelta td,
"invalid base unit");
}
}
+
+
+/*
+ * This function returns a pointer to the DateTimeMetaData
+ * contained within the provided datetime dtype.
+ *
+ * Copied near-verbatim from numpy/core/src/multiarray/datetime.c
+ */
+PyArray_DatetimeMetaData
+get_datetime_metadata_from_dtype(PyArray_Descr *dtype) {
+ return (((PyArray_DatetimeDTypeMetaData *)dtype->c_metadata)->meta);
+}
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime.h b/pandas/_libs/tslibs/src/datetime/np_datetime.h
index 0bbc24ed822c5..8e58be1ca8383 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime.h
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime.h
@@ -75,5 +75,12 @@ int cmp_npy_datetimestruct(const npy_datetimestruct *a,
void
add_minutes_to_datetimestruct(npy_datetimestruct *dts, int minutes);
+/*
+ * This function returns the DateTimeMetaData
+ * contained within the provided datetime dtype.
+ */
+PyArray_DatetimeMetaData get_datetime_metadata_from_dtype(
+ PyArray_Descr *dtype);
+
#endif // PANDAS__LIBS_TSLIBS_SRC_DATETIME_NP_DATETIME_H_
diff --git a/pandas/tests/tslibs/test_np_datetime.py b/pandas/tests/tslibs/test_np_datetime.py
new file mode 100644
index 0000000000000..00a2f90217434
--- /dev/null
+++ b/pandas/tests/tslibs/test_np_datetime.py
@@ -0,0 +1,37 @@
+import numpy as np
+
+from pandas._libs.tslibs.np_datetime import py_get_unit_from_dtype
+
+
+def test_get_unit_from_dtype():
+ # datetime64
+ assert py_get_unit_from_dtype(np.dtype("M8[Y]")) == 0
+ assert py_get_unit_from_dtype(np.dtype("M8[M]")) == 1
+ assert py_get_unit_from_dtype(np.dtype("M8[W]")) == 2
+ # B has been deprecated and removed -> no 3
+ assert py_get_unit_from_dtype(np.dtype("M8[D]")) == 4
+ assert py_get_unit_from_dtype(np.dtype("M8[h]")) == 5
+ assert py_get_unit_from_dtype(np.dtype("M8[m]")) == 6
+ assert py_get_unit_from_dtype(np.dtype("M8[s]")) == 7
+ assert py_get_unit_from_dtype(np.dtype("M8[ms]")) == 8
+ assert py_get_unit_from_dtype(np.dtype("M8[us]")) == 9
+ assert py_get_unit_from_dtype(np.dtype("M8[ns]")) == 10
+ assert py_get_unit_from_dtype(np.dtype("M8[ps]")) == 11
+ assert py_get_unit_from_dtype(np.dtype("M8[fs]")) == 12
+ assert py_get_unit_from_dtype(np.dtype("M8[as]")) == 13
+
+ # timedelta64
+ assert py_get_unit_from_dtype(np.dtype("m8[Y]")) == 0
+ assert py_get_unit_from_dtype(np.dtype("m8[M]")) == 1
+ assert py_get_unit_from_dtype(np.dtype("m8[W]")) == 2
+ # B has been deprecated and removed -> no 3
+ assert py_get_unit_from_dtype(np.dtype("m8[D]")) == 4
+ assert py_get_unit_from_dtype(np.dtype("m8[h]")) == 5
+ assert py_get_unit_from_dtype(np.dtype("m8[m]")) == 6
+ assert py_get_unit_from_dtype(np.dtype("m8[s]")) == 7
+ assert py_get_unit_from_dtype(np.dtype("m8[ms]")) == 8
+ assert py_get_unit_from_dtype(np.dtype("m8[us]")) == 9
+ assert py_get_unit_from_dtype(np.dtype("m8[ns]")) == 10
+ assert py_get_unit_from_dtype(np.dtype("m8[ps]")) == 11
+ assert py_get_unit_from_dtype(np.dtype("m8[fs]")) == 12
+ assert py_get_unit_from_dtype(np.dtype("m8[as]")) == 13
| Finding I need this in a bunch of non-nano branches.
cpplint gave a warning I didn't know what to do with so ignored; pls advise.
```
pandas/_libs/tslibs/src/datetime/np_datetime.c:787: Are you taking an address of a cast? This is dangerous: could be a temp var. Take the address before doing the cast, rather than after [runtime/casting] [4]
```
@mattip would this be a good candidate for adding to numpy's `__init__.pxd`? | https://api.github.com/repos/pandas-dev/pandas/pulls/46410 | 2022-03-18T01:07:50Z | 2022-03-18T20:32:45Z | 2022-03-18T20:32:45Z | 2022-03-18T20:35:24Z |
BUG: avoid RuntimeError in groupby.max | diff --git a/pandas/_libs/groupby.pyx b/pandas/_libs/groupby.pyx
index d84cc4873a250..899c56a0a075e 100644
--- a/pandas/_libs/groupby.pyx
+++ b/pandas/_libs/groupby.pyx
@@ -1047,6 +1047,7 @@ def group_last(
const uint8_t[:, :] mask,
uint8_t[:, ::1] result_mask=None,
Py_ssize_t min_count=-1,
+ bint is_datetimelike=False,
) -> None:
"""
Only aggregates on axis=0
@@ -1056,7 +1057,6 @@ def group_last(
iu_64_floating_obj_t val
ndarray[iu_64_floating_obj_t, ndim=2] resx
ndarray[int64_t, ndim=2] nobs
- bint runtime_error = False
bint uses_mask = mask is not None
bint isna_entry
@@ -1116,8 +1116,7 @@ def group_last(
if uses_mask:
isna_entry = mask[i, j]
else:
- isna_entry = _treat_as_na(val, True)
- # TODO: Sure we always want is_datetimelike=True?
+ isna_entry = _treat_as_na(val, is_datetimelike)
if not isna_entry:
nobs[lab, j] += 1
@@ -1125,26 +1124,30 @@ def group_last(
for i in range(ncounts):
for j in range(K):
+ # TODO(cython3): the entire next block can be shared
+ # across 3 places once conditional-nogil is available
if nobs[i, j] < min_count:
+ # if we are integer dtype, not is_datetimelike, and
+ # not uses_mask, then getting here implies that
+ # counts[i] < min_count, which means we will
+ # be cast to float64 and masked at the end
+ # of WrappedCythonOp._call_cython_op. So we can safely
+ # set a placeholder value in out[i, j].
if uses_mask:
result_mask[i, j] = True
elif iu_64_floating_obj_t is int64_t:
- # TODO: only if datetimelike?
+ # Per above, this is a placeholder in
+ # non-is_datetimelike cases.
out[i, j] = NPY_NAT
elif iu_64_floating_obj_t is uint64_t:
- runtime_error = True
- break
+ # placeholder, see above
+ out[i, j] = 0
else:
out[i, j] = NAN
else:
out[i, j] = resx[i, j]
- if runtime_error:
- # We cannot raise directly above because that is within a nogil
- # block.
- raise RuntimeError("empty group with uint64_t")
-
# TODO(cython3): GH#31710 use memorviews once cython 0.30 is released so we can
# use `const iu_64_floating_obj_t[:, :] values`
@@ -1159,6 +1162,7 @@ def group_nth(
uint8_t[:, ::1] result_mask=None,
int64_t min_count=-1,
int64_t rank=1,
+ bint is_datetimelike=False,
) -> None:
"""
Only aggregates on axis=0
@@ -1168,7 +1172,6 @@ def group_nth(
iu_64_floating_obj_t val
ndarray[iu_64_floating_obj_t, ndim=2] resx
ndarray[int64_t, ndim=2] nobs
- bint runtime_error = False
bint uses_mask = mask is not None
bint isna_entry
@@ -1230,8 +1233,7 @@ def group_nth(
if uses_mask:
isna_entry = mask[i, j]
else:
- isna_entry = _treat_as_na(val, True)
- # TODO: Sure we always want is_datetimelike=True?
+ isna_entry = _treat_as_na(val, is_datetimelike)
if not isna_entry:
nobs[lab, j] += 1
@@ -1241,25 +1243,27 @@ def group_nth(
for i in range(ncounts):
for j in range(K):
if nobs[i, j] < min_count:
+ # if we are integer dtype, not is_datetimelike, and
+ # not uses_mask, then getting here implies that
+ # counts[i] < min_count, which means we will
+ # be cast to float64 and masked at the end
+ # of WrappedCythonOp._call_cython_op. So we can safely
+ # set a placeholder value in out[i, j].
if uses_mask:
result_mask[i, j] = True
out[i, j] = 0
elif iu_64_floating_obj_t is int64_t:
- # TODO: only if datetimelike?
+ # Per above, this is a placeholder in
+ # non-is_datetimelike cases.
out[i, j] = NPY_NAT
elif iu_64_floating_obj_t is uint64_t:
- runtime_error = True
- break
+ # placeholder, see above
+ out[i, j] = 0
else:
out[i, j] = NAN
else:
out[i, j] = resx[i, j]
- if runtime_error:
- # We cannot raise directly above because that is within a nogil
- # block.
- raise RuntimeError("empty group with uint64_t")
-
@cython.boundscheck(False)
@cython.wraparound(False)
@@ -1386,7 +1390,6 @@ cdef group_min_max(
Py_ssize_t i, j, N, K, lab, ngroups = len(counts)
iu_64_floating_t val, nan_val
ndarray[iu_64_floating_t, ndim=2] group_min_or_max
- bint runtime_error = False
int64_t[:, ::1] nobs
bint uses_mask = mask is not None
bint isna_entry
@@ -1403,7 +1406,6 @@ cdef group_min_max(
group_min_or_max[:] = _get_min_or_max(<iu_64_floating_t>0, compute_max, is_datetimelike)
if iu_64_floating_t is int64_t:
- # TODO: only if is_datetimelike?
nan_val = NPY_NAT
elif iu_64_floating_t is uint64_t:
# NB: We do not define nan_val because there is no such thing
@@ -1442,25 +1444,30 @@ cdef group_min_max(
for i in range(ngroups):
for j in range(K):
if nobs[i, j] < min_count:
+ # if we are integer dtype, not is_datetimelike, and
+ # not uses_mask, then getting here implies that
+ # counts[i] < min_count, which means we will
+ # be cast to float64 and masked at the end
+ # of WrappedCythonOp._call_cython_op. So we can safely
+ # set a placeholder value in out[i, j].
if uses_mask:
result_mask[i, j] = True
# set out[i, j] to 0 to be deterministic, as
# it was initialized with np.empty. Also ensures
# we can downcast out if appropriate.
out[i, j] = 0
+ elif iu_64_floating_t is int64_t:
+ # Per above, this is a placeholder in
+ # non-is_datetimelike cases.
+ out[i, j] = nan_val
elif iu_64_floating_t is uint64_t:
- runtime_error = True
- break
+ # placeholder, see above
+ out[i, j] = 0
else:
out[i, j] = nan_val
else:
out[i, j] = group_min_or_max[i, j]
- if runtime_error:
- # We cannot raise directly above because that is within a nogil
- # block.
- raise RuntimeError("empty group with uint64_t")
-
@cython.wraparound(False)
@cython.boundscheck(False)
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 130c69400ea5f..15bc262997075 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -519,7 +519,7 @@ def _call_cython_op(
result = maybe_fill(np.empty(out_shape, dtype=out_dtype))
if self.kind == "aggregate":
counts = np.zeros(ngroups, dtype=np.int64)
- if self.how in ["min", "max", "mean"]:
+ if self.how in ["min", "max", "mean", "last", "first"]:
func(
out=result,
counts=counts,
@@ -530,16 +530,6 @@ def _call_cython_op(
result_mask=result_mask,
is_datetimelike=is_datetimelike,
)
- elif self.how in ["first", "last"]:
- func(
- out=result,
- counts=counts,
- values=values,
- labels=comp_ids,
- min_count=min_count,
- mask=mask,
- result_mask=result_mask,
- )
elif self.how in ["add"]:
# We support datetimelike
func(
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 8a96643b9834f..fbc3b385e5098 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -1856,15 +1856,11 @@ def test_resample_unsigned_int(any_unsigned_int_numpy_dtype):
)
df = df.loc[(df.index < "2000-01-02") | (df.index > "2000-01-03"), :]
- if any_unsigned_int_numpy_dtype == "uint64":
- with pytest.raises(RuntimeError, match="empty group with uint64_t"):
- df.resample("D").max()
- else:
- result = df.resample("D").max()
-
- expected = DataFrame(
- [1, np.nan, 0],
- columns=["x"],
- index=date_range(start="2000-01-01", end="2000-01-03 23", freq="D"),
- )
- tm.assert_frame_equal(result, expected)
+ result = df.resample("D").max()
+
+ expected = DataFrame(
+ [1, np.nan, 0],
+ columns=["x"],
+ index=date_range(start="2000-01-01", end="2000-01-03 23", freq="D"),
+ )
+ tm.assert_frame_equal(result, expected)
| - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
Addresses most of the remaining TODOs (except those waiting on cython3) i wanted to get done before pushing forward on more nullable cases. | https://api.github.com/repos/pandas-dev/pandas/pulls/46408 | 2022-03-17T20:53:56Z | 2022-03-18T00:33:12Z | 2022-03-18T00:33:12Z | 2022-03-18T01:08:17Z |
BUG: Fixed Unicode decoding error in `Period.strftime` when a locale-specific directive is used | diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml
index 301e7804ddbd8..9b3b3df9cbd0c 100644
--- a/.github/workflows/ubuntu.yml
+++ b/.github/workflows/ubuntu.yml
@@ -42,18 +42,26 @@ jobs:
- name: "Minimum Versions"
env_file: actions-38-minimum_versions.yaml
pattern: "not slow and not network and not single_cpu"
- - name: "Locale: it_IT.utf8"
+ - name: "Locale: it_IT"
env_file: actions-38.yaml
pattern: "not slow and not network and not single_cpu"
extra_apt: "language-pack-it"
+ # Use the utf8 version as the default, it has no bad side-effect.
lang: "it_IT.utf8"
lc_all: "it_IT.utf8"
- - name: "Locale: zh_CN.utf8"
+ # Also install it_IT (its encoding is ISO8859-1) but do not activate it.
+ # It will be temporarily activated during tests with locale.setlocale
+ extra_loc: "it_IT"
+ - name: "Locale: zh_CN"
env_file: actions-38.yaml
pattern: "not slow and not network and not single_cpu"
extra_apt: "language-pack-zh-hans"
+ # Use the utf8 version as the default, it has no bad side-effect.
lang: "zh_CN.utf8"
lc_all: "zh_CN.utf8"
+ # Also install zh_CN (its encoding is gb2312) but do not activate it.
+ # It will be temporarily activated during tests with locale.setlocale
+ extra_loc: "zh_CN"
- name: "Copy-on-Write"
env_file: actions-310.yaml
pattern: "not slow and not network and not single_cpu"
@@ -148,6 +156,12 @@ jobs:
# xsel for clipboard tests
run: sudo apt-get update && sudo apt-get install -y xsel ${{ env.EXTRA_APT }}
+ - name: Generate extra locales
+ # These extra locales will be available for locale.setlocale() calls in tests
+ run: |
+ sudo locale-gen ${{ matrix.extra_loc }}
+ if: ${{ matrix.extra_loc }}
+
- name: Set up Conda
uses: ./.github/actions/setup-conda
with:
diff --git a/doc/source/whatsnew/v1.6.0.rst b/doc/source/whatsnew/v1.6.0.rst
index c393b8a57f805..9d7e4c4dd5200 100644
--- a/doc/source/whatsnew/v1.6.0.rst
+++ b/doc/source/whatsnew/v1.6.0.rst
@@ -175,7 +175,7 @@ I/O
Period
^^^^^^
--
+- Bug in :meth:`Period.strftime` and :meth:`PeriodIndex.strftime`, raising ``UnicodeDecodeError`` when a locale-specific directive was passed (:issue:`46319`)
-
Plotting
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index d2d4838bfafc0..25f6386001ef6 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -1162,7 +1162,8 @@ cdef str period_format(int64_t value, int freq, object fmt=None):
return "NaT"
if isinstance(fmt, str):
- fmt = fmt.encode("utf-8")
+ # Encode using current locale, in case fmt contains non-utf8 chars
+ fmt = <bytes>util.string_encode_locale(fmt)
if fmt is None:
freq_group = get_freq_group(freq)
@@ -1231,7 +1232,8 @@ cdef str _period_strftime(int64_t value, int freq, bytes fmt):
# Execute c_strftime to process the usual datetime directives
formatted = c_strftime(&dts, <char*>fmt)
- result = util.char_to_string(formatted)
+ # Decode result according to current locale
+ result = util.char_to_string_locale(formatted)
free(formatted)
# Now we will fill the placeholders corresponding to our additional directives
diff --git a/pandas/_libs/tslibs/util.pxd b/pandas/_libs/tslibs/util.pxd
index 492b7d519551f..a28aace5d2f15 100644
--- a/pandas/_libs/tslibs/util.pxd
+++ b/pandas/_libs/tslibs/util.pxd
@@ -26,6 +26,10 @@ cdef extern from "Python.h":
const char* PyUnicode_AsUTF8AndSize(object obj,
Py_ssize_t* length) except NULL
+ object PyUnicode_EncodeLocale(object obj, const char *errors) nogil
+ object PyUnicode_DecodeLocale(const char *str, const char *errors) nogil
+
+
from numpy cimport (
float64_t,
int64_t,
@@ -219,3 +223,13 @@ cdef inline const char* get_c_string_buf_and_size(str py_string,
cdef inline const char* get_c_string(str py_string) except NULL:
return get_c_string_buf_and_size(py_string, NULL)
+
+
+cdef inline bytes string_encode_locale(str py_string):
+ """As opposed to PyUnicode_Encode, use current system locale to encode."""
+ return PyUnicode_EncodeLocale(py_string, NULL)
+
+
+cdef inline object char_to_string_locale(const char* data):
+ """As opposed to PyUnicode_FromString, use current system locale to decode."""
+ return PyUnicode_DecodeLocale(data, NULL)
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 443aa743a6444..4f8ab78c13766 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -1,9 +1,14 @@
"""
Test output formatting for Series/DataFrame, including to_string & reprs
"""
-from datetime import datetime
+from contextlib import nullcontext
+from datetime import (
+ datetime,
+ time,
+)
from io import StringIO
import itertools
+import locale
from operator import methodcaller
import os
from pathlib import Path
@@ -46,6 +51,13 @@
use_32bit_repr = is_platform_windows() or not IS64
+def get_local_am_pm():
+ """Return the AM and PM strings returned by strftime in current locale."""
+ am_local = time(1).strftime("%p")
+ pm_local = time(13).strftime("%p")
+ return am_local, pm_local
+
+
@pytest.fixture(params=["string", "pathlike", "buffer"])
def filepath_or_buffer_id(request):
"""
@@ -3219,6 +3231,67 @@ def test_period_tz(self):
per = dt.to_period(freq="H")
assert per.format()[0] == "2013-01-01 00:00"
+ @pytest.mark.parametrize(
+ "locale_str",
+ [
+ pytest.param(None, id=str(locale.getlocale())),
+ "it_IT.utf8",
+ "it_IT", # Note: encoding will be 'ISO8859-1'
+ "zh_CN.utf8",
+ "zh_CN", # Note: encoding will be 'gb2312'
+ ],
+ )
+ def test_period_non_ascii_fmt(self, locale_str):
+ # GH#46468 non-ascii char in input format string leads to wrong output
+
+ # Skip if locale cannot be set
+ if locale_str is not None and not tm.can_set_locale(locale_str, locale.LC_ALL):
+ pytest.skip(f"Skipping as locale '{locale_str}' cannot be set on host.")
+
+ # Change locale temporarily for this test.
+ with tm.set_locale(locale_str, locale.LC_ALL) if locale_str else nullcontext():
+ # Scalar
+ per = pd.Period("2018-03-11 13:00", freq="H")
+ assert per.strftime("%y é") == "18 é"
+
+ # Index
+ per = pd.period_range("2003-01-01 01:00:00", periods=2, freq="12h")
+ formatted = per.format(date_format="%y é")
+ assert formatted[0] == "03 é"
+ assert formatted[1] == "03 é"
+
+ @pytest.mark.parametrize(
+ "locale_str",
+ [
+ pytest.param(None, id=str(locale.getlocale())),
+ "it_IT.utf8",
+ "it_IT", # Note: encoding will be 'ISO8859-1'
+ "zh_CN.utf8",
+ "zh_CN", # Note: encoding will be 'gb2312'
+ ],
+ )
+ def test_period_custom_locale_directive(self, locale_str):
+ # GH#46319 locale-specific directive leads to non-utf8 c strftime char* result
+
+ # Skip if locale cannot be set
+ if locale_str is not None and not tm.can_set_locale(locale_str, locale.LC_ALL):
+ pytest.skip(f"Skipping as locale '{locale_str}' cannot be set on host.")
+
+ # Change locale temporarily for this test.
+ with tm.set_locale(locale_str, locale.LC_ALL) if locale_str else nullcontext():
+ # Get locale-specific reference
+ am_local, pm_local = get_local_am_pm()
+
+ # Scalar
+ per = pd.Period("2018-03-11 13:00", freq="H")
+ assert per.strftime("%p") == pm_local
+
+ # Index
+ per = pd.period_range("2003-01-01 01:00:00", periods=2, freq="12h")
+ formatted = per.format(date_format="%y %I:%M:%S%p")
+ assert formatted[0] == f"03 01:00:00{am_local}"
+ assert formatted[1] == f"03 01:00:00{pm_local}"
+
class TestDatetimeIndexFormat:
def test_datetime(self):
| - [x] closes #46319 , closes #46468
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
Note: this was extracted from #46116 to decompose the big PR into reviewable bits. More to come soon | https://api.github.com/repos/pandas-dev/pandas/pulls/46405 | 2022-03-17T13:57:38Z | 2022-09-08T15:19:54Z | 2022-09-08T15:19:54Z | 2022-10-13T16:59:51Z |
REGR: DataFrame.replace when the replacement value was explicitly None | diff --git a/doc/source/whatsnew/v1.4.2.rst b/doc/source/whatsnew/v1.4.2.rst
index 3523f691cae8f..4cbb8118055af 100644
--- a/doc/source/whatsnew/v1.4.2.rst
+++ b/doc/source/whatsnew/v1.4.2.rst
@@ -19,6 +19,7 @@ Fixed regressions
- Fixed memory performance regression in :meth:`Series.fillna` when called on a :class:`DataFrame` column with ``inplace=True`` (:issue:`46149`)
- Provided an alternative solution for passing custom Excel formats in :meth:`.Styler.to_excel`, which was a regression based on stricter CSS validation. Examples available in the documentation for :meth:`.Styler.format` (:issue:`46152`)
- Fixed regression in :meth:`DataFrame.replace` when a replacement value was also a target for replacement (:issue:`46306`)
+- Fixed regression in :meth:`DataFrame.replace` when the replacement value was explicitly ``None`` when passed in a dictionary to ``to_replace`` (:issue:`45601`, :issue:`45836`)
- Fixed regression when setting values with :meth:`DataFrame.loc` losing :class:`MultiIndex` names if :class:`DataFrame` was empty before (:issue:`46317`)
-
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index cdf2c47ad3f60..2ff195fa8e5d2 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -777,6 +777,13 @@ def _replace_coerce(
mask=mask,
)
else:
+ if value is None:
+ # gh-45601, gh-45836
+ nb = self.astype(np.dtype(object), copy=False)
+ if nb is self and not inplace:
+ nb = nb.copy()
+ putmask_inplace(nb.values, mask, value)
+ return [nb]
return self.replace(
to_replace=to_replace, value=value, inplace=inplace, mask=mask
)
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index d8cd477cdcff8..870a64cfa59c9 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -661,6 +661,20 @@ def test_replace_simple_nested_dict_with_nonexistent_value(self):
result = df.replace({"col": {-1: "-", 1: "a", 4: "b"}})
tm.assert_frame_equal(expected, result)
+ def test_replace_NA_with_None(self):
+ # gh-45601
+ df = DataFrame({"value": [42, None]}).astype({"value": "Int64"})
+ result = df.replace({pd.NA: None})
+ expected = DataFrame({"value": [42, None]}, dtype=object)
+ tm.assert_frame_equal(result, expected)
+
+ def test_replace_NAT_with_None(self):
+ # gh-45836
+ df = DataFrame([pd.NaT, pd.NaT])
+ result = df.replace({pd.NaT: None, np.NaN: None})
+ expected = DataFrame([None, None])
+ tm.assert_frame_equal(result, expected)
+
def test_replace_value_is_none(self, datetime_frame):
orig_value = datetime_frame.iloc[0, 0]
orig2 = datetime_frame.iloc[1, 0]
| - [ ] closes #45601
- [ ] closes #45836
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/46404 | 2022-03-17T13:33:13Z | 2022-03-19T18:26:22Z | 2022-03-19T18:26:21Z | 2022-03-21T00:58:48Z |
Revert " BUG: RecursionError when attempting to replace np.nan values (#45725)" | diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 69f66973d0954..cdf2c47ad3f60 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -568,7 +568,6 @@ def replace(
# go through replace_list
values = self.values
- value = self._standardize_fill_value(value) # GH#45725
if isinstance(values, Categorical):
# TODO: avoid special-casing
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index 2eb300a8905b8..d8cd477cdcff8 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -661,21 +661,6 @@ def test_replace_simple_nested_dict_with_nonexistent_value(self):
result = df.replace({"col": {-1: "-", 1: "a", 4: "b"}})
tm.assert_frame_equal(expected, result)
- def test_replace_numpy_nan(self, nulls_fixture):
- # GH#45725 ensure numpy.nan can be replaced with all other null types
- to_replace = np.nan
- value = nulls_fixture
- dtype = object
- df = DataFrame({"A": [to_replace]}, dtype=dtype)
- expected = DataFrame({"A": [value]}, dtype=dtype)
-
- result = df.replace({to_replace: value}).astype(dtype=dtype)
- tm.assert_frame_equal(result, expected)
-
- # same thing but different calling convention
- result = df.replace(to_replace, value).astype(dtype=dtype)
- tm.assert_frame_equal(result, expected)
-
def test_replace_value_is_none(self, datetime_frame):
orig_value = datetime_frame.iloc[0, 0]
orig2 = datetime_frame.iloc[1, 0]
diff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py
index 7177648df27ce..77c9cf4013bd7 100644
--- a/pandas/tests/series/methods/test_replace.py
+++ b/pandas/tests/series/methods/test_replace.py
@@ -36,23 +36,6 @@ def test_replace_explicit_none(self):
assert expected.iloc[-1] is None
tm.assert_series_equal(result, expected)
- def test_replace_numpy_nan(self, nulls_fixture):
- # GH#45725 ensure numpy.nan can be replaced with all other null types
- to_replace = np.nan
- value = nulls_fixture
- dtype = object
- ser = pd.Series([to_replace], dtype=dtype)
- expected = pd.Series([value], dtype=dtype)
-
- result = ser.replace({to_replace: value}).astype(dtype=dtype)
- tm.assert_series_equal(result, expected)
- assert result.dtype == dtype
-
- # same thing but different calling convention
- result = ser.replace(to_replace, value).astype(dtype=dtype)
- tm.assert_series_equal(result, expected)
- assert result.dtype == dtype
-
def test_replace_noop_doesnt_downcast(self):
# GH#44498
ser = pd.Series([None, None, pd.Timestamp("2021-12-16 17:31")], dtype=object)
| Reverts pandas-dev/pandas#45749
see https://github.com/pandas-dev/pandas/pull/45749#issuecomment-1070837621 | https://api.github.com/repos/pandas-dev/pandas/pulls/46403 | 2022-03-17T12:01:12Z | 2022-03-17T23:02:43Z | 2022-03-17T23:02:43Z | 2022-03-18T09:44:31Z |
CI: Use shared dependency file for ARM | diff --git a/.circleci/config.yml b/.circleci/config.yml
index a16492b022264..612552f4eac59 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -8,7 +8,7 @@ jobs:
environment:
ENV_FILE: ci/deps/circle-38-arm64.yaml
PYTEST_WORKERS: auto
- PATTERN: "not slow and not network and not clipboard and not arm_slow"
+ PATTERN: "not single_cpu and not slow and not network and not clipboard and not arm_slow and not db"
PYTEST_TARGET: "pandas"
PANDAS_CI: "1"
steps:
diff --git a/ci/deps/circle-38-arm64.yaml b/ci/deps/circle-38-arm64.yaml
index 7e5b56ebe081f..f38c401ca49f8 100644
--- a/ci/deps/circle-38-arm64.yaml
+++ b/ci/deps/circle-38-arm64.yaml
@@ -4,19 +4,52 @@ channels:
dependencies:
- python=3.8
- # tools
- - cython>=0.29.24
+ # test dependencies
+ - cython=0.29.24
- pytest>=6.0
+ - pytest-cov
- pytest-xdist>=1.31
- hypothesis>=5.5.3
+ - psutil
- pytest-asyncio
+ - boto3
- # pandas dependencies
- - botocore>=1.11
- - flask
- - moto
- - numpy
+ # required dependencies
- python-dateutil
+ - numpy
- pytz
+
+ # optional dependencies
+ - beautifulsoup4
+ - blosc
+ - bottleneck
+ - brotlipy
+ - fastparquet
+ - fsspec
+ - html5lib
+ - gcsfs
+ - jinja2
+ - lxml
+ - matplotlib
+ - numba
+ - numexpr
+ - openpyxl
+ - odfpy
+ - pandas-gbq
+ - psycopg2
+ - pyarrow
+ - pymysql
+ # Not provided on ARM
+ #- pyreadstat
+ - pytables
+ - python-snappy
+ - pyxlsb
+ - s3fs
+ - scipy
+ - sqlalchemy
+ - tabulate
+ - xarray
+ - xlrd
+ - xlsxwriter
+ - xlwt
- zstandard
- - pip
| - [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
| https://api.github.com/repos/pandas-dev/pandas/pulls/46401 | 2022-03-17T04:14:11Z | 2022-03-18T00:30:25Z | 2022-03-18T00:30:25Z | 2022-03-30T10:46:05Z |
REF/PERF: ArrowStringArray.__setitem__ | diff --git a/asv_bench/benchmarks/array.py b/asv_bench/benchmarks/array.py
index 103df0fd94847..b58200911749e 100644
--- a/asv_bench/benchmarks/array.py
+++ b/asv_bench/benchmarks/array.py
@@ -2,6 +2,8 @@
import pandas as pd
+from .pandas_vb_common import tm
+
class BooleanArray:
def setup(self):
@@ -39,3 +41,32 @@ def time_constructor(self):
def time_from_integer_array(self):
pd.array(self.values_integer, dtype="Int64")
+
+
+class ArrowStringArray:
+
+ params = [False, True]
+ param_names = ["multiple_chunks"]
+
+ def setup(self, multiple_chunks):
+ try:
+ import pyarrow as pa
+ except ImportError:
+ raise NotImplementedError
+ strings = tm.rands_array(3, 10_000)
+ if multiple_chunks:
+ chunks = [strings[i : i + 100] for i in range(0, len(strings), 100)]
+ self.array = pd.arrays.ArrowStringArray(pa.chunked_array(chunks))
+ else:
+ self.array = pd.arrays.ArrowStringArray(pa.array(strings))
+
+ def time_setitem(self, multiple_chunks):
+ for i in range(200):
+ self.array[i] = "foo"
+
+ def time_setitem_list(self, multiple_chunks):
+ indexer = list(range(0, 50)) + list(range(-50, 0))
+ self.array[indexer] = ["foo"] * len(indexer)
+
+ def time_setitem_slice(self, multiple_chunks):
+ self.array[::10] = "foo"
diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 089ba62e461d1..a16a615e70496 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -315,6 +315,7 @@ Performance improvements
- Performance improvement in :func:`merge` when left and/or right are empty (:issue:`45838`)
- Performance improvement in :meth:`DataFrame.join` when left and/or right are empty (:issue:`46015`)
- Performance improvement in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when target is a :class:`MultiIndex` (:issue:`46235`)
+- Performance improvement when setting values in a pyarrow backed string array (:issue:`46400`)
- Performance improvement in :func:`factorize` (:issue:`46109`)
- Performance improvement in :class:`DataFrame` and :class:`Series` constructors for extension dtype scalars (:issue:`45854`)
diff --git a/pandas/compat/__init__.py b/pandas/compat/__init__.py
index d0d7d6a1b8da6..5078d87bc91c7 100644
--- a/pandas/compat/__init__.py
+++ b/pandas/compat/__init__.py
@@ -22,6 +22,7 @@
pa_version_under2p0,
pa_version_under3p0,
pa_version_under4p0,
+ pa_version_under5p0,
)
PY39 = sys.version_info >= (3, 9)
@@ -148,4 +149,5 @@ def get_lzma_file():
"pa_version_under2p0",
"pa_version_under3p0",
"pa_version_under4p0",
+ "pa_version_under5p0",
]
diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index e39ebd3afd2ff..9b582a4e911a8 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -6,7 +6,6 @@
TYPE_CHECKING,
Any,
Union,
- cast,
overload,
)
@@ -31,6 +30,7 @@
pa_version_under2p0,
pa_version_under3p0,
pa_version_under4p0,
+ pa_version_under5p0,
)
from pandas.util._decorators import doc
@@ -362,49 +362,125 @@ def __setitem__(self, key: int | slice | np.ndarray, value: Any) -> None:
None
"""
key = check_array_indexer(self, key)
+ indices = self._key_to_indices(key)
- if is_integer(key):
- key = cast(int, key)
-
- if not is_scalar(value):
- raise ValueError("Must pass scalars with scalar indexer")
- elif isna(value):
+ if is_scalar(value):
+ if isna(value):
value = None
elif not isinstance(value, str):
raise ValueError("Scalar must be NA or str")
+ value = np.broadcast_to(value, len(indices))
+ else:
+ value = np.array(value, dtype=object, copy=True)
+ for i, v in enumerate(value):
+ if isna(v):
+ value[i] = None
+ elif not isinstance(v, str):
+ raise ValueError("Scalar must be NA or str")
+
+ if len(indices) != len(value):
+ raise ValueError("Length of indexer and values mismatch")
+
+ argsort = np.argsort(indices)
+ indices = indices[argsort]
+ value = value[argsort]
+
+ self._data = self._set_via_chunk_iteration(indices=indices, value=value)
+
+ def _key_to_indices(self, key: int | slice | np.ndarray) -> npt.NDArray[np.intp]:
+ """Convert indexing key for self to positional indices."""
+ if isinstance(key, slice):
+ indices = np.arange(len(self))[key]
+ elif is_bool_dtype(key):
+ key = np.asarray(key)
+ if len(key) != len(self):
+ raise ValueError("Length of indexer and values mismatch")
+ indices = key.nonzero()[0]
+ else:
+ key_arr = np.array([key]) if is_integer(key) else np.asarray(key)
+ indices = np.arange(len(self))[key_arr]
+ return indices
- # Slice data and insert in-between
- new_data = [
- *self._data[0:key].chunks,
+ def _set_via_chunk_iteration(
+ self, indices: npt.NDArray[np.intp], value: npt.NDArray[Any]
+ ) -> pa.ChunkedArray:
+ """
+ Loop through the array chunks and set the new values while
+ leaving the chunking layout unchanged.
+ """
+
+ chunk_indices = self._within_chunk_indices(indices)
+ new_data = []
+
+ for i, chunk in enumerate(self._data.iterchunks()):
+
+ c_ind = chunk_indices[i]
+ n = len(c_ind)
+ c_value, value = value[:n], value[n:]
+
+ if n == 1:
+ # fast path
+ chunk = self._set_single_index_in_chunk(chunk, c_ind[0], c_value[0])
+ elif n > 0:
+ mask = np.zeros(len(chunk), dtype=np.bool_)
+ mask[c_ind] = True
+ if not pa_version_under5p0:
+ if c_value is None or isna(np.array(c_value)).all():
+ chunk = pc.if_else(mask, None, chunk)
+ else:
+ chunk = pc.replace_with_mask(chunk, mask, c_value)
+ else:
+ # The pyarrow compute functions were added in
+ # version 5.0. For prior versions we implement
+ # our own by converting to numpy and back.
+ chunk = chunk.to_numpy(zero_copy_only=False)
+ chunk[mask] = c_value
+ chunk = pa.array(chunk, type=pa.string())
+
+ new_data.append(chunk)
+
+ return pa.chunked_array(new_data)
+
+ @staticmethod
+ def _set_single_index_in_chunk(chunk: pa.Array, index: int, value: Any) -> pa.Array:
+ """Set a single position in a pyarrow array."""
+ assert is_scalar(value)
+ return pa.concat_arrays(
+ [
+ chunk[:index],
pa.array([value], type=pa.string()),
- *self._data[(key + 1) :].chunks,
+ chunk[index + 1 :],
]
- self._data = pa.chunked_array(new_data)
- else:
- # Convert to integer indices and iteratively assign.
- # TODO: Make a faster variant of this in Arrow upstream.
- # This is probably extremely slow.
-
- # Convert all possible input key types to an array of integers
- if isinstance(key, slice):
- key_array = np.array(range(len(self))[key])
- elif is_bool_dtype(key):
- # TODO(ARROW-9430): Directly support setitem(booleans)
- key_array = np.argwhere(key).flatten()
- else:
- # TODO(ARROW-9431): Directly support setitem(integers)
- key_array = np.asanyarray(key)
+ )
- if is_scalar(value):
- value = np.broadcast_to(value, len(key_array))
+ def _within_chunk_indices(
+ self, indices: npt.NDArray[np.intp]
+ ) -> list[npt.NDArray[np.intp]]:
+ """
+ Convert indices for self into a list of ndarrays each containing
+ the indices *within* each chunk of the chunked array.
+ """
+ # indices must be sorted
+ chunk_indices = []
+ for start, stop in self._chunk_ranges():
+ if len(indices) == 0 or indices[0] >= stop:
+ c_ind = np.array([], dtype=np.intp)
else:
- value = np.asarray(value)
+ n = int(np.searchsorted(indices, stop, side="left"))
+ c_ind = indices[:n] - start
+ indices = indices[n:]
+ chunk_indices.append(c_ind)
+ return chunk_indices
- if len(key_array) != len(value):
- raise ValueError("Length of indexer and values mismatch")
-
- for k, v in zip(key_array, value):
- self[k] = v
+ def _chunk_ranges(self) -> list[tuple]:
+ """
+ Return a list of tuples each containing the left (inclusive)
+ and right (exclusive) bounds of each chunk.
+ """
+ lengths = [len(c) for c in self._data.iterchunks()]
+ stops = np.cumsum(lengths)
+ starts = np.concatenate([[0], stops[:-1]])
+ return list(zip(starts, stops))
def take(
self,
diff --git a/pandas/tests/arrays/string_/test_string_arrow.py b/pandas/tests/arrays/string_/test_string_arrow.py
index 265afa89d6530..de1b7a9c603af 100644
--- a/pandas/tests/arrays/string_/test_string_arrow.py
+++ b/pandas/tests/arrays/string_/test_string_arrow.py
@@ -132,3 +132,68 @@ def test_pyarrow_not_installed_raises():
with pytest.raises(ImportError, match=msg):
ArrowStringArray._from_sequence(["a", None, "b"])
+
+
+@skip_if_no_pyarrow
+@pytest.mark.parametrize("multiple_chunks", [False, True])
+@pytest.mark.parametrize(
+ "key, value, expected",
+ [
+ (-1, "XX", ["a", "b", "c", "d", "XX"]),
+ (1, "XX", ["a", "XX", "c", "d", "e"]),
+ (1, None, ["a", None, "c", "d", "e"]),
+ (1, pd.NA, ["a", None, "c", "d", "e"]),
+ ([1, 3], "XX", ["a", "XX", "c", "XX", "e"]),
+ ([1, 3], ["XX", "YY"], ["a", "XX", "c", "YY", "e"]),
+ ([1, 3], ["XX", None], ["a", "XX", "c", None, "e"]),
+ ([1, 3], ["XX", pd.NA], ["a", "XX", "c", None, "e"]),
+ ([0, -1], ["XX", "YY"], ["XX", "b", "c", "d", "YY"]),
+ ([-1, 0], ["XX", "YY"], ["YY", "b", "c", "d", "XX"]),
+ (slice(3, None), "XX", ["a", "b", "c", "XX", "XX"]),
+ (slice(2, 4), ["XX", "YY"], ["a", "b", "XX", "YY", "e"]),
+ (slice(3, 1, -1), ["XX", "YY"], ["a", "b", "YY", "XX", "e"]),
+ (slice(None), "XX", ["XX", "XX", "XX", "XX", "XX"]),
+ ([False, True, False, True, False], ["XX", "YY"], ["a", "XX", "c", "YY", "e"]),
+ ],
+)
+def test_setitem(multiple_chunks, key, value, expected):
+ import pyarrow as pa
+
+ result = pa.array(list("abcde"))
+ expected = pa.array(expected)
+
+ if multiple_chunks:
+ result = pa.chunked_array([result[:3], result[3:]])
+ expected = pa.chunked_array([expected[:3], expected[3:]])
+
+ result = ArrowStringArray(result)
+ expected = ArrowStringArray(expected)
+
+ result[key] = value
+ tm.assert_equal(result, expected)
+ assert result._data.num_chunks == expected._data.num_chunks
+
+
+@skip_if_no_pyarrow
+def test_setitem_invalid_indexer_raises():
+ import pyarrow as pa
+
+ arr = ArrowStringArray(pa.array(list("abcde")))
+
+ with pytest.raises(IndexError, match=None):
+ arr[5] = "foo"
+
+ with pytest.raises(IndexError, match=None):
+ arr[-6] = "foo"
+
+ with pytest.raises(IndexError, match=None):
+ arr[[0, 5]] = "foo"
+
+ with pytest.raises(IndexError, match=None):
+ arr[[0, -6]] = "foo"
+
+ with pytest.raises(IndexError, match=None):
+ arr[[True, True, False]] = "foo"
+
+ with pytest.raises(ValueError, match=None):
+ arr[[0, 1]] = ["foo", "bar", "baz"]
| - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added an entry in the latest `doc/source/whatsnew/v1.5.0.rst` file if fixing a bug or adding a new feature.
This PR improves the performance of `ArrowStringArray.__setitem__` and avoids some existing behavior that can lead to "over-chunking" of the underlying pyarrow `ChunkedArray` as well as exponential performance.
```
import pandas as pd
import pandas._testing as tm
import pyarrow as pa
ca = pa.chunked_array([
tm.rands_array(3, 1_000),
tm.rands_array(3, 1_000),
tm.rands_array(3, 1_000),
])
num_chunks = []
for n in [1000, 2000, 3000]:
arr = pd.arrays.ArrowStringArray(ca)
%timeit arr[:n] = "foo"
num_chunks.append(arr._data.num_chunks)
print("num_chunks:", num_chunks)
```
```
# main
1.72 s ± 142 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
7.23 s ± 761 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
17.5 s ± 1.26 s per loop (mean ± std. dev. of 7 runs, 1 loop each)
num_chunks: [1002, 2001, 3001]
```
```
# PR
88.5 µs ± 1.12 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
145 µs ± 2.55 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
199 µs ± 3.54 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
num_chunks: [3, 3, 3]
```
ASVs added:
```
before after ratio
<main> <arrow-setitem>
- 42.6±0.7ms 28.7±0.6ms 0.67 array.ArrowStringArray.time_setitem(True)
- 22.5±0.3ms 9.86±0.2ms 0.44 array.ArrowStringArray.time_setitem(False)
- 6.84±0.06ms 430±6μs 0.06 array.ArrowStringArray.time_setitem_list(False)
- 17.4±0.1ms 403±5μs 0.02 array.ArrowStringArray.time_setitem_list(True)
- 1.10±0.01s 3.51±0.04ms 0.00 array.ArrowStringArray.time_setitem_slice(True)
- 1.05±0.02s 259±3μs 0.00 array.ArrowStringArray.time_setitem_slice(False)
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/46400 | 2022-03-17T03:49:06Z | 2022-03-18T16:17:07Z | 2022-03-18T16:17:07Z | 2022-03-20T23:18:48Z |
REF: separate out _get_dst_hours | diff --git a/pandas/_libs/tslibs/tzconversion.pyx b/pandas/_libs/tslibs/tzconversion.pyx
index 111d16c27fb3f..1a1aa6dfec5a0 100644
--- a/pandas/_libs/tslibs/tzconversion.pyx
+++ b/pandas/_libs/tslibs/tzconversion.pyx
@@ -115,21 +115,19 @@ timedelta-like}
localized : ndarray[int64_t]
"""
cdef:
- int64_t[::1] deltas
- ndarray[uint8_t, cast=True] ambiguous_array, both_nat, both_eq
+ const int64_t[::1] deltas
+ ndarray[uint8_t, cast=True] ambiguous_array
Py_ssize_t i, isl, isr, idx, pos, ntrans, n = vals.shape[0]
Py_ssize_t delta_idx_offset, delta_idx, pos_left, pos_right
int64_t *tdata
int64_t v, left, right, val, v_left, v_right, new_local, remaining_mins
int64_t first_delta
int64_t shift_delta = 0
- ndarray[int64_t] trans, result, result_a, result_b, dst_hours, delta
- ndarray trans_idx, grp, a_idx, b_idx, one_diff
+ ndarray[int64_t] trans, result, result_a, result_b, dst_hours
npy_datetimestruct dts
bint infer_dst = False, is_dst = False, fill = False
bint shift_forward = False, shift_backward = False
bint fill_nonexist = False
- list trans_grp
str stamp
# Vectorized version of DstTzInfo.localize
@@ -223,49 +221,20 @@ timedelta-like}
# silence false-positive compiler warning
dst_hours = np.empty(0, dtype=np.int64)
if infer_dst:
- dst_hours = np.empty(n, dtype=np.int64)
- dst_hours[:] = NPY_NAT
-
- # Get the ambiguous hours (given the above, these are the hours
- # where result_a != result_b and neither of them are NAT)
- both_nat = np.logical_and(result_a != NPY_NAT, result_b != NPY_NAT)
- both_eq = result_a == result_b
- trans_idx = np.squeeze(np.nonzero(np.logical_and(both_nat, ~both_eq)))
- if trans_idx.size == 1:
- stamp = _render_tstamp(vals[trans_idx])
- raise pytz.AmbiguousTimeError(
- f"Cannot infer dst time from {stamp} as there "
- f"are no repeated times")
- # Split the array into contiguous chunks (where the difference between
- # indices is 1). These are effectively dst transitions in different
- # years which is useful for checking that there is not an ambiguous
- # transition in an individual year.
- if trans_idx.size > 0:
- one_diff = np.where(np.diff(trans_idx) != 1)[0] + 1
- trans_grp = np.array_split(trans_idx, one_diff)
-
- # Iterate through each day, if there are no hours where the
- # delta is negative (indicates a repeat of hour) the switch
- # cannot be inferred
- for grp in trans_grp:
-
- delta = np.diff(result_a[grp])
- if grp.size == 1 or np.all(delta > 0):
- stamp = _render_tstamp(vals[grp[0]])
- raise pytz.AmbiguousTimeError(stamp)
-
- # Find the index for the switch and pull from a for dst and b
- # for standard
- switch_idx = (delta <= 0).nonzero()[0]
- if switch_idx.size > 1:
- raise pytz.AmbiguousTimeError(
- f"There are {switch_idx.size} dst switches when "
- f"there should only be 1.")
- switch_idx = switch_idx[0] + 1
- # Pull the only index and adjust
- a_idx = grp[:switch_idx]
- b_idx = grp[switch_idx:]
- dst_hours[grp] = np.hstack((result_a[a_idx], result_b[b_idx]))
+ dst_hours = _get_dst_hours(vals, result_a, result_b)
+
+ # Pre-compute delta_idx_offset that will be used if we go down non-existent
+ # paths.
+ # Shift the delta_idx by if the UTC offset of
+ # the target tz is greater than 0 and we're moving forward
+ # or vice versa
+ first_delta = deltas[0]
+ if (shift_forward or shift_delta > 0) and first_delta > 0:
+ delta_idx_offset = 1
+ elif (shift_backward or shift_delta < 0) and first_delta < 0:
+ delta_idx_offset = 1
+ else:
+ delta_idx_offset = 0
for i in range(n):
val = vals[i]
@@ -290,7 +259,8 @@ timedelta-like}
stamp = _render_tstamp(val)
raise pytz.AmbiguousTimeError(
f"Cannot infer dst time from {stamp}, try using the "
- f"'ambiguous' argument")
+ "'ambiguous' argument"
+ )
elif left != NPY_NAT:
result[i] = left
elif right != NPY_NAT:
@@ -305,7 +275,7 @@ timedelta-like}
# time
if -1 < shift_delta + remaining_mins < HOUR_NANOS:
raise ValueError(
- f"The provided timedelta will relocalize on a "
+ "The provided timedelta will relocalize on a "
f"nonexistent time: {nonexistent}"
)
new_local = val + shift_delta
@@ -318,16 +288,6 @@ timedelta-like}
delta_idx = bisect_right_i8(tdata, new_local, ntrans)
- # Shift the delta_idx by if the UTC offset of
- # the target tz is greater than 0 and we're moving forward
- # or vice versa
- first_delta = deltas[0]
- if (shift_forward or shift_delta > 0) and first_delta > 0:
- delta_idx_offset = 1
- elif (shift_backward or shift_delta < 0) and first_delta < 0:
- delta_idx_offset = 1
- else:
- delta_idx_offset = 0
delta_idx = delta_idx - delta_idx_offset
result[i] = new_local - deltas[delta_idx]
elif fill_nonexist:
@@ -375,6 +335,70 @@ cdef inline str _render_tstamp(int64_t val):
return str(Timestamp(val))
+cdef ndarray[int64_t] _get_dst_hours(
+ # vals only needed here to potential render an exception message
+ ndarray[int64_t] vals,
+ ndarray[int64_t] result_a,
+ ndarray[int64_t] result_b,
+):
+ cdef:
+ Py_ssize_t n = vals.shape[0]
+ ndarray[uint8_t, cast=True] both_nat, both_eq
+ ndarray[int64_t] delta, dst_hours
+ ndarray trans_idx, grp, a_idx, b_idx, one_diff
+ list trans_grp
+
+ dst_hours = np.empty(n, dtype=np.int64)
+ dst_hours[:] = NPY_NAT
+
+ # Get the ambiguous hours (given the above, these are the hours
+ # where result_a != result_b and neither of them are NAT)
+ both_nat = np.logical_and(result_a != NPY_NAT, result_b != NPY_NAT)
+ both_eq = result_a == result_b
+ trans_idx = np.squeeze(np.nonzero(np.logical_and(both_nat, ~both_eq)))
+ if trans_idx.size == 1:
+ stamp = _render_tstamp(vals[trans_idx])
+ raise pytz.AmbiguousTimeError(
+ f"Cannot infer dst time from {stamp} as there "
+ "are no repeated times"
+ )
+
+ # Split the array into contiguous chunks (where the difference between
+ # indices is 1). These are effectively dst transitions in different
+ # years which is useful for checking that there is not an ambiguous
+ # transition in an individual year.
+ if trans_idx.size > 0:
+ one_diff = np.where(np.diff(trans_idx) != 1)[0] + 1
+ trans_grp = np.array_split(trans_idx, one_diff)
+
+ # Iterate through each day, if there are no hours where the
+ # delta is negative (indicates a repeat of hour) the switch
+ # cannot be inferred
+ for grp in trans_grp:
+
+ delta = np.diff(result_a[grp])
+ if grp.size == 1 or np.all(delta > 0):
+ stamp = _render_tstamp(vals[grp[0]])
+ raise pytz.AmbiguousTimeError(stamp)
+
+ # Find the index for the switch and pull from a for dst and b
+ # for standard
+ switch_idx = (delta <= 0).nonzero()[0]
+ if switch_idx.size > 1:
+ raise pytz.AmbiguousTimeError(
+ f"There are {switch_idx.size} dst switches when "
+ "there should only be 1."
+ )
+
+ switch_idx = switch_idx[0] + 1 # TODO: declare type for switch_idx
+ # Pull the only index and adjust
+ a_idx = grp[:switch_idx]
+ b_idx = grp[switch_idx:]
+ dst_hours[grp] = np.hstack((result_a[a_idx], result_b[b_idx]))
+
+ return dst_hours
+
+
# ----------------------------------------------------------------------
# Timezone Conversion
| There's a lot going on in tz_localize_to_utc, trying to split it into more tightly-scoped pieces. Future goals are a) identifying nano-specific pieces and b) getting rid of python-space numpy calls. | https://api.github.com/repos/pandas-dev/pandas/pulls/46399 | 2022-03-17T01:37:37Z | 2022-03-17T23:02:14Z | 2022-03-17T23:02:14Z | 2022-03-17T23:06:53Z |
REF: Localizer class to de-duplicate tzconversion code | diff --git a/pandas/_libs/tslibs/vectorized.pyx b/pandas/_libs/tslibs/vectorized.pyx
index 34b9e88e046e9..5829bf5492ef8 100644
--- a/pandas/_libs/tslibs/vectorized.pyx
+++ b/pandas/_libs/tslibs/vectorized.pyx
@@ -32,10 +32,7 @@ from .np_datetime cimport (
)
from .offsets cimport BaseOffset
from .period cimport get_period_ordinal
-from .timestamps cimport (
- create_timestamp_from_ts,
- normalize_i8_stamp,
-)
+from .timestamps cimport create_timestamp_from_ts
from .timezones cimport (
get_dst_info,
is_tzlocal,
@@ -47,6 +44,54 @@ from .tzconversion cimport (
localize_tzinfo_api,
)
+
+cdef const int64_t[::1] _deltas_placeholder = np.array([], dtype=np.int64)
+
+
+@cython.freelist(16)
+@cython.internal
+@cython.final
+cdef class Localizer:
+ cdef:
+ tzinfo tz
+ bint use_utc, use_fixed, use_tzlocal, use_dst, use_pytz
+ ndarray trans
+ Py_ssize_t ntrans
+ const int64_t[::1] deltas
+ int64_t delta
+
+ @cython.initializedcheck(False)
+ @cython.boundscheck(False)
+ def __cinit__(self, tzinfo tz):
+ self.tz = tz
+ self.use_utc = self.use_tzlocal = self.use_fixed = False
+ self.use_dst = self.use_pytz = False
+ self.ntrans = -1 # placeholder
+ self.delta = -1 # placeholder
+ self.deltas = _deltas_placeholder
+
+ if is_utc(tz) or tz is None:
+ self.use_utc = True
+
+ elif is_tzlocal(tz) or is_zoneinfo(tz):
+ self.use_tzlocal = True
+
+ else:
+ trans, deltas, typ = get_dst_info(tz)
+ self.trans = trans
+ self.ntrans = trans.shape[0]
+ self.deltas = deltas
+
+ if typ != "pytz" and typ != "dateutil":
+ # static/fixed; in this case we know that len(delta) == 1
+ self.use_fixed = True
+ self.delta = deltas[0]
+ else:
+ self.use_dst = True
+ if typ == "pytz":
+ self.use_pytz = True
+
+
# -------------------------------------------------------------------------
@@ -87,19 +132,14 @@ def ints_to_pydatetime(
ndarray[object] of type specified by box
"""
cdef:
- Py_ssize_t i, ntrans = -1, n = stamps.shape[0]
- ndarray[int64_t] trans
- int64_t[::1] deltas
+ Localizer info = Localizer(tz)
+ int64_t utc_val, local_val
+ Py_ssize_t pos, i, n = stamps.shape[0]
int64_t* tdata = NULL
- intp_t pos
- int64_t utc_val, local_val, delta = NPY_NAT
- bint use_utc = False, use_tzlocal = False, use_fixed = False
- str typ
npy_datetimestruct dts
tzinfo new_tz
ndarray[object] result = np.empty(n, dtype=object)
- bint use_pytz = False
bint use_date = False, use_time = False, use_ts = False, use_pydt = False
if box == "date":
@@ -116,20 +156,8 @@ def ints_to_pydatetime(
"box must be one of 'datetime', 'date', 'time' or 'timestamp'"
)
- if is_utc(tz) or tz is None:
- use_utc = True
- elif is_tzlocal(tz) or is_zoneinfo(tz):
- use_tzlocal = True
- else:
- trans, deltas, typ = get_dst_info(tz)
- ntrans = trans.shape[0]
- if typ not in ["pytz", "dateutil"]:
- # static/fixed; in this case we know that len(delta) == 1
- use_fixed = True
- delta = deltas[0]
- else:
- tdata = <int64_t*>cnp.PyArray_DATA(trans)
- use_pytz = typ == "pytz"
+ if info.use_dst:
+ tdata = <int64_t*>cnp.PyArray_DATA(info.trans)
for i in range(n):
utc_val = stamps[i]
@@ -139,17 +167,17 @@ def ints_to_pydatetime(
result[i] = <object>NaT
continue
- if use_utc:
+ if info.use_utc:
local_val = utc_val
- elif use_tzlocal:
+ elif info.use_tzlocal:
local_val = utc_val + localize_tzinfo_api(utc_val, tz)
- elif use_fixed:
- local_val = utc_val + delta
+ elif info.use_fixed:
+ local_val = utc_val + info.delta
else:
- pos = bisect_right_i8(tdata, utc_val, ntrans) - 1
- local_val = utc_val + deltas[pos]
+ pos = bisect_right_i8(tdata, utc_val, info.ntrans) - 1
+ local_val = utc_val + info.deltas[pos]
- if use_pytz:
+ if info.use_pytz:
# find right representation of dst etc in pytz timezone
new_tz = tz._tzinfos[tz._transition_info[pos]]
@@ -191,46 +219,31 @@ cdef inline c_Resolution _reso_stamp(npy_datetimestruct *dts):
@cython.boundscheck(False)
def get_resolution(const int64_t[:] stamps, tzinfo tz=None) -> Resolution:
cdef:
- Py_ssize_t i, ntrans = -1, n = stamps.shape[0]
- ndarray[int64_t] trans
- int64_t[::1] deltas
+ Localizer info = Localizer(tz)
+ int64_t utc_val, local_val
+ Py_ssize_t pos, i, n = stamps.shape[0]
int64_t* tdata = NULL
- intp_t pos
- int64_t utc_val, local_val, delta = NPY_NAT
- bint use_utc = False, use_tzlocal = False, use_fixed = False
- str typ
npy_datetimestruct dts
c_Resolution reso = c_Resolution.RESO_DAY, curr_reso
- if is_utc(tz) or tz is None:
- use_utc = True
- elif is_tzlocal(tz) or is_zoneinfo(tz):
- use_tzlocal = True
- else:
- trans, deltas, typ = get_dst_info(tz)
- ntrans = trans.shape[0]
- if typ not in ["pytz", "dateutil"]:
- # static/fixed; in this case we know that len(delta) == 1
- use_fixed = True
- delta = deltas[0]
- else:
- tdata = <int64_t*>cnp.PyArray_DATA(trans)
+ if info.use_dst:
+ tdata = <int64_t*>cnp.PyArray_DATA(info.trans)
for i in range(n):
utc_val = stamps[i]
if utc_val == NPY_NAT:
continue
- if use_utc:
+ if info.use_utc:
local_val = utc_val
- elif use_tzlocal:
+ elif info.use_tzlocal:
local_val = utc_val + localize_tzinfo_api(utc_val, tz)
- elif use_fixed:
- local_val = utc_val + delta
+ elif info.use_fixed:
+ local_val = utc_val + info.delta
else:
- pos = bisect_right_i8(tdata, utc_val, ntrans) - 1
- local_val = utc_val + deltas[pos]
+ pos = bisect_right_i8(tdata, utc_val, info.ntrans) - 1
+ local_val = utc_val + info.deltas[pos]
dt64_to_dtstruct(local_val, &dts)
curr_reso = _reso_stamp(&dts)
@@ -242,6 +255,8 @@ def get_resolution(const int64_t[:] stamps, tzinfo tz=None) -> Resolution:
# -------------------------------------------------------------------------
+
+@cython.cdivision(False)
@cython.wraparound(False)
@cython.boundscheck(False)
cpdef ndarray[int64_t] normalize_i8_timestamps(const int64_t[:] stamps, tzinfo tz):
@@ -260,30 +275,15 @@ cpdef ndarray[int64_t] normalize_i8_timestamps(const int64_t[:] stamps, tzinfo t
result : int64 ndarray of converted of normalized nanosecond timestamps
"""
cdef:
- Py_ssize_t i, ntrans = -1, n = stamps.shape[0]
- ndarray[int64_t] trans
- int64_t[::1] deltas
+ Localizer info = Localizer(tz)
+ int64_t utc_val, local_val
+ Py_ssize_t pos, i, n = stamps.shape[0]
int64_t* tdata = NULL
- intp_t pos
- int64_t utc_val, local_val, delta = NPY_NAT
- bint use_utc = False, use_tzlocal = False, use_fixed = False
- str typ
int64_t[::1] result = np.empty(n, dtype=np.int64)
- if is_utc(tz) or tz is None:
- use_utc = True
- elif is_tzlocal(tz) or is_zoneinfo(tz):
- use_tzlocal = True
- else:
- trans, deltas, typ = get_dst_info(tz)
- ntrans = trans.shape[0]
- if typ not in ["pytz", "dateutil"]:
- # static/fixed; in this case we know that len(delta) == 1
- use_fixed = True
- delta = deltas[0]
- else:
- tdata = <int64_t*>cnp.PyArray_DATA(trans)
+ if info.use_dst:
+ tdata = <int64_t*>cnp.PyArray_DATA(info.trans)
for i in range(n):
utc_val = stamps[i]
@@ -291,17 +291,17 @@ cpdef ndarray[int64_t] normalize_i8_timestamps(const int64_t[:] stamps, tzinfo t
result[i] = NPY_NAT
continue
- if use_utc:
+ if info.use_utc:
local_val = utc_val
- elif use_tzlocal:
+ elif info.use_tzlocal:
local_val = utc_val + localize_tzinfo_api(utc_val, tz)
- elif use_fixed:
- local_val = utc_val + delta
+ elif info.use_fixed:
+ local_val = utc_val + info.delta
else:
- pos = bisect_right_i8(tdata, utc_val, ntrans) - 1
- local_val = utc_val + deltas[pos]
+ pos = bisect_right_i8(tdata, utc_val, info.ntrans) - 1
+ local_val = utc_val + info.deltas[pos]
- result[i] = normalize_i8_stamp(local_val)
+ result[i] = local_val - (local_val % DAY_NANOS)
return result.base # `.base` to access underlying ndarray
@@ -324,40 +324,25 @@ def is_date_array_normalized(const int64_t[:] stamps, tzinfo tz=None) -> bool:
is_normalized : bool True if all stamps are normalized
"""
cdef:
- Py_ssize_t i, ntrans = -1, n = stamps.shape[0]
- ndarray[int64_t] trans
- int64_t[::1] deltas
+ Localizer info = Localizer(tz)
+ int64_t utc_val, local_val
+ Py_ssize_t pos, i, n = stamps.shape[0]
int64_t* tdata = NULL
- intp_t pos
- int64_t utc_val, local_val, delta = NPY_NAT
- bint use_utc = False, use_tzlocal = False, use_fixed = False
- str typ
-
- if is_utc(tz) or tz is None:
- use_utc = True
- elif is_tzlocal(tz) or is_zoneinfo(tz):
- use_tzlocal = True
- else:
- trans, deltas, typ = get_dst_info(tz)
- ntrans = trans.shape[0]
- if typ not in ["pytz", "dateutil"]:
- # static/fixed; in this case we know that len(delta) == 1
- use_fixed = True
- delta = deltas[0]
- else:
- tdata = <int64_t*>cnp.PyArray_DATA(trans)
+
+ if info.use_dst:
+ tdata = <int64_t*>cnp.PyArray_DATA(info.trans)
for i in range(n):
utc_val = stamps[i]
- if use_utc:
+ if info.use_utc:
local_val = utc_val
- elif use_tzlocal:
+ elif info.use_tzlocal:
local_val = utc_val + localize_tzinfo_api(utc_val, tz)
- elif use_fixed:
- local_val = utc_val + delta
+ elif info.use_fixed:
+ local_val = utc_val + info.delta
else:
- pos = bisect_right_i8(tdata, utc_val, ntrans) - 1
- local_val = utc_val + deltas[pos]
+ pos = bisect_right_i8(tdata, utc_val, info.ntrans) - 1
+ local_val = utc_val + info.deltas[pos]
if local_val % DAY_NANOS != 0:
return False
@@ -372,31 +357,16 @@ def is_date_array_normalized(const int64_t[:] stamps, tzinfo tz=None) -> bool:
@cython.boundscheck(False)
def dt64arr_to_periodarr(const int64_t[:] stamps, int freq, tzinfo tz):
cdef:
- Py_ssize_t i, ntrans = -1, n = stamps.shape[0]
- ndarray[int64_t] trans
- int64_t[::1] deltas
+ Localizer info = Localizer(tz)
+ int64_t utc_val, local_val
+ Py_ssize_t pos, i, n = stamps.shape[0]
int64_t* tdata = NULL
- intp_t pos
- int64_t utc_val, local_val, delta = NPY_NAT
- bint use_utc = False, use_tzlocal = False, use_fixed = False
- str typ
npy_datetimestruct dts
int64_t[::1] result = np.empty(n, dtype=np.int64)
- if is_utc(tz) or tz is None:
- use_utc = True
- elif is_tzlocal(tz) or is_zoneinfo(tz):
- use_tzlocal = True
- else:
- trans, deltas, typ = get_dst_info(tz)
- ntrans = trans.shape[0]
- if typ not in ["pytz", "dateutil"]:
- # static/fixed; in this case we know that len(delta) == 1
- use_fixed = True
- delta = deltas[0]
- else:
- tdata = <int64_t*>cnp.PyArray_DATA(trans)
+ if info.use_dst:
+ tdata = <int64_t*>cnp.PyArray_DATA(info.trans)
for i in range(n):
utc_val = stamps[i]
@@ -404,15 +374,15 @@ def dt64arr_to_periodarr(const int64_t[:] stamps, int freq, tzinfo tz):
result[i] = NPY_NAT
continue
- if use_utc:
+ if info.use_utc:
local_val = utc_val
- elif use_tzlocal:
+ elif info.use_tzlocal:
local_val = utc_val + localize_tzinfo_api(utc_val, tz)
- elif use_fixed:
- local_val = utc_val + delta
+ elif info.use_fixed:
+ local_val = utc_val + info.delta
else:
- pos = bisect_right_i8(tdata, utc_val, ntrans) - 1
- local_val = utc_val + deltas[pos]
+ pos = bisect_right_i8(tdata, utc_val, info.ntrans) - 1
+ local_val = utc_val + info.deltas[pos]
dt64_to_dtstruct(local_val, &dts)
result[i] = get_period_ordinal(&dts, freq)
| Second attempt at #46246. Perf impact isn't _as_ bad, but is still ugly, see asvs posted below.
The lines:
```
if info.use_utc:
local_val = stamps[i]
elif info.use_tzlocal:
local_val = tz_convert_utc_to_tzlocal(stamps[i], tz)
elif info.use_fixed:
local_val = stamps[i] + info.delta
else:
pos = bisect_right_i8(tdata, stamps[i], info.ntrans) - 1
local_val = stamps[i] + info.deltas[pos]
```
are repeated 5 times in this file, once more with small edits in tzconversion.pyx, and potentially a couple others. So I'd _really_ like to turn them into either a Localizer method or just a module-level function. Doing so causes even bigger performance hits.
Also these lines are liable to change as we add zoneinfo and non-nano support, so making them a function would be helpful for keeping them in sync.
The only idea I have for troubleshooting perf is to move the `info.use_foo` checks (or the info.delta and info.deltas lookups) outside of the loop, but that doesn't seem to make any difference.
Asking for help from the big guns cc @jreback @WillAyd @realead @da-woods
```
time asv continuous -E virtualenv -f 1.01 main HEAD -b tslibs.normalize -b TimeDT64ArrToPeriodArr -b TimeIntsToPydatetime -b TimeResolution --record-samples --append-samples
[...]
before after ratio
[49937b93] [c1085df7]
<perf-gb-mask> <ref-localizer-2>
+ 1.62±0.05μs 2.45±0.03μs 1.51 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 5000, datetime.timezone.utc)
+ 1.89±0.02ms 2.68±0.4ms 1.41 tslibs.normalize.Normalize.time_is_date_array_normalized(1000000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 4.19±0.1μs 5.70±0.6μs 1.36 tslibs.resolution.TimeResolution.time_get_resolution('us', 0, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 4.57±0.1μs 6.12±0.2μs 1.34 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 3000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.90±0.1μs 2.51±0.3μs 1.32 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 7000, None)
+ 4.11±0.06μs 5.42±0.07μs 1.32 tslibs.resolution.TimeResolution.time_get_resolution('m', 1, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 4.00±0.09μs 5.23±0.2μs 1.31 tslibs.resolution.TimeResolution.time_get_resolution('us', 1, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 4.04±0.09μs 5.27±0.5μs 1.30 tslibs.resolution.TimeResolution.time_get_resolution('m', 0, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 974±10ns 1.26±0.1μs 1.29 tslibs.resolution.TimeResolution.time_get_resolution('ns', 0, tzlocal())
+ 4.76±0.1μs 6.13±0.4μs 1.29 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 2011, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.76±0.08μs 2.26±0.1μs 1.28 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4000, tzlocal())
+ 1.77±0.02μs 2.26±0.3μs 1.28 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 6000, tzlocal())
+ 1.67±0.03μs 2.13±0.01μs 1.28 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4006, None)
+ 2.12±0.07μs 2.70±0.05μs 1.27 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.70±0.05μs 2.16±0.02μs 1.27 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 3000, tzlocal())
+ 1.64±0.01μs 2.07±0.04μs 1.27 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 7000, datetime.timezone.utc)
+ 2.27±0.04μs 2.87±0.03μs 1.27 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 951±10ns 1.20±0.01μs 1.26 tslibs.resolution.TimeResolution.time_get_resolution('us', 1, datetime.timezone.utc)
+ 244±20μs 308±30μs 1.26 tslibs.resolution.TimeResolution.time_get_resolution('us', 10000, datetime.timezone.utc)
+ 8.57±0.2μs 10.8±0.6μs 1.26 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 4000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 923±7ns 1.16±0.04μs 1.26 tslibs.resolution.TimeResolution.time_get_resolution('s', 0, datetime.timezone.utc)
+ 1.70±0.03μs 2.14±0.03μs 1.26 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 8000, None)
+ 4.40±0.05μs 5.53±0.2μs 1.26 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 4000, None)
+ 1.67±0.05μs 2.10±0.01μs 1.26 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4000, None)
+ 1.53±0.04μs 1.92±0.1μs 1.26 tslibs.resolution.TimeResolution.time_get_resolution('ns', 1, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 2.31±0.03μs 2.90±0.03μs 1.25 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 5000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.42±0.03μs 1.78±0.04μs 1.25 tslibs.resolution.TimeResolution.time_get_resolution('us', 1, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.64±0.02μs 2.05±0.03μs 1.25 tslibs.resolution.TimeResolution.time_get_resolution('m', 1, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.97±0.07μs 2.47±0.3μs 1.25 tslibs.normalize.Normalize.time_normalize_i8_timestamps(100, datetime.timezone.utc)
+ 7.16±0.05μs 8.95±0.6μs 1.25 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 3000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 2.28±0.04μs 2.85±0.2μs 1.25 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 7000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 4.94±0.08μs 6.15±0.2μs 1.25 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 7000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.03±0.1μs 1.28±0.01μs 1.25 tslibs.resolution.TimeResolution.time_get_resolution('us', 1, None)
+ 2.08±0.04μs 2.58±0.02μs 1.24 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 5000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 286±9μs 355±4μs 1.24 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(10000, 9000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.67±0.04μs 2.07±0.03μs 1.24 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4006, datetime.timezone.utc)
+ 1.03±0.04μs 1.28±0μs 1.24 tslibs.resolution.TimeResolution.time_get_resolution('s', 0, None)
+ 4.96±0.1μs 6.14±0.1μs 1.24 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 10000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 2.10±0.03μs 2.60±0.05μs 1.24 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4006, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 4.15±0.07μs 5.13±0.03μs 1.24 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 6000, None)
+ 4.68±0.1μs 5.78±0.1μs 1.24 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 2011, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 4.95±0.1μs 6.12±0.1μs 1.23 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4006, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 674±20μs 832±70μs 1.23 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(10000, 9000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 4.84±0.1μs 5.96±0.2μs 1.23 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 6.37±0.09μs 7.83±0.2μs 1.23 tslibs.resolution.TimeResolution.time_get_resolution('m', 100, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 5.13±0.04μs 6.29±0.2μs 1.23 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 10000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 5.00±0.4μs 6.11±0.1μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 8000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 3.67±0.07ms 4.49±0.07ms 1.22 tslibs.resolution.TimeResolution.time_get_resolution('s', 100, tzlocal())
+ 1.92±0.09μs 2.35±0.02μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 9000, None)
+ 1.55±0.03μs 1.89±0.03μs 1.22 tslibs.resolution.TimeResolution.time_get_resolution('m', 0, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 4.92±0.3μs 6.02±0.2μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 5000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.06±0.03μs 1.30±0.1μs 1.22 tslibs.resolution.TimeResolution.time_get_resolution('m', 0, None)
+ 208±4μs 254±0.9μs 1.22 tslibs.resolution.TimeResolution.time_get_resolution('m', 10000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 9.37±0.08μs 11.4±0.06μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 5000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 27.7±2ms 33.8±0.2ms 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 7000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 2.32±0.03μs 2.83±0.1μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 8000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 2.30±0.03μs 2.81±0.03μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 6000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 5.41±0.2μs 6.60±0.6μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 7000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.77±0.06μs 2.16±0.02μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 7000, tzlocal())
+ 1.45±0.01μs 1.76±0.05μs 1.22 tslibs.resolution.TimeResolution.time_get_resolution('m', 1, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 4.02±0.02μs 4.89±0.5μs 1.22 tslibs.resolution.TimeResolution.time_get_resolution('D', 1, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 2.46±0.08μs 2.98±0.09μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 10000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 2.11±0.07μs 2.56±0.2μs 1.22 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 7000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 2.97±0.02μs 3.61±0.06μs 1.21 tslibs.resolution.TimeResolution.time_get_resolution('m', 100, None)
+ 2.05±0.03μs 2.48±0.08μs 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 3000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 4.87±0.2μs 5.91±0.2μs 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 6000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 7.60±0.4μs 9.21±0.2μs 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 11000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.01±0.01μs 1.22±0.03μs 1.21 tslibs.resolution.TimeResolution.time_get_resolution('us', 0, None)
+ 7.10±0.2μs 8.61±0.2μs 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 1011, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.73±0.04μs 2.09±0.02μs 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4000, datetime.timezone.utc)
+ 4.11±0.2μs 4.98±0.2μs 1.21 tslibs.resolution.TimeResolution.time_get_resolution('D', 0, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 69.1±3ms 83.7±5ms 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 4006, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 64.8±0.6ms 78.5±4ms 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 8000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 4.02±0.05μs 4.86±0.09μs 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 1011, datetime.timezone.utc)
+ 1.85±0.2μs 2.24±0.04μs 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 1000, None)
+ 28.1±0.6ms 34.0±2ms 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 10000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 205±4μs 248±1μs 1.21 tslibs.resolution.TimeResolution.time_get_resolution('m', 10000, None)
+ 5.13±0.2μs 6.18±0.3μs 1.21 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 2000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 4.17±0.06μs 5.03±0.5μs 1.20 tslibs.resolution.TimeResolution.time_get_resolution('ns', 1, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.77±0.03μs 2.13±0.02μs 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 5000, tzlocal())
+ 551±5μs 663±40μs 1.20 tslibs.resolution.TimeResolution.time_get_resolution('s', 10000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.72±0.04μs 2.07±0.01μs 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 5000, None)
+ 5.08±0.06μs 6.11±0.04μs 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 9000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.76±0.04μs 2.11±0.02μs 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 6000, None)
+ 2.55±0.07μs 3.06±0.3μs 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 24.9±1μs 29.9±0.7μs 1.20 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 100, datetime.timezone.utc)
+ 2.29±0.1μs 2.75±0.07μs 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 3000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 4.52±0.3μs 5.43±0.06μs 1.20 tslibs.resolution.TimeResolution.time_get_resolution('h', 1, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 3.56±0.06ms 4.27±0.2ms 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 11000, tzlocal())
+ 1.35±0.02μs 1.62±0.01μs 1.20 tslibs.resolution.TimeResolution.time_get_resolution('s', 0, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 23.6±0.5ms 28.4±0.5ms 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 2000, datetime.timezone.utc)
+ 3.84±0.2μs 4.61±0.07μs 1.20 tslibs.resolution.TimeResolution.time_get_resolution('m', 100, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 28.5±0.9ms 34.1±3ms 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 4000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 26.4±0.3ms 31.6±2ms 1.20 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 11000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 5.27±0.09μs 6.29±0.4μs 1.19 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 12000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 21.9±0.5μs 26.2±0.6μs 1.19 tslibs.normalize.Normalize.time_is_date_array_normalized(10000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 2.37±0.1μs 2.82±0.1μs 1.19 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 2000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 7.79±0.5μs 9.28±0.1μs 1.19 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 7000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 25.6±0.2μs 30.5±0.6μs 1.19 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 100, None)
+ 2.31±0.08μs 2.75±0.1μs 1.19 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 2011, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 3.38±0.02ms 4.01±0.1ms 1.19 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 10000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 27.4±0.6ms 32.5±2ms 1.19 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 6000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 5.16±0.2μs 6.13±0.1μs 1.19 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 12000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.77±0.04μs 2.11±0.01μs 1.19 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4006, tzlocal())
+ 2.07±0.05μs 2.45±0.2μs 1.19 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 0, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.60±0.01μs 1.90±0.03μs 1.19 tslibs.resolution.TimeResolution.time_get_resolution('us', 0, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 209±4μs 248±5μs 1.19 tslibs.resolution.TimeResolution.time_get_resolution('ns', 10000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.75±0.06μs 2.07±0.02μs 1.19 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 3000, datetime.timezone.utc)
+ 2.24±0.2μs 2.65±0.02μs 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 10000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 5.42±0.1μs 6.42±0.7μs 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4006, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 3.64±0.2ms 4.31±0.04ms 1.18 tslibs.resolution.TimeResolution.time_get_resolution('m', 100, tzlocal())
+ 2.24±0.07μs 2.65±0.2μs 1.18 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 1, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.78±0.03μs 2.10±0.2μs 1.18 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 0, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 2.02±0.02μs 2.39±0.2μs 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 2011, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 66.3±2ms 78.4±1ms 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 11000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 2.26±0.1μs 2.67±0.1μs 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 26.2±0.7μs 30.9±0.3μs 1.18 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 100, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.89±0.1μs 2.23±0.03μs 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 5000, None)
+ 340±6ms 401±20ms 1.18 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('datetime', 1000000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 25.3±0.4ms 29.9±0.5ms 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 6000, datetime.timezone.utc)
+ 65.1±1ms 76.8±0.5ms 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 6000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 2.07±0.03μs 2.44±0.1μs 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 11000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 3.05±0.1μs 3.60±0.04μs 1.18 tslibs.resolution.TimeResolution.time_get_resolution('m', 100, datetime.timezone.utc)
+ 67.4±1ms 79.3±3ms 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 7000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.46±0.1μs 1.72±0.07μs 1.18 tslibs.resolution.TimeResolution.time_get_resolution('h', 0, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.73±0.04μs 2.03±0.1μs 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 7000, None)
+ 1.46±0.03μs 1.72±0.04μs 1.18 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 0, None)
+ 1.88±0.09μs 2.21±0.1μs 1.18 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 9000, tzlocal())
+ 5.28±0.02μs 6.20±0.08μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 4000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 2.40±0.1μs 2.82±0.07μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 4006, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 5.14±0.2μs 6.04±0.05μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 11000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 2.13±0.02μs 2.50±0.1μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 8000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.70±0.08μs 1.99±0.04μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 9000, tzlocal())
+ 1.81±0.2μs 2.13±0.05μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 7000, datetime.timezone.utc)
+ 1.75±0.02μs 2.05±0.2μs 1.17 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 1, None)
+ 990±9ns 1.16±0.07μs 1.17 tslibs.resolution.TimeResolution.time_get_resolution('m', 1, datetime.timezone.utc)
+ 3.57±0.04ms 4.18±0.3ms 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 10000, tzlocal())
+ 207±10μs 242±3μs 1.17 tslibs.resolution.TimeResolution.time_get_resolution('m', 10000, datetime.timezone.utc)
+ 8.14±0.2μs 9.52±0.3μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 1011, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 2.24±0.05μs 2.62±0.2μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 9000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.74±0.1μs 2.03±0.08μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 12000, datetime.timezone.utc)
+ 1.05±0.04μs 1.23±0.02μs 1.17 tslibs.resolution.TimeResolution.time_get_resolution('m', 1, None)
+ 8.17±0.04μs 9.52±0.4μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 5000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 2.42±0.1μs 2.82±0.03μs 1.17 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 3000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 360±4ms 420±20ms 1.17 tslibs.resolution.TimeResolution.time_get_resolution('h', 10000, tzlocal())
+ 615±10μs 715±10μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(10000, 1011, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.01±0.06μs 1.17±0.03μs 1.16 tslibs.resolution.TimeResolution.time_get_resolution('D', 0, tzlocal())
+ 1.82±0.04μs 2.11±0.01μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 11000, None)
+ 29.8±0.5μs 34.6±0.7μs 1.16 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 100, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 243±4μs 283±40μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(10000, 1000, datetime.timezone.utc)
+ 5.12±0.3μs 5.95±0.1μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 10000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 4.51±0.03μs 5.24±0.1μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 4006, None)
+ 7.70±0.2μs 8.94±0.5μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 4000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 2.27±0.2μs 2.63±0.07μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 2000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 7.95±0.1μs 9.22±0.6μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 2011, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.03±0.01μs 1.19±0.03μs 1.16 tslibs.resolution.TimeResolution.time_get_resolution('D', 0, None)
+ 1.72±0.03μs 2.00±0.1μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 9000, None)
+ 912±30ns 1.06±0.09μs 1.16 tslibs.resolution.TimeResolution.time_get_resolution('m', 0, datetime.timezone.utc)
+ 4.26±0.08μs 4.94±0.1μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 1011, None)
+ 2.22±0.2μs 2.57±0.08μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 12000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 2.51±0.2μs 2.91±0.07μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 1000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 4.98±0.08μs 5.76±0.2μs 1.16 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 3000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 37.1±2μs 42.9±0.3μs 1.15 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 100, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 25.5±0.8ms 29.4±0.5ms 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 6000, None)
+ 25.5±0.9ms 29.4±0.2ms 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 1011, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 207±6μs 238±10μs 1.15 tslibs.resolution.TimeResolution.time_get_resolution('h', 10000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 4.42±0.03μs 5.10±0.4μs 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 4000, datetime.timezone.utc)
+ 4.13±0.09μs 4.76±0.02μs 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 3000, datetime.timezone.utc)
+ 4.16±0.2μs 4.79±0.05μs 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 2011, datetime.timezone.utc)
+ 25.8±1ms 29.7±0.2ms 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 2000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 967±10ns 1.11±0.03μs 1.15 tslibs.resolution.TimeResolution.time_get_resolution('ns', 1, None)
+ 1.75±0.04μs 2.02±0.1μs 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 8000, tzlocal())
+ 1.84±0.1μs 2.11±0.02μs 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 12000, None)
+ 21.8±1ms 25.0±0.3ms 1.15 tslibs.resolution.TimeResolution.time_get_resolution('m', 1000000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.81±0.05μs 2.08±0.2μs 1.15 tslibs.normalize.Normalize.time_normalize_i8_timestamps(1, datetime.timezone.utc)
+ 3.71±0.02ms 4.26±0.1ms 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 1000, tzlocal())
+ 38.3±1μs 44.0±1μs 1.15 tslibs.resolution.TimeResolution.time_get_resolution('D', 1, tzlocal())
+ 231±10μs 265±2μs 1.15 tslibs.resolution.TimeResolution.time_get_resolution('m', 10000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.85±0.08μs 2.13±0.03μs 1.15 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 3000, None)
+ 1.50±0.1μs 1.72±0.03μs 1.15 tslibs.resolution.TimeResolution.time_get_resolution('h', 1, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 373±8ms 427±10ms 1.15 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 10000, tzlocal())
+ 57.5±2ms 65.8±1ms 1.14 tslibs.resolution.TimeResolution.time_get_resolution('s', 1000000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 7.52±0.4μs 8.60±0.7μs 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 8000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 4.90±0.07μs 5.59±0.03μs 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 1011, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 4.84±0.1μs 5.52±0.5μs 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 11000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 25.4±0.3ms 28.9±2ms 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 9000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 203±5μs 231±6μs 1.14 tslibs.resolution.TimeResolution.time_get_resolution('D', 10000, None)
+ 1.10±0.09μs 1.25±0.01μs 1.14 tslibs.resolution.TimeResolution.time_get_resolution('s', 0, tzlocal())
+ 4.54±0.4μs 5.17±0.03μs 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 9000, None)
+ 3.26±0.04μs 3.72±0.3μs 1.14 tslibs.resolution.TimeResolution.time_get_resolution('us', 100, None)
+ 6.28±0.07μs 7.16±0.5μs 1.14 tslibs.resolution.TimeResolution.time_get_resolution('us', 100, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 25.1±1ms 28.6±0.4ms 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 1000, None)
+ 26.2±0.3ms 29.9±0.8ms 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 11000, datetime.timezone.utc)
+ 4.22±0.2ms 4.80±0.01ms 1.14 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 10000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 5.37±0.2μs 6.11±0.1μs 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 354±9ms 403±20ms 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(10000, 9000, tzlocal())
+ 26.7±1ms 30.4±0.9ms 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 6000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.69±0.02μs 1.92±0.1μs 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 10000, datetime.timezone.utc)
+ 266±5μs 302±10μs 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(10000, 1011, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 239±8μs 271±10μs 1.14 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(10000, 1011, datetime.timezone.utc)
+ 4.25±0.07ms 4.82±0.1ms 1.13 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 10000, datetime.timezone.utc)
+ 202±2μs 229±10μs 1.13 tslibs.resolution.TimeResolution.time_get_resolution('s', 10000, datetime.timezone.utc)
+ 3.83±0.1ms 4.33±0.2ms 1.13 tslibs.resolution.TimeResolution.time_get_resolution('ns', 100, tzlocal())
+ 1.74±0.04μs 1.97±0.04μs 1.13 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 6000, datetime.timezone.utc)
+ 1.82±0.02μs 2.06±0.05μs 1.13 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 1, datetime.timezone.utc)
+ 6.80±0.5μs 7.69±0.2μs 1.13 tslibs.resolution.TimeResolution.time_get_resolution('h', 100, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 2.61±0.09μs 2.95±0.05μs 1.13 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 1011, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 195±3μs 220±9μs 1.13 tslibs.resolution.TimeResolution.time_get_resolution('D', 10000, datetime.timezone.utc)
+ 2.12±0.07μs 2.39±0.2μs 1.13 tslibs.normalize.Normalize.time_normalize_i8_timestamps(100, None)
+ 1.84±0.1μs 2.07±0.2μs 1.13 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 6000, datetime.timezone.utc)
+ 2.39±0.1μs 2.69±0.2μs 1.13 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 2011, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 5.14±0.3μs 5.77±0.07μs 1.12 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 1000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 61.1±3ms 68.6±0.3ms 1.12 tslibs.resolution.TimeResolution.time_get_resolution('m', 1000000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.88±0.06μs 2.11±0.03μs 1.12 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 11000, None)
+ 1.99±0.2μs 2.23±0.03μs 1.12 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 2011, tzlocal())
+ 39.6±1μs 44.4±0.6μs 1.12 tslibs.resolution.TimeResolution.time_get_resolution('m', 1, tzlocal())
+ 450±3ms 504±20ms 1.12 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 1000000, datetime.timezone.utc)
+ 1.90±0.1μs 2.13±0.02μs 1.12 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4000, None)
+ 442±3ms 495±30ms 1.12 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('datetime', 1000000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 3.57±0.02ms 3.99±0.2ms 1.12 tslibs.resolution.TimeResolution.time_get_resolution('h', 100, tzlocal())
+ 1.90±0.2μs 2.12±0.03μs 1.12 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 1000, tzlocal())
+ 2.48±0.02μs 2.77±0.02μs 1.12 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 1011, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 2.40±0.09μs 2.68±0.06μs 1.12 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4006, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 5.21±0.1μs 5.80±0.4μs 1.11 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 9000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 42.4±2μs 47.2±0.3μs 1.11 tslibs.resolution.TimeResolution.time_get_resolution('s', 1, tzlocal())
+ 3.79±0.1ms 4.21±0.01ms 1.11 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 100, tzlocal())
+ 4.46±0.04μs 4.96±0.2μs 1.11 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 0, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 5.48±0.4μs 6.09±0.07μs 1.11 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 3000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.88±0.1μs 2.09±0.03μs 1.11 tslibs.normalize.Normalize.time_normalize_i8_timestamps(1, None)
+ 5.27±0.2μs 5.86±0.2μs 1.11 tslibs.normalize.Normalize.time_normalize_i8_timestamps(1, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 223±2μs 248±20μs 1.11 tslibs.resolution.TimeResolution.time_get_resolution('s', 10000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 3.94±0.06μs 4.38±0.06μs 1.11 tslibs.resolution.TimeResolution.time_get_resolution('h', 100, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.83±0.1μs 2.03±0.02μs 1.11 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4000, datetime.timezone.utc)
+ 5.97±0.4μs 6.63±0.6μs 1.11 tslibs.normalize.Normalize.time_normalize_i8_timestamps(100, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.34±0.03μs 1.49±0.03μs 1.11 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 0, datetime.timezone.utc)
+ 1.94±0.04μs 2.15±0.02μs 1.11 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4006, None)
+ 2.33±0.09μs 2.58±0.04μs 1.11 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 1000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.84±0.08μs 2.04±0.09μs 1.11 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 1000, datetime.timezone.utc)
+ 2.59±0.05μs 2.86±0.02μs 1.11 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 12000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 6.05±0.1μs 6.69±0.2μs 1.11 tslibs.resolution.TimeResolution.time_get_resolution('ns', 100, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 7.79±0.7μs 8.60±0.03μs 1.10 tslibs.resolution.TimeResolution.time_get_resolution('h', 100, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 28.3±0.7ms 31.3±0.5ms 1.10 tslibs.normalize.Normalize.time_normalize_i8_timestamps(1000000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.77±0.2μs 1.95±0.04μs 1.10 tslibs.resolution.TimeResolution.time_get_resolution('h', 1, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 5.52±0.4μs 6.06±0.1μs 1.10 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 11000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.88±0.03μs 2.07±0.04μs 1.10 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 11000, tzlocal())
+ 605±8μs 664±10μs 1.10 tslibs.resolution.TimeResolution.time_get_resolution('m', 10000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 949±20ns 1.04±0.05μs 1.10 tslibs.resolution.TimeResolution.time_get_resolution('us', 0, datetime.timezone.utc)
+ 1.95±0.1μs 2.14±0.04μs 1.10 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4000, tzlocal())
+ 5.58±0.2μs 6.12±0.05μs 1.10 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 1000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 919±30ns 1.01±0.03μs 1.10 tslibs.resolution.TimeResolution.time_get_resolution('ns', 1, datetime.timezone.utc)
+ 4.77±0.1μs 5.21±0.3μs 1.09 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 9000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 328±3ms 358±5ms 1.09 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('datetime', 1000000, None)
+ 3.69±0.1ms 4.03±0.2ms 1.09 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 2011, tzlocal())
+ 2.07±0.01μs 2.26±0.1μs 1.09 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1, 9000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 335±5ms 365±30ms 1.09 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('datetime', 1000000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 63.2±2ms 68.9±0.9ms 1.09 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(1000000, 1000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 2.56±0.1μs 2.79±0.04μs 1.09 tslibs.normalize.Normalize.time_normalize_i8_timestamps(1, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.90±0.1μs 2.07±0.03μs 1.09 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 2000, datetime.timezone.utc)
+ 1.97±0.03μs 2.14±0.07μs 1.08 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 1, None)
+ 2.03±0.09μs 2.20±0.08μs 1.08 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 0, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 7.09±0.06μs 7.66±0.4μs 1.08 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(100, 2000, datetime.timezone(datetime.timedelta(seconds=3600)))
+ 1.58±0.06μs 1.70±0.05μs 1.08 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 0, tzlocal())
+ 35.2±0.8μs 38.0±0.7μs 1.08 tslibs.normalize.Normalize.time_is_date_array_normalized(10000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 21.8±1ms 23.5±0.2ms 1.08 tslibs.resolution.TimeResolution.time_get_resolution('D', 1000000, None)
+ 2.01±0.1μs 2.17±0.09μs 1.08 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 2000, tzlocal())
+ 1.39±0.02μs 1.50±0.06μs 1.08 tslibs.resolution.TimeResolution.time_get_resolution('ns', 1, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 2.61±0.08μs 2.81±0.04μs 1.07 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 3000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 338±4ms 363±20ms 1.07 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('datetime', 1000000, datetime.timezone.utc)
+ 549±30ns 590±20ns 1.07 tslibs.normalize.Normalize.time_is_date_array_normalized(1, None)
+ 2.44±0.1μs 2.62±0.02μs 1.07 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 11000, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 1.94±0.08μs 2.08±0.04μs 1.07 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 4006, datetime.timezone.utc)
+ 5.17±0.3μs 5.52±0.04μs 1.07 tslibs.normalize.Normalize.time_normalize_i8_timestamps(100, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
+ 3.40±0.1μs 3.63±0.02μs 1.07 tslibs.resolution.TimeResolution.time_get_resolution('h', 100, None)
+ 2.67±0.1ms 2.83±0.02ms 1.06 tslibs.normalize.Normalize.time_normalize_i8_timestamps(1000000, datetime.timezone.utc)
+ 2.52±0.1μs 2.67±0.02μs 1.06 tslibs.period.TimeDT64ArrToPeriodArr.time_dt64arr_to_periodarr(0, 11000, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
+ 1.51±0.05μs 1.57±0.02μs 1.04 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 0, tzlocal())
+ 43.7±0.2μs 45.5±2μs 1.04 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('timestamp', 100, datetime.timezone(datetime.timedelta(seconds=3600)))
- 3.53±0.03ms 3.36±0.01ms 0.95 tslibs.normalize.Normalize.time_normalize_i8_timestamps(1000000, datetime.timezone(datetime.timedelta(seconds=3600)))
- 1.34±0.04ms 1.27±0.02ms 0.95 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('date', 10000, None)
- 279±20ms 265±4ms 0.95 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 1000000, datetime.timezone(datetime.timedelta(seconds=3600)))
- 276±9ms 261±2ms 0.95 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('time', 1000000, datetime.timezone.utc)
- 151±3ms 142±2ms 0.94 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('date', 1000000, None)
- 2.29±0.1μs 2.09±0.04μs 0.91 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('datetime', 0, tzfile('/usr/share/zoneinfo/Asia/Tokyo'))
- 1.57±0.03μs 1.41±0.09μs 0.90 tslibs.resolution.TimeResolution.time_get_resolution('ns', 0, <DstTzInfo 'US/Pacific' LMT-1 day, 16:07:00 STD>)
- 3.54±0.2ms 3.07±0.05ms 0.87 tslibs.tslib.TimeIntsToPydatetime.time_ints_to_pydatetime('datetime', 10000, datetime.timezone.utc)
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/46397 | 2022-03-16T21:34:43Z | 2022-04-18T22:31:06Z | 2022-04-18T22:31:06Z | 2022-04-18T23:33:59Z |
TYP/CI: Fix failing clipboard typing | diff --git a/pandas/io/clipboard/__init__.py b/pandas/io/clipboard/__init__.py
index 2ebe03f5f298c..6a39b20869497 100644
--- a/pandas/io/clipboard/__init__.py
+++ b/pandas/io/clipboard/__init__.py
@@ -94,7 +94,8 @@ class PyperclipException(RuntimeError):
class PyperclipWindowsException(PyperclipException):
def __init__(self, message) -> None:
- message += f" ({ctypes.WinError()})"
+ # attr only exists on Windows, so typing fails on other platforms
+ message += f" ({ctypes.WinError()})" # type: ignore[attr-defined]
super().__init__(message)
| - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/46395 | 2022-03-16T15:22:45Z | 2022-03-16T18:12:45Z | 2022-03-16T18:12:45Z | 2022-03-16T20:12:31Z |
CI: Use conda-forge PyPy | diff --git a/.github/workflows/posix.yml b/.github/workflows/posix.yml
index b86dcea59edb8..35c40f2a4aa54 100644
--- a/.github/workflows/posix.yml
+++ b/.github/workflows/posix.yml
@@ -155,24 +155,11 @@ jobs:
channel-priority: flexible
environment-file: ${{ env.ENV_FILE }}
use-only-tar-bz2: true
- if: ${{ env.IS_PYPY == 'false' }} # No pypy3.8 support
- name: Upgrade Arrow version
run: conda install -n pandas-dev -c conda-forge --no-update-deps pyarrow=${{ matrix.pyarrow_version }}
if: ${{ matrix.pyarrow_version }}
- - name: Setup PyPy
- uses: actions/setup-python@v3
- with:
- python-version: "pypy-3.8"
- if: ${{ env.IS_PYPY == 'true' }}
-
- - name: Setup PyPy dependencies
- run: |
- # TODO: re-enable cov, its slowing the tests down though
- pip install Cython numpy python-dateutil pytz pytest>=6.0 pytest-xdist>=1.31.0 pytest-asyncio>=0.17 hypothesis>=5.5.3
- if: ${{ env.IS_PYPY == 'true' }}
-
- name: Build Pandas
uses: ./.github/actions/build_pandas
diff --git a/ci/deps/actions-pypy-38.yaml b/ci/deps/actions-pypy-38.yaml
index ad05d2ab2dacc..eda35ee14ec65 100644
--- a/ci/deps/actions-pypy-38.yaml
+++ b/ci/deps/actions-pypy-38.yaml
@@ -11,6 +11,7 @@ dependencies:
- cython>=0.29.24
- pytest>=6.0
- pytest-cov
+ - pytest-asyncio
- pytest-xdist>=1.31
- hypothesis>=5.5.3
| - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/46394 | 2022-03-16T14:28:37Z | 2022-05-16T22:06:00Z | 2022-05-16T22:06:00Z | 2022-05-17T09:17:11Z |
TST: skip -> xfail | diff --git a/pandas/tests/frame/methods/test_between_time.py b/pandas/tests/frame/methods/test_between_time.py
index d8a742c644e9e..eb5cfbc2bfbe8 100644
--- a/pandas/tests/frame/methods/test_between_time.py
+++ b/pandas/tests/frame/methods/test_between_time.py
@@ -18,7 +18,7 @@
class TestBetweenTime:
- @td.skip_if_has_locale
+ @td.skip_if_not_us_locale
def test_between_time_formats(self, frame_or_series):
# GH#11818
rng = date_range("1/1/2000", "1/5/2000", freq="5min")
diff --git a/pandas/tests/groupby/test_quantile.py b/pandas/tests/groupby/test_quantile.py
index 1badc4aa7995a..bf06495f935cd 100644
--- a/pandas/tests/groupby/test_quantile.py
+++ b/pandas/tests/groupby/test_quantile.py
@@ -34,10 +34,13 @@
],
)
@pytest.mark.parametrize("q", [0, 0.25, 0.5, 0.75, 1])
-def test_quantile(interpolation, a_vals, b_vals, q):
+def test_quantile(interpolation, a_vals, b_vals, q, request):
if interpolation == "nearest" and q == 0.5 and b_vals == [4, 3, 2, 1]:
- pytest.skip(
- "Unclear numpy expectation for nearest result with equidistant data"
+ request.node.add_marker(
+ pytest.mark.xfail(
+ reason="Unclear numpy expectation for nearest "
+ "result with equidistant data"
+ )
)
a_expected = pd.Series(a_vals).quantile(q, interpolation=interpolation)
diff --git a/pandas/tests/io/formats/test_series_info.py b/pandas/tests/io/formats/test_series_info.py
index fc83b6c3d23ea..761dd07dbef51 100644
--- a/pandas/tests/io/formats/test_series_info.py
+++ b/pandas/tests/io/formats/test_series_info.py
@@ -116,7 +116,7 @@ def test_info_shows_dtypes():
assert name in res
-@pytest.mark.skipif(PYPY, reason="on PyPy deep=True doesn't change result")
+@pytest.mark.xfail(PYPY, reason="on PyPy deep=True doesn't change result")
def test_info_memory_usage_deep_not_pypy():
s_with_object_index = Series({"a": [1]}, index=["foo"])
assert s_with_object_index.memory_usage(
@@ -127,7 +127,7 @@ def test_info_memory_usage_deep_not_pypy():
assert s_object.memory_usage(deep=True) > s_object.memory_usage()
-@pytest.mark.skipif(not PYPY, reason="on PyPy deep=True does not change result")
+@pytest.mark.xfail(not PYPY, reason="on PyPy deep=True does not change result")
def test_info_memory_usage_deep_pypy():
s_with_object_index = Series({"a": [1]}, index=["foo"])
assert s_with_object_index.memory_usage(
diff --git a/pandas/tests/io/json/test_ujson.py b/pandas/tests/io/json/test_ujson.py
index 93318bed2a6af..e82a888f47388 100644
--- a/pandas/tests/io/json/test_ujson.py
+++ b/pandas/tests/io/json/test_ujson.py
@@ -945,9 +945,11 @@ def test_array_numpy_labelled(self):
class TestPandasJSONTests:
- def test_dataframe(self, orient, numpy):
+ def test_dataframe(self, request, orient, numpy):
if orient == "records" and numpy:
- pytest.skip("Not idiomatic pandas")
+ request.node.add_marker(
+ pytest.mark.xfail(reason=f"Not idiomatic pandas if orient={orient}")
+ )
dtype = get_int32_compat_dtype(numpy, orient)
diff --git a/pandas/tests/io/parser/common/test_read_errors.py b/pandas/tests/io/parser/common/test_read_errors.py
index 2274646ae7c69..47f1052808e0c 100644
--- a/pandas/tests/io/parser/common/test_read_errors.py
+++ b/pandas/tests/io/parser/common/test_read_errors.py
@@ -241,11 +241,16 @@ def test_null_byte_char(all_parsers):
@td.check_file_leaks
-def test_open_file(all_parsers):
+def test_open_file(request, all_parsers):
# GH 39024
parser = all_parsers
if parser.engine == "c":
- pytest.skip("'c' engine does not support sep=None with delim_whitespace=False")
+ request.node.add_marker(
+ pytest.mark.xfail(
+ reason=f"{parser.engine} engine does not support sep=None "
+ f"with delim_whitespace=False"
+ )
+ )
with tm.ensure_clean() as path:
file = Path(path)
diff --git a/pandas/tests/io/parser/dtypes/test_dtypes_basic.py b/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
index 4d99b3c3c8c85..eded3c1126bad 100644
--- a/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
+++ b/pandas/tests/io/parser/dtypes/test_dtypes_basic.py
@@ -191,31 +191,39 @@ def test_delimiter_with_usecols_and_parse_dates(all_parsers):
@pytest.mark.parametrize("thousands", ["_", None])
-def test_decimal_and_exponential(python_parser_only, numeric_decimal, thousands):
+def test_decimal_and_exponential(
+ request, python_parser_only, numeric_decimal, thousands
+):
# GH#31920
- decimal_number_check(python_parser_only, numeric_decimal, thousands, None)
+ decimal_number_check(request, python_parser_only, numeric_decimal, thousands, None)
@pytest.mark.parametrize("thousands", ["_", None])
@pytest.mark.parametrize("float_precision", [None, "legacy", "high", "round_trip"])
def test_1000_sep_decimal_float_precision(
- c_parser_only, numeric_decimal, float_precision, thousands
+ request, c_parser_only, numeric_decimal, float_precision, thousands
):
# test decimal and thousand sep handling in across 'float_precision'
# parsers
- decimal_number_check(c_parser_only, numeric_decimal, thousands, float_precision)
+ decimal_number_check(
+ request, c_parser_only, numeric_decimal, thousands, float_precision
+ )
text, value = numeric_decimal
text = " " + text + " "
if isinstance(value, str): # the negative cases (parse as text)
value = " " + value + " "
- decimal_number_check(c_parser_only, (text, value), thousands, float_precision)
+ decimal_number_check(
+ request, c_parser_only, (text, value), thousands, float_precision
+ )
-def decimal_number_check(parser, numeric_decimal, thousands, float_precision):
+def decimal_number_check(request, parser, numeric_decimal, thousands, float_precision):
# GH#31920
value = numeric_decimal[0]
- if thousands is None and "_" in value:
- pytest.skip("Skip test if no thousands sep is defined and sep is in value")
+ if thousands is None and value in ("1_,", "1_234,56", "1_234,56e0"):
+ request.node.add_marker(
+ pytest.mark.xfail(reason=f"thousands={thousands} and sep is in {value}")
+ )
df = parser.read_csv(
StringIO(value),
float_precision=float_precision,
diff --git a/pandas/tests/io/parser/test_compression.py b/pandas/tests/io/parser/test_compression.py
index d97b594623023..576542306c164 100644
--- a/pandas/tests/io/parser/test_compression.py
+++ b/pandas/tests/io/parser/test_compression.py
@@ -91,7 +91,7 @@ def test_zip_error_invalid_zip(parser_and_data):
@skip_pyarrow
@pytest.mark.parametrize("filename", [None, "test.{ext}"])
-def test_compression(parser_and_data, compression_only, buffer, filename):
+def test_compression(request, parser_and_data, compression_only, buffer, filename):
parser, data, expected = parser_and_data
compress_type = compression_only
@@ -99,7 +99,11 @@ def test_compression(parser_and_data, compression_only, buffer, filename):
filename = filename if filename is None else filename.format(ext=ext)
if filename and buffer:
- pytest.skip("Cannot deduce compression from buffer of compressed data.")
+ request.node.add_marker(
+ pytest.mark.xfail(
+ reason="Cannot deduce compression from buffer of compressed data."
+ )
+ )
with tm.ensure_clean(filename=filename) as path:
tm.write_to_compressed(compress_type, path, data)
diff --git a/pandas/tests/io/parser/test_unsupported.py b/pandas/tests/io/parser/test_unsupported.py
index f346fad7acecf..2f28697daf9e2 100644
--- a/pandas/tests/io/parser/test_unsupported.py
+++ b/pandas/tests/io/parser/test_unsupported.py
@@ -191,11 +191,13 @@ def test_close_file_handle_on_invalid_usecols(all_parsers):
os.unlink(fname)
-def test_invalid_file_inputs(all_parsers):
+def test_invalid_file_inputs(request, all_parsers):
# GH#45957
parser = all_parsers
if parser.engine == "python":
- pytest.skip("Python engine supports lists.")
+ request.node.add_marker(
+ pytest.mark.xfail(reason=f"{parser.engine} engine supports lists.")
+ )
with pytest.raises(ValueError, match="Invalid"):
parser.read_csv([])
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 31add4743d1e9..e4318f1d79102 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -1719,7 +1719,7 @@ def test_default_date_load(self):
# MySQL SHOULD be converted.
assert issubclass(df.DateCol.dtype.type, np.datetime64)
- def test_datetime_with_timezone(self):
+ def test_datetime_with_timezone(self, request):
# edge case that converts postgresql datetime with time zone types
# to datetime64[ns,psycopg2.tz.FixedOffsetTimezone..], which is ok
# but should be more natural, so coerce to datetime64[ns] for now
@@ -1760,7 +1760,9 @@ def check(col):
# GH11216
df = read_sql_query("select * from types", self.conn)
if not hasattr(df, "DateColWithTz"):
- pytest.skip("no column with datetime with time zone")
+ request.node.add_marker(
+ pytest.mark.xfail(reason="no column with datetime with time zone")
+ )
# this is parsed on Travis (linux), but not on macosx for some reason
# even with the same versions of psycopg2 & sqlalchemy, possibly a
@@ -1772,7 +1774,9 @@ def check(col):
"select * from types", self.conn, parse_dates=["DateColWithTz"]
)
if not hasattr(df, "DateColWithTz"):
- pytest.skip("no column with datetime with time zone")
+ request.node.add_marker(
+ pytest.mark.xfail(reason="no column with datetime with time zone")
+ )
col = df.DateColWithTz
assert is_datetime64tz_dtype(col.dtype)
assert str(col.dt.tz) == "UTC"
@@ -2275,8 +2279,9 @@ def test_get_engine_auto_error_message(self):
class _TestSQLAlchemyConn(_EngineToConnMixin, _TestSQLAlchemy):
+ @pytest.mark.xfail(reason="Nested transactions rollbacks don't work with Pandas")
def test_transactions(self):
- pytest.skip("Nested transactions rollbacks don't work with Pandas")
+ super().test_transactions()
class _TestSQLiteAlchemy:
diff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py
index dd83ac49eda86..992f67c2affc6 100644
--- a/pandas/tests/series/indexing/test_setitem.py
+++ b/pandas/tests/series/indexing/test_setitem.py
@@ -759,10 +759,6 @@ def test_series_where(self, obj, key, expected, val, is_inplace):
self._check_inplace(is_inplace, orig, arr, obj)
def test_index_where(self, obj, key, expected, val):
- if obj.dtype.kind == "c" or expected.dtype.kind == "c":
- # TODO(Index[complex]): Should become unreachable
- pytest.skip("test not applicable for this dtype")
-
mask = np.zeros(obj.shape, dtype=bool)
mask[key] = True
@@ -770,10 +766,6 @@ def test_index_where(self, obj, key, expected, val):
tm.assert_index_equal(res, Index(expected, dtype=expected.dtype))
def test_index_putmask(self, obj, key, expected, val):
- if obj.dtype.kind == "c" or expected.dtype.kind == "c":
- # TODO(Index[complex]): Should become unreachable
- pytest.skip("test not applicable for this dtype")
-
mask = np.zeros(obj.shape, dtype=bool)
mask[key] = True
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 1ffdb10369134..c8044a44b48ee 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -823,11 +823,13 @@ def test_series_inplace_ops(self, dtype1, dtype2, dtype_expected, dtype_mul):
tm.assert_series_equal(ser1, expected)
-def test_none_comparison(series_with_simple_index):
+def test_none_comparison(request, series_with_simple_index):
series = series_with_simple_index
if len(series) < 1:
- pytest.skip("Test doesn't make sense on empty data")
+ request.node.add_marker(
+ pytest.mark.xfail(reason="Test doesn't make sense on empty data")
+ )
# bug brought up by #1079
# changed from TypeError in 0.17.0
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 3b7ae28be68fa..e416b1f625993 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -801,31 +801,6 @@ def test_constructor_floating_data_int_dtype(self, frame_or_series):
obj = frame_or_series(list(arr), dtype="i8")
tm.assert_equal(obj, expected)
- @td.skip_if_no("dask")
- def test_construct_dask_float_array_int_dtype_match_ndarray(self):
- # GH#40110 make sure we treat a float-dtype dask array with the same
- # rules we would for an ndarray
- import dask.dataframe as dd
-
- arr = np.array([1, 2.5, 3])
- darr = dd.from_array(arr)
-
- res = Series(darr)
- expected = Series(arr)
- tm.assert_series_equal(res, expected)
-
- res = Series(darr, dtype="i8")
- expected = Series(arr, dtype="i8")
- tm.assert_series_equal(res, expected)
-
- msg = "In a future version, passing float-dtype values containing NaN"
- arr[2] = np.nan
- with tm.assert_produces_warning(FutureWarning, match=msg):
- res = Series(darr, dtype="i8")
- with tm.assert_produces_warning(FutureWarning, match=msg):
- expected = Series(arr, dtype="i8")
- tm.assert_series_equal(res, expected)
-
def test_constructor_coerce_float_fail(self, any_int_numpy_dtype):
# see gh-15832
# Updated: make sure we treat this list the same as we would treat
@@ -1989,9 +1964,7 @@ def test_numpy_array(input_dict, expected):
tm.assert_numpy_array_equal(result, expected)
-@pytest.mark.skipif(
- not np_version_under1p19, reason="check failure on numpy below 1.19"
-)
+@pytest.mark.xfail(not np_version_under1p19, reason="check failure on numpy below 1.19")
def test_numpy_array_np_v1p19():
with pytest.raises(KeyError, match="0"):
np.array([Series({1: 1})])
diff --git a/pandas/tests/strings/test_extract.py b/pandas/tests/strings/test_extract.py
index 0f4ffccd8ad7f..04c355c6c78c5 100644
--- a/pandas/tests/strings/test_extract.py
+++ b/pandas/tests/strings/test_extract.py
@@ -174,13 +174,13 @@ def test_extract_expand_capture_groups(any_string_dtype):
tm.assert_frame_equal(result, expected)
-def test_extract_expand_capture_groups_index(index, any_string_dtype):
+def test_extract_expand_capture_groups_index(request, index, any_string_dtype):
# https://github.com/pandas-dev/pandas/issues/6348
# not passing index to the extractor
data = ["A1", "B2", "C"]
if len(index) < len(data):
- pytest.skip("Index too short")
+ request.node.add_marker(pytest.mark.xfail(reason="Index too short."))
index = index[: len(data)]
s = Series(data, index=index, dtype=any_string_dtype)
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index ce7c7a634f5a9..c1e7a8ae883ae 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -11,7 +11,10 @@
import pandas.util._test_decorators as td
import pandas as pd
-from pandas import DataFrame
+from pandas import (
+ DataFrame,
+ Series,
+)
import pandas._testing as tm
# geopandas, xarray, fsspec, fastparquet all produce these
@@ -70,7 +73,7 @@ def test_dask_ufunc():
import dask.array as da
import dask.dataframe as dd
- s = pd.Series([1.5, 2.3, 3.7, 4.0])
+ s = Series([1.5, 2.3, 3.7, 4.0])
ds = dd.from_pandas(s, npartitions=2)
result = da.fix(ds).compute()
@@ -80,6 +83,32 @@ def test_dask_ufunc():
pd.set_option("compute.use_numexpr", olduse)
+@td.skip_if_no("dask")
+def test_construct_dask_float_array_int_dtype_match_ndarray():
+ # GH#40110 make sure we treat a float-dtype dask array with the same
+ # rules we would for an ndarray
+ import dask.dataframe as dd
+
+ arr = np.array([1, 2.5, 3])
+ darr = dd.from_array(arr)
+
+ res = Series(darr)
+ expected = Series(arr)
+ tm.assert_series_equal(res, expected)
+
+ res = Series(darr, dtype="i8")
+ expected = Series(arr, dtype="i8")
+ tm.assert_series_equal(res, expected)
+
+ msg = "In a future version, passing float-dtype values containing NaN"
+ arr[2] = np.nan
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ res = Series(darr, dtype="i8")
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ expected = Series(arr, dtype="i8")
+ tm.assert_series_equal(res, expected)
+
+
def test_xarray(df):
xarray = import_module("xarray") # noqa:F841
@@ -224,7 +253,7 @@ def test_torch_frame_construction(using_array_manager):
if not using_array_manager:
assert np.shares_memory(df, val_tensor)
- ser = pd.Series(val_tensor[0])
+ ser = Series(val_tensor[0])
assert np.shares_memory(ser, val_tensor)
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 6907b1f334f53..7597d4345cfce 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -315,7 +315,7 @@ def test_to_datetime_format_microsecond(self, cache):
def test_to_datetime_format_time(self, cache, value, format, dt):
assert to_datetime(value, format=format, cache=cache) == dt
- @td.skip_if_has_locale
+ @td.skip_if_not_us_locale
def test_to_datetime_with_non_exact(self, cache):
# GH 10834
# 8904
@@ -1738,7 +1738,7 @@ def test_to_datetime_with_space_in_series(self, cache):
result_ignore = to_datetime(ser, errors="ignore", cache=cache)
tm.assert_series_equal(result_ignore, ser)
- @td.skip_if_has_locale
+ @td.skip_if_not_us_locale
def test_to_datetime_with_apply(self, cache):
# this is only locale tested with US/None locales
# GH 5195
@@ -1748,7 +1748,7 @@ def test_to_datetime_with_apply(self, cache):
result = td.apply(to_datetime, format="%b %y", cache=cache)
tm.assert_series_equal(result, expected)
- @td.skip_if_has_locale
+ @td.skip_if_not_us_locale
def test_to_datetime_with_apply_with_empty_str(self, cache):
# this is only locale tested with US/None locales
# GH 5195
diff --git a/pandas/tests/tslibs/test_parsing.py b/pandas/tests/tslibs/test_parsing.py
index 3d2daec442c38..279a84b174e36 100644
--- a/pandas/tests/tslibs/test_parsing.py
+++ b/pandas/tests/tslibs/test_parsing.py
@@ -183,7 +183,7 @@ def test_guess_datetime_format_with_dayfirst(dayfirst, expected):
assert result == expected
-@td.skip_if_has_locale
+@td.skip_if_not_us_locale
@pytest.mark.parametrize(
"string,fmt",
[
diff --git a/pandas/tests/tslibs/test_timezones.py b/pandas/tests/tslibs/test_timezones.py
index 7ab0ad0856af0..aa10ab15f4744 100644
--- a/pandas/tests/tslibs/test_timezones.py
+++ b/pandas/tests/tslibs/test_timezones.py
@@ -23,9 +23,6 @@ def test_is_utc(utc_fixture):
@pytest.mark.parametrize("tz_name", list(pytz.common_timezones))
def test_cache_keys_are_distinct_for_pytz_vs_dateutil(tz_name):
- if tz_name == "UTC":
- pytest.skip("UTC: special case in dateutil")
-
tz_p = timezones.maybe_get_tz(tz_name)
tz_d = timezones.maybe_get_tz("dateutil/" + tz_name)
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index 10322a25ffd18..d7eba6b8319fb 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -115,12 +115,6 @@ def _skip_if_no_mpl():
return True
-def _skip_if_has_locale():
- lang, _ = locale.getlocale()
- if lang is not None:
- return True
-
-
def _skip_if_not_us_locale():
lang, _ = locale.getlocale()
if lang != "en_US":
@@ -198,9 +192,6 @@ def skip_if_no(package: str, min_version: str | None = None):
skip_if_mpl = pytest.mark.skipif(not _skip_if_no_mpl(), reason="matplotlib is present")
skip_if_32bit = pytest.mark.skipif(not IS64, reason="skipping for 32 bit")
skip_if_windows = pytest.mark.skipif(is_platform_windows(), reason="Running on Windows")
-skip_if_has_locale = pytest.mark.skipif(
- _skip_if_has_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}"
-)
skip_if_not_us_locale = pytest.mark.skipif(
_skip_if_not_us_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}"
)
| - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/46387 | 2022-03-16T03:04:26Z | 2022-03-17T23:01:26Z | 2022-03-17T23:01:26Z | 2022-03-18T00:31:45Z |
Bug gb cummax | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 8dac952874f89..b18d5aaac6539 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -454,6 +454,7 @@ Groupby/resample/rolling
- Bug in :meth:`DataFrameGroupby.cumsum` with ``skipna=False`` giving incorrect results (:issue:`46216`)
- Bug in :meth:`.GroupBy.cumsum` with ``timedelta64[ns]`` dtype failing to recognize ``NaT`` as a null value (:issue:`46216`)
- Bug in :meth:`GroupBy.cummin` and :meth:`GroupBy.cummax` with nullable dtypes incorrectly altering the original data in place (:issue:`46220`)
+- Bug in :meth:`GroupBy.cummax` with ``int64`` dtype with leading value being the smallest possible int64 (:issue:`46382`)
-
Reshaping
diff --git a/pandas/_libs/groupby.pyx b/pandas/_libs/groupby.pyx
index ff5258e37e352..d84cc4873a250 100644
--- a/pandas/_libs/groupby.pyx
+++ b/pandas/_libs/groupby.pyx
@@ -989,13 +989,18 @@ cdef inline bint _treat_as_na(numeric_object_t val, bint is_datetimelike) nogil:
return False
-cdef numeric_t _get_min_or_max(numeric_t val, bint compute_max):
+cdef numeric_t _get_min_or_max(numeric_t val, bint compute_max, bint is_datetimelike):
"""
Find either the min or the max supported by numeric_t; 'val' is a placeholder
to effectively make numeric_t an argument.
"""
if numeric_t is int64_t:
- return -_int64_max if compute_max else util.INT64_MAX
+ if compute_max and is_datetimelike:
+ return -_int64_max
+ # Note(jbrockmendel) 2022-03-15 for reasons unknown, using util.INT64_MIN
+ # instead of NPY_NAT here causes build warnings and failure in
+ # test_cummax_i8_at_implementation_bound
+ return NPY_NAT if compute_max else util.INT64_MAX
elif numeric_t is int32_t:
return util.INT32_MIN if compute_max else util.INT32_MAX
elif numeric_t is int16_t:
@@ -1395,7 +1400,7 @@ cdef group_min_max(
nobs = np.zeros((<object>out).shape, dtype=np.int64)
group_min_or_max = np.empty_like(out)
- group_min_or_max[:] = _get_min_or_max(<iu_64_floating_t>0, compute_max)
+ group_min_or_max[:] = _get_min_or_max(<iu_64_floating_t>0, compute_max, is_datetimelike)
if iu_64_floating_t is int64_t:
# TODO: only if is_datetimelike?
@@ -1564,7 +1569,7 @@ cdef group_cummin_max(
bint isna_entry
accum = np.empty((ngroups, (<object>values).shape[1]), dtype=values.dtype)
- accum[:] = _get_min_or_max(<iu_64_floating_t>0, compute_max)
+ accum[:] = _get_min_or_max(<iu_64_floating_t>0, compute_max, is_datetimelike)
na_val = _get_na_val(<iu_64_floating_t>0, is_datetimelike)
diff --git a/pandas/tests/groupby/test_function.py b/pandas/tests/groupby/test_function.py
index ec7f3200b682b..7440b63e78b65 100644
--- a/pandas/tests/groupby/test_function.py
+++ b/pandas/tests/groupby/test_function.py
@@ -830,6 +830,18 @@ def test_cummax(dtypes_for_minmax):
tm.assert_series_equal(result, expected)
+def test_cummax_i8_at_implementation_bound():
+ # the minimum value used to be treated as NPY_NAT+1 instead of NPY_NAT
+ # for int64 dtype GH#46382
+ ser = Series([pd.NaT.value + n for n in range(5)])
+ df = DataFrame({"A": 1, "B": ser, "C": ser.view("M8[ns]")})
+ gb = df.groupby("A")
+
+ res = gb.cummax()
+ exp = df[["B", "C"]]
+ tm.assert_frame_equal(res, exp)
+
+
@pytest.mark.parametrize("method", ["cummin", "cummax"])
@pytest.mark.parametrize("dtype", ["float", "Int64", "Float64"])
@pytest.mark.parametrize(
| - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/46382 | 2022-03-15T23:36:00Z | 2022-03-16T02:01:52Z | 2022-03-16T02:01:52Z | 2022-03-16T20:51:15Z |
Backport PR #46354 on branch 1.4.x (DOC: minor fixes to 1.4.2 release notes) | diff --git a/doc/source/whatsnew/v1.4.2.rst b/doc/source/whatsnew/v1.4.2.rst
index 06f1f406c3816..3523f691cae8f 100644
--- a/doc/source/whatsnew/v1.4.2.rst
+++ b/doc/source/whatsnew/v1.4.2.rst
@@ -18,8 +18,8 @@ Fixed regressions
- Fixed regression in :func:`read_csv` killing python process when invalid file input was given for ``engine="c"`` (:issue:`45957`)
- Fixed memory performance regression in :meth:`Series.fillna` when called on a :class:`DataFrame` column with ``inplace=True`` (:issue:`46149`)
- Provided an alternative solution for passing custom Excel formats in :meth:`.Styler.to_excel`, which was a regression based on stricter CSS validation. Examples available in the documentation for :meth:`.Styler.format` (:issue:`46152`)
-- Fixed regression in :meth:`DataFrame.replace` when a replacement value was also a target for replacement (:issue:`46335`)
-- Fixed regression in :meth:`DataFrame.loc.__setitem__` losing :class:`MultiIndex` names if :class:`DataFrame` was empty before (:issue:`46317`)
+- Fixed regression in :meth:`DataFrame.replace` when a replacement value was also a target for replacement (:issue:`46306`)
+- Fixed regression when setting values with :meth:`DataFrame.loc` losing :class:`MultiIndex` names if :class:`DataFrame` was empty before (:issue:`46317`)
-
.. ---------------------------------------------------------------------------
| Backport PR #46354: DOC: minor fixes to 1.4.2 release notes | https://api.github.com/repos/pandas-dev/pandas/pulls/46380 | 2022-03-15T23:12:06Z | 2022-03-16T01:41:45Z | 2022-03-16T01:41:45Z | 2022-03-16T01:41:45Z |
BUG: Nullable _get_common_dtype match non-nullable behavior | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 610592bb3ce1f..ed0cfe0408ba9 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -462,6 +462,7 @@ Reshaping
- Bug in :func:`concat` between a :class:`Series` with integer dtype and another with :class:`CategoricalDtype` with integer categories and containing ``NaN`` values casting to object dtype instead of ``float64`` (:issue:`45359`)
- Bug in :func:`get_dummies` that selected object and categorical dtypes but not string (:issue:`44965`)
- Bug in :meth:`DataFrame.align` when aligning a :class:`MultiIndex` to a :class:`Series` with another :class:`MultiIndex` (:issue:`46001`)
+- Bug in concanenation with ``IntegerDtype``, or ``FloatingDtype`` arrays where the resulting dtype did not mirror the behavior of the non-nullable dtypes (:issue:`46379`)
-
Sparse
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index 5294b4061ad44..b40d7904e33e4 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -137,18 +137,6 @@ def __from_arrow__(
else:
return BooleanArray._concat_same_type(results)
- def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
- # Handle only boolean + np.bool_ -> boolean, since other cases like
- # Int64 + boolean -> Int64 will be handled by the other type
- if all(
- isinstance(t, BooleanDtype)
- or (isinstance(t, np.dtype) and (np.issubdtype(t, np.bool_)))
- for t in dtypes
- ):
- return BooleanDtype()
- else:
- return None
-
def coerce_to_array(
values, mask=None, copy: bool = False
diff --git a/pandas/core/arrays/floating.py b/pandas/core/arrays/floating.py
index 49a71922f331b..0c14fac57d9db 100644
--- a/pandas/core/arrays/floating.py
+++ b/pandas/core/arrays/floating.py
@@ -2,8 +2,6 @@
import numpy as np
-from pandas._typing import DtypeObj
-
from pandas.core.dtypes.common import is_float_dtype
from pandas.core.dtypes.dtypes import register_extension_dtype
@@ -37,20 +35,6 @@ def construct_array_type(cls) -> type[FloatingArray]:
"""
return FloatingArray
- def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
- # for now only handle other floating types
- if not all(isinstance(t, FloatingDtype) for t in dtypes):
- return None
- np_dtype = np.find_common_type(
- # error: Item "ExtensionDtype" of "Union[Any, ExtensionDtype]" has no
- # attribute "numpy_dtype"
- [t.numpy_dtype for t in dtypes], # type: ignore[union-attr]
- [],
- )
- if np.issubdtype(np_dtype, np.floating):
- return FLOAT_STR_TO_DTYPE[str(np_dtype)]
- return None
-
@classmethod
def _str_to_dtype_mapping(cls):
return FLOAT_STR_TO_DTYPE
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 9ef3939656ecd..24e5fa1bef552 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -2,12 +2,9 @@
import numpy as np
-from pandas._typing import DtypeObj
-
from pandas.core.dtypes.base import register_extension_dtype
from pandas.core.dtypes.common import is_integer_dtype
-from pandas.core.arrays.masked import BaseMaskedDtype
from pandas.core.arrays.numeric import (
NumericArray,
NumericDtype,
@@ -38,38 +35,6 @@ def construct_array_type(cls) -> type[IntegerArray]:
"""
return IntegerArray
- def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
- # we only handle nullable EA dtypes and numeric numpy dtypes
- if not all(
- isinstance(t, BaseMaskedDtype)
- or (
- isinstance(t, np.dtype)
- and (np.issubdtype(t, np.number) or np.issubdtype(t, np.bool_))
- )
- for t in dtypes
- ):
- return None
- np_dtype = np.find_common_type(
- # error: List comprehension has incompatible type List[Union[Any,
- # dtype, ExtensionDtype]]; expected List[Union[dtype, None, type,
- # _SupportsDtype, str, Tuple[Any, Union[int, Sequence[int]]],
- # List[Any], _DtypeDict, Tuple[Any, Any]]]
- [
- t.numpy_dtype # type: ignore[misc]
- if isinstance(t, BaseMaskedDtype)
- else t
- for t in dtypes
- ],
- [],
- )
- if np.issubdtype(np_dtype, np.integer):
- return INT_STR_TO_DTYPE[str(np_dtype)]
- elif np.issubdtype(np_dtype, np.floating):
- from pandas.core.arrays.floating import FLOAT_STR_TO_DTYPE
-
- return FLOAT_STR_TO_DTYPE[str(np_dtype)]
- return None
-
@classmethod
def _str_to_dtype_mapping(cls):
return INT_STR_TO_DTYPE
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index 946892822720c..66eed0a75fa19 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -1437,3 +1437,22 @@ def from_numpy_dtype(cls, dtype: np.dtype) -> BaseMaskedDtype:
return FLOAT_STR_TO_DTYPE[dtype.name]
else:
raise NotImplementedError(dtype)
+
+ def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+ # We unwrap any masked dtypes, find the common dtype we would use
+ # for that, then re-mask the result.
+ from pandas.core.dtypes.cast import find_common_type
+
+ new_dtype = find_common_type(
+ [
+ dtype.numpy_dtype if isinstance(dtype, BaseMaskedDtype) else dtype
+ for dtype in dtypes
+ ]
+ )
+ if not isinstance(new_dtype, np.dtype):
+ # If we ever support e.g. Masked[DatetimeArray] then this will change
+ return None
+ try:
+ return type(self).from_numpy_dtype(new_dtype)
+ except (KeyError, NotImplementedError):
+ return None
diff --git a/pandas/tests/arrays/integer/test_concat.py b/pandas/tests/arrays/integer/test_concat.py
index 2e8ef506140af..feba574da548f 100644
--- a/pandas/tests/arrays/integer/test_concat.py
+++ b/pandas/tests/arrays/integer/test_concat.py
@@ -15,11 +15,13 @@
(["UInt8", "Int8"], "Int16"),
(["Int32", "UInt32"], "Int64"),
(["Int64", "UInt64"], "Float64"),
- (["Int64", "boolean"], "Int64"),
- (["UInt8", "boolean"], "UInt8"),
+ (["Int64", "boolean"], "object"),
+ (["UInt8", "boolean"], "object"),
],
)
def test_concat_series(to_concat_dtypes, result_dtype):
+ # we expect the same dtypes as we would get with non-masked inputs,
+ # just masked where available.
result = pd.concat([pd.Series([0, 1, pd.NA], dtype=t) for t in to_concat_dtypes])
expected = pd.concat([pd.Series([0, 1, pd.NA], dtype=object)] * 2).astype(
@@ -47,11 +49,13 @@ def test_concat_series(to_concat_dtypes, result_dtype):
(["UInt8", "int8"], "Int16"),
(["Int32", "uint32"], "Int64"),
(["Int64", "uint64"], "Float64"),
- (["Int64", "bool"], "Int64"),
- (["UInt8", "bool"], "UInt8"),
+ (["Int64", "bool"], "object"),
+ (["UInt8", "bool"], "object"),
],
)
def test_concat_series_with_numpy(to_concat_dtypes, result_dtype):
+ # we expect the same dtypes as we would get with non-masked inputs,
+ # just masked where available.
s1 = pd.Series([0, 1, pd.NA], dtype=to_concat_dtypes[0])
s2 = pd.Series(np.array([0, 1], dtype=to_concat_dtypes[1]))
| - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/46379 | 2022-03-15T22:50:16Z | 2022-03-17T02:03:31Z | 2022-03-17T02:03:31Z | 2022-03-17T03:21:33Z |
REF: disallow ints from delta_to_nanoseconds | diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 8eaf86b3d193f..f8f8a6f81d801 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -173,11 +173,11 @@ cpdef int64_t delta_to_nanoseconds(delta) except? -1:
if is_tick_object(delta):
return delta.nanos
if isinstance(delta, _Timedelta):
- delta = delta.value
+ return delta.value
+
if is_timedelta64_object(delta):
return get_timedelta64_value(ensure_td64ns(delta))
- if is_integer_object(delta):
- return delta
+
if PyDelta_Check(delta):
try:
return (
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 7a7bad02fde72..e070f23b35315 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -1316,7 +1316,9 @@ def __add__(self, other):
elif is_integer_dtype(other_dtype):
if not is_period_dtype(self.dtype):
raise integer_op_not_supported(self)
- result = cast("PeriodArray", self)._addsub_int_array(other, operator.add)
+ result = cast("PeriodArray", self)._addsub_int_array_or_scalar(
+ other, operator.add
+ )
else:
# Includes Categorical, other ExtensionArrays
# For PeriodDtype, if self is a TimedeltaArray and other is a
@@ -1376,7 +1378,9 @@ def __sub__(self, other):
elif is_integer_dtype(other_dtype):
if not is_period_dtype(self.dtype):
raise integer_op_not_supported(self)
- result = cast("PeriodArray", self)._addsub_int_array(other, operator.sub)
+ result = cast("PeriodArray", self)._addsub_int_array_or_scalar(
+ other, operator.sub
+ )
else:
# Includes ExtensionArrays, float_dtype
return NotImplemented
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 2368af0de1bf3..b2a8dfddc6b68 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -747,8 +747,8 @@ def _sub_period_array(self, other):
new_values[mask] = NaT
return new_values
- def _addsub_int_array(
- self, other: np.ndarray, op: Callable[[Any, Any], Any]
+ def _addsub_int_array_or_scalar(
+ self, other: np.ndarray | int, op: Callable[[Any, Any], Any]
) -> PeriodArray:
"""
Add or subtract array of integers; equivalent to applying
@@ -756,7 +756,7 @@ def _addsub_int_array(
Parameters
----------
- other : np.ndarray[integer-dtype]
+ other : np.ndarray[int64] or int
op : {operator.add, operator.sub}
Returns
@@ -775,12 +775,7 @@ def _add_offset(self, other: BaseOffset):
assert not isinstance(other, Tick)
self._require_matching_freq(other, base=True)
-
- # Note: when calling parent class's _add_timedeltalike_scalar,
- # it will call delta_to_nanoseconds(delta). Because delta here
- # is an integer, delta_to_nanoseconds will return it unchanged.
- result = super()._add_timedeltalike_scalar(other.n)
- return type(self)(result, freq=self.freq)
+ return self._addsub_int_array_or_scalar(other.n, operator.add)
def _add_timedeltalike_scalar(self, other):
"""
@@ -800,10 +795,8 @@ def _add_timedeltalike_scalar(self, other):
# special handling for np.timedelta64("NaT"), avoid calling
# _check_timedeltalike_freq_compat as that would raise TypeError
other = self._check_timedeltalike_freq_compat(other)
+ other = np.timedelta64(other, "ns")
- # Note: when calling parent class's _add_timedeltalike_scalar,
- # it will call delta_to_nanoseconds(delta). Because delta here
- # is an integer, delta_to_nanoseconds will return it unchanged.
return super()._add_timedeltalike_scalar(other)
def _add_timedelta_arraylike(self, other):
@@ -828,7 +821,7 @@ def _add_timedelta_arraylike(self, other):
# all-NaT TimedeltaIndex is equivalent to a single scalar td64 NaT
return self + np.timedelta64("NaT")
- ordinals = self._addsub_int_array(delta, operator.add).asi8
+ ordinals = self._addsub_int_array_or_scalar(delta, operator.add).asi8
return type(self)(ordinals, dtype=self.dtype)
def _check_timedeltalike_freq_compat(self, other):
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index a296ce130bbf5..fc7b122689ebb 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -272,7 +272,7 @@ def __new__(
def values(self) -> np.ndarray:
return np.asarray(self, dtype=object)
- def _maybe_convert_timedelta(self, other):
+ def _maybe_convert_timedelta(self, other) -> int | npt.NDArray[np.int64]:
"""
Convert timedelta-like input to an integer multiple of self.freq
diff --git a/pandas/tests/tslibs/test_timedeltas.py b/pandas/tests/tslibs/test_timedeltas.py
index a0ec563d1f48f..7d7de7492a07b 100644
--- a/pandas/tests/tslibs/test_timedeltas.py
+++ b/pandas/tests/tslibs/test_timedeltas.py
@@ -30,9 +30,6 @@
24 * 3600e9 + 111,
), # GH43764
(offsets.Nano(125), 125),
- (1, 1),
- (np.int64(2), 2),
- (np.int32(3), 3),
],
)
def test_delta_to_nanoseconds(obj, expected):
@@ -46,6 +43,15 @@ def test_delta_to_nanoseconds_error():
with pytest.raises(TypeError, match="<class 'numpy.ndarray'>"):
delta_to_nanoseconds(obj)
+ with pytest.raises(TypeError, match="float"):
+ delta_to_nanoseconds(1.5)
+ with pytest.raises(TypeError, match="int"):
+ delta_to_nanoseconds(1)
+ with pytest.raises(TypeError, match="int"):
+ delta_to_nanoseconds(np.int64(2))
+ with pytest.raises(TypeError, match="int"):
+ delta_to_nanoseconds(np.int32(3))
+
def test_huge_nanoseconds_overflow():
# GH 32402
| chipping away at non-nano roadblocks | https://api.github.com/repos/pandas-dev/pandas/pulls/46378 | 2022-03-15T22:42:16Z | 2022-03-16T00:45:40Z | 2022-03-16T00:45:40Z | 2022-03-16T01:01:44Z |
TST: Fix warnings & skip -> xfail | diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 1b0ae40949d5b..86cf0c79759f5 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -45,7 +45,7 @@ jobs:
/opt/python/cp38-cp38/bin/python -m venv ~/virtualenvs/pandas-dev && \
. ~/virtualenvs/pandas-dev/bin/activate && \
python -m pip install --no-deps -U pip wheel 'setuptools<60.0.0' && \
- pip install cython numpy python-dateutil pytz pytest pytest-xdist hypothesis && \
+ pip install cython numpy python-dateutil pytz pytest pytest-xdist pytest-asyncio hypothesis && \
python setup.py build_ext -q -j2 && \
python -m pip install --no-build-isolation -e . && \
pytest -m 'not slow and not network and not clipboard and not single_cpu' pandas --junitxml=test-data.xml"
diff --git a/ci/deps/actions-310-numpydev.yaml b/ci/deps/actions-310-numpydev.yaml
index 3e32665d5433f..a5eb8a69e19da 100644
--- a/ci/deps/actions-310-numpydev.yaml
+++ b/ci/deps/actions-310-numpydev.yaml
@@ -9,6 +9,7 @@ dependencies:
- pytest-cov
- pytest-xdist>=1.31
- hypothesis>=5.5.3
+ - pytest-asyncio
# pandas dependencies
- python-dateutil
diff --git a/ci/deps/circle-38-arm64.yaml b/ci/deps/circle-38-arm64.yaml
index 60608c3ee1a86..7e5b56ebe081f 100644
--- a/ci/deps/circle-38-arm64.yaml
+++ b/ci/deps/circle-38-arm64.yaml
@@ -9,6 +9,7 @@ dependencies:
- pytest>=6.0
- pytest-xdist>=1.31
- hypothesis>=5.5.3
+ - pytest-asyncio
# pandas dependencies
- botocore>=1.11
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
index 8b2aea5c2e2e1..59b9d2f2f8908 100644
--- a/pandas/tests/arrays/string_/test_string.py
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -523,7 +523,7 @@ def test_memory_usage(dtype):
# GH 33963
if dtype.storage == "pyarrow":
- pytest.skip("not applicable")
+ pytest.skip(f"not applicable for {dtype.storage}")
series = pd.Series(["a", "b", "c"], dtype=dtype)
diff --git a/pandas/tests/extension/base/ops.py b/pandas/tests/extension/base/ops.py
index 1d3d736ca7ee2..a1d232b737da7 100644
--- a/pandas/tests/extension/base/ops.py
+++ b/pandas/tests/extension/base/ops.py
@@ -114,17 +114,22 @@ def test_add_series_with_extension_array(self, data):
self.assert_series_equal(result, expected)
@pytest.mark.parametrize("box", [pd.Series, pd.DataFrame])
- def test_direct_arith_with_ndframe_returns_not_implemented(self, data, box):
+ def test_direct_arith_with_ndframe_returns_not_implemented(
+ self, request, data, box
+ ):
# EAs should return NotImplemented for ops with Series/DataFrame
# Pandas takes care of unboxing the series and calling the EA's op.
other = pd.Series(data)
if box is pd.DataFrame:
other = other.to_frame()
- if hasattr(data, "__add__"):
- result = data.__add__(other)
- assert result is NotImplemented
- else:
- raise pytest.skip(f"{type(data).__name__} does not implement add")
+ if not hasattr(data, "__add__"):
+ request.node.add_marker(
+ pytest.mark.xfail(
+ reason=f"{type(data).__name__} does not implement add"
+ )
+ )
+ result = data.__add__(other)
+ assert result is NotImplemented
class BaseComparisonOpsTests(BaseOpsUtil):
diff --git a/pandas/tests/extension/json/test_json.py b/pandas/tests/extension/json/test_json.py
index f13ef65267304..84491adb30ef6 100644
--- a/pandas/tests/extension/json/test_json.py
+++ b/pandas/tests/extension/json/test_json.py
@@ -156,10 +156,10 @@ def test_contains(self, data):
class TestConstructors(BaseJSON, base.BaseConstructorsTests):
- @pytest.mark.skip(reason="not implemented constructor from dtype")
+ @pytest.mark.xfail(reason="not implemented constructor from dtype")
def test_from_dtype(self, data):
# construct from our dtype & string dtype
- pass
+ super(self).test_from_dtype(data)
@pytest.mark.xfail(reason="RecursionError, GH-33900")
def test_series_constructor_no_data_with_index(self, dtype, na_value):
diff --git a/pandas/tests/extension/test_categorical.py b/pandas/tests/extension/test_categorical.py
index d21110e078709..1e17bf33c806c 100644
--- a/pandas/tests/extension/test_categorical.py
+++ b/pandas/tests/extension/test_categorical.py
@@ -50,7 +50,7 @@ def data():
"""Length-100 array for this type.
* data[0] and data[1] should both be non missing
- * data[0] and data[1] should not gbe equal
+ * data[0] and data[1] should not be equal
"""
return Categorical(make_data())
@@ -86,7 +86,7 @@ class TestDtype(base.BaseDtypeTests):
class TestInterface(base.BaseInterfaceTests):
- @pytest.mark.skip(reason="Memory usage doesn't match")
+ @pytest.mark.xfail(reason="Memory usage doesn't match")
def test_memory_usage(self, data):
# Is this deliberate?
super().test_memory_usage(data)
@@ -149,13 +149,7 @@ class TestIndex(base.BaseIndexTests):
class TestMissing(base.BaseMissingTests):
- @pytest.mark.skip(reason="Not implemented")
- def test_fillna_limit_pad(self, data_missing):
- super().test_fillna_limit_pad(data_missing)
-
- @pytest.mark.skip(reason="Not implemented")
- def test_fillna_limit_backfill(self, data_missing):
- super().test_fillna_limit_backfill(data_missing)
+ pass
class TestReduce(base.BaseNoReduceTests):
@@ -163,7 +157,7 @@ class TestReduce(base.BaseNoReduceTests):
class TestMethods(base.BaseMethodsTests):
- @pytest.mark.skip(reason="Unobserved categories included")
+ @pytest.mark.xfail(reason="Unobserved categories included")
def test_value_counts(self, all_data, dropna):
return super().test_value_counts(all_data, dropna)
@@ -184,10 +178,6 @@ def test_combine_add(self, data_repeated):
expected = pd.Series([a + val for a in list(orig_data1)])
self.assert_series_equal(result, expected)
- @pytest.mark.skip(reason="Not Applicable")
- def test_fillna_length_mismatch(self, data_missing):
- super().test_fillna_length_mismatch(data_missing)
-
class TestCasting(base.BaseCastingTests):
@pytest.mark.parametrize("cls", [Categorical, CategoricalIndex])
diff --git a/pandas/tests/extension/test_datetime.py b/pandas/tests/extension/test_datetime.py
index a64b42fad9415..92796c604333d 100644
--- a/pandas/tests/extension/test_datetime.py
+++ b/pandas/tests/extension/test_datetime.py
@@ -175,9 +175,7 @@ class TestMissing(BaseDatetimeTests, base.BaseMissingTests):
class TestReshaping(BaseDatetimeTests, base.BaseReshapingTests):
- @pytest.mark.skip(reason="We have DatetimeTZBlock")
- def test_concat(self, data, in_frame):
- pass
+ pass
class TestSetitem(BaseDatetimeTests, base.BaseSetitemTests):
diff --git a/pandas/tests/extension/test_interval.py b/pandas/tests/extension/test_interval.py
index e2f4d69c489ba..0f916cea9d518 100644
--- a/pandas/tests/extension/test_interval.py
+++ b/pandas/tests/extension/test_interval.py
@@ -121,9 +121,9 @@ def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna):
class TestMethods(BaseInterval, base.BaseMethodsTests):
- @pytest.mark.skip(reason="addition is not defined for intervals")
+ @pytest.mark.xfail(reason="addition is not defined for intervals")
def test_combine_add(self, data_repeated):
- pass
+ super().test_combine_add(data_repeated)
@pytest.mark.xfail(
reason="Raises with incorrect message bc it disallows *all* listlikes "
@@ -134,29 +134,31 @@ def test_fillna_length_mismatch(self, data_missing):
class TestMissing(BaseInterval, base.BaseMissingTests):
- # Index.fillna only accepts scalar `value`, so we have to skip all
+ # Index.fillna only accepts scalar `value`, so we have to xfail all
# non-scalar fill tests.
- unsupported_fill = pytest.mark.skip("Unsupported fillna option.")
+ unsupported_fill = pytest.mark.xfail(
+ reason="Unsupported fillna option for Interval."
+ )
@unsupported_fill
def test_fillna_limit_pad(self):
- pass
+ super().test_fillna_limit_pad()
@unsupported_fill
def test_fillna_series_method(self):
- pass
+ super().test_fillna_series_method()
@unsupported_fill
def test_fillna_limit_backfill(self):
- pass
+ super().test_fillna_limit_backfill()
@unsupported_fill
def test_fillna_no_op_returns_copy(self):
- pass
+ super().test_fillna_no_op_returns_copy()
@unsupported_fill
def test_fillna_series(self):
- pass
+ super().test_fillna_series()
def test_fillna_non_scalar_raises(self, data_missing):
msg = "can only insert Interval objects and NA into an IntervalArray"
@@ -173,9 +175,9 @@ class TestSetitem(BaseInterval, base.BaseSetitemTests):
class TestPrinting(BaseInterval, base.BasePrintingTests):
- @pytest.mark.skip(reason="custom repr")
+ @pytest.mark.xfail(reason="Interval has custom repr")
def test_array_repr(self, data, size):
- pass
+ super().test_array_repr()
class TestParsing(BaseInterval, base.BaseParsingTests):
diff --git a/pandas/tests/extension/test_numpy.py b/pandas/tests/extension/test_numpy.py
index 2e1112ccf2205..ee181101a181a 100644
--- a/pandas/tests/extension/test_numpy.py
+++ b/pandas/tests/extension/test_numpy.py
@@ -208,10 +208,15 @@ def test_series_constructor_scalar_with_index(self, data, dtype):
class TestDtype(BaseNumPyTests, base.BaseDtypeTests):
- @pytest.mark.skip(reason="Incorrect expected.")
- # we unsurprisingly clash with a NumPy name.
- def test_check_dtype(self, data):
- pass
+ def test_check_dtype(self, data, request):
+ if data.dtype.numpy_dtype == "object":
+ request.node.add_marker(
+ pytest.mark.xfail(
+ reason=f"PandasArray expectedly clashes with a "
+ f"NumPy name: {data.dtype.numpy_dtype}"
+ )
+ )
+ super().test_check_dtype(data)
class TestGetitem(BaseNumPyTests, base.BaseGetitemTests):
@@ -345,11 +350,6 @@ def test_fillna_frame(self, data_missing):
class TestReshaping(BaseNumPyTests, base.BaseReshapingTests):
- @pytest.mark.skip(reason="Incorrect expected.")
- def test_merge(self, data, na_value):
- # Fails creating expected (key column becomes a PandasDtype because)
- super().test_merge(data, na_value)
-
@pytest.mark.parametrize(
"in_frame",
[
diff --git a/pandas/tests/extension/test_string.py b/pandas/tests/extension/test_string.py
index 73682620b8353..a4c22e016581d 100644
--- a/pandas/tests/extension/test_string.py
+++ b/pandas/tests/extension/test_string.py
@@ -26,7 +26,7 @@
def split_array(arr):
if arr.dtype.storage != "pyarrow":
- pytest.skip("chunked array n/a")
+ pytest.skip("only applicable for pyarrow chunked array n/a")
def _split_array(arr):
import pyarrow as pa
@@ -156,13 +156,9 @@ def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna):
class TestMethods(base.BaseMethodsTests):
- @pytest.mark.skip(reason="returns nullable")
- def test_value_counts(self, all_data, dropna):
- return super().test_value_counts(all_data, dropna)
-
- @pytest.mark.skip(reason="returns nullable")
+ @pytest.mark.xfail(reason="returns nullable: GH 44692")
def test_value_counts_with_normalize(self, data):
- pass
+ super().test_value_counts_with_normalize(data)
class TestCasting(base.BaseCastingTests):
diff --git a/pandas/tests/plotting/frame/test_frame.py b/pandas/tests/plotting/frame/test_frame.py
index 62540a15f47bd..684d8e661d185 100644
--- a/pandas/tests/plotting/frame/test_frame.py
+++ b/pandas/tests/plotting/frame/test_frame.py
@@ -146,12 +146,11 @@ def test_nullable_int_plot(self):
df = DataFrame(
{
"A": [1, 2, 3, 4, 5],
- "B": [1.0, 2.0, 3.0, 4.0, 5.0],
- "C": [7, 5, np.nan, 3, 2],
+ "B": [1, 2, 3, 4, 5],
+ "C": np.array([7, 5, np.nan, 3, 2], dtype=object),
"D": pd.to_datetime(dates, format="%Y").view("i8"),
"E": pd.to_datetime(dates, format="%Y", utc=True).view("i8"),
- },
- dtype=np.int64,
+ }
)
_check_plot_works(df.plot, x="A", y="B")
diff --git a/pandas/tests/plotting/test_converter.py b/pandas/tests/plotting/test_converter.py
index 04d3397faddb7..0258d2fae116d 100644
--- a/pandas/tests/plotting/test_converter.py
+++ b/pandas/tests/plotting/test_converter.py
@@ -327,7 +327,7 @@ def test_conversion(self):
rs = self.pc.convert(
np.array(
- ["2012-01-01 00:00:00+0000", "2012-01-02 00:00:00+0000"],
+ ["2012-01-01 00:00:00", "2012-01-02 00:00:00"],
dtype="datetime64[ns]",
),
None,
diff --git a/pyproject.toml b/pyproject.toml
index ae4072d37a22d..90c1cba90a9aa 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -56,6 +56,7 @@ markers = [
"arm_slow: mark a test as slow for arm64 architecture",
"arraymanager: mark a test to run with ArrayManager enabled",
]
+asyncio_mode = "strict"
[tool.mypy]
# Import discovery
| - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/46370 | 2022-03-15T04:59:23Z | 2022-03-16T00:38:30Z | 2022-03-16T00:38:30Z | 2022-03-30T10:50:57Z |
DOC: Add docs about using numba with parallel | diff --git a/doc/source/user_guide/enhancingperf.rst b/doc/source/user_guide/enhancingperf.rst
index 0e948504051c6..1a1229f95523b 100644
--- a/doc/source/user_guide/enhancingperf.rst
+++ b/doc/source/user_guide/enhancingperf.rst
@@ -350,6 +350,28 @@ a larger amount of data points (e.g. 1+ million).
In [6]: %timeit roll.apply(f, engine='cython', raw=True)
3.92 s ± 59 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+If your compute hardware contains multiple CPUs, the largest performance gain can be realized by setting ``parallel`` to ``True``
+to leverage more than 1 CPU. Internally, pandas leverages numba to parallelize computations over the columns of a :class:`DataFrame`;
+therefore, this performance benefit is only beneficial for a :class:`DataFrame` with a large number of columns.
+
+.. code-block:: ipython
+
+ In [1]: import numba
+
+ In [2]: numba.set_num_threads(1)
+
+ In [3]: df = pd.DataFrame(np.random.randn(10_000, 100))
+
+ In [4]: roll = df.rolling(100)
+
+ In [5]: %timeit roll.mean(engine="numba", engine_kwargs={"parallel": True})
+ 347 ms ± 26 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
+ In [6]: numba.set_num_threads(2)
+
+ In [7]: %timeit roll.mean(engine="numba", engine_kwargs={"parallel": True})
+ 201 ms ± 2.97 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
Custom Function Examples
~~~~~~~~~~~~~~~~~~~~~~~~
| - [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/46368 | 2022-03-15T03:28:34Z | 2022-03-15T22:17:39Z | 2022-03-15T22:17:39Z | 2022-03-16T00:31:40Z |
BUG: Fix remaining cases of groupby(...).transform with dropna=True | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 14e9fda1b910c..42cd34c94b069 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -83,32 +83,44 @@ did not have the same index as the input.
.. code-block:: ipython
- In [3]: df.groupby('a', dropna=True).transform(lambda x: x.sum())
+ In [3]: # Value in the last row should be np.nan
+ df.groupby('a', dropna=True).transform('sum')
Out[3]:
b
0 5
1 5
+ 2 5
- In [3]: df.groupby('a', dropna=True).transform(lambda x: x)
+ In [3]: # Should have one additional row with the value np.nan
+ df.groupby('a', dropna=True).transform(lambda x: x.sum())
Out[3]:
b
- 0 2
- 1 3
+ 0 5
+ 1 5
+
+ In [3]: # The value in the last row is np.nan interpreted as an integer
+ df.groupby('a', dropna=True).transform('ffill')
+ Out[3]:
+ b
+ 0 2
+ 1 3
+ 2 -9223372036854775808
- In [3]: df.groupby('a', dropna=True).transform('sum')
+ In [3]: # Should have one additional row with the value np.nan
+ df.groupby('a', dropna=True).transform(lambda x: x)
Out[3]:
b
- 0 5
- 1 5
- 2 5
+ 0 2
+ 1 3
*New behavior*:
.. ipython:: python
+ df.groupby('a', dropna=True).transform('sum')
df.groupby('a', dropna=True).transform(lambda x: x.sum())
+ df.groupby('a', dropna=True).transform('ffill')
df.groupby('a', dropna=True).transform(lambda x: x)
- df.groupby('a', dropna=True).transform('sum')
.. _whatsnew_150.notable_bug_fixes.visualization:
diff --git a/pandas/core/groupby/base.py b/pandas/core/groupby/base.py
index 0c8474c9badc7..ec9a2e4a4b5c0 100644
--- a/pandas/core/groupby/base.py
+++ b/pandas/core/groupby/base.py
@@ -70,7 +70,6 @@ class OutputKey:
"mean",
"median",
"min",
- "ngroup",
"nth",
"nunique",
"prod",
@@ -113,6 +112,7 @@ def maybe_normalize_deprecated_kernels(kernel):
"diff",
"ffill",
"fillna",
+ "ngroup",
"pad",
"pct_change",
"rank",
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 9f80c8f91ac6f..4a617d1b63639 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -62,6 +62,7 @@ class providing the base-class of operations.
)
from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.cast import ensure_dtype_can_hold_na
from pandas.core.dtypes.common import (
is_bool_dtype,
is_datetime64_dtype,
@@ -950,7 +951,13 @@ def curried(x):
if name in base.plotting_methods:
return self.apply(curried)
- return self._python_apply_general(curried, self._obj_with_exclusions)
+ result = self._python_apply_general(curried, self._obj_with_exclusions)
+
+ if self.grouper.has_dropped_na and name in base.transformation_kernels:
+ # result will have dropped rows due to nans, fill with null
+ # and ensure index is ordered same as the input
+ result = self._set_result_index_ordered(result)
+ return result
wrapper.__name__ = name
return wrapper
@@ -2608,7 +2615,11 @@ def blk_func(values: ArrayLike) -> ArrayLike:
# then there will be no -1s in indexer, so we can use
# the original dtype (no need to ensure_dtype_can_hold_na)
if isinstance(values, np.ndarray):
- out = np.empty(values.shape, dtype=values.dtype)
+ dtype = values.dtype
+ if self.grouper.has_dropped_na:
+ # dropped null groups give rise to nan in the result
+ dtype = ensure_dtype_can_hold_na(values.dtype)
+ out = np.empty(values.shape, dtype=dtype)
else:
out = type(values)._empty(values.shape, dtype=values.dtype)
@@ -3114,9 +3125,16 @@ def ngroup(self, ascending: bool = True):
"""
with self._group_selection_context():
index = self._selected_obj.index
- result = self._obj_1d_constructor(
- self.grouper.group_info[0], index, dtype=np.int64
- )
+ comp_ids = self.grouper.group_info[0]
+
+ dtype: type
+ if self.grouper.has_dropped_na:
+ comp_ids = np.where(comp_ids == -1, np.nan, comp_ids)
+ dtype = np.float64
+ else:
+ dtype = np.int64
+
+ result = self._obj_1d_constructor(comp_ids, index, dtype=dtype)
if not ascending:
result = self.ngroups - 1 - result
return result
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 15bc262997075..5f15e11c4740c 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -98,15 +98,25 @@
class WrappedCythonOp:
"""
Dispatch logic for functions defined in _libs.groupby
+
+ Parameters
+ ----------
+ kind: str
+ Whether the operation is an aggregate or transform.
+ how: str
+ Operation name, e.g. "mean".
+ has_dropped_na: bool
+ True precisely when dropna=True and the grouper contains a null value.
"""
# Functions for which we do _not_ attempt to cast the cython result
# back to the original dtype.
cast_blocklist = frozenset(["rank", "count", "size", "idxmin", "idxmax"])
- def __init__(self, kind: str, how: str) -> None:
+ def __init__(self, kind: str, how: str, has_dropped_na: bool) -> None:
self.kind = kind
self.how = how
+ self.has_dropped_na = has_dropped_na
_CYTHON_FUNCTIONS = {
"aggregate": {
@@ -194,7 +204,9 @@ def _get_cython_vals(self, values: np.ndarray) -> np.ndarray:
values = ensure_float64(values)
elif values.dtype.kind in ["i", "u"]:
- if how in ["add", "var", "prod", "mean", "ohlc"]:
+ if how in ["add", "var", "prod", "mean", "ohlc"] or (
+ self.kind == "transform" and self.has_dropped_na
+ ):
# result may still include NaN, so we have to cast
values = ensure_float64(values)
@@ -582,6 +594,10 @@ def _call_cython_op(
result = result.T
+ if self.how == "rank" and self.has_dropped_na:
+ # TODO: Wouldn't need this if group_rank supported mask
+ result = np.where(comp_ids < 0, np.nan, result)
+
if self.how not in self.cast_blocklist:
# e.g. if we are int64 and need to restore to datetime64/timedelta64
# "rank" is the only member of cast_blocklist we get here
@@ -959,7 +975,7 @@ def _cython_operation(
"""
assert kind in ["transform", "aggregate"]
- cy_op = WrappedCythonOp(kind=kind, how=how)
+ cy_op = WrappedCythonOp(kind=kind, how=how, has_dropped_na=self.has_dropped_na)
ids, _, _ = self.group_info
ngroups = self.ngroups
diff --git a/pandas/tests/apply/test_frame_transform.py b/pandas/tests/apply/test_frame_transform.py
index 3384f9d46029a..2d4deff8ebc4a 100644
--- a/pandas/tests/apply/test_frame_transform.py
+++ b/pandas/tests/apply/test_frame_transform.py
@@ -139,6 +139,10 @@ def test_transform_bad_dtype(op, frame_or_series, request):
raises=ValueError, reason="GH 40418: rank does not raise a TypeError"
)
)
+ elif op == "ngroup":
+ request.node.add_marker(
+ pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+ )
obj = DataFrame({"A": 3 * [object]}) # DataFrame that will fail on most transforms
obj = tm.get_obj(obj, frame_or_series)
@@ -157,9 +161,14 @@ def test_transform_bad_dtype(op, frame_or_series, request):
@pytest.mark.parametrize("op", frame_kernels_raise)
-def test_transform_partial_failure_typeerror(op):
+def test_transform_partial_failure_typeerror(request, op):
# GH 35964
+ if op == "ngroup":
+ request.node.add_marker(
+ pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+ )
+
# Using object makes most transform kernels fail
df = DataFrame({"A": 3 * [object], "B": [1, 2, 3]})
diff --git a/pandas/tests/apply/test_str.py b/pandas/tests/apply/test_str.py
index 554fd4174c7a4..2af063dee8b55 100644
--- a/pandas/tests/apply/test_str.py
+++ b/pandas/tests/apply/test_str.py
@@ -243,8 +243,12 @@ def test_agg_cython_table_transform_frame(df, func, expected, axis):
@pytest.mark.parametrize("op", series_transform_kernels)
-def test_transform_groupby_kernel_series(string_series, op):
+def test_transform_groupby_kernel_series(request, string_series, op):
# GH 35964
+ if op == "ngroup":
+ request.node.add_marker(
+ pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+ )
# TODO(2.0) Remove after pad/backfill deprecation enforced
op = maybe_normalize_deprecated_kernels(op)
args = [0.0] if op == "fillna" else []
@@ -255,9 +259,15 @@ def test_transform_groupby_kernel_series(string_series, op):
@pytest.mark.parametrize("op", frame_transform_kernels)
-def test_transform_groupby_kernel_frame(axis, float_frame, op):
+def test_transform_groupby_kernel_frame(request, axis, float_frame, op):
# TODO(2.0) Remove after pad/backfill deprecation enforced
op = maybe_normalize_deprecated_kernels(op)
+
+ if op == "ngroup":
+ request.node.add_marker(
+ pytest.mark.xfail(raises=ValueError, reason="ngroup not valid for NDFrame")
+ )
+
# GH 35964
args = [0.0] if op == "fillna" else []
diff --git a/pandas/tests/groupby/test_rank.py b/pandas/tests/groupby/test_rank.py
index 83b8d5c29bbf0..7830c229ece2f 100644
--- a/pandas/tests/groupby/test_rank.py
+++ b/pandas/tests/groupby/test_rank.py
@@ -658,6 +658,8 @@ def test_non_unique_index():
)
result = df.groupby([df.index, "A"]).value.rank(ascending=True, pct=True)
expected = Series(
- [1.0] * 4, index=[pd.Timestamp("20170101", tz="US/Eastern")] * 4, name="value"
+ [1.0, 1.0, 1.0, np.nan],
+ index=[pd.Timestamp("20170101", tz="US/Eastern")] * 4,
+ name="value",
)
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index 0f450adf67b23..3042e38d9014c 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -168,6 +168,10 @@ def test_transform_axis_1(request, transformation_func):
# TODO(2.0) Remove after pad/backfill deprecation enforced
transformation_func = maybe_normalize_deprecated_kernels(transformation_func)
+ if transformation_func == "ngroup":
+ msg = "ngroup fails with axis=1: #45986"
+ request.node.add_marker(pytest.mark.xfail(reason=msg))
+
warn = None
if transformation_func == "tshift":
warn = FutureWarning
@@ -383,6 +387,15 @@ def test_transform_transformation_func(request, transformation_func):
elif transformation_func == "fillna":
test_op = lambda x: x.transform("fillna", value=0)
mock_op = lambda x: x.fillna(value=0)
+ elif transformation_func == "ngroup":
+ test_op = lambda x: x.transform("ngroup")
+ counter = -1
+
+ def mock_op(x):
+ nonlocal counter
+ counter += 1
+ return Series(counter, index=x.index)
+
elif transformation_func == "tshift":
msg = (
"Current behavior of groupby.tshift is inconsistent with other "
@@ -394,10 +407,14 @@ def test_transform_transformation_func(request, transformation_func):
mock_op = lambda x: getattr(x, transformation_func)()
result = test_op(df.groupby("A"))
- groups = [df[["B"]].iloc[:4], df[["B"]].iloc[4:6], df[["B"]].iloc[6:]]
- expected = concat([mock_op(g) for g in groups])
+ # pass the group in same order as iterating `for ... in df.groupby(...)`
+ # but reorder to match df's index since this is a transform
+ groups = [df[["B"]].iloc[4:6], df[["B"]].iloc[6:], df[["B"]].iloc[:4]]
+ expected = concat([mock_op(g) for g in groups]).sort_index()
+ # sort_index does not preserve the freq
+ expected = expected.set_axis(df.index)
- if transformation_func == "cumcount":
+ if transformation_func in ("cumcount", "ngroup"):
tm.assert_series_equal(result, expected)
else:
tm.assert_frame_equal(result, expected)
@@ -1122,10 +1139,6 @@ def test_transform_agg_by_name(request, reduction_func, obj):
func = reduction_func
g = obj.groupby(np.repeat([0, 1], 3))
- if func == "ngroup": # GH#27468
- request.node.add_marker(
- pytest.mark.xfail(reason="TODO: g.transform('ngroup') doesn't work")
- )
if func == "corrwith" and isinstance(obj, Series): # GH#32293
request.node.add_marker(
pytest.mark.xfail(reason="TODO: implement SeriesGroupBy.corrwith")
@@ -1137,8 +1150,8 @@ def test_transform_agg_by_name(request, reduction_func, obj):
# this is the *definition* of a transformation
tm.assert_index_equal(result.index, obj.index)
- if func != "size" and obj.ndim == 2:
- # size returns a Series, unlike other transforms
+ if func not in ("ngroup", "size") and obj.ndim == 2:
+ # size/ngroup return a Series, unlike other transforms
tm.assert_index_equal(result.columns, obj.columns)
# verify that values were broadcasted across each group
@@ -1312,7 +1325,7 @@ def test_null_group_lambda_self(sort, dropna):
def test_null_group_str_reducer(request, dropna, reduction_func):
# GH 17093
- if reduction_func in ("corrwith", "ngroup"):
+ if reduction_func == "corrwith":
msg = "incorrectly raises"
request.node.add_marker(pytest.mark.xfail(reason=msg))
index = [1, 2, 3, 4] # test transform preserves non-standard index
@@ -1358,31 +1371,11 @@ def test_null_group_str_reducer(request, dropna, reduction_func):
@pytest.mark.filterwarnings("ignore:tshift is deprecated:FutureWarning")
-def test_null_group_str_transformer(
- request, using_array_manager, dropna, transformation_func
-):
+def test_null_group_str_transformer(request, dropna, transformation_func):
# GH 17093
- xfails_block = (
- "cummax",
- "cummin",
- "cumsum",
- "fillna",
- "rank",
- "backfill",
- "ffill",
- "bfill",
- "pad",
- )
- xfails_array = ("cummax", "cummin", "cumsum", "fillna", "rank")
if transformation_func == "tshift":
msg = "tshift requires timeseries"
request.node.add_marker(pytest.mark.xfail(reason=msg))
- elif dropna and (
- (not using_array_manager and transformation_func in xfails_block)
- or (using_array_manager and transformation_func in xfails_array)
- ):
- msg = "produces incorrect results when nans are present"
- request.node.add_marker(pytest.mark.xfail(reason=msg))
args = (0,) if transformation_func == "fillna" else ()
df = DataFrame({"A": [1, 1, np.nan], "B": [1, 2, 2]}, index=[1, 2, 3])
gb = df.groupby("A", dropna=dropna)
@@ -1420,10 +1413,6 @@ def test_null_group_str_reducer_series(request, dropna, reduction_func):
msg = "corrwith not implemented for SeriesGroupBy"
request.node.add_marker(pytest.mark.xfail(reason=msg))
- if reduction_func == "ngroup":
- msg = "ngroup fails"
- request.node.add_marker(pytest.mark.xfail(reason=msg))
-
# GH 17093
index = [1, 2, 3, 4] # test transform preserves non-standard index
ser = Series([1, 2, 2, 3], index=index)
@@ -1470,15 +1459,6 @@ def test_null_group_str_transformer_series(request, dropna, transformation_func)
if transformation_func == "tshift":
msg = "tshift requires timeseries"
request.node.add_marker(pytest.mark.xfail(reason=msg))
- elif dropna and transformation_func in (
- "cummax",
- "cummin",
- "cumsum",
- "fillna",
- "rank",
- ):
- msg = "produces incorrect results when nans are present"
- request.node.add_marker(pytest.mark.xfail(reason=msg))
args = (0,) if transformation_func == "fillna" else ()
ser = Series([1, 2, 2], index=[1, 2, 3])
gb = ser.groupby([1, 1, np.nan], dropna=dropna)
@@ -1502,4 +1482,10 @@ def test_null_group_str_transformer_series(request, dropna, transformation_func)
msg = f"{transformation_func} is deprecated"
with tm.assert_produces_warning(warn, match=msg):
result = gb.transform(transformation_func, *args)
- tm.assert_equal(result, expected)
+ if dropna and transformation_func == "fillna":
+ # GH#46369 - result name is the group; remove this block when fixed.
+ tm.assert_equal(result, expected, check_names=False)
+ # This should be None
+ assert result.name == 1.0
+ else:
+ tm.assert_equal(result, expected)
| - [x] closes #17093 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/46367 | 2022-03-15T03:27:34Z | 2022-03-22T23:25:02Z | 2022-03-22T23:25:01Z | 2023-07-15T11:02:53Z |
Fixed `Period` and `PeriodIndex` formatting | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 089ba62e461d1..2536a9994399c 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -434,6 +434,7 @@ I/O
Period
^^^^^^
- Bug in subtraction of :class:`Period` from :class:`PeriodArray` returning wrong results (:issue:`45999`)
+- Bug in :meth:`Period.strftime` and :meth:`PeriodIndex.strftime`, directives ``%l`` and ``%u`` were giving wrong results (:issue:`46252`)
-
Plotting
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index 9c05c6867f71f..182502ba9ad7f 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -9,6 +9,7 @@ from cpython.object cimport (
PyObject_RichCompareBool,
)
from numpy cimport (
+ int32_t,
int64_t,
ndarray,
)
@@ -1217,10 +1218,14 @@ cdef str _period_strftime(int64_t value, int freq, bytes fmt):
char *formatted
bytes pat, brepl
list found_pat = [False] * len(extra_fmts)
- int year, quarter
+ int quarter
+ int32_t us, ps
str result, repl
get_date_info(value, freq, &dts)
+
+ # Find our additional directives in the pattern and replace them with
+ # placeholders that are not processed by c_strftime
for i in range(len(extra_fmts)):
pat = extra_fmts[i][0]
brepl = extra_fmts[i][1]
@@ -1228,28 +1233,41 @@ cdef str _period_strftime(int64_t value, int freq, bytes fmt):
fmt = fmt.replace(pat, brepl)
found_pat[i] = True
+ # Execute c_strftime to process the usual datetime directives
formatted = c_strftime(&dts, <char*>fmt)
result = util.char_to_string(formatted)
free(formatted)
+ # Now we will fill the placeholders corresponding to our additional directives
+
+ # First prepare the contents
+ # Save these to local vars as dts can be modified by get_yq below
+ us = dts.us
+ ps = dts.ps
+ if any(found_pat[0:3]):
+ # Note: this modifies `dts` in-place so that year becomes fiscal year
+ # However it looses the us and ps
+ quarter = get_yq(value, freq, &dts)
+ else:
+ quarter = 0
+
+ # Now do the filling per se
for i in range(len(extra_fmts)):
if found_pat[i]:
- quarter = get_yq(value, freq, &dts)
-
- if i == 0:
- repl = str(quarter)
- elif i == 1: # %f, 2-digit year
+ if i == 0: # %q, 1-digit quarter.
+ repl = f"{quarter}"
+ elif i == 1: # %f, 2-digit 'Fiscal' year
repl = f"{(dts.year % 100):02d}"
- elif i == 2:
+ elif i == 2: # %F, 'Fiscal' year with a century
repl = str(dts.year)
- elif i == 3:
- repl = f"{(value % 1_000):03d}"
- elif i == 4:
- repl = f"{(value % 1_000_000):06d}"
- elif i == 5:
- repl = f"{(value % 1_000_000_000):09d}"
+ elif i == 3: # %l, milliseconds
+ repl = f"{(us // 1_000):03d}"
+ elif i == 4: # %u, microseconds
+ repl = f"{(us):06d}"
+ elif i == 5: # %n, nanoseconds
+ repl = f"{((us * 1000) + (ps // 1000)):09d}"
result = result.replace(str_extra_fmts[i], repl)
@@ -2302,7 +2320,8 @@ cdef class _Period(PeriodMixin):
containing one or several directives. The method recognizes the same
directives as the :func:`time.strftime` function of the standard Python
distribution, as well as the specific additional directives ``%f``,
- ``%F``, ``%q``. (formatting & docs originally from scikits.timeries).
+ ``%F``, ``%q``, ``%l``, ``%u``, ``%n``.
+ (formatting & docs originally from scikits.timeries).
+-----------+--------------------------------+-------+
| Directive | Meaning | Notes |
@@ -2349,11 +2368,20 @@ cdef class _Period(PeriodMixin):
| | AM or PM. | |
+-----------+--------------------------------+-------+
| ``%q`` | Quarter as a decimal number | |
- | | [01,04] | |
+ | | [1,4] | |
+-----------+--------------------------------+-------+
| ``%S`` | Second as a decimal number | \(4) |
| | [00,61]. | |
+-----------+--------------------------------+-------+
+ | ``%l`` | Millisecond as a decimal number| |
+ | | [000,999]. | |
+ +-----------+--------------------------------+-------+
+ | ``%u`` | Microsecond as a decimal number| |
+ | | [000000,999999]. | |
+ +-----------+--------------------------------+-------+
+ | ``%n`` | Nanosecond as a decimal number | |
+ | | [000000000,999999999]. | |
+ +-----------+--------------------------------+-------+
| ``%U`` | Week number of the year | \(5) |
| | (Sunday as the first day of | |
| | the week) as a decimal number | |
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 487a39976a0e8..8f0516abe8bb3 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -1593,6 +1593,14 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
of the string format can be found in `python string format
doc <%(URL)s>`__.
+ Formats supported by the C `strftime` API but not by the python string format
+ doc (such as `"%%R"`, `"%%r"`) are not officially supported and should be
+ preferably replaced with their supported equivalents (such as `"%%H:%%M"`,
+ `"%%I:%%M:%%S %%p"`).
+
+ Note that `PeriodIndex` support additional directives, detailed in
+ `Period.strftime`.
+
Parameters
----------
date_format : str
@@ -1609,6 +1617,8 @@ def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
DatetimeIndex.normalize : Return DatetimeIndex with times to midnight.
DatetimeIndex.round : Round the DatetimeIndex to the specified freq.
DatetimeIndex.floor : Floor the DatetimeIndex to the specified freq.
+ Timestamp.strftime : Format a single Timestamp.
+ Period.strftime : Format a single Period.
Examples
--------
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index b2a8dfddc6b68..fa543f6773634 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -642,17 +642,17 @@ def _format_native_types(
values = self.astype(object)
if date_format:
- formatter = lambda dt: dt.strftime(date_format)
+ formatter = lambda per: per.strftime(date_format)
else:
- formatter = lambda dt: str(dt)
+ formatter = lambda per: str(per)
if self._hasna:
mask = self._isnan
values[mask] = na_rep
imask = ~mask
- values[imask] = np.array([formatter(dt) for dt in values[imask]])
+ values[imask] = np.array([formatter(per) for per in values[imask]])
else:
- values = np.array([formatter(dt) for dt in values])
+ values = np.array([formatter(per) for per in values])
return values
# ------------------------------------------------------------------
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index adcaeba5cfd8d..9ab3e4cf6afac 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -1,7 +1,6 @@
"""
Test output formatting for Series/DataFrame, including to_string & reprs
"""
-
from datetime import datetime
from io import StringIO
import itertools
@@ -3167,6 +3166,65 @@ def test_str(self):
assert str(NaT) == "NaT"
+class TestPeriodIndexFormat:
+ def test_period_format_and_strftime_default(self):
+ per = pd.PeriodIndex([datetime(2003, 1, 1, 12), None], freq="H")
+
+ # Default formatting
+ formatted = per.format()
+ assert formatted[0] == "2003-01-01 12:00" # default: minutes not shown
+ assert formatted[1] == "NaT"
+ # format is equivalent to strftime(None)...
+ assert formatted[0] == per.strftime(None)[0]
+ assert per.strftime(None)[1] is np.nan # ...except for NaTs
+
+ # Same test with nanoseconds freq
+ per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="n")
+ formatted = per.format()
+ assert (formatted == per.strftime(None)).all()
+ assert formatted[0] == "2003-01-01 12:01:01.123456789"
+ assert formatted[1] == "2003-01-01 12:01:01.123456790"
+
+ def test_period_custom(self):
+ # GH#46252 custom formatting directives %l (ms) and %u (us)
+
+ # 3 digits
+ per = pd.period_range("2003-01-01 12:01:01.123", periods=2, freq="l")
+ formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
+ assert formatted[0] == "03 12:01:01 (ms=123 us=123000 ns=123000000)"
+ assert formatted[1] == "03 12:01:01 (ms=124 us=124000 ns=124000000)"
+
+ # 6 digits
+ per = pd.period_range("2003-01-01 12:01:01.123456", periods=2, freq="u")
+ formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
+ assert formatted[0] == "03 12:01:01 (ms=123 us=123456 ns=123456000)"
+ assert formatted[1] == "03 12:01:01 (ms=123 us=123457 ns=123457000)"
+
+ # 9 digits
+ per = pd.period_range("2003-01-01 12:01:01.123456789", periods=2, freq="n")
+ formatted = per.format(date_format="%y %I:%M:%S (ms=%l us=%u ns=%n)")
+ assert formatted[0] == "03 12:01:01 (ms=123 us=123456 ns=123456789)"
+ assert formatted[1] == "03 12:01:01 (ms=123 us=123456 ns=123456790)"
+
+ def test_period_tz(self):
+ # Formatting periods created from a datetime with timezone.
+
+ # This timestamp is in 2013 in Europe/Paris but is 2012 in UTC
+ dt = pd.to_datetime(["2013-01-01 00:00:00+01:00"], utc=True)
+
+ # Converting to a period looses the timezone information
+ # Since tz is currently set as utc, we'll see 2012
+ with tm.assert_produces_warning(UserWarning, match="will drop timezone"):
+ per = dt.to_period(freq="H")
+ assert per.format()[0] == "2012-12-31 23:00"
+
+ # If tz is currently set as paris before conversion, we'll see 2013
+ dt = dt.tz_convert("Europe/Paris")
+ with tm.assert_produces_warning(UserWarning, match="will drop timezone"):
+ per = dt.to_period(freq="H")
+ assert per.format()[0] == "2013-01-01 00:00"
+
+
class TestDatetimeIndexFormat:
def test_datetime(self):
formatted = pd.to_datetime([datetime(2003, 1, 1, 12), NaT]).format()
| - [x] closes #46252
- [x] Improved docstring for `PeriodIndex.strftime` and `Period.strftime`
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
Note: this is the first PR extracted from #46116. More to come soon :) | https://api.github.com/repos/pandas-dev/pandas/pulls/46361 | 2022-03-14T15:04:34Z | 2022-03-18T00:34:24Z | 2022-03-18T00:34:23Z | 2022-03-18T10:56:31Z |
CI: Debug Windows stack overflow | diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index e6dc98179b7d6..1b0ae40949d5b 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -45,7 +45,7 @@ jobs:
/opt/python/cp38-cp38/bin/python -m venv ~/virtualenvs/pandas-dev && \
. ~/virtualenvs/pandas-dev/bin/activate && \
python -m pip install --no-deps -U pip wheel 'setuptools<60.0.0' && \
- pip install cython numpy python-dateutil pytz pytest pytest-xdist hypothesis pytest-azurepipelines && \
+ pip install cython numpy python-dateutil pytz pytest pytest-xdist hypothesis && \
python setup.py build_ext -q -j2 && \
python -m pip install --no-build-isolation -e . && \
pytest -m 'not slow and not network and not clipboard and not single_cpu' pandas --junitxml=test-data.xml"
diff --git a/pandas/tests/extension/arrow/test_bool.py b/pandas/tests/extension/arrow/test_bool.py
index bdfbbef937019..0205b8aad9431 100644
--- a/pandas/tests/extension/arrow/test_bool.py
+++ b/pandas/tests/extension/arrow/test_bool.py
@@ -1,6 +1,11 @@
import numpy as np
import pytest
+from pandas.compat import (
+ is_ci_environment,
+ is_platform_windows,
+)
+
import pandas as pd
import pandas._testing as tm
from pandas.api.types import is_bool_dtype
@@ -82,6 +87,10 @@ def test_reduce_series_boolean(self):
pass
+@pytest.mark.skipif(
+ is_ci_environment() and is_platform_windows(),
+ reason="Causes stack overflow on Windows CI",
+)
class TestReduceBoolean(base.BaseBooleanReduceTests):
pass
diff --git a/pandas/tests/extension/json/test_json.py b/pandas/tests/extension/json/test_json.py
index d530a75b74c8f..f13ef65267304 100644
--- a/pandas/tests/extension/json/test_json.py
+++ b/pandas/tests/extension/json/test_json.py
@@ -1,5 +1,6 @@
import collections
import operator
+import sys
import pytest
@@ -163,12 +164,24 @@ def test_from_dtype(self, data):
@pytest.mark.xfail(reason="RecursionError, GH-33900")
def test_series_constructor_no_data_with_index(self, dtype, na_value):
# RecursionError: maximum recursion depth exceeded in comparison
- super().test_series_constructor_no_data_with_index(dtype, na_value)
+ rec_limit = sys.getrecursionlimit()
+ try:
+ # Limit to avoid stack overflow on Windows CI
+ sys.setrecursionlimit(100)
+ super().test_series_constructor_no_data_with_index(dtype, na_value)
+ finally:
+ sys.setrecursionlimit(rec_limit)
@pytest.mark.xfail(reason="RecursionError, GH-33900")
def test_series_constructor_scalar_na_with_index(self, dtype, na_value):
# RecursionError: maximum recursion depth exceeded in comparison
- super().test_series_constructor_scalar_na_with_index(dtype, na_value)
+ rec_limit = sys.getrecursionlimit()
+ try:
+ # Limit to avoid stack overflow on Windows CI
+ sys.setrecursionlimit(100)
+ super().test_series_constructor_scalar_na_with_index(dtype, na_value)
+ finally:
+ sys.setrecursionlimit(rec_limit)
@pytest.mark.xfail(reason="collection as scalar, GH-33901")
def test_series_constructor_scalar_with_index(self, data, dtype):
| ```
Thread 0x0000142c (most recent call first):
File "C:\Miniconda\en.vs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 400 in read
File "C:\Miniconda\envs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 432 in from_io
File "C:\Miniconda\envs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 967 in _thread_receiver
File "C:\Miniconda\envs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 220 in run
File "C:\Miniconda\envs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 285 in _perform_spawn
Current thread 0x00000520 (most recent call first):
File "D:\a\1\s\pandas\core\construction.py", line 850 in is_empty_data
File "D:\a\1\s\pandas\core\construction.py", line 887 in create_series_with_explicit_dtype
File "D:\a\1\s\pandas\core\series.py", line 515 in _init_dict
File "D:\a\1\s\pandas\core\series.py", line 422 in __init__
File "D:\a\1\s\pandas\core\construction.py", line 889 in create_series_with_explicit_dtype
File "D:\a\1\s\pandas\core\series.py", line 515 in _init_dict
File "D:\a\1\s\pandas\core\series.py", line 422 in __init__
File "D:\a\1\s\pandas\core\construction.py", line 889 in create_series_with_explicit_dtype
File "D:\a\1\s\pandas\core\series.py", line 515 in _init_dict
File "D:\a\1\s\pandas\core\series.py", line 422 in __init__
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/46358 | 2022-03-13T18:16:00Z | 2022-03-15T19:43:34Z | 2022-03-15T19:43:34Z | 2022-03-29T12:23:41Z |
ENH: consistency of input args for boundaries - pd.interval_range | diff --git a/doc/source/user_guide/advanced.rst b/doc/source/user_guide/advanced.rst
index b8df21ab5a5b4..3081c6f7c6a08 100644
--- a/doc/source/user_guide/advanced.rst
+++ b/doc/source/user_guide/advanced.rst
@@ -1082,14 +1082,14 @@ of :ref:`frequency aliases <timeseries.offset_aliases>` with datetime-like inter
pd.interval_range(start=pd.Timedelta("0 days"), periods=3, freq="9H")
-Additionally, the ``closed`` parameter can be used to specify which side(s) the intervals
-are closed on. Intervals are closed on the right side by default.
+Additionally, the ``inclusive`` parameter can be used to specify which side(s) the intervals
+are closed on. Intervals are closed on the both side by default.
.. ipython:: python
- pd.interval_range(start=0, end=4, closed="both")
+ pd.interval_range(start=0, end=4, inclusive="both")
- pd.interval_range(start=0, end=4, closed="neither")
+ pd.interval_range(start=0, end=4, inclusive="neither")
Specifying ``start``, ``end``, and ``periods`` will generate a range of evenly spaced
intervals from ``start`` to ``end`` inclusively, with ``periods`` number of elements
diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 56b1a6317472b..8607294244052 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -426,6 +426,7 @@ Other Deprecations
- Deprecated behavior of method :meth:`DataFrame.quantile`, attribute ``numeric_only`` will default False. Including datetime/timedelta columns in the result (:issue:`7308`).
- Deprecated :attr:`Timedelta.freq` and :attr:`Timedelta.is_populated` (:issue:`46430`)
- Deprecated :attr:`Timedelta.delta` (:issue:`46476`)
+- Deprecated the ``closed`` argument in :meth:`interval_range` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 425e7d3f4432e..f6a20a418c32b 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -11,6 +11,7 @@
Hashable,
Literal,
)
+import warnings
import numpy as np
@@ -160,7 +161,7 @@ def _new_IntervalIndex(cls, d):
A new ``IntervalIndex`` is typically constructed using
:func:`interval_range`:
- >>> pd.interval_range(start=0, end=5)
+ >>> pd.interval_range(start=0, end=5, inclusive="right")
IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
dtype='interval[int64, right]')
@@ -443,7 +444,7 @@ def is_overlapping(self) -> bool:
Intervals that share closed endpoints overlap:
- >>> index = pd.interval_range(0, 3, closed='both')
+ >>> index = pd.interval_range(0, 3, inclusive='both')
>>> index
IntervalIndex([[0, 1], [1, 2], [2, 3]],
dtype='interval[int64, both]')
@@ -452,7 +453,7 @@ def is_overlapping(self) -> bool:
Intervals that only have an open endpoint in common do not overlap:
- >>> index = pd.interval_range(0, 3, closed='left')
+ >>> index = pd.interval_range(0, 3, inclusive='left')
>>> index
IntervalIndex([[0, 1), [1, 2), [2, 3)],
dtype='interval[int64, left]')
@@ -956,7 +957,8 @@ def interval_range(
periods=None,
freq=None,
name: Hashable = None,
- closed: IntervalClosedType = "right",
+ closed: lib.NoDefault = lib.no_default,
+ inclusive: IntervalClosedType | None = None,
) -> IntervalIndex:
"""
Return a fixed frequency IntervalIndex.
@@ -979,6 +981,14 @@ def interval_range(
Whether the intervals are closed on the left-side, right-side, both
or neither.
+ .. deprecated:: 1.5.0
+ Argument `closed` has been deprecated to standardize boundary inputs.
+ Use `inclusive` instead, to set each bound as closed or open.
+ inclusive : {"both", "neither", "left", "right"}, default "both"
+ Include boundaries; Whether to set each bound as closed or open.
+
+ .. versionadded:: 1.5.0
+
Returns
-------
IntervalIndex
@@ -1001,14 +1011,14 @@ def interval_range(
--------
Numeric ``start`` and ``end`` is supported.
- >>> pd.interval_range(start=0, end=5)
+ >>> pd.interval_range(start=0, end=5, inclusive="right")
IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
dtype='interval[int64, right]')
Additionally, datetime-like input is also supported.
>>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
- ... end=pd.Timestamp('2017-01-04'))
+ ... end=pd.Timestamp('2017-01-04'), inclusive="right")
IntervalIndex([(2017-01-01, 2017-01-02], (2017-01-02, 2017-01-03],
(2017-01-03, 2017-01-04]],
dtype='interval[datetime64[ns], right]')
@@ -1017,7 +1027,7 @@ def interval_range(
endpoints of the individual intervals within the ``IntervalIndex``. For
numeric ``start`` and ``end``, the frequency must also be numeric.
- >>> pd.interval_range(start=0, periods=4, freq=1.5)
+ >>> pd.interval_range(start=0, periods=4, freq=1.5, inclusive="right")
IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
dtype='interval[float64, right]')
@@ -1025,7 +1035,7 @@ def interval_range(
convertible to a DateOffset.
>>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
- ... periods=3, freq='MS')
+ ... periods=3, freq='MS', inclusive="right")
IntervalIndex([(2017-01-01, 2017-02-01], (2017-02-01, 2017-03-01],
(2017-03-01, 2017-04-01]],
dtype='interval[datetime64[ns], right]')
@@ -1033,17 +1043,40 @@ def interval_range(
Specify ``start``, ``end``, and ``periods``; the frequency is generated
automatically (linearly spaced).
- >>> pd.interval_range(start=0, end=6, periods=4)
+ >>> pd.interval_range(start=0, end=6, periods=4, inclusive="right")
IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
dtype='interval[float64, right]')
- The ``closed`` parameter specifies which endpoints of the individual
+ The ``inclusive`` parameter specifies which endpoints of the individual
intervals within the ``IntervalIndex`` are closed.
- >>> pd.interval_range(end=5, periods=4, closed='both')
+ >>> pd.interval_range(end=5, periods=4, inclusive='both')
IntervalIndex([[1, 2], [2, 3], [3, 4], [4, 5]],
dtype='interval[int64, both]')
"""
+ if inclusive is not None and not isinstance(closed, lib.NoDefault):
+ raise ValueError(
+ "Deprecated argument `closed` cannot be passed "
+ "if argument `inclusive` is not None"
+ )
+ elif not isinstance(closed, lib.NoDefault):
+ warnings.warn(
+ "Argument `closed` is deprecated in favor of `inclusive`.",
+ FutureWarning,
+ stacklevel=2,
+ )
+ if closed is None:
+ inclusive = "both"
+ elif closed in ("both", "neither", "left", "right"):
+ inclusive = closed
+ else:
+ raise ValueError(
+ "Argument `closed` has to be either"
+ "'both', 'neither', 'left' or 'right'"
+ )
+ elif inclusive is None:
+ inclusive = "both"
+
start = maybe_box_datetimelike(start)
end = maybe_box_datetimelike(end)
endpoint = start if start is not None else end
@@ -1120,4 +1153,4 @@ def interval_range(
else:
breaks = timedelta_range(start=start, end=end, periods=periods, freq=freq)
- return IntervalIndex.from_breaks(breaks, name=name, closed=closed)
+ return IntervalIndex.from_breaks(breaks, name=name, closed=inclusive)
diff --git a/pandas/tests/frame/methods/test_round.py b/pandas/tests/frame/methods/test_round.py
index dd9206940bcd6..77cadfff55e2f 100644
--- a/pandas/tests/frame/methods/test_round.py
+++ b/pandas/tests/frame/methods/test_round.py
@@ -210,7 +210,7 @@ def test_round_nonunique_categorical(self):
def test_round_interval_category_columns(self):
# GH#30063
- columns = pd.CategoricalIndex(pd.interval_range(0, 2))
+ columns = pd.CategoricalIndex(pd.interval_range(0, 2, inclusive="right"))
df = DataFrame([[0.66, 1.1], [0.3, 0.25]], columns=columns)
result = df.round()
diff --git a/pandas/tests/groupby/aggregate/test_cython.py b/pandas/tests/groupby/aggregate/test_cython.py
index 96009be5d12e3..9631de7833cf4 100644
--- a/pandas/tests/groupby/aggregate/test_cython.py
+++ b/pandas/tests/groupby/aggregate/test_cython.py
@@ -214,7 +214,7 @@ def test_cython_agg_empty_buckets_nanops(observed):
result = df.groupby(pd.cut(df["a"], grps), observed=observed)._cython_agg_general(
"add", alt=None, numeric_only=True
)
- intervals = pd.interval_range(0, 20, freq=5)
+ intervals = pd.interval_range(0, 20, freq=5, inclusive="right")
expected = DataFrame(
{"a": [0, 0, 36, 0]},
index=pd.CategoricalIndex(intervals, name="a", ordered=True),
diff --git a/pandas/tests/indexes/interval/test_astype.py b/pandas/tests/indexes/interval/test_astype.py
index c253a745ef5a2..4cdbe2bbcf12b 100644
--- a/pandas/tests/indexes/interval/test_astype.py
+++ b/pandas/tests/indexes/interval/test_astype.py
@@ -117,7 +117,7 @@ def test_subtype_integer(self, subtype_start, subtype_end):
@pytest.mark.xfail(reason="GH#15832")
def test_subtype_integer_errors(self):
# int64 -> uint64 fails with negative values
- index = interval_range(-10, 10)
+ index = interval_range(-10, 10, inclusive="right")
dtype = IntervalDtype("uint64", "right")
# Until we decide what the exception message _should_ be, we
@@ -133,7 +133,7 @@ class TestFloatSubtype(AstypeTests):
"""Tests specific to IntervalIndex with float subtype"""
indexes = [
- interval_range(-10.0, 10.0, closed="neither"),
+ interval_range(-10.0, 10.0, inclusive="neither"),
IntervalIndex.from_arrays(
[-1.5, np.nan, 0.0, 0.0, 1.5], [-0.5, np.nan, 1.0, 1.0, 3.0], closed="both"
),
@@ -170,7 +170,7 @@ def test_subtype_integer_with_non_integer_borders(self, subtype):
def test_subtype_integer_errors(self):
# float64 -> uint64 fails with negative values
- index = interval_range(-10.0, 10.0)
+ index = interval_range(-10.0, 10.0, inclusive="right")
dtype = IntervalDtype("uint64", "right")
msg = re.escape(
"Cannot convert interval[float64, right] to interval[uint64, right]; "
@@ -191,10 +191,10 @@ class TestDatetimelikeSubtype(AstypeTests):
"""Tests specific to IntervalIndex with datetime-like subtype"""
indexes = [
- interval_range(Timestamp("2018-01-01"), periods=10, closed="neither"),
+ interval_range(Timestamp("2018-01-01"), periods=10, inclusive="neither"),
interval_range(Timestamp("2018-01-01"), periods=10).insert(2, NaT),
interval_range(Timestamp("2018-01-01", tz="US/Eastern"), periods=10),
- interval_range(Timedelta("0 days"), periods=10, closed="both"),
+ interval_range(Timedelta("0 days"), periods=10, inclusive="both"),
interval_range(Timedelta("0 days"), periods=10).insert(2, NaT),
]
diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index 37c13c37d070b..8880cab2ce29b 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -167,10 +167,10 @@ def test_delete(self, closed):
@pytest.mark.parametrize(
"data",
[
- interval_range(0, periods=10, closed="neither"),
- interval_range(1.7, periods=8, freq=2.5, closed="both"),
- interval_range(Timestamp("20170101"), periods=12, closed="left"),
- interval_range(Timedelta("1 day"), periods=6, closed="right"),
+ interval_range(0, periods=10, inclusive="neither"),
+ interval_range(1.7, periods=8, freq=2.5, inclusive="both"),
+ interval_range(Timestamp("20170101"), periods=12, inclusive="left"),
+ interval_range(Timedelta("1 day"), periods=6, inclusive="right"),
],
)
def test_insert(self, data):
@@ -868,9 +868,9 @@ def test_nbytes(self):
@pytest.mark.parametrize("new_closed", ["left", "right", "both", "neither"])
def test_set_closed(self, name, closed, new_closed):
# GH 21670
- index = interval_range(0, 5, closed=closed, name=name)
+ index = interval_range(0, 5, inclusive=closed, name=name)
result = index.set_closed(new_closed)
- expected = interval_range(0, 5, closed=new_closed, name=name)
+ expected = interval_range(0, 5, inclusive=new_closed, name=name)
tm.assert_index_equal(result, expected)
@pytest.mark.parametrize("bad_closed", ["foo", 10, "LEFT", True, False])
diff --git a/pandas/tests/indexes/interval/test_interval_range.py b/pandas/tests/indexes/interval/test_interval_range.py
index 2f28c33a3bbc6..63e7f3aa2b120 100644
--- a/pandas/tests/indexes/interval/test_interval_range.py
+++ b/pandas/tests/indexes/interval/test_interval_range.py
@@ -34,25 +34,25 @@ def test_constructor_numeric(self, closed, name, freq, periods):
# defined from start/end/freq
result = interval_range(
- start=start, end=end, freq=freq, name=name, closed=closed
+ start=start, end=end, freq=freq, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
# defined from start/periods/freq
result = interval_range(
- start=start, periods=periods, freq=freq, name=name, closed=closed
+ start=start, periods=periods, freq=freq, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
# defined from end/periods/freq
result = interval_range(
- end=end, periods=periods, freq=freq, name=name, closed=closed
+ end=end, periods=periods, freq=freq, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
# GH 20976: linspace behavior defined from start/end/periods
result = interval_range(
- start=start, end=end, periods=periods, name=name, closed=closed
+ start=start, end=end, periods=periods, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
@@ -67,19 +67,19 @@ def test_constructor_timestamp(self, closed, name, freq, periods, tz):
# defined from start/end/freq
result = interval_range(
- start=start, end=end, freq=freq, name=name, closed=closed
+ start=start, end=end, freq=freq, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
# defined from start/periods/freq
result = interval_range(
- start=start, periods=periods, freq=freq, name=name, closed=closed
+ start=start, periods=periods, freq=freq, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
# defined from end/periods/freq
result = interval_range(
- end=end, periods=periods, freq=freq, name=name, closed=closed
+ end=end, periods=periods, freq=freq, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
@@ -88,7 +88,7 @@ def test_constructor_timestamp(self, closed, name, freq, periods, tz):
# matches expected only for non-anchored offsets and tz naive
# (anchored/DST transitions cause unequal spacing in expected)
result = interval_range(
- start=start, end=end, periods=periods, name=name, closed=closed
+ start=start, end=end, periods=periods, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
@@ -102,25 +102,25 @@ def test_constructor_timedelta(self, closed, name, freq, periods):
# defined from start/end/freq
result = interval_range(
- start=start, end=end, freq=freq, name=name, closed=closed
+ start=start, end=end, freq=freq, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
# defined from start/periods/freq
result = interval_range(
- start=start, periods=periods, freq=freq, name=name, closed=closed
+ start=start, periods=periods, freq=freq, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
# defined from end/periods/freq
result = interval_range(
- end=end, periods=periods, freq=freq, name=name, closed=closed
+ end=end, periods=periods, freq=freq, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
# GH 20976: linspace behavior defined from start/end/periods
result = interval_range(
- start=start, end=end, periods=periods, name=name, closed=closed
+ start=start, end=end, periods=periods, name=name, inclusive=closed
)
tm.assert_index_equal(result, expected)
@@ -163,7 +163,9 @@ def test_no_invalid_float_truncation(self, start, end, freq):
breaks = [0.5, 2.0, 3.5, 5.0, 6.5]
expected = IntervalIndex.from_breaks(breaks)
- result = interval_range(start=start, end=end, periods=4, freq=freq)
+ result = interval_range(
+ start=start, end=end, periods=4, freq=freq, inclusive="right"
+ )
tm.assert_index_equal(result, expected)
@pytest.mark.parametrize(
@@ -184,7 +186,7 @@ def test_no_invalid_float_truncation(self, start, end, freq):
def test_linspace_dst_transition(self, start, mid, end):
# GH 20976: linspace behavior defined from start/end/periods
# accounts for the hour gained/lost during DST transition
- result = interval_range(start=start, end=end, periods=2)
+ result = interval_range(start=start, end=end, periods=2, inclusive="right")
expected = IntervalIndex.from_breaks([start, mid, end])
tm.assert_index_equal(result, expected)
@@ -353,3 +355,17 @@ def test_errors(self):
msg = "Start and end cannot both be tz-aware with different timezones"
with pytest.raises(TypeError, match=msg):
interval_range(start=start, end=end)
+
+ def test_interval_range_error_and_warning(self):
+ # GH 40245
+
+ msg = (
+ "Deprecated argument `closed` cannot "
+ "be passed if argument `inclusive` is not None"
+ )
+ with pytest.raises(ValueError, match=msg):
+ interval_range(end=5, periods=4, closed="both", inclusive="both")
+
+ msg = "Argument `closed` is deprecated in favor of `inclusive`"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ interval_range(end=5, periods=4, closed="right")
diff --git a/pandas/tests/indexes/interval/test_setops.py b/pandas/tests/indexes/interval/test_setops.py
index 059b0b75f4190..51a1d36398aa4 100644
--- a/pandas/tests/indexes/interval/test_setops.py
+++ b/pandas/tests/indexes/interval/test_setops.py
@@ -194,7 +194,7 @@ def test_set_incompatible_types(self, closed, op_name, sort):
tm.assert_index_equal(result, expected)
# GH 19016: incompatible dtypes -> cast to object
- other = interval_range(Timestamp("20180101"), periods=9, closed=closed)
+ other = interval_range(Timestamp("20180101"), periods=9, inclusive=closed)
expected = getattr(index.astype(object), op_name)(other, sort=sort)
if op_name == "difference":
expected = index
diff --git a/pandas/tests/indexing/test_coercion.py b/pandas/tests/indexing/test_coercion.py
index 2d54a9ba370ca..4504c55698a9a 100644
--- a/pandas/tests/indexing/test_coercion.py
+++ b/pandas/tests/indexing/test_coercion.py
@@ -709,7 +709,7 @@ def test_fillna_datetime64tz(self, index_or_series, fill_val, fill_dtype):
],
)
def test_fillna_interval(self, index_or_series, fill_val):
- ii = pd.interval_range(1.0, 5.0, closed="right").insert(1, np.nan)
+ ii = pd.interval_range(1.0, 5.0, inclusive="right").insert(1, np.nan)
assert isinstance(ii.dtype, pd.IntervalDtype)
obj = index_or_series(ii)
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index 4702b5e5c4504..3f8e4401808b7 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -1508,12 +1508,12 @@ def test_loc_getitem_interval_index(self):
def test_loc_getitem_interval_index2(self):
# GH#19977
- index = pd.interval_range(start=0, periods=3, closed="both")
+ index = pd.interval_range(start=0, periods=3, inclusive="both")
df = DataFrame(
[[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=index, columns=["A", "B", "C"]
)
- index_exp = pd.interval_range(start=0, periods=2, freq=1, closed="both")
+ index_exp = pd.interval_range(start=0, periods=2, freq=1, inclusive="both")
expected = Series([1, 4], index=index_exp, name="A")
result = df.loc[1, "A"]
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/io/excel/test_writers.py b/pandas/tests/io/excel/test_writers.py
index e475c9a4c6145..26c283a7dcc45 100644
--- a/pandas/tests/io/excel/test_writers.py
+++ b/pandas/tests/io/excel/test_writers.py
@@ -282,7 +282,10 @@ def test_multiindex_interval_datetimes(self, ext):
[
range(4),
pd.interval_range(
- start=pd.Timestamp("2020-01-01"), periods=4, freq="6M"
+ start=pd.Timestamp("2020-01-01"),
+ periods=4,
+ freq="6M",
+ inclusive="right",
),
]
)
diff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py
index 992f67c2affc6..1e84a05e2ae97 100644
--- a/pandas/tests/series/indexing/test_setitem.py
+++ b/pandas/tests/series/indexing/test_setitem.py
@@ -779,7 +779,7 @@ def test_index_putmask(self, obj, key, expected, val):
pytest.param(
# GH#45568 setting a valid NA value into IntervalDtype[int] should
# cast to IntervalDtype[float]
- Series(interval_range(1, 5)),
+ Series(interval_range(1, 5, inclusive="right")),
Series(
[Interval(1, 2), np.nan, Interval(3, 4), Interval(4, 5)],
dtype="interval[float64]",
@@ -1356,7 +1356,7 @@ class TestPeriodIntervalCoercion(CoercionTest):
@pytest.fixture(
params=[
period_range("2016-01-01", periods=3, freq="D"),
- interval_range(1, 5),
+ interval_range(1, 5, inclusive="right"),
]
)
def obj(self, request):
diff --git a/pandas/tests/util/test_assert_interval_array_equal.py b/pandas/tests/util/test_assert_interval_array_equal.py
index 8cc4ade3d7e95..243f357d7298c 100644
--- a/pandas/tests/util/test_assert_interval_array_equal.py
+++ b/pandas/tests/util/test_assert_interval_array_equal.py
@@ -9,7 +9,7 @@
[
{"start": 0, "periods": 4},
{"start": 1, "periods": 5},
- {"start": 5, "end": 10, "closed": "left"},
+ {"start": 5, "end": 10, "inclusive": "left"},
],
)
def test_interval_array_equal(kwargs):
@@ -19,8 +19,8 @@ def test_interval_array_equal(kwargs):
def test_interval_array_equal_closed_mismatch():
kwargs = {"start": 0, "periods": 5}
- arr1 = interval_range(closed="left", **kwargs).values
- arr2 = interval_range(closed="right", **kwargs).values
+ arr1 = interval_range(inclusive="left", **kwargs).values
+ arr2 = interval_range(inclusive="right", **kwargs).values
msg = """\
IntervalArray are different
| - [x] xref #40245
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/46355 | 2022-03-13T16:26:36Z | 2022-04-04T20:57:36Z | 2022-04-04T20:57:36Z | 2022-05-31T16:12:54Z |
DOC: minor fixes to 1.4.2 release notes | diff --git a/doc/source/whatsnew/v1.4.2.rst b/doc/source/whatsnew/v1.4.2.rst
index 06f1f406c3816..3523f691cae8f 100644
--- a/doc/source/whatsnew/v1.4.2.rst
+++ b/doc/source/whatsnew/v1.4.2.rst
@@ -18,8 +18,8 @@ Fixed regressions
- Fixed regression in :func:`read_csv` killing python process when invalid file input was given for ``engine="c"`` (:issue:`45957`)
- Fixed memory performance regression in :meth:`Series.fillna` when called on a :class:`DataFrame` column with ``inplace=True`` (:issue:`46149`)
- Provided an alternative solution for passing custom Excel formats in :meth:`.Styler.to_excel`, which was a regression based on stricter CSS validation. Examples available in the documentation for :meth:`.Styler.format` (:issue:`46152`)
-- Fixed regression in :meth:`DataFrame.replace` when a replacement value was also a target for replacement (:issue:`46335`)
-- Fixed regression in :meth:`DataFrame.loc.__setitem__` losing :class:`MultiIndex` names if :class:`DataFrame` was empty before (:issue:`46317`)
+- Fixed regression in :meth:`DataFrame.replace` when a replacement value was also a target for replacement (:issue:`46306`)
+- Fixed regression when setting values with :meth:`DataFrame.loc` losing :class:`MultiIndex` names if :class:`DataFrame` was empty before (:issue:`46317`)
-
.. ---------------------------------------------------------------------------
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/46354 | 2022-03-13T14:30:57Z | 2022-03-15T23:11:38Z | 2022-03-15T23:11:38Z | 2022-03-16T09:06:12Z |
TST: xfail(strict=False) flaky hashtable test | diff --git a/pandas/tests/libs/test_hashtable.py b/pandas/tests/libs/test_hashtable.py
index 6af81468ef1ef..bed427da5dd12 100644
--- a/pandas/tests/libs/test_hashtable.py
+++ b/pandas/tests/libs/test_hashtable.py
@@ -246,7 +246,16 @@ def test_lookup_overflow(self, writable):
(ht.Float64HashTable, ht.Float64Vector, "float64", False),
(ht.Int64HashTable, ht.Int64Vector, "int64", False),
(ht.Int32HashTable, ht.Int32Vector, "int32", False),
- (ht.UInt64HashTable, ht.UInt64Vector, "uint64", False),
+ pytest.param(
+ ht.UInt64HashTable,
+ ht.UInt64Vector,
+ "uint64",
+ False,
+ marks=pytest.mark.xfail(
+ reason="Sometimes doesn't raise.",
+ strict=False,
+ ),
+ ),
],
)
def test_vector_resize(
| - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
Example: https://app.circleci.com/pipelines/github/pandas-dev/pandas/8766/workflows/4a9ce4f4-0e1c-49aa-b035-ffcb6334be45/jobs/39610
| https://api.github.com/repos/pandas-dev/pandas/pulls/46350 | 2022-03-12T22:56:27Z | 2022-03-15T22:39:08Z | 2022-03-15T22:39:08Z | 2022-03-16T00:31:54Z |
PERF: Index[StringArray] | diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index b5432f0d1346c..f3db5598e306c 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -42,10 +42,10 @@
ExtensionArray,
FloatingArray,
IntegerArray,
- PandasArray,
)
from pandas.core.arrays.floating import FloatingDtype
from pandas.core.arrays.integer import IntegerDtype
+from pandas.core.arrays.numpy_ import PandasArray
from pandas.core.construction import extract_array
from pandas.core.indexers import check_array_indexer
from pandas.core.missing import isna
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index c673848bc022a..6005ce1fe836c 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -147,6 +147,7 @@
validate_tz_from_dtype,
)
from pandas.core.arrays.sparse import SparseDtype
+from pandas.core.arrays.string_ import StringArray
from pandas.core.base import (
IndexOpsMixin,
PandasObject,
@@ -5032,7 +5033,11 @@ def _get_engine_target(self) -> ArrayLike:
Get the ndarray or ExtensionArray that we can pass to the IndexEngine
constructor.
"""
- return self._values
+ vals = self._values
+ if isinstance(vals, StringArray):
+ # GH#45652 much more performant than ExtensionEngine
+ return vals._ndarray
+ return vals
def _from_join_target(self, result: np.ndarray) -> ArrayLike:
"""
| - [x] closes #45652 (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
bandaid until we can improve perf in ExtensionEngine | https://api.github.com/repos/pandas-dev/pandas/pulls/46349 | 2022-03-12T22:32:11Z | 2022-03-15T23:40:38Z | 2022-03-15T23:40:38Z | 2022-03-15T23:41:17Z |
Fix snappy version | diff --git a/ci/deps/actions-310.yaml b/ci/deps/actions-310.yaml
index 8f333c72f002c..37e7ea04a348a 100644
--- a/ci/deps/actions-310.yaml
+++ b/ci/deps/actions-310.yaml
@@ -42,10 +42,10 @@ dependencies:
- pytables
- pyarrow
- pyreadstat
+ - python-snappy
- pyxlsb
- s3fs
- scipy
- - snappy
- sqlalchemy
- tabulate
- xarray
diff --git a/ci/deps/actions-38-downstream_compat.yaml b/ci/deps/actions-38-downstream_compat.yaml
index 7386649f1c627..40f48884f1822 100644
--- a/ci/deps/actions-38-downstream_compat.yaml
+++ b/ci/deps/actions-38-downstream_compat.yaml
@@ -38,14 +38,14 @@ dependencies:
- odfpy
- pandas-gbq
- psycopg2
- - pymysql
- - pytables
- pyarrow
+ - pymysql
- pyreadstat
+ - pytables
+ - python-snappy
- pyxlsb
- s3fs
- scipy
- - snappy
- sqlalchemy
- tabulate
- xarray
diff --git a/ci/deps/actions-38-minimum_versions.yaml b/ci/deps/actions-38-minimum_versions.yaml
index 5726001ea1290..abba5ddd60325 100644
--- a/ci/deps/actions-38-minimum_versions.yaml
+++ b/ci/deps/actions-38-minimum_versions.yaml
@@ -40,14 +40,14 @@ dependencies:
- openpyxl=3.0.3
- pandas-gbq=0.14.0
- psycopg2=2.8.4
- - pymysql=0.10.1
- - pytables=3.6.1
- pyarrow=1.0.1
+ - pymysql=0.10.1
- pyreadstat=1.1.0
+ - pytables=3.6.1
+ - python-snappy=0.6.0
- pyxlsb=1.0.6
- s3fs=0.4.0
- scipy=1.4.1
- - snappy=1.1.8
- sqlalchemy=1.4.0
- tabulate=0.8.7
- xarray=0.15.1
diff --git a/ci/deps/actions-38.yaml b/ci/deps/actions-38.yaml
index 85a25571bb9fd..9c46eca4ab989 100644
--- a/ci/deps/actions-38.yaml
+++ b/ci/deps/actions-38.yaml
@@ -37,14 +37,14 @@ dependencies:
- odfpy
- pandas-gbq
- psycopg2
- - pymysql
- - pytables
- pyarrow
+ - pymysql
- pyreadstat
+ - pytables
+ - python-snappy
- pyxlsb
- s3fs
- scipy
- - snappy
- sqlalchemy
- tabulate
- xarray
diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index 8cff9539300f0..89b647372d7bc 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -38,13 +38,13 @@ dependencies:
- pandas-gbq
- psycopg2
- pymysql
- - pytables
- pyarrow
- pyreadstat
+ - pytables
+ - python-snappy
- pyxlsb
- s3fs
- scipy
- - snappy
- sqlalchemy
- tabulate
- xarray
diff --git a/doc/source/getting_started/install.rst b/doc/source/getting_started/install.rst
index 8706292d60def..dc02460a671d6 100644
--- a/doc/source/getting_started/install.rst
+++ b/doc/source/getting_started/install.rst
@@ -411,6 +411,6 @@ Compression
Dependency Minimum Version Notes
========================= ================== =============================================================
brotli 0.7.0 Brotli compression
-snappy 1.1.8 Snappy compression
+python-snappy 0.6.0 Snappy compression
Zstandard 0.15.2 Zstandard compression
========================= ================== =============================================================
diff --git a/pandas/compat/_optional.py b/pandas/compat/_optional.py
index baae5c913c05d..e69bee5c647d8 100644
--- a/pandas/compat/_optional.py
+++ b/pandas/compat/_optional.py
@@ -35,7 +35,7 @@
"pyxlsb": "1.0.6",
"s3fs": "0.4.0",
"scipy": "1.4.1",
- "snappy": "1.1.8",
+ "snappy": "0.6.0",
"sqlalchemy": "1.4.0",
"tables": "3.6.1",
"tabulate": "0.8.7",
@@ -53,12 +53,13 @@
"bs4": "beautifulsoup4",
"bottleneck": "Bottleneck",
"brotli": "brotlipy",
+ "jinja2": "Jinja2",
"lxml.etree": "lxml",
"odf": "odfpy",
"pandas_gbq": "pandas-gbq",
- "tables": "pytables",
+ "snappy": "python-snappy",
"sqlalchemy": "SQLAlchemy",
- "jinja2": "Jinja2",
+ "tables": "pytables",
}
@@ -72,6 +73,10 @@ def get_version(module: types.ModuleType) -> str:
if module.__name__ == "brotli":
# brotli doesn't contain attributes to confirm it's version
return ""
+ if module.__name__ == "snappy":
+ # snappy doesn't contain attributes to confirm it's version
+ # See https://github.com/andrix/python-snappy/pull/119
+ return ""
raise ImportError(f"Can't determine version for {module.__name__}")
if module.__name__ == "psycopg2":
# psycopg2 appends " (dt dec pq3 ext lo64)" to it's version
| Fix for https://github.com/pandas-dev/pandas/pull/46260
- [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/46347 | 2022-03-12T21:28:08Z | 2022-03-15T22:39:43Z | 2022-03-15T22:39:43Z | 2022-03-30T10:47:12Z |
TST: Avoid stack overflow on Windows CI with recursion test | diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index bf13e6b7b4629..15f6e82419049 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -17,6 +17,7 @@
import itertools
from numbers import Number
import re
+import sys
import numpy as np
import pytest
@@ -205,8 +206,14 @@ def foo():
inference.is_list_like([])
foo()
- with tm.external_error_raised(RecursionError):
- foo()
+ rec_limit = sys.getrecursionlimit()
+ try:
+ # Limit to avoid stack overflow on Windows CI
+ sys.setrecursionlimit(100)
+ with tm.external_error_raised(RecursionError):
+ foo()
+ finally:
+ sys.setrecursionlimit(rec_limit)
def test_is_list_like_iter_is_none():
| - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
Trying to avoid this outcome: https://dev.azure.com/pandas-dev/pandas/_build/results?buildId=75264&view=logs&jobId=f64eb602-b0ed-5dcc-0a60-a7288ad39597&j=f64eb602-b0ed-5dcc-0a60-a7288ad39597&t=129bd72d-2137-55bd-1811-c4ce50c6dce8
```
.......................Windows fatal exception: stack overflow
Thread 0x0000148c (most recent call first):
File "C:\Miniconda\envs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 400 in read
File "C:\Miniconda\envs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 432 in from_io
File "C:\Miniconda\envs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 967 in _thread_receiver
File "C:\Miniconda\envs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 220 in run
File "C:\Miniconda\envs\pandas-dev\lib\site-packages\execnet\gateway_base.py", line 285 in _perform_spawn
Current thread 0x00000750 (most recent call first):
File "D:\a\1\s\pandas\tests\dtypes\test_inference.py", line 206 in foo
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/46345 | 2022-03-12T19:01:38Z | 2022-03-13T00:20:47Z | 2022-03-13T00:20:47Z | 2022-03-13T00:20:50Z |
TYP: Add typing for pd.to_timedelta, fix Timedelta operator return types | diff --git a/pandas/_libs/tslibs/timedeltas.pyi b/pandas/_libs/tslibs/timedeltas.pyi
index 9377261979be4..28c2f7db62158 100644
--- a/pandas/_libs/tslibs/timedeltas.pyi
+++ b/pandas/_libs/tslibs/timedeltas.pyi
@@ -1,19 +1,65 @@
from datetime import timedelta
from typing import (
ClassVar,
+ Literal,
Type,
TypeVar,
overload,
)
import numpy as np
-import numpy.typing as npt
from pandas._libs.tslibs import (
NaTType,
Tick,
)
+from pandas._typing import npt
+# This should be kept consistent with the keys in the dict timedelta_abbrevs
+# in pandas/_libs/tslibs/timedeltas.pyx
+UnitChoices = Literal[
+ "Y",
+ "y",
+ "M",
+ "W",
+ "w",
+ "D",
+ "d",
+ "days",
+ "day",
+ "hours",
+ "hour",
+ "hr",
+ "h",
+ "m",
+ "minute",
+ "min",
+ "minutes",
+ "t",
+ "s",
+ "seconds",
+ "sec",
+ "second",
+ "ms",
+ "milliseconds",
+ "millisecond",
+ "milli",
+ "millis",
+ "l",
+ "us",
+ "microseconds",
+ "microsecond",
+ "µs",
+ "micro",
+ "micros",
+ "u",
+ "ns",
+ "nanoseconds",
+ "nano",
+ "nanos",
+ "nanosecond",
+ "n",
+]
_S = TypeVar("_S", bound=timedelta)
def ints_to_pytimedelta(
@@ -25,7 +71,7 @@ def array_to_timedelta64(
unit: str | None = ...,
errors: str = ...,
) -> np.ndarray: ... # np.ndarray[m8ns]
-def parse_timedelta_unit(unit: str | None) -> str: ...
+def parse_timedelta_unit(unit: str | None) -> UnitChoices: ...
def delta_to_nanoseconds(delta: np.timedelta64 | timedelta | Tick) -> int: ...
class Timedelta(timedelta):
@@ -59,20 +105,20 @@ class Timedelta(timedelta):
def ceil(self: _S, freq: str) -> _S: ...
@property
def resolution_string(self) -> str: ...
- def __add__(self, other: timedelta) -> timedelta: ...
- def __radd__(self, other: timedelta) -> timedelta: ...
- def __sub__(self, other: timedelta) -> timedelta: ...
- def __rsub__(self, other: timedelta) -> timedelta: ...
- def __neg__(self) -> timedelta: ...
- def __pos__(self) -> timedelta: ...
- def __abs__(self) -> timedelta: ...
- def __mul__(self, other: float) -> timedelta: ...
- def __rmul__(self, other: float) -> timedelta: ...
+ def __add__(self, other: timedelta) -> Timedelta: ...
+ def __radd__(self, other: timedelta) -> Timedelta: ...
+ def __sub__(self, other: timedelta) -> Timedelta: ...
+ def __rsub__(self, other: timedelta) -> Timedelta: ...
+ def __neg__(self) -> Timedelta: ...
+ def __pos__(self) -> Timedelta: ...
+ def __abs__(self) -> Timedelta: ...
+ def __mul__(self, other: float) -> Timedelta: ...
+ def __rmul__(self, other: float) -> Timedelta: ...
# error: Signature of "__floordiv__" incompatible with supertype "timedelta"
@overload # type: ignore[override]
def __floordiv__(self, other: timedelta) -> int: ...
@overload
- def __floordiv__(self, other: int | float) -> timedelta: ...
+ def __floordiv__(self, other: int | float) -> Timedelta: ...
@overload
def __floordiv__(
self, other: npt.NDArray[np.timedelta64]
@@ -90,11 +136,13 @@ class Timedelta(timedelta):
@overload
def __truediv__(self, other: timedelta) -> float: ...
@overload
- def __truediv__(self, other: float) -> timedelta: ...
- def __mod__(self, other: timedelta) -> timedelta: ...
- def __divmod__(self, other: timedelta) -> tuple[int, timedelta]: ...
+ def __truediv__(self, other: float) -> Timedelta: ...
+ def __mod__(self, other: timedelta) -> Timedelta: ...
+ def __divmod__(self, other: timedelta) -> tuple[int, Timedelta]: ...
def __le__(self, other: timedelta) -> bool: ...
def __lt__(self, other: timedelta) -> bool: ...
def __ge__(self, other: timedelta) -> bool: ...
def __gt__(self, other: timedelta) -> bool: ...
def __hash__(self) -> int: ...
+ def isoformat(self) -> str: ...
+ def to_numpy(self) -> np.timedelta64: ...
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 8eaf86b3d193f..e6b27b4459aae 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -81,6 +81,7 @@ Components = collections.namedtuple(
],
)
+# This should be kept consistent with UnitChoices in pandas/_libs/tslibs/timedeltas.pyi
cdef dict timedelta_abbrevs = {
"Y": "Y",
"y": "Y",
diff --git a/pandas/_typing.py b/pandas/_typing.py
index cabf0e8275d08..2b42a0a3efb44 100644
--- a/pandas/_typing.py
+++ b/pandas/_typing.py
@@ -313,3 +313,4 @@ def closed(self) -> bool:
# datetime and NaTType
DatetimeNaTType = Union[datetime, "NaTType"]
+DateTimeErrorChoices = Literal["ignore", "raise", "coerce"]
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index 3ff6e7f09b72a..46fd1cad97440 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -39,6 +39,7 @@
from pandas._typing import (
AnyArrayLike,
ArrayLike,
+ DateTimeErrorChoices,
Timezone,
)
from pandas.util._exceptions import find_stack_level
@@ -79,6 +80,7 @@
if TYPE_CHECKING:
from pandas._libs.tslibs.nattype import NaTType
+ from pandas._libs.tslibs.timedeltas import UnitChoices
from pandas import (
DataFrame,
@@ -657,7 +659,7 @@ def _adjust_to_origin(arg, origin, unit):
@overload
def to_datetime(
arg: DatetimeScalar,
- errors: str = ...,
+ errors: DateTimeErrorChoices = ...,
dayfirst: bool = ...,
yearfirst: bool = ...,
utc: bool | None = ...,
@@ -674,7 +676,7 @@ def to_datetime(
@overload
def to_datetime(
arg: Series | DictConvertible,
- errors: str = ...,
+ errors: DateTimeErrorChoices = ...,
dayfirst: bool = ...,
yearfirst: bool = ...,
utc: bool | None = ...,
@@ -691,7 +693,7 @@ def to_datetime(
@overload
def to_datetime(
arg: list | tuple | Index | ArrayLike,
- errors: str = ...,
+ errors: DateTimeErrorChoices = ...,
dayfirst: bool = ...,
yearfirst: bool = ...,
utc: bool | None = ...,
@@ -707,7 +709,7 @@ def to_datetime(
def to_datetime(
arg: DatetimeScalarOrArrayConvertible | DictConvertible,
- errors: str = "raise",
+ errors: DateTimeErrorChoices = "raise",
dayfirst: bool = False,
yearfirst: bool = False,
utc: bool | None = None,
@@ -1148,7 +1150,7 @@ def to_datetime(
}
-def _assemble_from_unit_mappings(arg, errors, tz):
+def _assemble_from_unit_mappings(arg, errors: DateTimeErrorChoices, tz):
"""
assemble the unit specified fields from the arg (DataFrame)
Return a Series for actual parsing
@@ -1228,7 +1230,8 @@ def coerce(values):
except (TypeError, ValueError) as err:
raise ValueError(f"cannot assemble the datetimes: {err}") from err
- for u in ["h", "m", "s", "ms", "us", "ns"]:
+ units: list[UnitChoices] = ["h", "m", "s", "ms", "us", "ns"]
+ for u in units:
value = unit_rev.get(u)
if value is not None and value in arg:
try:
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index 81b2be4e10e62..720d02f0cf59e 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -3,6 +3,12 @@
"""
from __future__ import annotations
+from datetime import timedelta
+from typing import (
+ TYPE_CHECKING,
+ overload,
+)
+
import numpy as np
from pandas._libs import lib
@@ -23,8 +29,61 @@
from pandas.core.arrays.timedeltas import sequence_to_td64ns
-
-def to_timedelta(arg, unit=None, errors="raise"):
+if TYPE_CHECKING:
+ from pandas._libs.tslibs.timedeltas import UnitChoices
+ from pandas._typing import (
+ ArrayLike,
+ DateTimeErrorChoices,
+ )
+
+ from pandas import (
+ Index,
+ Series,
+ TimedeltaIndex,
+ )
+
+
+@overload
+def to_timedelta(
+ arg: str | int | float | timedelta,
+ unit: UnitChoices | None = ...,
+ errors: DateTimeErrorChoices = ...,
+) -> Timedelta:
+ ...
+
+
+@overload
+def to_timedelta(
+ arg: Series,
+ unit: UnitChoices | None = ...,
+ errors: DateTimeErrorChoices = ...,
+) -> Series:
+ ...
+
+
+@overload
+def to_timedelta(
+ arg: list | tuple | range | ArrayLike | Index,
+ unit: UnitChoices | None = ...,
+ errors: DateTimeErrorChoices = ...,
+) -> TimedeltaIndex:
+ ...
+
+
+def to_timedelta(
+ arg: str
+ | int
+ | float
+ | timedelta
+ | list
+ | tuple
+ | range
+ | ArrayLike
+ | Index
+ | Series,
+ unit: UnitChoices | None = None,
+ errors: DateTimeErrorChoices = "raise",
+) -> Timedelta | TimedeltaIndex | Series:
"""
Convert argument to timedelta.
@@ -133,7 +192,11 @@ def to_timedelta(arg, unit=None, errors="raise"):
return _convert_listlike(arg, unit=unit, errors=errors, name=arg.name)
elif isinstance(arg, np.ndarray) and arg.ndim == 0:
# extract array scalar and process below
- arg = lib.item_from_zerodim(arg)
+ # error: Incompatible types in assignment (expression has type "object",
+ # variable has type "Union[str, int, float, timedelta, List[Any],
+ # Tuple[Any, ...], Union[Union[ExtensionArray, ndarray[Any, Any]], Index,
+ # Series]]") [assignment]
+ arg = lib.item_from_zerodim(arg) # type: ignore[assignment]
elif is_list_like(arg) and getattr(arg, "ndim", 1) == 1:
return _convert_listlike(arg, unit=unit, errors=errors)
elif getattr(arg, "ndim", 1) > 1:
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index e004e9c1ecbcc..0bb27334e1651 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -25,7 +25,10 @@
import numpy as np
import pandas._libs.lib as lib
-from pandas._typing import DtypeArg
+from pandas._typing import (
+ DateTimeErrorChoices,
+ DtypeArg,
+)
from pandas.compat._optional import import_optional_dependency
from pandas.errors import AbstractMethodError
from pandas.util._exceptions import find_stack_level
@@ -86,7 +89,7 @@ def _handle_date_column(
# read_sql like functions.
# Format can take on custom to_datetime argument values such as
# {"errors": "coerce"} or {"dayfirst": True}
- error = format.pop("errors", None) or "ignore"
+ error: DateTimeErrorChoices = format.pop("errors", None) or "ignore"
return to_datetime(col, errors=error, **format)
else:
# Allow passing of formatting string for integers
| Add typing for pd.to_timedelta
Change operators on `Timedelta` to return `Timedelta` rather than `timedelta`
| https://api.github.com/repos/pandas-dev/pandas/pulls/46343 | 2022-03-12T18:43:38Z | 2022-03-16T01:07:03Z | 2022-03-16T01:07:03Z | 2023-02-13T21:02:37Z |
PERF: use bisect_right_i8 in vectorized | diff --git a/pandas/_libs/tslibs/vectorized.pyx b/pandas/_libs/tslibs/vectorized.pyx
index bc254b6c5a5cf..0704edb3c5724 100644
--- a/pandas/_libs/tslibs/vectorized.pyx
+++ b/pandas/_libs/tslibs/vectorized.pyx
@@ -9,12 +9,15 @@ from cpython.datetime cimport (
import numpy as np
+cimport numpy as cnp
from numpy cimport (
int64_t,
intp_t,
ndarray,
)
+cnp.import_array()
+
from .conversion cimport normalize_i8_stamp
from .dtypes import Resolution
@@ -35,52 +38,13 @@ from .timezones cimport (
is_tzlocal,
is_utc,
)
-from .tzconversion cimport tz_convert_utc_to_tzlocal
+from .tzconversion cimport (
+ bisect_right_i8,
+ tz_convert_utc_to_tzlocal,
+)
# -------------------------------------------------------------------------
-cdef inline object create_datetime_from_ts(
- int64_t value,
- npy_datetimestruct dts,
- tzinfo tz,
- object freq,
- bint fold,
-):
- """
- Convenience routine to construct a datetime.datetime from its parts.
- """
- return datetime(
- dts.year, dts.month, dts.day, dts.hour, dts.min, dts.sec, dts.us,
- tz, fold=fold,
- )
-
-
-cdef inline object create_date_from_ts(
- int64_t value,
- npy_datetimestruct dts,
- tzinfo tz,
- object freq,
- bint fold
-):
- """
- Convenience routine to construct a datetime.date from its parts.
- """
- # GH#25057 add fold argument to match other func_create signatures
- return date(dts.year, dts.month, dts.day)
-
-
-cdef inline object create_time_from_ts(
- int64_t value,
- npy_datetimestruct dts,
- tzinfo tz,
- object freq,
- bint fold
-):
- """
- Convenience routine to construct a datetime.time from its parts.
- """
- return time(dts.hour, dts.min, dts.sec, dts.us, tz, fold=fold)
-
@cython.wraparound(False)
@cython.boundscheck(False)
@@ -119,29 +83,29 @@ def ints_to_pydatetime(
ndarray[object] of type specified by box
"""
cdef:
- Py_ssize_t i, n = len(stamps)
+ Py_ssize_t i, ntrans =- 1, n = len(stamps)
ndarray[int64_t] trans
int64_t[::1] deltas
- intp_t[:] pos
+ int64_t* tdata = NULL
+ intp_t pos
npy_datetimestruct dts
object dt, new_tz
str typ
int64_t value, local_val, delta = NPY_NAT # dummy for delta
ndarray[object] result = np.empty(n, dtype=object)
- object (*func_create)(int64_t, npy_datetimestruct, tzinfo, object, bint)
bint use_utc = False, use_tzlocal = False, use_fixed = False
bint use_pytz = False
+ bint use_date = False, use_time = False, use_ts = False, use_pydt = False
if box == "date":
assert (tz is None), "tz should be None when converting to date"
-
- func_create = create_date_from_ts
+ use_date = True
elif box == "timestamp":
- func_create = create_timestamp_from_ts
+ use_ts = True
elif box == "time":
- func_create = create_time_from_ts
+ use_time = True
elif box == "datetime":
- func_create = create_datetime_from_ts
+ use_pydt = True
else:
raise ValueError(
"box must be one of 'datetime', 'date', 'time' or 'timestamp'"
@@ -153,12 +117,13 @@ def ints_to_pydatetime(
use_tzlocal = True
else:
trans, deltas, typ = get_dst_info(tz)
+ ntrans = trans.shape[0]
if typ not in ["pytz", "dateutil"]:
# static/fixed; in this case we know that len(delta) == 1
use_fixed = True
delta = deltas[0]
else:
- pos = trans.searchsorted(stamps, side="right") - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
use_pytz = typ == "pytz"
for i in range(n):
@@ -176,14 +141,26 @@ def ints_to_pydatetime(
elif use_fixed:
local_val = value + delta
else:
- local_val = value + deltas[pos[i]]
+ pos = bisect_right_i8(tdata, value, ntrans) - 1
+ local_val = value + deltas[pos]
- if use_pytz:
- # find right representation of dst etc in pytz timezone
- new_tz = tz._tzinfos[tz._transition_info[pos[i]]]
+ if use_pytz:
+ # find right representation of dst etc in pytz timezone
+ new_tz = tz._tzinfos[tz._transition_info[pos]]
dt64_to_dtstruct(local_val, &dts)
- result[i] = func_create(value, dts, new_tz, freq, fold)
+
+ if use_ts:
+ result[i] = create_timestamp_from_ts(value, dts, new_tz, freq, fold)
+ elif use_pydt:
+ result[i] = datetime(
+ dts.year, dts.month, dts.day, dts.hour, dts.min, dts.sec, dts.us,
+ new_tz, fold=fold,
+ )
+ elif use_date:
+ result[i] = date(dts.year, dts.month, dts.day)
+ else:
+ result[i] = time(dts.hour, dts.min, dts.sec, dts.us, new_tz, fold=fold)
return result
@@ -219,12 +196,13 @@ cdef inline int _reso_stamp(npy_datetimestruct *dts):
def get_resolution(const int64_t[:] stamps, tzinfo tz=None) -> Resolution:
cdef:
- Py_ssize_t i, n = len(stamps)
+ Py_ssize_t i, ntrans=-1, n = len(stamps)
npy_datetimestruct dts
int reso = RESO_DAY, curr_reso
ndarray[int64_t] trans
int64_t[::1] deltas
- intp_t[:] pos
+ int64_t* tdata = NULL
+ intp_t pos
int64_t local_val, delta = NPY_NAT
bint use_utc = False, use_tzlocal = False, use_fixed = False
@@ -234,12 +212,13 @@ def get_resolution(const int64_t[:] stamps, tzinfo tz=None) -> Resolution:
use_tzlocal = True
else:
trans, deltas, typ = get_dst_info(tz)
+ ntrans = trans.shape[0]
if typ not in ["pytz", "dateutil"]:
# static/fixed; in this case we know that len(delta) == 1
use_fixed = True
delta = deltas[0]
else:
- pos = trans.searchsorted(stamps, side="right") - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
for i in range(n):
if stamps[i] == NPY_NAT:
@@ -252,7 +231,8 @@ def get_resolution(const int64_t[:] stamps, tzinfo tz=None) -> Resolution:
elif use_fixed:
local_val = stamps[i] + delta
else:
- local_val = stamps[i] + deltas[pos[i]]
+ pos = bisect_right_i8(tdata, stamps[i], ntrans) - 1
+ local_val = stamps[i] + deltas[pos]
dt64_to_dtstruct(local_val, &dts)
curr_reso = _reso_stamp(&dts)
@@ -282,12 +262,13 @@ cpdef ndarray[int64_t] normalize_i8_timestamps(const int64_t[:] stamps, tzinfo t
result : int64 ndarray of converted of normalized nanosecond timestamps
"""
cdef:
- Py_ssize_t i, n = len(stamps)
+ Py_ssize_t i, ntrans =- 1, n = len(stamps)
int64_t[:] result = np.empty(n, dtype=np.int64)
ndarray[int64_t] trans
int64_t[::1] deltas
+ int64_t* tdata = NULL
str typ
- Py_ssize_t[:] pos
+ Py_ssize_t pos
int64_t local_val, delta = NPY_NAT
bint use_utc = False, use_tzlocal = False, use_fixed = False
@@ -297,12 +278,13 @@ cpdef ndarray[int64_t] normalize_i8_timestamps(const int64_t[:] stamps, tzinfo t
use_tzlocal = True
else:
trans, deltas, typ = get_dst_info(tz)
+ ntrans = trans.shape[0]
if typ not in ["pytz", "dateutil"]:
# static/fixed; in this case we know that len(delta) == 1
use_fixed = True
delta = deltas[0]
else:
- pos = trans.searchsorted(stamps, side="right") - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
for i in range(n):
if stamps[i] == NPY_NAT:
@@ -316,7 +298,8 @@ cpdef ndarray[int64_t] normalize_i8_timestamps(const int64_t[:] stamps, tzinfo t
elif use_fixed:
local_val = stamps[i] + delta
else:
- local_val = stamps[i] + deltas[pos[i]]
+ pos = bisect_right_i8(tdata, stamps[i], ntrans) - 1
+ local_val = stamps[i] + deltas[pos]
result[i] = normalize_i8_stamp(local_val)
@@ -341,10 +324,11 @@ def is_date_array_normalized(const int64_t[:] stamps, tzinfo tz=None) -> bool:
is_normalized : bool True if all stamps are normalized
"""
cdef:
- Py_ssize_t i, n = len(stamps)
+ Py_ssize_t i, ntrans =- 1, n = len(stamps)
ndarray[int64_t] trans
int64_t[::1] deltas
- intp_t[:] pos
+ int64_t* tdata = NULL
+ intp_t pos
int64_t local_val, delta = NPY_NAT
str typ
int64_t day_nanos = 24 * 3600 * 1_000_000_000
@@ -356,12 +340,13 @@ def is_date_array_normalized(const int64_t[:] stamps, tzinfo tz=None) -> bool:
use_tzlocal = True
else:
trans, deltas, typ = get_dst_info(tz)
+ ntrans = trans.shape[0]
if typ not in ["pytz", "dateutil"]:
# static/fixed; in this case we know that len(delta) == 1
use_fixed = True
delta = deltas[0]
else:
- pos = trans.searchsorted(stamps, side="right") - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
for i in range(n):
if use_utc:
@@ -371,7 +356,8 @@ def is_date_array_normalized(const int64_t[:] stamps, tzinfo tz=None) -> bool:
elif use_fixed:
local_val = stamps[i] + delta
else:
- local_val = stamps[i] + deltas[pos[i]]
+ pos = bisect_right_i8(tdata, stamps[i], ntrans) - 1
+ local_val = stamps[i] + deltas[pos]
if local_val % day_nanos != 0:
return False
@@ -386,11 +372,12 @@ def is_date_array_normalized(const int64_t[:] stamps, tzinfo tz=None) -> bool:
@cython.boundscheck(False)
def dt64arr_to_periodarr(const int64_t[:] stamps, int freq, tzinfo tz):
cdef:
- Py_ssize_t i, n = len(stamps)
+ Py_ssize_t i, ntrans =- 1, n = len(stamps)
int64_t[:] result = np.empty(n, dtype=np.int64)
ndarray[int64_t] trans
int64_t[::1] deltas
- Py_ssize_t[:] pos
+ int64_t* tdata = NULL
+ intp_t pos
npy_datetimestruct dts
int64_t local_val, delta = NPY_NAT
bint use_utc = False, use_tzlocal = False, use_fixed = False
@@ -401,12 +388,13 @@ def dt64arr_to_periodarr(const int64_t[:] stamps, int freq, tzinfo tz):
use_tzlocal = True
else:
trans, deltas, typ = get_dst_info(tz)
+ ntrans = trans.shape[0]
if typ not in ["pytz", "dateutil"]:
# static/fixed; in this case we know that len(delta) == 1
use_fixed = True
delta = deltas[0]
else:
- pos = trans.searchsorted(stamps, side="right") - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
for i in range(n):
if stamps[i] == NPY_NAT:
@@ -420,7 +408,8 @@ def dt64arr_to_periodarr(const int64_t[:] stamps, int freq, tzinfo tz):
elif use_fixed:
local_val = stamps[i] + delta
else:
- local_val = stamps[i] + deltas[pos[i]]
+ pos = bisect_right_i8(tdata, stamps[i], ntrans) - 1
+ local_val = stamps[i] + deltas[pos]
dt64_to_dtstruct(local_val, &dts)
result[i] = get_period_ordinal(&dts, freq)
| - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/46341 | 2022-03-12T16:15:36Z | 2022-03-15T22:40:02Z | 2022-03-15T22:40:02Z | 2022-03-15T23:40:34Z |
Backport PR #46335 on branch 1.4.x (BUG: replace with value also being replaced) | diff --git a/doc/source/whatsnew/v1.4.2.rst b/doc/source/whatsnew/v1.4.2.rst
index 2bdbeb0ab6991..06f1f406c3816 100644
--- a/doc/source/whatsnew/v1.4.2.rst
+++ b/doc/source/whatsnew/v1.4.2.rst
@@ -18,6 +18,7 @@ Fixed regressions
- Fixed regression in :func:`read_csv` killing python process when invalid file input was given for ``engine="c"`` (:issue:`45957`)
- Fixed memory performance regression in :meth:`Series.fillna` when called on a :class:`DataFrame` column with ``inplace=True`` (:issue:`46149`)
- Provided an alternative solution for passing custom Excel formats in :meth:`.Styler.to_excel`, which was a regression based on stricter CSS validation. Examples available in the documentation for :meth:`.Styler.format` (:issue:`46152`)
+- Fixed regression in :meth:`DataFrame.replace` when a replacement value was also a target for replacement (:issue:`46335`)
- Fixed regression in :meth:`DataFrame.loc.__setitem__` losing :class:`MultiIndex` names if :class:`DataFrame` was empty before (:issue:`46317`)
-
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 5810f3515c4ae..e0df274fbc596 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -708,9 +708,18 @@ def replace(
else:
# split so that we only upcast where necessary
- return self.split_and_operate(
- type(self).replace, to_replace, value, inplace=True
- )
+ blocks = []
+ for i, nb in enumerate(self._split()):
+ blocks.extend(
+ type(self).replace(
+ nb,
+ to_replace=to_replace,
+ value=value,
+ inplace=True,
+ mask=mask[i : i + 1],
+ )
+ )
+ return blocks
@final
def _replace_regex(
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index b9024b4233d7f..4393dbacc6fcf 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -1519,3 +1519,10 @@ def test_replace_regex_dtype_frame(self, regex):
expected_df2 = DataFrame({"A": [1], "B": ["1"]})
result_df2 = df2.replace(to_replace="0", value=1, regex=regex)
tm.assert_frame_equal(result_df2, expected_df2)
+
+ def test_replace_with_value_also_being_replaced(self):
+ # GH46306
+ df = DataFrame({"A": [0, 1, 2], "B": [1, 0, 2]})
+ result = df.replace({0: 1, 1: np.nan})
+ expected = DataFrame({"A": [1, np.nan, 2], "B": [np.nan, 1, 2]})
+ tm.assert_frame_equal(result, expected)
| Backport PR #46335: BUG: replace with value also being replaced | https://api.github.com/repos/pandas-dev/pandas/pulls/46340 | 2022-03-12T15:11:50Z | 2022-03-12T16:38:55Z | 2022-03-12T16:38:55Z | 2022-03-12T16:38:55Z |
REF: de-duplicate hard-coded unit code | diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index 5c852e85efdc0..063b95953bd91 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -243,7 +243,7 @@ def array_with_unit_to_datetime(
)
return result, tz
- m, p = precision_from_unit(unit)
+ m, _ = precision_from_unit(unit)
if is_raise:
# try a quick conversion to i8/f8
diff --git a/pandas/_libs/tslibs/dtypes.pxd b/pandas/_libs/tslibs/dtypes.pxd
index ae25de38c5bfd..3686ee216b546 100644
--- a/pandas/_libs/tslibs/dtypes.pxd
+++ b/pandas/_libs/tslibs/dtypes.pxd
@@ -1,7 +1,13 @@
+from pandas._libs.tslibs.np_datetime cimport NPY_DATETIMEUNIT
+
+
+cdef str npy_unit_to_abbrev(NPY_DATETIMEUNIT unit)
+cdef NPY_DATETIMEUNIT freq_group_code_to_npy_unit(int freq) nogil
+
cdef dict attrname_to_abbrevs
cdef enum c_FreqGroup:
- # Mirrors FreqGroup in the .pxy file
+ # Mirrors FreqGroup in the .pyx file
FR_ANN = 1000
FR_QTR = 2000
FR_MTH = 3000
@@ -17,6 +23,20 @@ cdef enum c_FreqGroup:
FR_UND = -10000 # undefined
+cdef enum c_Resolution:
+ # Mirrors Resolution in the .pyx file
+ RESO_NS = 0
+ RESO_US = 1
+ RESO_MS = 2
+ RESO_SEC = 3
+ RESO_MIN = 4
+ RESO_HR = 5
+ RESO_DAY = 6
+ RESO_MTH = 7
+ RESO_QTR = 8
+ RESO_YR = 9
+
+
cdef enum PeriodDtypeCode:
# Annual freqs with various fiscal year ends.
# eg, 2005 for A_FEB runs Mar 1, 2004 to Feb 28, 2005
diff --git a/pandas/_libs/tslibs/dtypes.pyi b/pandas/_libs/tslibs/dtypes.pyi
index 8c642bc847a29..ab66677a8be3a 100644
--- a/pandas/_libs/tslibs/dtypes.pyi
+++ b/pandas/_libs/tslibs/dtypes.pyi
@@ -2,6 +2,8 @@ from enum import Enum
from pandas._libs.tslibs.offsets import BaseOffset
+# These are not public API, but are exposed in the .pyi file because they
+# are imported in tests.
_attrname_to_abbrevs: dict[str, str]
_period_code_map: dict[str, int]
@@ -10,13 +12,11 @@ class PeriodDtypeBase:
# actually __cinit__
def __new__(cls, code: int): ...
- def freq_group_code(self) -> int: ...
- def date_offset(self) -> BaseOffset: ...
- @classmethod
- def from_date_offset(cls, offset: BaseOffset) -> PeriodDtypeBase: ...
+ def _freq_group_code(self) -> int: ...
@property
- def resolution(self) -> Resolution: ...
+ def _resolution_obj(self) -> Resolution: ...
def _get_to_timestamp_base(self) -> int: ...
+ def _freqstr(self) -> str: ...
class FreqGroup(Enum):
FR_ANN: int
@@ -33,7 +33,7 @@ class FreqGroup(Enum):
FR_NS: int
FR_UND: int
@staticmethod
- def get_freq_group(code: int) -> FreqGroup: ...
+ def from_period_dtype_code(code: int) -> FreqGroup: ...
class Resolution(Enum):
RESO_NS: int
@@ -49,10 +49,10 @@ class Resolution(Enum):
def __lt__(self, other: Resolution) -> bool: ...
def __ge__(self, other: Resolution) -> bool: ...
@property
- def freq_group(self) -> FreqGroup: ...
- @property
def attrname(self) -> str: ...
@classmethod
def from_attrname(cls, attrname: str) -> Resolution: ...
@classmethod
- def get_reso_from_freq(cls, freq: str) -> Resolution: ...
+ def get_reso_from_freqstr(cls, freq: str) -> Resolution: ...
+ @property
+ def attr_abbrev(self) -> str: ...
diff --git a/pandas/_libs/tslibs/dtypes.pyx b/pandas/_libs/tslibs/dtypes.pyx
index b64a360510ab9..43f33b98b8eaa 100644
--- a/pandas/_libs/tslibs/dtypes.pyx
+++ b/pandas/_libs/tslibs/dtypes.pyx
@@ -2,6 +2,8 @@
# originals
from enum import Enum
+from pandas._libs.tslibs.np_datetime cimport NPY_DATETIMEUNIT
+
cdef class PeriodDtypeBase:
"""
@@ -23,32 +25,24 @@ cdef class PeriodDtypeBase:
return self._dtype_code == other._dtype_code
@property
- def freq_group_code(self) -> int:
+ def _freq_group_code(self) -> int:
# See also: libperiod.get_freq_group
return (self._dtype_code // 1000) * 1000
@property
- def resolution(self) -> "Resolution":
- fgc = self.freq_group_code
- return Resolution.from_freq_group(FreqGroup(fgc))
+ def _resolution_obj(self) -> "Resolution":
+ fgc = self._freq_group_code
+ freq_group = FreqGroup(fgc)
+ abbrev = _reverse_period_code_map[freq_group.value].split("-")[0]
+ if abbrev == "B":
+ return Resolution.RESO_DAY
+ attrname = _abbrev_to_attrnames[abbrev]
+ return Resolution.from_attrname(attrname)
@property
- def date_offset(self):
- """
- Corresponding DateOffset object.
-
- This mapping is mainly for backward-compatibility.
- """
- from .offsets import to_offset
-
- freqstr = _reverse_period_code_map.get(self._dtype_code)
-
- return to_offset(freqstr)
-
- @classmethod
- def from_date_offset(cls, offset):
- code = offset._period_dtype_code
- return cls(code)
+ def _freqstr(self) -> str:
+ # Will be passed to to_offset in Period._maybe_convert_freq
+ return _reverse_period_code_map.get(self._dtype_code)
cpdef int _get_to_timestamp_base(self):
"""
@@ -73,52 +67,52 @@ cdef class PeriodDtypeBase:
_period_code_map = {
# Annual freqs with various fiscal year ends.
# eg, 2005 for A-FEB runs Mar 1, 2004 to Feb 28, 2005
- "A-DEC": 1000, # Annual - December year end
- "A-JAN": 1001, # Annual - January year end
- "A-FEB": 1002, # Annual - February year end
- "A-MAR": 1003, # Annual - March year end
- "A-APR": 1004, # Annual - April year end
- "A-MAY": 1005, # Annual - May year end
- "A-JUN": 1006, # Annual - June year end
- "A-JUL": 1007, # Annual - July year end
- "A-AUG": 1008, # Annual - August year end
- "A-SEP": 1009, # Annual - September year end
- "A-OCT": 1010, # Annual - October year end
- "A-NOV": 1011, # Annual - November year end
+ "A-DEC": PeriodDtypeCode.A_DEC, # Annual - December year end
+ "A-JAN": PeriodDtypeCode.A_JAN, # Annual - January year end
+ "A-FEB": PeriodDtypeCode.A_FEB, # Annual - February year end
+ "A-MAR": PeriodDtypeCode.A_MAR, # Annual - March year end
+ "A-APR": PeriodDtypeCode.A_APR, # Annual - April year end
+ "A-MAY": PeriodDtypeCode.A_MAY, # Annual - May year end
+ "A-JUN": PeriodDtypeCode.A_JUN, # Annual - June year end
+ "A-JUL": PeriodDtypeCode.A_JUL, # Annual - July year end
+ "A-AUG": PeriodDtypeCode.A_AUG, # Annual - August year end
+ "A-SEP": PeriodDtypeCode.A_SEP, # Annual - September year end
+ "A-OCT": PeriodDtypeCode.A_OCT, # Annual - October year end
+ "A-NOV": PeriodDtypeCode.A_NOV, # Annual - November year end
# Quarterly frequencies with various fiscal year ends.
# eg, Q42005 for Q-OCT runs Aug 1, 2005 to Oct 31, 2005
- "Q-DEC": 2000, # Quarterly - December year end
- "Q-JAN": 2001, # Quarterly - January year end
- "Q-FEB": 2002, # Quarterly - February year end
- "Q-MAR": 2003, # Quarterly - March year end
- "Q-APR": 2004, # Quarterly - April year end
- "Q-MAY": 2005, # Quarterly - May year end
- "Q-JUN": 2006, # Quarterly - June year end
- "Q-JUL": 2007, # Quarterly - July year end
- "Q-AUG": 2008, # Quarterly - August year end
- "Q-SEP": 2009, # Quarterly - September year end
- "Q-OCT": 2010, # Quarterly - October year end
- "Q-NOV": 2011, # Quarterly - November year end
-
- "M": 3000, # Monthly
-
- "W-SUN": 4000, # Weekly - Sunday end of week
- "W-MON": 4001, # Weekly - Monday end of week
- "W-TUE": 4002, # Weekly - Tuesday end of week
- "W-WED": 4003, # Weekly - Wednesday end of week
- "W-THU": 4004, # Weekly - Thursday end of week
- "W-FRI": 4005, # Weekly - Friday end of week
- "W-SAT": 4006, # Weekly - Saturday end of week
-
- "B": 5000, # Business days
- "D": 6000, # Daily
- "H": 7000, # Hourly
- "T": 8000, # Minutely
- "S": 9000, # Secondly
- "L": 10000, # Millisecondly
- "U": 11000, # Microsecondly
- "N": 12000, # Nanosecondly
+ "Q-DEC": PeriodDtypeCode.Q_DEC, # Quarterly - December year end
+ "Q-JAN": PeriodDtypeCode.Q_JAN, # Quarterly - January year end
+ "Q-FEB": PeriodDtypeCode.Q_FEB, # Quarterly - February year end
+ "Q-MAR": PeriodDtypeCode.Q_MAR, # Quarterly - March year end
+ "Q-APR": PeriodDtypeCode.Q_APR, # Quarterly - April year end
+ "Q-MAY": PeriodDtypeCode.Q_MAY, # Quarterly - May year end
+ "Q-JUN": PeriodDtypeCode.Q_JUN, # Quarterly - June year end
+ "Q-JUL": PeriodDtypeCode.Q_JUL, # Quarterly - July year end
+ "Q-AUG": PeriodDtypeCode.Q_AUG, # Quarterly - August year end
+ "Q-SEP": PeriodDtypeCode.Q_SEP, # Quarterly - September year end
+ "Q-OCT": PeriodDtypeCode.Q_OCT, # Quarterly - October year end
+ "Q-NOV": PeriodDtypeCode.Q_NOV, # Quarterly - November year end
+
+ "M": PeriodDtypeCode.M, # Monthly
+
+ "W-SUN": PeriodDtypeCode.W_SUN, # Weekly - Sunday end of week
+ "W-MON": PeriodDtypeCode.W_MON, # Weekly - Monday end of week
+ "W-TUE": PeriodDtypeCode.W_TUE, # Weekly - Tuesday end of week
+ "W-WED": PeriodDtypeCode.W_WED, # Weekly - Wednesday end of week
+ "W-THU": PeriodDtypeCode.W_THU, # Weekly - Thursday end of week
+ "W-FRI": PeriodDtypeCode.W_FRI, # Weekly - Friday end of week
+ "W-SAT": PeriodDtypeCode.W_SAT, # Weekly - Saturday end of week
+
+ "B": PeriodDtypeCode.B, # Business days
+ "D": PeriodDtypeCode.D, # Daily
+ "H": PeriodDtypeCode.H, # Hourly
+ "T": PeriodDtypeCode.T, # Minutely
+ "S": PeriodDtypeCode.S, # Secondly
+ "L": PeriodDtypeCode.L, # Millisecondly
+ "U": PeriodDtypeCode.U, # Microsecondly
+ "N": PeriodDtypeCode.N, # Nanosecondly
}
_reverse_period_code_map = {
@@ -131,7 +125,7 @@ _period_code_map.update({"Y" + key[1:]: _period_code_map[key]
_period_code_map.update({
"Q": 2000, # Quarterly - December year end (default quarterly)
- "A": 1000, # Annual
+ "A": PeriodDtypeCode.A, # Annual
"W": 4000, # Weekly
"C": 5000, # Custom Business Day
})
@@ -159,41 +153,38 @@ cdef dict _abbrev_to_attrnames = {v: k for k, v in attrname_to_abbrevs.items()}
class FreqGroup(Enum):
# Mirrors c_FreqGroup in the .pxd file
- FR_ANN = 1000
- FR_QTR = 2000
- FR_MTH = 3000
- FR_WK = 4000
- FR_BUS = 5000
- FR_DAY = 6000
- FR_HR = 7000
- FR_MIN = 8000
- FR_SEC = 9000
- FR_MS = 10000
- FR_US = 11000
- FR_NS = 12000
- FR_UND = -10000 # undefined
+ FR_ANN = c_FreqGroup.FR_ANN
+ FR_QTR = c_FreqGroup.FR_QTR
+ FR_MTH = c_FreqGroup.FR_MTH
+ FR_WK = c_FreqGroup.FR_WK
+ FR_BUS = c_FreqGroup.FR_BUS
+ FR_DAY = c_FreqGroup.FR_DAY
+ FR_HR = c_FreqGroup.FR_HR
+ FR_MIN = c_FreqGroup.FR_MIN
+ FR_SEC = c_FreqGroup.FR_SEC
+ FR_MS = c_FreqGroup.FR_MS
+ FR_US = c_FreqGroup.FR_US
+ FR_NS = c_FreqGroup.FR_NS
+ FR_UND = -c_FreqGroup.FR_UND # undefined
@staticmethod
- def get_freq_group(code: int) -> "FreqGroup":
- # See also: PeriodDtypeBase.freq_group_code
+ def from_period_dtype_code(code: int) -> "FreqGroup":
+ # See also: PeriodDtypeBase._freq_group_code
code = (code // 1000) * 1000
return FreqGroup(code)
class Resolution(Enum):
-
- # Note: cython won't allow us to reference the cdef versions at the
- # module level
- RESO_NS = 0
- RESO_US = 1
- RESO_MS = 2
- RESO_SEC = 3
- RESO_MIN = 4
- RESO_HR = 5
- RESO_DAY = 6
- RESO_MTH = 7
- RESO_QTR = 8
- RESO_YR = 9
+ RESO_NS = c_Resolution.RESO_NS
+ RESO_US = c_Resolution.RESO_US
+ RESO_MS = c_Resolution.RESO_MS
+ RESO_SEC = c_Resolution.RESO_SEC
+ RESO_MIN = c_Resolution.RESO_MIN
+ RESO_HR = c_Resolution.RESO_HR
+ RESO_DAY = c_Resolution.RESO_DAY
+ RESO_MTH = c_Resolution.RESO_MTH
+ RESO_QTR = c_Resolution.RESO_QTR
+ RESO_YR = c_Resolution.RESO_YR
def __lt__(self, other):
return self.value < other.value
@@ -202,29 +193,9 @@ class Resolution(Enum):
return self.value >= other.value
@property
- def freq_group(self) -> FreqGroup:
- if self == Resolution.RESO_NS:
- return FreqGroup.FR_NS
- elif self == Resolution.RESO_US:
- return FreqGroup.FR_US
- elif self == Resolution.RESO_MS:
- return FreqGroup.FR_MS
- elif self == Resolution.RESO_SEC:
- return FreqGroup.FR_SEC
- elif self == Resolution.RESO_MIN:
- return FreqGroup.FR_MIN
- elif self == Resolution.RESO_HR:
- return FreqGroup.FR_HR
- elif self == Resolution.RESO_DAY:
- return FreqGroup.FR_DAY
- elif self == Resolution.RESO_MTH:
- return FreqGroup.FR_MTH
- elif self == Resolution.RESO_QTR:
- return FreqGroup.FR_QTR
- elif self == Resolution.RESO_YR:
- return FreqGroup.FR_ANN
- else:
- raise ValueError(self) # pragma: no cover
+ def attr_abbrev(self) -> str:
+ # string that we can pass to to_offset
+ return _attrname_to_abbrevs[self.attrname]
@property
def attrname(self) -> str:
@@ -254,7 +225,7 @@ class Resolution(Enum):
return cls(_str_reso_map[attrname])
@classmethod
- def get_reso_from_freq(cls, freq: str) -> "Resolution":
+ def get_reso_from_freqstr(cls, freq: str) -> "Resolution":
"""
Return resolution code against frequency str.
@@ -262,10 +233,10 @@ class Resolution(Enum):
Examples
--------
- >>> Resolution.get_reso_from_freq('H')
+ >>> Resolution.get_reso_from_freqstr('H')
<Resolution.RESO_HR: 5>
- >>> Resolution.get_reso_from_freq('H') == Resolution.RESO_HR
+ >>> Resolution.get_reso_from_freqstr('H') == Resolution.RESO_HR
True
"""
try:
@@ -283,13 +254,57 @@ class Resolution(Enum):
return cls.from_attrname(attr_name)
- @classmethod
- def from_freq_group(cls, freq_group: FreqGroup) -> "Resolution":
- abbrev = _reverse_period_code_map[freq_group.value].split("-")[0]
- if abbrev == "B":
- return cls.RESO_DAY
- attrname = _abbrev_to_attrnames[abbrev]
- return cls.from_attrname(attrname)
+
+cdef str npy_unit_to_abbrev(NPY_DATETIMEUNIT unit):
+ if unit == NPY_DATETIMEUNIT.NPY_FR_ns or unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC:
+ # generic -> default to nanoseconds
+ return "ns"
+ elif unit == NPY_DATETIMEUNIT.NPY_FR_us:
+ return "us"
+ elif unit == NPY_DATETIMEUNIT.NPY_FR_ms:
+ return "ms"
+ elif unit == NPY_DATETIMEUNIT.NPY_FR_s:
+ return "s"
+ elif unit == NPY_DATETIMEUNIT.NPY_FR_m:
+ return "m"
+ elif unit == NPY_DATETIMEUNIT.NPY_FR_h:
+ return "h"
+ elif unit == NPY_DATETIMEUNIT.NPY_FR_D:
+ return "D"
+ elif unit == NPY_DATETIMEUNIT.NPY_FR_W:
+ return "W"
+ elif unit == NPY_DATETIMEUNIT.NPY_FR_M:
+ return "M"
+ elif unit == NPY_DATETIMEUNIT.NPY_FR_Y:
+ return "Y"
+ else:
+ raise NotImplementedError(unit)
+
+
+cdef NPY_DATETIMEUNIT freq_group_code_to_npy_unit(int freq) nogil:
+ """
+ Convert the freq to the corresponding NPY_DATETIMEUNIT to pass
+ to npy_datetimestruct_to_datetime.
+ """
+ if freq == FR_MTH:
+ return NPY_DATETIMEUNIT.NPY_FR_M
+ elif freq == FR_DAY:
+ return NPY_DATETIMEUNIT.NPY_FR_D
+ elif freq == FR_HR:
+ return NPY_DATETIMEUNIT.NPY_FR_h
+ elif freq == FR_MIN:
+ return NPY_DATETIMEUNIT.NPY_FR_m
+ elif freq == FR_SEC:
+ return NPY_DATETIMEUNIT.NPY_FR_s
+ elif freq == FR_MS:
+ return NPY_DATETIMEUNIT.NPY_FR_ms
+ elif freq == FR_US:
+ return NPY_DATETIMEUNIT.NPY_FR_us
+ elif freq == FR_NS:
+ return NPY_DATETIMEUNIT.NPY_FR_ns
+ elif freq == FR_UND:
+ # Default to Day
+ return NPY_DATETIMEUNIT.NPY_FR_D
cdef dict _reso_str_map = {
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index 54cae834d7024..9c05c6867f71f 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -95,6 +95,7 @@ from pandas._libs.tslibs.dtypes cimport (
FR_WK,
PeriodDtypeBase,
attrname_to_abbrevs,
+ freq_group_code_to_npy_unit,
)
from pandas._libs.tslibs.parsing cimport quarter_to_myear
@@ -689,8 +690,7 @@ cdef char* c_strftime(npy_datetimestruct *dts, char *fmt):
# Conversion between date_info and npy_datetimestruct
cdef inline int get_freq_group(int freq) nogil:
- # Note: this is equivalent to libfrequencies.get_freq_group, specialized
- # to integer argument.
+ # See also FreqGroup.get_freq_group
return (freq // 1000) * 1000
@@ -806,36 +806,10 @@ cdef int64_t get_period_ordinal(npy_datetimestruct *dts, int freq) nogil:
unix_date = npy_datetimestruct_to_datetime(NPY_FR_D, dts)
return DtoB(dts, 0, unix_date)
- unit = get_unit(freq)
+ unit = freq_group_code_to_npy_unit(freq)
return npy_datetimestruct_to_datetime(unit, dts)
-cdef NPY_DATETIMEUNIT get_unit(int freq) nogil:
- """
- Convert the freq to the corresponding NPY_DATETIMEUNIT to pass
- to npy_datetimestruct_to_datetime.
- """
- if freq == FR_MTH:
- return NPY_DATETIMEUNIT.NPY_FR_M
- elif freq == FR_DAY:
- return NPY_DATETIMEUNIT.NPY_FR_D
- elif freq == FR_HR:
- return NPY_DATETIMEUNIT.NPY_FR_h
- elif freq == FR_MIN:
- return NPY_DATETIMEUNIT.NPY_FR_m
- elif freq == FR_SEC:
- return NPY_DATETIMEUNIT.NPY_FR_s
- elif freq == FR_MS:
- return NPY_DATETIMEUNIT.NPY_FR_ms
- elif freq == FR_US:
- return NPY_DATETIMEUNIT.NPY_FR_us
- elif freq == FR_NS:
- return NPY_DATETIMEUNIT.NPY_FR_ns
- elif freq == FR_UND:
- # Default to Day
- return NPY_DATETIMEUNIT.NPY_FR_D
-
-
cdef void get_date_info(int64_t ordinal, int freq, npy_datetimestruct *dts) nogil:
cdef:
int64_t unix_date, nanos
@@ -1649,7 +1623,7 @@ cdef class _Period(PeriodMixin):
if isinstance(freq, int):
# We already have a dtype code
dtype = PeriodDtypeBase(freq)
- freq = dtype.date_offset
+ freq = dtype._freqstr
freq = to_offset(freq)
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 8eaf86b3d193f..e88fb42adfc78 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -36,6 +36,7 @@ from pandas._libs.tslibs.conversion cimport (
cast_from_unit,
precision_from_unit,
)
+from pandas._libs.tslibs.dtypes cimport npy_unit_to_abbrev
from pandas._libs.tslibs.nattype cimport (
NPY_NAT,
c_NaT as NaT,
@@ -192,32 +193,6 @@ cpdef int64_t delta_to_nanoseconds(delta) except? -1:
raise TypeError(type(delta))
-cdef str npy_unit_to_abbrev(NPY_DATETIMEUNIT unit):
- if unit == NPY_DATETIMEUNIT.NPY_FR_ns or unit == NPY_DATETIMEUNIT.NPY_FR_GENERIC:
- # generic -> default to nanoseconds
- return "ns"
- elif unit == NPY_DATETIMEUNIT.NPY_FR_us:
- return "us"
- elif unit == NPY_DATETIMEUNIT.NPY_FR_ms:
- return "ms"
- elif unit == NPY_DATETIMEUNIT.NPY_FR_s:
- return "s"
- elif unit == NPY_DATETIMEUNIT.NPY_FR_m:
- return "m"
- elif unit == NPY_DATETIMEUNIT.NPY_FR_h:
- return "h"
- elif unit == NPY_DATETIMEUNIT.NPY_FR_D:
- return "D"
- elif unit == NPY_DATETIMEUNIT.NPY_FR_W:
- return "W"
- elif unit == NPY_DATETIMEUNIT.NPY_FR_M:
- return "M"
- elif unit == NPY_DATETIMEUNIT.NPY_FR_Y:
- return "Y"
- else:
- raise NotImplementedError(unit)
-
-
@cython.overflowcheck(True)
cdef object ensure_td64ns(object ts):
"""
diff --git a/pandas/_libs/tslibs/vectorized.pyx b/pandas/_libs/tslibs/vectorized.pyx
index bc254b6c5a5cf..f63cb4f58609a 100644
--- a/pandas/_libs/tslibs/vectorized.pyx
+++ b/pandas/_libs/tslibs/vectorized.pyx
@@ -191,16 +191,12 @@ def ints_to_pydatetime(
# -------------------------------------------------------------------------
cdef:
- int RESO_NS = 0
- int RESO_US = 1
- int RESO_MS = 2
- int RESO_SEC = 3
- int RESO_MIN = 4
- int RESO_HR = 5
- int RESO_DAY = 6
- int RESO_MTH = 7
- int RESO_QTR = 8
- int RESO_YR = 9
+ int RESO_US = Resolution.RESO_US.value
+ int RESO_MS = Resolution.RESO_MS.value
+ int RESO_SEC = Resolution.RESO_SEC.value
+ int RESO_MIN = Resolution.RESO_MIN.value
+ int RESO_HR = Resolution.RESO_HR.value
+ int RESO_DAY = Resolution.RESO_DAY.value
cdef inline int _reso_stamp(npy_datetimestruct *dts):
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 7a7bad02fde72..d58555a49e2e6 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -956,7 +956,7 @@ def _resolution_obj(self) -> Resolution | None:
if freqstr is None:
return None
try:
- return Resolution.get_reso_from_freq(freqstr)
+ return Resolution.get_reso_from_freqstr(freqstr)
except KeyError:
return None
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index afc20fcc54376..dc63cd92bbb2b 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -1023,6 +1023,7 @@ def sequence_to_td64ns(
# cast the unit, multiply base/frac separately
# to avoid precision issues from float -> int
mask = np.isnan(data)
+ # The next few lines are effectively a vectorized 'cast_from_unit'
m, p = precision_from_unit(unit or "ns")
base = data.astype(np.int64)
frac = data - base
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 4acdc7e6c7556..3954cb28c2aca 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -573,8 +573,7 @@ def _parsed_string_to_bounds(self, reso: Resolution, parsed: datetime):
-------
lower, upper: pd.Timestamp
"""
- grp = reso.freq_group
- per = Period(parsed, freq=grp.value)
+ per = Period(parsed, freq=reso.attr_abbrev)
start, end = per.start_time, per.end_time
# GH 24076
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index a296ce130bbf5..3105bef6d506f 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -446,8 +446,9 @@ def get_loc(self, key, method=None, tolerance=None):
# TODO: pass if method is not None, like DTI does?
raise KeyError(key) from err
- if reso == self.dtype.resolution:
- # the reso < self.dtype.resolution case goes through _get_string_slice
+ if reso == self.dtype._resolution_obj:
+ # the reso < self.dtype._resolution_obj case goes
+ # through _get_string_slice
key = Period(parsed, freq=self.freq)
loc = self.get_loc(key, method=method, tolerance=tolerance)
# Recursing instead of falling through matters for the exception
@@ -495,14 +496,13 @@ def _maybe_cast_slice_bound(self, label, side: str, kind=lib.no_default):
return super()._maybe_cast_slice_bound(label, side, kind=kind)
def _parsed_string_to_bounds(self, reso: Resolution, parsed: datetime):
- grp = reso.freq_group
- iv = Period(parsed, freq=grp.value)
+ iv = Period(parsed, freq=reso.attr_abbrev)
return (iv.asfreq(self.freq, how="start"), iv.asfreq(self.freq, how="end"))
def _can_partial_date_slice(self, reso: Resolution) -> bool:
assert isinstance(reso, Resolution), (type(reso), reso)
# e.g. test_getitem_setitem_periodindex
- return reso > self.dtype.resolution
+ return reso > self.dtype._resolution_obj
def period_range(
diff --git a/pandas/plotting/_matplotlib/converter.py b/pandas/plotting/_matplotlib/converter.py
index 6c40770b4fac5..e5fb6b1dafa98 100644
--- a/pandas/plotting/_matplotlib/converter.py
+++ b/pandas/plotting/_matplotlib/converter.py
@@ -533,34 +533,35 @@ def has_level_label(label_flags: np.ndarray, vmin: float) -> bool:
def _daily_finder(vmin, vmax, freq: BaseOffset):
# error: "BaseOffset" has no attribute "_period_dtype_code"
dtype_code = freq._period_dtype_code # type: ignore[attr-defined]
+ freq_group = FreqGroup.from_period_dtype_code(dtype_code)
periodsperday = -1
if dtype_code >= FreqGroup.FR_HR.value:
- if dtype_code == FreqGroup.FR_NS.value:
+ if freq_group == FreqGroup.FR_NS:
periodsperday = 24 * 60 * 60 * 1000000000
- elif dtype_code == FreqGroup.FR_US.value:
+ elif freq_group == FreqGroup.FR_US:
periodsperday = 24 * 60 * 60 * 1000000
- elif dtype_code == FreqGroup.FR_MS.value:
+ elif freq_group == FreqGroup.FR_MS:
periodsperday = 24 * 60 * 60 * 1000
- elif dtype_code == FreqGroup.FR_SEC.value:
+ elif freq_group == FreqGroup.FR_SEC:
periodsperday = 24 * 60 * 60
- elif dtype_code == FreqGroup.FR_MIN.value:
+ elif freq_group == FreqGroup.FR_MIN:
periodsperday = 24 * 60
- elif dtype_code == FreqGroup.FR_HR.value:
+ elif freq_group == FreqGroup.FR_HR:
periodsperday = 24
else: # pragma: no cover
raise ValueError(f"unexpected frequency: {dtype_code}")
periodsperyear = 365 * periodsperday
periodspermonth = 28 * periodsperday
- elif dtype_code == FreqGroup.FR_BUS.value:
+ elif freq_group == FreqGroup.FR_BUS:
periodsperyear = 261
periodspermonth = 19
- elif dtype_code == FreqGroup.FR_DAY.value:
+ elif freq_group == FreqGroup.FR_DAY:
periodsperyear = 365
periodspermonth = 28
- elif FreqGroup.get_freq_group(dtype_code) == FreqGroup.FR_WK:
+ elif freq_group == FreqGroup.FR_WK:
periodsperyear = 52
periodspermonth = 3
else: # pragma: no cover
@@ -898,14 +899,13 @@ def _annual_finder(vmin, vmax, freq):
def get_finder(freq: BaseOffset):
# error: "BaseOffset" has no attribute "_period_dtype_code"
dtype_code = freq._period_dtype_code # type: ignore[attr-defined]
- fgroup = (dtype_code // 1000) * 1000
- fgroup = FreqGroup(fgroup)
+ fgroup = FreqGroup.from_period_dtype_code(dtype_code)
if fgroup == FreqGroup.FR_ANN:
return _annual_finder
elif fgroup == FreqGroup.FR_QTR:
return _quarterly_finder
- elif dtype_code == FreqGroup.FR_MTH.value:
+ elif fgroup == FreqGroup.FR_MTH:
return _monthly_finder
elif (dtype_code >= FreqGroup.FR_BUS.value) or fgroup == FreqGroup.FR_WK:
return _daily_finder
@@ -919,7 +919,7 @@ class TimeSeries_DateLocator(Locator):
Parameters
----------
- freq : {var}
+ freq : BaseOffset
Valid frequency specifier.
minor_locator : {False, True}, optional
Whether the locator is for minor ticks (True) or not.
@@ -933,7 +933,7 @@ class TimeSeries_DateLocator(Locator):
def __init__(
self,
- freq,
+ freq: BaseOffset,
minor_locator=False,
dynamic_mode=True,
base=1,
@@ -1010,7 +1010,7 @@ class TimeSeries_DateFormatter(Formatter):
Parameters
----------
- freq : {int, string}
+ freq : BaseOffset
Valid frequency specifier.
minor_locator : bool, default False
Whether the current formatter should apply to minor ticks (True) or
@@ -1021,7 +1021,7 @@ class TimeSeries_DateFormatter(Formatter):
def __init__(
self,
- freq,
+ freq: BaseOffset,
minor_locator: bool = False,
dynamic_mode: bool = True,
plot_obj=None,
diff --git a/pandas/tests/tseries/frequencies/test_freq_code.py b/pandas/tests/tseries/frequencies/test_freq_code.py
index 41257bb3f67fd..e961fdc295c96 100644
--- a/pandas/tests/tseries/frequencies/test_freq_code.py
+++ b/pandas/tests/tseries/frequencies/test_freq_code.py
@@ -38,12 +38,12 @@ def test_get_to_timestamp_base(freqstr, exp_freqstr):
],
)
def test_get_attrname_from_abbrev(freqstr, expected):
- assert Resolution.get_reso_from_freq(freqstr).attrname == expected
+ assert Resolution.get_reso_from_freqstr(freqstr).attrname == expected
@pytest.mark.parametrize("freq", ["D", "H", "T", "S", "L", "U", "N"])
def test_get_freq_roundtrip2(freq):
- obj = Resolution.get_reso_from_freq(freq)
+ obj = Resolution.get_reso_from_freqstr(freq)
result = _attrname_to_abbrevs[obj.attrname]
assert freq == result
| I had hoped to go further and get rid of one of the dtypes.pyx/pxd classes entirely, but ATM i dont think thats feasible. | https://api.github.com/repos/pandas-dev/pandas/pulls/46338 | 2022-03-12T03:38:14Z | 2022-03-16T00:36:18Z | 2022-03-16T00:36:18Z | 2022-03-16T01:22:12Z |
BUG: replace with value also being replaced | diff --git a/doc/source/whatsnew/v1.4.2.rst b/doc/source/whatsnew/v1.4.2.rst
index 2bdbeb0ab6991..06f1f406c3816 100644
--- a/doc/source/whatsnew/v1.4.2.rst
+++ b/doc/source/whatsnew/v1.4.2.rst
@@ -18,6 +18,7 @@ Fixed regressions
- Fixed regression in :func:`read_csv` killing python process when invalid file input was given for ``engine="c"`` (:issue:`45957`)
- Fixed memory performance regression in :meth:`Series.fillna` when called on a :class:`DataFrame` column with ``inplace=True`` (:issue:`46149`)
- Provided an alternative solution for passing custom Excel formats in :meth:`.Styler.to_excel`, which was a regression based on stricter CSS validation. Examples available in the documentation for :meth:`.Styler.format` (:issue:`46152`)
+- Fixed regression in :meth:`DataFrame.replace` when a replacement value was also a target for replacement (:issue:`46335`)
- Fixed regression in :meth:`DataFrame.loc.__setitem__` losing :class:`MultiIndex` names if :class:`DataFrame` was empty before (:issue:`46317`)
-
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 3693edbae7d95..69f66973d0954 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -612,9 +612,18 @@ def replace(
else:
# split so that we only upcast where necessary
- return self.split_and_operate(
- type(self).replace, to_replace, value, inplace=True
- )
+ blocks = []
+ for i, nb in enumerate(self._split()):
+ blocks.extend(
+ type(self).replace(
+ nb,
+ to_replace=to_replace,
+ value=value,
+ inplace=True,
+ mask=mask[i : i + 1],
+ )
+ )
+ return blocks
@final
def _replace_regex(
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index 6b53ef400e53d..2eb300a8905b8 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -1542,3 +1542,10 @@ def test_replace_regex_dtype_frame(self, regex):
expected_df2 = DataFrame({"A": [1], "B": ["1"]})
result_df2 = df2.replace(to_replace="0", value=1, regex=regex)
tm.assert_frame_equal(result_df2, expected_df2)
+
+ def test_replace_with_value_also_being_replaced(self):
+ # GH46306
+ df = DataFrame({"A": [0, 1, 2], "B": [1, 0, 2]})
+ result = df.replace({0: 1, 1: np.nan})
+ expected = DataFrame({"A": [1, np.nan, 2], "B": [np.nan, 1, 2]})
+ tm.assert_frame_equal(result, expected)
| - [x] closes #46306
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added an entry in `doc/source/whatsnew/v1.4.2.rst`
| https://api.github.com/repos/pandas-dev/pandas/pulls/46335 | 2022-03-12T00:15:53Z | 2022-03-12T15:11:05Z | 2022-03-12T15:11:05Z | 2022-03-20T23:18:58Z |
Backport PR #46322 on branch 1.4.x (Regression in loc.setitem losing mi names when df is empty) | diff --git a/doc/source/whatsnew/v1.4.2.rst b/doc/source/whatsnew/v1.4.2.rst
index badda6a73d1c8..0b1c7af594110 100644
--- a/doc/source/whatsnew/v1.4.2.rst
+++ b/doc/source/whatsnew/v1.4.2.rst
@@ -17,6 +17,7 @@ Fixed regressions
- Fixed regression in :meth:`DataFrame.drop` and :meth:`Series.drop` when :class:`Index` had extension dtype and duplicates (:issue:`45860`)
- Fixed memory performance regression in :meth:`Series.fillna` when called on a :class:`DataFrame` column with ``inplace=True`` (:issue:`46149`)
- Provided an alternative solution for passing custom Excel formats in :meth:`.Styler.to_excel`, which was a regression based on stricter CSS validation. Examples available in the documentation for :meth:`.Styler.format` (:issue:`46152`)
+- Fixed regression in :meth:`DataFrame.loc.__setitem__` losing :class:`MultiIndex` names if :class:`DataFrame` was empty before (:issue:`46317`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 0c3640e12e3b5..60de68052639c 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -2003,7 +2003,14 @@ def _setitem_with_indexer_missing(self, indexer, value):
# We will ignore the existing dtypes instead of using
# internals.concat logic
df = value.to_frame().T
- df.index = Index([indexer], name=self.obj.index.name)
+
+ idx = self.obj.index
+ if isinstance(idx, MultiIndex):
+ name = idx.names
+ else:
+ name = idx.name
+
+ df.index = Index([indexer], name=name)
if not has_dtype:
# i.e. if we already had a Series or ndarray, keep that
# dtype. But if we had a list or dict, then do inference
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index b186a55b221c8..76da8e3c38b0f 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -1288,6 +1288,18 @@ def test_loc_expand_empty_frame_keep_index_name(self):
expected = DataFrame({"b": [1]}, index=Index([0], name="a"))
tm.assert_frame_equal(df, expected)
+ def test_loc_expand_empty_frame_keep_midx_names(self):
+ # GH#46317
+ df = DataFrame(
+ columns=["d"], index=MultiIndex.from_tuples([], names=["a", "b", "c"])
+ )
+ df.loc[(1, 2, 3)] = "foo"
+ expected = DataFrame(
+ {"d": ["foo"]},
+ index=MultiIndex.from_tuples([(1, 2, 3)], names=["a", "b", "c"]),
+ )
+ tm.assert_frame_equal(df, expected)
+
class TestDataFrameIndexingUInt64:
def test_setitem(self, uint64_frame):
| Backport PR #46322: Regression in loc.setitem losing mi names when df is empty | https://api.github.com/repos/pandas-dev/pandas/pulls/46334 | 2022-03-11T23:45:18Z | 2022-03-12T03:15:35Z | 2022-03-12T03:15:34Z | 2022-03-12T03:15:35Z |
Backport PR #46325 on branch 1.4.x (Regression in read csv causing segfault for invalid file input) | diff --git a/doc/source/whatsnew/v1.4.2.rst b/doc/source/whatsnew/v1.4.2.rst
index badda6a73d1c8..239f02b0b6bcf 100644
--- a/doc/source/whatsnew/v1.4.2.rst
+++ b/doc/source/whatsnew/v1.4.2.rst
@@ -15,6 +15,7 @@ including other versions of pandas.
Fixed regressions
~~~~~~~~~~~~~~~~~
- Fixed regression in :meth:`DataFrame.drop` and :meth:`Series.drop` when :class:`Index` had extension dtype and duplicates (:issue:`45860`)
+- Fixed regression in :func:`read_csv` killing python process when invalid file input was given for ``engine="c"`` (:issue:`45957`)
- Fixed memory performance regression in :meth:`Series.fillna` when called on a :class:`DataFrame` column with ``inplace=True`` (:issue:`46149`)
- Provided an alternative solution for passing custom Excel formats in :meth:`.Styler.to_excel`, which was a regression based on stricter CSS validation. Examples available in the documentation for :meth:`.Styler.format` (:issue:`46152`)
-
diff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py
index 577c38deb4ed4..7d0e78ce43b71 100644
--- a/pandas/io/parsers/readers.py
+++ b/pandas/io/parsers/readers.py
@@ -1227,6 +1227,10 @@ def _make_engine(
assert self.handles is not None
f = self.handles.handle
+ elif engine != "python":
+ msg = f"Invalid file path or buffer object type: {type(f)}"
+ raise ValueError(msg)
+
try:
return mapping[engine](f, **self.options)
except Exception:
diff --git a/pandas/tests/io/parser/test_unsupported.py b/pandas/tests/io/parser/test_unsupported.py
index fad5c3d785e97..e360b9a49474d 100644
--- a/pandas/tests/io/parser/test_unsupported.py
+++ b/pandas/tests/io/parser/test_unsupported.py
@@ -189,3 +189,13 @@ def test_close_file_handle_on_invalide_usecols(all_parsers):
parser.read_csv(fname, usecols=["col1", "col2", "col3"])
# unlink fails on windows if file handles still point to it
os.unlink(fname)
+
+
+def test_invalid_file_inputs(all_parsers):
+ # GH#45957
+ parser = all_parsers
+ if parser.engine == "python":
+ pytest.skip("Python engine supports lists.")
+
+ with pytest.raises(ValueError, match="Invalid"):
+ parser.read_csv([])
| Backport PR #46325: Regression in read csv causing segfault for invalid file input | https://api.github.com/repos/pandas-dev/pandas/pulls/46333 | 2022-03-11T23:44:53Z | 2022-03-12T03:15:42Z | 2022-03-12T03:15:42Z | 2022-03-12T03:15:43Z |
REF/PERF: MultiIndex.get_locs to use boolean arrays internally | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 089ba62e461d1..b2bf596dd8dd4 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -310,7 +310,7 @@ Performance improvements
- Performance improvement in :meth:`.GroupBy.diff` (:issue:`16706`)
- Performance improvement in :meth:`.GroupBy.transform` when broadcasting values for user-defined functions (:issue:`45708`)
- Performance improvement in :meth:`.GroupBy.transform` for user-defined functions when only a single group exists (:issue:`44977`)
-- Performance improvement in :meth:`MultiIndex.get_locs` (:issue:`45681`, :issue:`46040`)
+- Performance improvement in :meth:`DataFrame.loc` and :meth:`Series.loc` for tuple-based indexing of a :class:`MultiIndex` (:issue:`45681`, :issue:`46040`, :issue:`46330`)
- Performance improvement in :attr:`MultiIndex.values` when the MultiIndex contains levels of type DatetimeIndex, TimedeltaIndex or ExtensionDtypes (:issue:`46288`)
- Performance improvement in :func:`merge` when left and/or right are empty (:issue:`45838`)
- Performance improvement in :meth:`DataFrame.join` when left and/or right are empty (:issue:`46015`)
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 4daf59b911ce1..1105e7b8a274f 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -84,7 +84,6 @@
get_unanimous_names,
)
from pandas.core.indexes.frozen import FrozenList
-from pandas.core.indexes.numeric import Int64Index
from pandas.core.ops.invalid import make_invalid_op
from pandas.core.sorting import (
get_group_index,
@@ -3160,10 +3159,10 @@ def maybe_mi_droplevels(indexer, levels):
return indexer, result_index
def _get_level_indexer(
- self, key, level: int = 0, indexer: Int64Index | None = None
+ self, key, level: int = 0, indexer: npt.NDArray[np.bool_] | None = None
):
# `level` kwarg is _always_ positional, never name
- # return an indexer, boolean array or a slice showing where the key is
+ # return a boolean array or slice showing where the key is
# in the totality of values
# if the indexer is provided, then use this
@@ -3171,36 +3170,26 @@ def _get_level_indexer(
level_codes = self.codes[level]
def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
- # given the inputs and the codes/indexer, compute an indexer set
- # if we have a provided indexer, then this need not consider
- # the entire labels set
- r = np.arange(start, stop, step)
-
- if indexer is not None and len(indexer) != len(codes):
-
- # we have an indexer which maps the locations in the labels
- # that we have already selected (and is not an indexer for the
- # entire set) otherwise this is wasteful so we only need to
- # examine locations that are in this set the only magic here is
- # that the result are the mappings to the set that we have
- # selected
- from pandas import Series
-
- mapper = Series(indexer)
- indexer = codes.take(ensure_platform_int(indexer))
- result = Series(Index(indexer).isin(r).nonzero()[0])
- m = result.map(mapper)
- # error: Incompatible types in assignment (expression has type
- # "ndarray", variable has type "Series")
- m = np.asarray(m) # type: ignore[assignment]
-
+ # Compute a bool indexer to identify the positions to take.
+ # If we have an existing indexer, we only need to examine the
+ # subset of positions where the existing indexer is True.
+ if indexer is not None:
+ # we only need to look at the subset of codes where the
+ # existing indexer equals True
+ codes = codes[indexer]
+
+ if step is None or step == 1:
+ new_indexer = (codes >= start) & (codes < stop)
else:
- # error: Incompatible types in assignment (expression has type
- # "ndarray", variable has type "Series")
- m = np.zeros(len(codes), dtype=bool) # type: ignore[assignment]
- m[np.in1d(codes, r, assume_unique=Index(codes).is_unique)] = True
+ r = np.arange(start, stop, step, dtype=codes.dtype)
+ new_indexer = algos.isin(codes, r)
+
+ if indexer is None:
+ return new_indexer
- return m
+ indexer = indexer.copy()
+ indexer[indexer] = new_indexer
+ return indexer
if isinstance(key, slice):
# handle a slice, returning a slice if we can
@@ -3327,62 +3316,41 @@ def get_locs(self, seq):
f"on levels {true_slices}, lexsort depth {self._lexsort_depth}"
)
- n = len(self)
- # indexer is the list of all positions that we want to take; it
- # is created on the first entry in seq and narrowed down as we
- # look at remaining entries
- indexer = None
-
if any(x is Ellipsis for x in seq):
raise NotImplementedError(
"MultiIndex does not support indexing with Ellipsis"
)
- def _convert_to_indexer(r) -> Int64Index:
- # return an indexer
- if isinstance(r, slice):
- m = np.zeros(n, dtype=bool)
- m[r] = True
- r = m.nonzero()[0]
- elif com.is_bool_indexer(r):
- if len(r) != n:
- raise ValueError(
- "cannot index with a boolean indexer "
- "that is not the same length as the "
- "index"
- )
- r = r.nonzero()[0]
- return Int64Index(r)
+ n = len(self)
- def _update_indexer(idxr: Index, indexer: Index | None) -> Index:
- if indexer is None:
- return idxr
- indexer_intersection = indexer.intersection(idxr)
- if indexer_intersection.empty and not idxr.empty and not indexer.empty:
- raise KeyError(seq)
- return indexer_intersection
+ def _to_bool_indexer(indexer) -> npt.NDArray[np.bool_]:
+ if isinstance(indexer, slice):
+ new_indexer = np.zeros(n, dtype=np.bool_)
+ new_indexer[indexer] = True
+ return new_indexer
+ return indexer
+
+ # a bool indexer for the positions we want to take
+ indexer: npt.NDArray[np.bool_] | None = None
for i, k in enumerate(seq):
+ lvl_indexer: npt.NDArray[np.bool_] | slice | None = None
+
if com.is_bool_indexer(k):
- # a boolean indexer, must be the same length!
- k = np.asarray(k)
- lvl_indexer = _convert_to_indexer(k)
- indexer = _update_indexer(lvl_indexer, indexer=indexer)
+ if len(k) != n:
+ raise ValueError(
+ "cannot index with a boolean indexer that "
+ "is not the same length as the index"
+ )
+ lvl_indexer = np.asarray(k)
elif is_list_like(k):
- # a collection of labels to include from this level (these
- # are or'd)
-
- indexers: Int64Index | None = None
+ # a collection of labels to include from this level (these are or'd)
# GH#27591 check if this is a single tuple key in the level
try:
- # Argument "indexer" to "_get_level_indexer" of "MultiIndex"
- # has incompatible type "Index"; expected "Optional[Int64Index]"
- lev_loc = self._get_level_indexer(
- k, level=i, indexer=indexer # type: ignore[arg-type]
- )
+ lvl_indexer = self._get_level_indexer(k, level=i, indexer=indexer)
except (InvalidIndexError, TypeError, KeyError) as err:
# InvalidIndexError e.g. non-hashable, fall back to treating
# this as a sequence of labels
@@ -3394,11 +3362,8 @@ def _update_indexer(idxr: Index, indexer: Index | None) -> Index:
# e.g. slice
raise err
try:
- # Argument "indexer" to "_get_level_indexer" of "MultiIndex"
- # has incompatible type "Index"; expected
- # "Optional[Int64Index]"
- item_lvl_indexer = self._get_level_indexer(
- x, level=i, indexer=indexer # type: ignore[arg-type]
+ item_indexer = self._get_level_indexer(
+ x, level=i, indexer=indexer
)
except KeyError:
# ignore not founds; see discussion in GH#39424
@@ -3418,82 +3383,63 @@ def _update_indexer(idxr: Index, indexer: Index | None) -> Index:
)
continue
else:
- idxrs = _convert_to_indexer(item_lvl_indexer)
-
- if indexers is None:
- indexers = idxrs
+ if lvl_indexer is None:
+ lvl_indexer = _to_bool_indexer(item_indexer)
+ elif isinstance(item_indexer, slice):
+ lvl_indexer[item_indexer] = True # type: ignore[index]
else:
- indexers = indexers.union(idxrs, sort=False)
-
- else:
- idxrs = _convert_to_indexer(lev_loc)
- if indexers is None:
- indexers = idxrs
- else:
- indexers = indexers.union(idxrs, sort=False)
+ lvl_indexer |= item_indexer
- if indexers is not None:
- indexer = _update_indexer(indexers, indexer=indexer)
- else:
+ if lvl_indexer is None:
# no matches we are done
# test_loc_getitem_duplicates_multiindex_empty_indexer
return np.array([], dtype=np.intp)
elif com.is_null_slice(k):
# empty slice
- if indexer is None:
- indexer = Index(np.arange(n))
+ if indexer is None and i == len(seq) - 1:
+ return np.arange(n, dtype=np.intp)
+ continue
- elif isinstance(k, slice):
+ else:
+ # a slice or a single label
+ lvl_indexer = self._get_level_indexer(k, level=i, indexer=indexer)
- # a slice, include BOTH of the labels
- # Argument "indexer" to "_get_level_indexer" of "MultiIndex" has
- # incompatible type "Index"; expected "Optional[Int64Index]"
- lvl_indexer = self._get_level_indexer(
- k,
- level=i,
- indexer=indexer, # type: ignore[arg-type]
- )
- indexer = _update_indexer(
- _convert_to_indexer(lvl_indexer),
- indexer=indexer,
- )
+ # update indexer
+ lvl_indexer = _to_bool_indexer(lvl_indexer)
+ if indexer is None:
+ indexer = lvl_indexer
else:
- # a single label
- lvl_indexer = self._get_loc_level(k, level=i)[0]
- indexer = _update_indexer(
- _convert_to_indexer(lvl_indexer),
- indexer=indexer,
- )
+ indexer &= lvl_indexer
+ if not np.any(indexer) and np.any(lvl_indexer):
+ raise KeyError(seq)
# empty indexer
if indexer is None:
return np.array([], dtype=np.intp)
- assert isinstance(indexer, Int64Index), type(indexer)
- indexer = self._reorder_indexer(seq, indexer)
-
- return indexer._values.astype(np.intp, copy=False)
+ pos_indexer = indexer.nonzero()[0]
+ return self._reorder_indexer(seq, pos_indexer)
# --------------------------------------------------------------------
def _reorder_indexer(
self,
seq: tuple[Scalar | Iterable | AnyArrayLike, ...],
- indexer: Int64Index,
- ) -> Int64Index:
+ indexer: npt.NDArray[np.intp],
+ ) -> npt.NDArray[np.intp]:
"""
- Reorder an indexer of a MultiIndex (self) so that the label are in the
+ Reorder an indexer of a MultiIndex (self) so that the labels are in the
same order as given in seq
Parameters
----------
seq : label/slice/list/mask or a sequence of such
- indexer: an Int64Index indexer of self
+ indexer: a position indexer of self
Returns
-------
- indexer : a sorted Int64Index indexer of self ordered as seq
+ indexer : a sorted position indexer of self ordered as seq
"""
# If the index is lexsorted and the list_like label in seq are sorted
# then we do not need to sort
| - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
Use boolean arrays internally within `MultiIndex.get_locs` rather than int64 indexes. Logical operations show performance improvements over intersecting int64 indexes. The output remains an integer positional indexer.
```
before after ratio
[17dda440] [94121581]
<main> <multiindex-get-locs-bool-arrays>
- 563±10μs 519±8μs 0.92 indexing.MultiIndexing.time_loc_all_scalars(True)
- 33.9±0.6ms 30.4±0.4ms 0.89 indexing.MultiIndexing.time_loc_all_null_slices(True)
- 38.7±1ms 34.5±1ms 0.89 indexing.MultiIndexing.time_loc_all_null_slices(False)
- 1.62±0.02ms 1.43±0.01ms 0.88 indexing.MultiIndexing.time_loc_all_slices(True)
- 6.40±0.06ms 5.53±0.1ms 0.86 indexing.MultiIndexing.time_loc_all_bool_indexers(True)
- 107±1ms 41.6±0.6ms 0.39 indexing.MultiIndexing.time_loc_all_lists(True)
- 34.6±0.8ms 8.24±0.4ms 0.24 indexing.MultiIndexing.time_loc_all_slices(False)
- 236±4ms 23.6±0.2ms 0.10 indexing.MultiIndexing.time_loc_all_lists(False)
- 97.3±0.7ms 9.16±0.4ms 0.09 indexing.MultiIndexing.time_loc_null_slice_plus_slice(False)
- 36.5±0.5ms 1.36±0.03ms 0.04 indexing.MultiIndexing.time_loc_null_slice_plus_slice(True)
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/46330 | 2022-03-11T20:59:28Z | 2022-03-18T01:52:13Z | 2022-03-18T01:52:13Z | 2022-03-20T23:18:48Z |
PERF: faster searchsorted in tzconversion | diff --git a/pandas/_libs/tslibs/conversion.pyx b/pandas/_libs/tslibs/conversion.pyx
index 7ea3c85fe9ddb..7dce3cad9d339 100644
--- a/pandas/_libs/tslibs/conversion.pyx
+++ b/pandas/_libs/tslibs/conversion.pyx
@@ -69,6 +69,7 @@ from pandas._libs.tslibs.nattype cimport (
checknull_with_nat,
)
from pandas._libs.tslibs.tzconversion cimport (
+ bisect_right_i8,
tz_convert_utc_to_tzlocal,
tz_localize_to_utc_single,
)
@@ -536,6 +537,7 @@ cdef _TSObject _create_tsobject_tz_using_offset(npy_datetimestruct dts,
int64_t value # numpy dt64
datetime dt
ndarray[int64_t] trans
+ int64_t* tdata
int64_t[::1] deltas
value = dtstruct_to_dt64(&dts)
@@ -556,7 +558,8 @@ cdef _TSObject _create_tsobject_tz_using_offset(npy_datetimestruct dts,
trans, deltas, typ = get_dst_info(tz)
if typ == 'dateutil':
- pos = trans.searchsorted(obj.value, side='right') - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
+ pos = bisect_right_i8(tdata, obj.value, trans.shape[0]) - 1
obj.fold = _infer_tsobject_fold(obj, trans, deltas, pos)
# Keep the converter same as PyDateTime's
@@ -708,7 +711,8 @@ cdef inline void _localize_tso(_TSObject obj, tzinfo tz):
ndarray[int64_t] trans
int64_t[::1] deltas
int64_t local_val
- Py_ssize_t pos
+ int64_t* tdata
+ Py_ssize_t pos, ntrans
str typ
assert obj.tzinfo is None
@@ -723,17 +727,20 @@ cdef inline void _localize_tso(_TSObject obj, tzinfo tz):
else:
# Adjust datetime64 timestamp, recompute datetimestruct
trans, deltas, typ = get_dst_info(tz)
+ ntrans = trans.shape[0]
if typ == "pytz":
# i.e. treat_tz_as_pytz(tz)
- pos = trans.searchsorted(obj.value, side="right") - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
+ pos = bisect_right_i8(tdata, obj.value, ntrans) - 1
local_val = obj.value + deltas[pos]
# find right representation of dst etc in pytz timezone
tz = tz._tzinfos[tz._transition_info[pos]]
elif typ == "dateutil":
# i.e. treat_tz_as_dateutil(tz)
- pos = trans.searchsorted(obj.value, side="right") - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
+ pos = bisect_right_i8(tdata, obj.value, ntrans) - 1
local_val = obj.value + deltas[pos]
# dateutil supports fold, so we infer fold from value
diff --git a/pandas/_libs/tslibs/tzconversion.pxd b/pandas/_libs/tslibs/tzconversion.pxd
index 3666d00707ac8..0837a5c436197 100644
--- a/pandas/_libs/tslibs/tzconversion.pxd
+++ b/pandas/_libs/tslibs/tzconversion.pxd
@@ -9,3 +9,5 @@ cpdef int64_t tz_convert_from_utc_single(int64_t val, tzinfo tz)
cdef int64_t tz_localize_to_utc_single(
int64_t val, tzinfo tz, object ambiguous=*, object nonexistent=*
) except? -1
+
+cdef Py_ssize_t bisect_right_i8(int64_t *data, int64_t val, Py_ssize_t n)
diff --git a/pandas/_libs/tslibs/tzconversion.pyx b/pandas/_libs/tslibs/tzconversion.pyx
index 2173ca37da7fa..111d16c27fb3f 100644
--- a/pandas/_libs/tslibs/tzconversion.pyx
+++ b/pandas/_libs/tslibs/tzconversion.pyx
@@ -116,9 +116,8 @@ timedelta-like}
"""
cdef:
int64_t[::1] deltas
- int64_t[:] idx_shifted, idx_shifted_left, idx_shifted_right
ndarray[uint8_t, cast=True] ambiguous_array, both_nat, both_eq
- Py_ssize_t i, idx, pos, ntrans, n = vals.shape[0]
+ Py_ssize_t i, isl, isr, idx, pos, ntrans, n = vals.shape[0]
Py_ssize_t delta_idx_offset, delta_idx, pos_left, pos_right
int64_t *tdata
int64_t v, left, right, val, v_left, v_right, new_local, remaining_mins
@@ -194,21 +193,28 @@ timedelta-like}
result_a[:] = NPY_NAT
result_b[:] = NPY_NAT
- idx_shifted_left = (np.maximum(0, trans.searchsorted(
- vals - DAY_NANOS, side='right') - 1)).astype(np.int64)
-
- idx_shifted_right = (np.maximum(0, trans.searchsorted(
- vals + DAY_NANOS, side='right') - 1)).astype(np.int64)
-
for i in range(n):
val = vals[i]
- v_left = val - deltas[idx_shifted_left[i]]
+ if val == NPY_NAT:
+ continue
+
+ # TODO: be careful of overflow in val-DAY_NANOS
+ isl = bisect_right_i8(tdata, val - DAY_NANOS, ntrans) - 1
+ if isl < 0:
+ isl = 0
+
+ v_left = val - deltas[isl]
pos_left = bisect_right_i8(tdata, v_left, ntrans) - 1
# timestamp falls to the left side of the DST transition
if v_left + deltas[pos_left] == val:
result_a[i] = v_left
- v_right = val - deltas[idx_shifted_right[i]]
+ # TODO: be careful of overflow in val+DAY_NANOS
+ isr = bisect_right_i8(tdata, val + DAY_NANOS, ntrans) - 1
+ if isr < 0:
+ isr = 0
+
+ v_right = val - deltas[isr]
pos_right = bisect_right_i8(tdata, v_right, ntrans) - 1
# timestamp falls to the right side of the DST transition
if v_right + deltas[pos_right] == val:
@@ -309,7 +315,9 @@ timedelta-like}
# Subtract 1 since the beginning hour is _inclusive_ of
# nonexistent times
new_local = val - remaining_mins - 1
- delta_idx = trans.searchsorted(new_local, side='right')
+
+ delta_idx = bisect_right_i8(tdata, new_local, ntrans)
+
# Shift the delta_idx by if the UTC offset of
# the target tz is greater than 0 and we're moving forward
# or vice versa
@@ -333,17 +341,22 @@ timedelta-like}
cdef inline Py_ssize_t bisect_right_i8(int64_t *data,
int64_t val, Py_ssize_t n):
+ # Caller is responsible for checking n > 0
+ # This looks very similar to local_search_right in the ndarray.searchsorted
+ # implementation.
cdef:
Py_ssize_t pivot, left = 0, right = n
- assert n >= 1
-
# edge cases
if val > data[n - 1]:
return n
- if val < data[0]:
- return 0
+ # Caller is responsible for ensuring 'val >= data[0]'. This is
+ # ensured by the fact that 'data' comes from get_dst_info where data[0]
+ # is *always* NPY_NAT+1. If that ever changes, we will need to restore
+ # the following disabled check.
+ # if val < data[0]:
+ # return 0
while left < right:
pivot = left + (right - left) // 2
@@ -403,6 +416,7 @@ cpdef int64_t tz_convert_from_utc_single(int64_t val, tzinfo tz):
int64_t delta
int64_t[::1] deltas
ndarray[int64_t, ndim=1] trans
+ int64_t* tdata
intp_t pos
if val == NPY_NAT:
@@ -418,7 +432,8 @@ cpdef int64_t tz_convert_from_utc_single(int64_t val, tzinfo tz):
return val + delta
else:
trans, deltas, _ = get_dst_info(tz)
- pos = trans.searchsorted(val, side="right") - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
+ pos = bisect_right_i8(tdata, val, trans.shape[0]) - 1
return val + deltas[pos]
@@ -462,10 +477,11 @@ cdef const int64_t[:] _tz_convert_from_utc(const int64_t[:] vals, tzinfo tz):
"""
cdef:
int64_t[::1] converted, deltas
- Py_ssize_t i, n = vals.shape[0]
+ Py_ssize_t i, ntrans = -1, n = vals.shape[0]
int64_t val, delta = 0 # avoid not-initialized-warning
- intp_t[:] pos
+ intp_t pos
ndarray[int64_t] trans
+ int64_t* tdata = NULL
str typ
bint use_tzlocal = False, use_fixed = False, use_utc = True
@@ -479,13 +495,14 @@ cdef const int64_t[:] _tz_convert_from_utc(const int64_t[:] vals, tzinfo tz):
use_tzlocal = True
else:
trans, deltas, typ = get_dst_info(tz)
+ ntrans = trans.shape[0]
if typ not in ["pytz", "dateutil"]:
# FixedOffset, we know len(deltas) == 1
delta = deltas[0]
use_fixed = True
else:
- pos = trans.searchsorted(vals, side="right") - 1
+ tdata = <int64_t*>cnp.PyArray_DATA(trans)
converted = np.empty(n, dtype=np.int64)
@@ -502,7 +519,8 @@ cdef const int64_t[:] _tz_convert_from_utc(const int64_t[:] vals, tzinfo tz):
elif use_fixed:
converted[i] = val + delta
else:
- converted[i] = val + deltas[pos[i]]
+ pos = bisect_right_i8(tdata, val, ntrans) - 1
+ converted[i] = val + deltas[pos]
return converted
| ```
ts = pd.Timestamp(0)
ts2 = ts.tz_localize("US/Pacific")
%timeit ts.tz_localize("US/Pacific")
35.1 µs ± 385 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each) # <- main
16.8 µs ± 312 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) # <- PR
%timeit ts2.tz_localize(None)
5.1 µs ± 54.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) # <- main
2.7 µs ± 68.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) # <- PR
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/46329 | 2022-03-11T19:34:19Z | 2022-03-11T23:41:01Z | 2022-03-11T23:41:01Z | 2022-03-12T00:35:52Z |
TST: resolve issues with test_constructor_dtype_datetime64 | diff --git a/pandas/tests/frame/test_dtypes.py b/pandas/tests/frame/test_dtypes.py
index b37bf02a6b8e7..ca54993712439 100644
--- a/pandas/tests/frame/test_dtypes.py
+++ b/pandas/tests/frame/test_dtypes.py
@@ -808,11 +808,15 @@ def test_astype_to_incorrect_datetimelike(self, unit):
other = "m8[{}]".format(unit)
df = DataFrame(np.array([[1, 2, 3]], dtype=dtype))
- with pytest.raises(TypeError):
+ msg = (r"cannot astype a datetimelike from \[datetime64\[ns\]\] to"
+ r" \[timedelta64\[{}\]\]").format(unit)
+ with pytest.raises(TypeError, match=msg):
df.astype(other)
+ msg = (r"cannot astype a timedelta from \[timedelta64\[ns\]\] to"
+ r" \[datetime64\[{}\]\]").format(unit)
df = DataFrame(np.array([[1, 2, 3]], dtype=other))
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
df.astype(dtype)
def test_timedeltas(self):
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 8525b877618c9..96e18c6a60cac 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -683,17 +683,44 @@ def test_constructor_dtype_datetime64(self):
assert s.dtype == 'M8[ns]'
# GH3414 related
- # msg = (r"cannot astype a datetimelike from \[datetime64\[ns\]\] to"
- # r" \[int32\]")
- # with pytest.raises(TypeError, match=msg):
- # Series(Series(dates).astype('int') / 1000000, dtype='M8[ms]')
- pytest.raises(TypeError, lambda x: Series(
- Series(dates).astype('int') / 1000000, dtype='M8[ms]'))
-
- msg = (r"The 'datetime64' dtype has no unit\. Please pass in"
- r" 'datetime64\[ns\]' instead\.")
- with pytest.raises(ValueError, match=msg):
- Series(dates, dtype='datetime64')
+ expected = Series([
+ datetime(2013, 1, 1),
+ datetime(2013, 1, 2),
+ datetime(2013, 1, 3),
+ ], dtype='datetime64[ns]')
+
+ result = Series(
+ Series(dates).astype(np.int64) / 1000000, dtype='M8[ms]')
+ tm.assert_series_equal(result, expected)
+
+ result = Series(dates, dtype='datetime64[ns]')
+ tm.assert_series_equal(result, expected)
+
+ expected = Series([
+ pd.NaT,
+ datetime(2013, 1, 2),
+ datetime(2013, 1, 3),
+ ], dtype='datetime64[ns]')
+ result = Series([np.nan] + dates[1:], dtype='datetime64[ns]')
+ tm.assert_series_equal(result, expected)
+
+ dts = Series(dates, dtype='datetime64[ns]')
+
+ # valid astype
+ dts.astype('int64')
+
+ # invalid casting
+ msg = (r"cannot astype a datetimelike from \[datetime64\[ns\]\] to"
+ r" \[int32\]")
+ with pytest.raises(TypeError, match=msg):
+ dts.astype('int32')
+
+ # ints are ok
+ # we test with np.int64 to get similar results on
+ # windows / 32-bit platforms
+ result = Series(dts, dtype=np.int64)
+ expected = Series(dts.astype(np.int64))
+ tm.assert_series_equal(result, expected)
# invalid dates can be help as object
result = Series([datetime(2, 1, 1)])
diff --git a/pandas/tests/series/test_dtypes.py b/pandas/tests/series/test_dtypes.py
index d8046c4944afc..735b8553b14d3 100644
--- a/pandas/tests/series/test_dtypes.py
+++ b/pandas/tests/series/test_dtypes.py
@@ -415,7 +415,9 @@ def test_astype_generic_timestamp_no_frequency(self, dtype):
data = [1]
s = Series(data)
- msg = "dtype has no unit. Please pass in"
+ msg = ((r"The '{dtype}' dtype has no unit\. "
+ r"Please pass in '{dtype}\[ns\]' instead.")
+ .format(dtype=dtype.__name__))
with pytest.raises(ValueError, match=msg):
s.astype(dtype)
| closes #24827
xref https://github.com/pandas-dev/pandas/pull/24812#discussion_r248666576
while changing pytest.raises to use the context manager and check the error message it appeared that a test was not raising exceptions as originally intended.
the test was related to a legacy numpy related issue #3414 | https://api.github.com/repos/pandas-dev/pandas/pulls/24868 | 2019-01-21T21:12:00Z | 2019-03-13T15:44:41Z | 2019-03-13T15:44:41Z | 2019-03-13T17:17:59Z |
BUG: Ensure .astype doesn't use PandasArray | diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 360f3ea23ec97..e631a6b4937c4 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -27,13 +27,13 @@
CategoricalDtype, ExtensionDtype, PandasExtensionDtype)
from pandas.core.dtypes.generic import (
ABCDataFrame, ABCDatetimeIndex, ABCExtensionArray, ABCIndexClass,
- ABCSeries)
+ ABCPandasArray, ABCSeries)
from pandas.core.dtypes.missing import (
_isna_compat, array_equivalent, isna, notna)
import pandas.core.algorithms as algos
from pandas.core.arrays import (
- Categorical, DatetimeArray, ExtensionArray, TimedeltaArray)
+ Categorical, DatetimeArray, ExtensionArray, PandasDtype, TimedeltaArray)
from pandas.core.base import PandasObject
import pandas.core.common as com
from pandas.core.indexes.datetimes import DatetimeIndex
@@ -576,23 +576,14 @@ def _astype(self, dtype, copy=False, errors='raise', values=None,
return self.make_block(Categorical(self.values, dtype=dtype))
- # convert dtypes if needed
dtype = pandas_dtype(dtype)
+
# astype processing
if is_dtype_equal(self.dtype, dtype):
if copy:
return self.copy()
return self
- klass = None
- if is_sparse(self.values):
- # special case sparse, Series[Sparse].astype(object) is sparse
- klass = ExtensionBlock
- elif is_object_dtype(dtype):
- klass = ObjectBlock
- elif is_extension_array_dtype(dtype):
- klass = ExtensionBlock
-
try:
# force the copy here
if values is None:
@@ -624,7 +615,7 @@ def _astype(self, dtype, copy=False, errors='raise', values=None,
pass
newb = make_block(values, placement=self.mgr_locs,
- klass=klass, ndim=self.ndim)
+ ndim=self.ndim)
except Exception: # noqa: E722
if errors == 'raise':
raise
@@ -3041,6 +3032,13 @@ def get_block_type(values, dtype=None):
def make_block(values, placement, klass=None, ndim=None, dtype=None,
fastpath=None):
+ # Ensure that we don't allow PandasArray / PandasDtype in internals.
+ # For now, blocks should be backed by ndarrays when possible.
+ if isinstance(values, ABCPandasArray):
+ values = values.to_numpy()
+ if isinstance(dtype, PandasDtype):
+ dtype = dtype.numpy_dtype
+
if fastpath is not None:
# GH#19265 pyarrow is passing this
warnings.warn("fastpath argument is deprecated, will be removed "
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index fc520436f02f7..f73b7842ef901 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -1291,3 +1291,23 @@ def test_block_shape():
assert (a._data.blocks[0].mgr_locs.indexer ==
b._data.blocks[0].mgr_locs.indexer)
+
+
+def test_make_block_no_pandas_array():
+ # https://github.com/pandas-dev/pandas/pull/24866
+ arr = pd.array([1, 2])
+
+ # PandasArray, no dtype
+ result = make_block(arr, slice(len(arr)))
+ assert result.is_integer is True
+ assert result.is_extension is False
+
+ # PandasArray, PandasDtype
+ result = make_block(arr, slice(len(arr)), dtype=arr.dtype)
+ assert result.is_integer is True
+ assert result.is_extension is False
+
+ # ndarray, PandasDtype
+ result = make_block(arr.to_numpy(), slice(len(arr)), dtype=arr.dtype)
+ assert result.is_integer is True
+ assert result.is_extension is False
diff --git a/pandas/tests/series/test_internals.py b/pandas/tests/series/test_internals.py
index e8f5344689e6f..f6f4a2db359f7 100644
--- a/pandas/tests/series/test_internals.py
+++ b/pandas/tests/series/test_internals.py
@@ -312,6 +312,14 @@ def test_constructor_no_pandas_array(self):
tm.assert_series_equal(ser, result)
assert isinstance(result._data.blocks[0], IntBlock)
+ def test_astype_no_pandas_dtype(self):
+ # https://github.com/pandas-dev/pandas/pull/24866
+ ser = pd.Series([1, 2], dtype="int64")
+ # Don't have PandasDtype in the public API, so we use `.array.dtype`,
+ # which is a PandasDtype.
+ result = ser.astype(ser.array.dtype)
+ tm.assert_series_equal(result, ser)
+
def test_from_array(self):
result = pd.Series(pd.array(['1H', '2H'], dtype='timedelta64[ns]'))
assert result._data.blocks[0].is_extension is False
| On 0.24.0rc1, it's possible to end up with a PandasArray in internals.
```python
In [8]: ser = pd.Series([1, 2])
In [9]: ser.astype(ser.array.dtype)._data.blocks[0]
Out[9]: ExtensionBlock: 2 dtype: int64
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/24866 | 2019-01-21T19:22:21Z | 2019-04-28T21:14:54Z | 2019-04-28T21:14:54Z | 2019-04-28T21:14:58Z |
CLN: fix typo in asv eval.Query suite | diff --git a/asv_bench/benchmarks/eval.py b/asv_bench/benchmarks/eval.py
index 837478efbad64..68df38cd50742 100644
--- a/asv_bench/benchmarks/eval.py
+++ b/asv_bench/benchmarks/eval.py
@@ -45,7 +45,7 @@ def setup(self):
index = pd.date_range('20010101', periods=N, freq='T')
s = pd.Series(index)
self.ts = s.iloc[halfway]
- self.df = pd.DataFrame({'a': np.random.randn(N), 'dates': s},
+ self.df = pd.DataFrame({'a': np.random.randn(N), 'dates': index},
index=index)
data = np.random.randn(N)
self.min_val = data.min()
| The `eval.Query` asv suite has a large amount of setup overhead due to a typo:
```
$ time asv dev -b eval.Query
· Discovering benchmarks
· Running 3 total benchmarks (1 commits * 1 environments * 3 benchmarks)
[ 0.00%] ·· Benchmarking existing-py_home_chris_anaconda3_bin_python
[ 16.67%] ··· eval.Query.time_query_datetime_column 18.3±0ms
[ 33.33%] ··· eval.Query.time_query_datetime_index 24.8±0ms
[ 50.00%] ··· eval.Query.time_query_with_boolean_selection 44.2±0ms
real ***0m25.883s***
user 0m23.047s
sys 0m2.531s
```
This typo also breaks the intent of the benchmark, as a test done on a datetime column is being done on one entirely of `NaT`s:
```
a dates
2001-01-01 00:00:00 -1.228806 NaT
2001-01-01 00:01:00 -2.561029 NaT
2001-01-01 00:02:00 0.879283 NaT
2001-01-01 00:03:00 -0.814045 NaT
2001-01-01 00:04:00 -0.905315 NaT
```
This occurs due to `s` having a `RangeIndex` and being re-indexed to `DatetimeIndex`. This triggers a casting of both to `object` type to find any intersection; this is both slow and unsuccessful here. Instead, we pass the index directly as the input for the dates column:
```
a dates
2001-01-01 00:00:00 -1.068134 2001-01-01 00:00:00
2001-01-01 00:01:00 0.440343 2001-01-01 00:01:00
2001-01-01 00:02:00 -0.767818 2001-01-01 00:02:00
2001-01-01 00:03:00 -0.849333 2001-01-01 00:03:00
2001-01-01 00:04:00 0.737811 2001-01-01 00:04:00
```
And get a nice speedup in `asv` setup time as well:
```
$ time asv dev -b eval.Query
· Discovering benchmarks
· Running 3 total benchmarks (1 commits * 1 environments * 3 benchmarks)
[ 0.00%] ·· Benchmarking existing-py_home_chris_anaconda3_bin_python
[ 16.67%] ··· eval.Query.time_query_datetime_column 26.9±0ms
[ 33.33%] ··· eval.Query.time_query_datetime_index 28.1±0ms
[ 50.00%] ··· eval.Query.time_query_with_boolean_selection 47.1±0ms
real 0m6.336s
user 0m4.281s
sys 0m1.828s
```
And here's the timings on the fixed benchmark:
```
$ asv compare v0.23.4 v0.24.0rc1
All benchmarks:
before after ratio
[04095216] [fdc4db25]
<v0.23.4^0> <v0.24.0rc1^0>
14.8±2ms 12.3±1ms ~0.83 eval.Query.time_query_datetime_column
15.7±1ms 14.0±1ms ~0.89 eval.Query.time_query_datetime_index
21.0±4ms 20.9±7ms 0.99 eval.Query.time_query_with_boolean_selection
```
- [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24865 | 2019-01-21T18:58:36Z | 2019-01-21T19:38:39Z | 2019-01-21T19:38:39Z | 2019-01-21T19:38:43Z |
BLD: silence npy_no_deprecated warnings with numpy>=1.16.0 | diff --git a/setup.py b/setup.py
index ed2d905f4358b..4bf040b8c8e20 100755
--- a/setup.py
+++ b/setup.py
@@ -457,6 +457,11 @@ def run(self):
directives['linetrace'] = True
macros = [('CYTHON_TRACE', '1'), ('CYTHON_TRACE_NOGIL', '1')]
+# in numpy>=1.16.0, silence build warnings about deprecated API usage
+# we can't do anything about these warnings because they stem from
+# cython+numpy version mismatches.
+macros.append(('NPY_NO_DEPRECATED_API', '0'))
+
# ----------------------------------------------------------------------
# Specification of Dependencies
| - [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24864 | 2019-01-21T16:36:36Z | 2019-01-26T17:47:33Z | 2019-01-26T17:47:32Z | 2020-04-05T17:37:14Z |
BUG: fix floating precision formatting in presence of inf | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 69b59793f7c0d..6787022ba295c 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1751,6 +1751,7 @@ I/O
- Bug in :meth:`DataFrame.to_stata`, :class:`pandas.io.stata.StataWriter` and :class:`pandas.io.stata.StataWriter117` where a exception would leave a partially written and invalid dta file (:issue:`23573`)
- Bug in :meth:`DataFrame.to_stata` and :class:`pandas.io.stata.StataWriter117` that produced invalid files when using strLs with non-ASCII characters (:issue:`23573`)
- Bug in :class:`HDFStore` that caused it to raise ``ValueError`` when reading a Dataframe in Python 3 from fixed format written in Python 2 (:issue:`24510`)
+- Bug in :func:`DataFrame.to_string()` and more generally in the floating ``repr`` formatter. Zeros were not trimmed if ``inf`` was present in a columns while it was the case with NA values. Zeros are now trimmed as in the presence of NA (:issue:`24861`).
Plotting
^^^^^^^^
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index bdeed58d856cc..2c1fcab1ebde9 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -1414,16 +1414,20 @@ def _trim_zeros(str_floats, na_rep='NaN'):
"""
trimmed = str_floats
+ def _is_number(x):
+ return (x != na_rep and not x.endswith('inf'))
+
def _cond(values):
- non_na = [x for x in values if x != na_rep]
- return (len(non_na) > 0 and all(x.endswith('0') for x in non_na) and
- not (any(('e' in x) or ('E' in x) for x in non_na)))
+ finite = [x for x in values if _is_number(x)]
+ return (len(finite) > 0 and all(x.endswith('0') for x in finite) and
+ not (any(('e' in x) or ('E' in x) for x in finite)))
while _cond(trimmed):
- trimmed = [x[:-1] if x != na_rep else x for x in trimmed]
+ trimmed = [x[:-1] if _is_number(x) else x for x in trimmed]
# leave one 0 after the decimal points if need be.
- return [x + "0" if x.endswith('.') and x != na_rep else x for x in trimmed]
+ return [x + "0" if x.endswith('.') and _is_number(x) else x
+ for x in trimmed]
def _has_names(index):
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 52dce572c6d4f..31ab1e050d95c 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -1465,6 +1465,39 @@ def test_to_string_format_na(self):
'4 4.0 bar')
assert result == expected
+ def test_to_string_format_inf(self):
+ # Issue #24861
+ tm.reset_display_options()
+ df = DataFrame({
+ 'A': [-np.inf, np.inf, -1, -2.1234, 3, 4],
+ 'B': [-np.inf, np.inf, 'foo', 'foooo', 'fooooo', 'bar']
+ })
+ result = df.to_string()
+
+ expected = (' A B\n'
+ '0 -inf -inf\n'
+ '1 inf inf\n'
+ '2 -1.0000 foo\n'
+ '3 -2.1234 foooo\n'
+ '4 3.0000 fooooo\n'
+ '5 4.0000 bar')
+ assert result == expected
+
+ df = DataFrame({
+ 'A': [-np.inf, np.inf, -1., -2., 3., 4.],
+ 'B': [-np.inf, np.inf, 'foo', 'foooo', 'fooooo', 'bar']
+ })
+ result = df.to_string()
+
+ expected = (' A B\n'
+ '0 -inf -inf\n'
+ '1 inf inf\n'
+ '2 -1.0 foo\n'
+ '3 -2.0 foooo\n'
+ '4 3.0 fooooo\n'
+ '5 4.0 bar')
+ assert result == expected
+
def test_to_string_decimal(self):
# Issue #23614
df = DataFrame({'A': [6.0, 3.1, 2.2]})
| - [x] closes #24861
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24863 | 2019-01-21T16:34:06Z | 2019-01-23T12:23:51Z | 2019-01-23T12:23:50Z | 2019-01-23T12:23:56Z |
BUG: Properly parse unicode usecols names in CSV | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index a4598b315cbb7..ff017c743a00f 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1705,6 +1705,7 @@ I/O
^^^
- Bug in :func:`read_csv` in which a column specified with ``CategoricalDtype`` of boolean categories was not being correctly coerced from string values to booleans (:issue:`20498`)
+- Bug in :func:`read_csv` in which unicode column names were not being properly recognized with Python 2.x (:issue:`13253`)
- Bug in :meth:`DataFrame.to_sql` when writing timezone aware data (``datetime64[ns, tz]`` dtype) would raise a ``TypeError`` (:issue:`9086`)
- Bug in :meth:`DataFrame.to_sql` where a naive :class:`DatetimeIndex` would be written as ``TIMESTAMP WITH TIMEZONE`` type in supported databases, e.g. PostgreSQL (:issue:`23510`)
- Bug in :meth:`read_excel()` when ``parse_cols`` is specified with an empty dataset (:issue:`9208`)
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index 5590e8f445c67..b31d3f665f47f 100755
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -1296,15 +1296,28 @@ def _validate_usecols_arg(usecols):
if usecols is not None:
if callable(usecols):
return usecols, None
- # GH20529, ensure is iterable container but not string.
- elif not is_list_like(usecols):
+
+ if not is_list_like(usecols):
+ # see gh-20529
+ #
+ # Ensure it is iterable container but not string.
raise ValueError(msg)
- else:
- usecols_dtype = lib.infer_dtype(usecols, skipna=False)
- if usecols_dtype not in ('empty', 'integer',
- 'string', 'unicode'):
- raise ValueError(msg)
- return set(usecols), usecols_dtype
+
+ usecols_dtype = lib.infer_dtype(usecols, skipna=False)
+
+ if usecols_dtype not in ("empty", "integer",
+ "string", "unicode"):
+ raise ValueError(msg)
+
+ usecols = set(usecols)
+
+ if usecols_dtype == "unicode":
+ # see gh-13253
+ #
+ # Python 2.x compatibility
+ usecols = {col.encode("utf-8") for col in usecols}
+
+ return usecols, usecols_dtype
return usecols, None
diff --git a/pandas/tests/io/parser/test_usecols.py b/pandas/tests/io/parser/test_usecols.py
index 068227908a285..652f78d198ee8 100644
--- a/pandas/tests/io/parser/test_usecols.py
+++ b/pandas/tests/io/parser/test_usecols.py
@@ -9,7 +9,7 @@
import pytest
from pandas._libs.tslib import Timestamp
-from pandas.compat import PY2, StringIO
+from pandas.compat import StringIO
from pandas import DataFrame, Index
import pandas.util.testing as tm
@@ -387,8 +387,7 @@ def test_usecols_with_mixed_encoding_strings(all_parsers, usecols):
@pytest.mark.parametrize("usecols", [
["あああ", "いい"],
- pytest.param([u"あああ", u"いい"], marks=pytest.mark.skipif(
- PY2, reason="Buggy behavior: see gh-13253"))
+ [u"あああ", u"いい"]
])
def test_usecols_with_multi_byte_characters(all_parsers, usecols):
data = """あああ,いい,ううう,ええええ
| Closes #13253.
| https://api.github.com/repos/pandas-dev/pandas/pulls/24856 | 2019-01-21T01:53:36Z | 2019-01-21T14:21:32Z | 2019-01-21T14:21:31Z | 2019-01-27T00:26:55Z |
DOC: Document AttributeError for accessor | diff --git a/doc/source/extending.rst b/doc/source/extending.rst
index 3cb7e1ae019e1..e6928d9efde06 100644
--- a/doc/source/extending.rst
+++ b/doc/source/extending.rst
@@ -28,8 +28,14 @@ decorate a class, providing the name of attribute to add. The class's
@pd.api.extensions.register_dataframe_accessor("geo")
class GeoAccessor(object):
def __init__(self, pandas_obj):
+ self._validate(pandas_obj)
self._obj = pandas_obj
+ @staticmethod
+ def _validate(obj):
+ if 'lat' not in obj.columns or 'lon' not in obj.columns:
+ raise AttributeError("Must have 'lat' and 'lon'.")
+
@property
def center(self):
# return the geographic center point of this DataFrame
@@ -54,6 +60,13 @@ This can be a convenient way to extend pandas objects without subclassing them.
If you write a custom accessor, make a pull request adding it to our
:ref:`ecosystem` page.
+We highly recommend validating the data in your accessor's `__init__`.
+In our ``GeoAccessor``, we validate that the data contains the expected columns,
+raising an ``AttributeError`` when the validation fails.
+For a ``Series`` accessor, you should validate the ``dtype`` if the accessor
+applies only to certain dtypes.
+
+
.. _extending.extension-types:
Extension Types
| Closes https://github.com/pandas-dev/pandas/issues/20579 | https://api.github.com/repos/pandas-dev/pandas/pulls/24855 | 2019-01-21T01:41:53Z | 2019-01-21T11:58:08Z | 2019-01-21T11:58:07Z | 2019-01-21T11:58:12Z |
DEPS: Bump pyarrow min version to 0.9.0 | diff --git a/ci/deps/travis-27.yaml b/ci/deps/travis-27.yaml
index 0f2194e71de31..2624797b24fa1 100644
--- a/ci/deps/travis-27.yaml
+++ b/ci/deps/travis-27.yaml
@@ -22,7 +22,7 @@ dependencies:
- patsy
- psycopg2
- py
- - pyarrow=0.7.0
+ - pyarrow=0.9.0
- PyCrypto
- pymysql=0.6.3
- pytables
diff --git a/doc/source/install.rst b/doc/source/install.rst
index fa3ff2f20b150..92364fcc9ebd2 100644
--- a/doc/source/install.rst
+++ b/doc/source/install.rst
@@ -257,7 +257,7 @@ Optional Dependencies
* `SciPy <http://www.scipy.org>`__: miscellaneous statistical functions, Version 0.18.1 or higher
* `xarray <http://xarray.pydata.org>`__: pandas like handling for > 2 dims, needed for converting Panels to xarray objects. Version 0.7.0 or higher is recommended.
* `PyTables <http://www.pytables.org>`__: necessary for HDF5-based storage, Version 3.4.2 or higher
-* `pyarrow <http://arrow.apache.org/docs/python/>`__ (>= 0.7.0): necessary for feather-based storage.
+* `pyarrow <http://arrow.apache.org/docs/python/>`__ (>= 0.9.0): necessary for feather-based storage.
* `Apache Parquet <https://parquet.apache.org/>`__, either `pyarrow <http://arrow.apache.org/docs/python/>`__ (>= 0.7.0) or `fastparquet <https://fastparquet.readthedocs.io/en/latest>`__ (>= 0.2.1) for parquet-based storage. The `snappy <https://pypi.org/project/python-snappy>`__ and `brotli <https://pypi.org/project/brotlipy>`__ are available for compression support.
* `SQLAlchemy <http://www.sqlalchemy.org>`__: for SQL database support. Version 0.8.1 or higher recommended. Besides SQLAlchemy, you also need a database specific driver. You can find an overview of supported drivers for each SQL dialect in the `SQLAlchemy docs <http://docs.sqlalchemy.org/en/latest/dialects/index.html>`__. Some common drivers are:
diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index a4598b315cbb7..fbc3c4fe4ce92 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -438,7 +438,7 @@ Pandas 0.24.0 includes a number of API breaking changes.
Dependencies have increased minimum versions
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-We have updated our minimum supported versions of dependencies (:issue:`21242`, :issue:`18742`, :issue:`23774`).
+We have updated our minimum supported versions of dependencies (:issue:`21242`, :issue:`18742`, :issue:`23774`, :issue:`24767`).
If installed, we now require:
+-----------------+-----------------+----------+
@@ -456,7 +456,7 @@ If installed, we now require:
+-----------------+-----------------+----------+
| pandas-gbq | 0.8.0 | |
+-----------------+-----------------+----------+
-| pyarrow | 0.7.0 | |
+| pyarrow | 0.9.0 | |
+-----------------+-----------------+----------+
| pytables | 3.4.2 | |
+-----------------+-----------------+----------+
diff --git a/environment.yml b/environment.yml
index 7a177cfee3d39..47fe8e4c2a640 100644
--- a/environment.yml
+++ b/environment.yml
@@ -39,7 +39,7 @@ dependencies:
- nbsphinx
- numexpr>=2.6.8
- openpyxl
- - pyarrow>=0.7.0
+ - pyarrow>=0.9.0
- pytables>=3.4.2
- pytest-cov
- pytest-xdist
diff --git a/pandas/io/feather_format.py b/pandas/io/feather_format.py
index 5c8ab37c7c917..d76e6b75d3762 100644
--- a/pandas/io/feather_format.py
+++ b/pandas/io/feather_format.py
@@ -24,8 +24,8 @@ def _try_import():
"or via pip\n"
"pip install -U pyarrow\n")
- if LooseVersion(pyarrow.__version__) < LooseVersion('0.4.1'):
- raise ImportError("pyarrow >= 0.4.1 required for feather support\n\n"
+ if LooseVersion(pyarrow.__version__) < LooseVersion('0.9.0'):
+ raise ImportError("pyarrow >= 0.9.0 required for feather support\n\n"
"you can install via conda\n"
"conda install pyarrow -c conda-forge"
"or via pip\n"
diff --git a/pandas/io/parquet.py b/pandas/io/parquet.py
index a40fe0c9aa74f..dada9000d901a 100644
--- a/pandas/io/parquet.py
+++ b/pandas/io/parquet.py
@@ -89,9 +89,9 @@ def __init__(self):
"\nor via pip\n"
"pip install -U pyarrow\n"
)
- if LooseVersion(pyarrow.__version__) < '0.7.0':
+ if LooseVersion(pyarrow.__version__) < '0.9.0':
raise ImportError(
- "pyarrow >= 0.7.0 is required for parquet support\n\n"
+ "pyarrow >= 0.9.0 is required for parquet support\n\n"
"you can install via conda\n"
"conda install pyarrow -c conda-forge\n"
"\nor via pip\n"
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index 8833c6f7813c6..01a47a67ad1b6 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -47,8 +47,6 @@ def engine(request):
def pa():
if not _HAVE_PYARROW:
pytest.skip("pyarrow is not installed")
- if LooseVersion(pyarrow.__version__) < LooseVersion('0.7.0'):
- pytest.skip("pyarrow is < 0.7.0")
return 'pyarrow'
@@ -289,11 +287,6 @@ def test_read_columns(self, engine):
def test_write_index(self, engine):
check_names = engine != 'fastparquet'
- if engine == 'pyarrow':
- import pyarrow
- if LooseVersion(pyarrow.__version__) < LooseVersion('0.7.0'):
- pytest.skip("pyarrow is < 0.7.0")
-
df = pd.DataFrame({'A': [1, 2, 3]})
check_round_trip(df, engine)
@@ -386,10 +379,8 @@ def test_basic(self, pa, df_full):
df = df_full
# additional supported types for pyarrow
- import pyarrow
- if LooseVersion(pyarrow.__version__) >= LooseVersion('0.7.0'):
- df['datetime_tz'] = pd.date_range('20130101', periods=3,
- tz='Europe/Brussels')
+ df['datetime_tz'] = pd.date_range('20130101', periods=3,
+ tz='Europe/Brussels')
df['bool_with_none'] = [True, None, True]
check_round_trip(df, pa)
diff --git a/requirements-dev.txt b/requirements-dev.txt
index ba78430a4b19e..76aaeefa648f4 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -28,7 +28,7 @@ matplotlib>=2.0.0
nbsphinx
numexpr>=2.6.8
openpyxl
-pyarrow>=0.7.0
+pyarrow>=0.9.0
tables>=3.4.2
pytest-cov
pytest-xdist
| xref:
* https://github.com/pandas-dev/pandas/issues/24617#issuecomment-451702104
* https://github.com/pandas-dev/pandas/issues/24767#issuecomment-455468954
* https://github.com/pandas-dev/pandas/issues/24617#issuecomment-451774147
Closes #24767. | https://api.github.com/repos/pandas-dev/pandas/pulls/24854 | 2019-01-21T01:27:57Z | 2019-01-21T02:46:33Z | 2019-01-21T02:46:32Z | 2019-01-21T03:04:24Z |
DOC: CategoricalIndex doc string | diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index c6d31339f950d..b494c41c3b58c 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -42,20 +42,35 @@
typ='method', overwrite=True)
class CategoricalIndex(Index, accessor.PandasDelegate):
"""
- Immutable Index implementing an ordered, sliceable set. CategoricalIndex
- represents a sparsely populated Index with an underlying Categorical.
+ Index based on an underlying :class:`Categorical`.
+
+ CategoricalIndex, like Categorical, can only take on a limited,
+ and usually fixed, number of possible values (`categories`). Also,
+ like Categorical, it might have an order, but numerical operations
+ (additions, divisions, ...) are not possible.
Parameters
----------
- data : array-like or Categorical, (1-dimensional)
- categories : optional, array-like
- categories for the CategoricalIndex
- ordered : boolean,
- designating if the categories are ordered
- copy : bool
- Make a copy of input ndarray
- name : object
- Name to be stored in the index
+ data : array-like (1-dimensional)
+ The values of the categorical. If `categories` are given, values not in
+ `categories` will be replaced with NaN.
+ categories : index-like, optional
+ The categories for the categorical. Items need to be unique.
+ If the categories are not given here (and also not in `dtype`), they
+ will be inferred from the `data`.
+ ordered : bool, optional
+ Whether or not this categorical is treated as an ordered
+ categorical. If not given here or in `dtype`, the resulting
+ categorical will be unordered.
+ dtype : CategoricalDtype or the string "category", optional
+ If :class:`CategoricalDtype`, cannot be used together with
+ `categories` or `ordered`.
+
+ .. versionadded:: 0.21.0
+ copy : bool, default False
+ Make a copy of input ndarray.
+ name : object, optional
+ Name to be stored in the index.
Attributes
----------
@@ -75,9 +90,45 @@ class CategoricalIndex(Index, accessor.PandasDelegate):
as_unordered
map
+ Raises
+ ------
+ ValueError
+ If the categories do not validate.
+ TypeError
+ If an explicit ``ordered=True`` is given but no `categories` and the
+ `values` are not sortable.
+
See Also
--------
- Categorical, Index
+ Index : The base pandas Index type.
+ Categorical : A categorical array.
+ CategoricalDtype : Type for categorical data.
+
+ Notes
+ -----
+ See the `user guide
+ <http://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#categoricalindex>`_
+ for more.
+
+ Examples
+ --------
+ >>> pd.CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'])
+ CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'], categories=['a', 'b', 'c'], ordered=False, dtype='category') # noqa
+
+ ``CategoricalIndex`` can also be instantiated from a ``Categorical``:
+
+ >>> c = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
+ >>> pd.CategoricalIndex(c)
+ CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'], categories=['a', 'b', 'c'], ordered=False, dtype='category') # noqa
+
+ Ordered ``CategoricalIndex`` can have a min and max value.
+
+ >>> ci = pd.CategoricalIndex(['a','b','c','a','b','c'], ordered=True,
+ ... categories=['c', 'b', 'a'])
+ >>> ci
+ CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'], categories=['c', 'b', 'a'], ordered=True, dtype='category') # noqa
+ >>> ci.min()
+ 'c'
"""
_typ = 'categoricalindex'
| Improvements to the doc string of ``CategoricalIndex`` . | https://api.github.com/repos/pandas-dev/pandas/pulls/24852 | 2019-01-20T23:23:53Z | 2019-02-28T00:30:34Z | 2019-02-28T00:30:34Z | 2019-02-28T11:25:03Z |
fix MacPython pandas-wheels failure | diff --git a/pandas/tests/reshape/test_concat.py b/pandas/tests/reshape/test_concat.py
index 899daf488638a..ec6123bae327e 100644
--- a/pandas/tests/reshape/test_concat.py
+++ b/pandas/tests/reshape/test_concat.py
@@ -975,7 +975,8 @@ def test_append_different_columns_types_raises(
msg = (r"unorderable types: (Interval|int)\(\) > "
r"(int|long|float|str)\(\)|"
r"Expected tuple, got (int|long|float|str)|"
- r"Cannot compare type 'Timestamp' with type '(int|long)'")
+ r"Cannot compare type 'Timestamp' with type '(int|long)'|"
+ r"'>' not supported between instances of 'int' and 'str'")
with pytest.raises(TypeError, match=msg):
df.append(ser)
| xref https://github.com/pandas-dev/pandas/pull/24838#issuecomment-455878312 | https://api.github.com/repos/pandas-dev/pandas/pulls/24851 | 2019-01-20T21:30:39Z | 2019-01-20T22:14:55Z | 2019-01-20T22:14:55Z | 2019-01-20T22:29:16Z |
BUG : ValueError in case on NaN value in groupby columns | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 3268575c7064d..c2e5f3b3c9aa2 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1782,6 +1782,7 @@ Groupby/Resample/Rolling
- Bug in :meth:`DataFrame.groupby` did not respect the ``observed`` argument when selecting a column and instead always used ``observed=False`` (:issue:`23970`)
- Bug in :func:`pandas.core.groupby.SeriesGroupBy.pct_change` or :func:`pandas.core.groupby.DataFrameGroupBy.pct_change` would previously work across groups when calculating the percent change, where it now correctly works per group (:issue:`21200`, :issue:`21235`).
- Bug preventing hash table creation with very large number (2^32) of rows (:issue:`22805`)
+- Bug in groupby when grouping on categorical causes ``ValueError`` and incorrect grouping if ``observed=True`` and ``nan`` is present in categorical column (:issue:`24740`, :issue:`21151`).
Reshaping
^^^^^^^^^
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index d8df227d4911a..16c7ea687237c 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -299,6 +299,7 @@ def __init__(self, index, grouper=None, obj=None, name=None, level=None,
self._labels = self.grouper.codes
if observed:
codes = algorithms.unique1d(self.grouper.codes)
+ codes = codes[codes != -1]
else:
codes = np.arange(len(categories))
diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py
index 144b64025e1c0..e118135ccc75d 100644
--- a/pandas/tests/groupby/test_categorical.py
+++ b/pandas/tests/groupby/test_categorical.py
@@ -420,6 +420,39 @@ def test_observed_groups(observed):
tm.assert_dict_equal(result, expected)
+def test_observed_groups_with_nan(observed):
+ # GH 24740
+ df = pd.DataFrame({'cat': pd.Categorical(['a', np.nan, 'a'],
+ categories=['a', 'b', 'd']),
+ 'vals': [1, 2, 3]})
+ g = df.groupby('cat', observed=observed)
+ result = g.groups
+ if observed:
+ expected = {'a': Index([0, 2], dtype='int64')}
+ else:
+ expected = {'a': Index([0, 2], dtype='int64'),
+ 'b': Index([], dtype='int64'),
+ 'd': Index([], dtype='int64')}
+ tm.assert_dict_equal(result, expected)
+
+
+def test_dataframe_categorical_with_nan(observed):
+ # GH 21151
+ s1 = pd.Categorical([np.nan, 'a', np.nan, 'a'],
+ categories=['a', 'b', 'c'])
+ s2 = pd.Series([1, 2, 3, 4])
+ df = pd.DataFrame({'s1': s1, 's2': s2})
+ result = df.groupby('s1', observed=observed).first().reset_index()
+ if observed:
+ expected = DataFrame({'s1': pd.Categorical(['a'],
+ categories=['a', 'b', 'c']), 's2': [2]})
+ else:
+ expected = DataFrame({'s1': pd.Categorical(['a', 'b', 'c'],
+ categories=['a', 'b', 'c']),
+ 's2': [2, np.nan, np.nan]})
+ tm.assert_frame_equal(result, expected)
+
+
def test_datetime():
# GH9049: ensure backward compatibility
levels = pd.date_range('2014-01-01', periods=4)
| Fixes GH24740
- [x] closes #24740
- [x] closes #21151
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
**Before**
```python
In [5]: ds.groupby("b").groups
Out[5]: {'b': Int64Index([1], dtype='int64'), 'c': Int64Index([2], dtype='int64')}
In [6]: ds.groupby("b", observed=True).groups
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-6-d76af2ea5948> in <module>
----> 1 ds.groupby("b", observed=True).groups
~/Softwares/pandas/pandas/core/groupby/groupby.py in groups(self)
388 """
389 self._assure_grouper()
--> 390 return self.grouper.groups
391
```
**After**
```python
In [5]: ds.groupby('b',observed=True).groups
Out[5]: {'b': Int64Index([1], dtype='int64'), 'c': Int64Index([2], dtype='int64')}
```
**Better Example**
```python
In [6]: df = pd.DataFrame({'cat': pd.Categorical(['a', 'c', 'a'],
...: categories=['a', 'b', 'd', 'e', 'f']),
...: 'vals': [1, 2, 3]})
In [7]: df
Out[7]:
cat vals
0 a 1
1 NaN 2
2 a 3
In [8]: df.groupby('cat').groups
Out[8]:
{'a': Int64Index([0, 2], dtype='int64'),
'b': Int64Index([], dtype='int64'),
'd': Int64Index([], dtype='int64'),
'e': Int64Index([], dtype='int64'),
'f': Int64Index([], dtype='int64')}
In [9]: df.groupby('cat',observed=True).groups
Out[9]: {'a': Int64Index([0, 2], dtype='int64')}
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/24850 | 2019-01-20T21:14:03Z | 2019-01-22T23:29:34Z | 2019-01-22T23:29:34Z | 2019-01-22T23:29:38Z |
Start whatsnew for 0.24.1 and 0.25.0 | diff --git a/doc/source/whatsnew/v0.24.1.rst b/doc/source/whatsnew/v0.24.1.rst
new file mode 100644
index 0000000000000..ee4b7ab62b31a
--- /dev/null
+++ b/doc/source/whatsnew/v0.24.1.rst
@@ -0,0 +1,77 @@
+:orphan:
+
+.. _whatsnew_0241:
+
+Whats New in 0.24.1 (February XX, 2019)
+---------------------------------------
+
+.. warning::
+
+ The 0.24.x series of releases will be the last to support Python 2. Future feature
+ releases will support Python 3 only. See :ref:`install.dropping-27` for more.
+
+{{ header }}
+
+These are the changes in pandas 0.24.1. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+
+.. _whatsnew_0241.enhancements:
+
+Enhancements
+^^^^^^^^^^^^
+
+
+.. _whatsnew_0241.bug_fixes:
+
+Bug Fixes
+~~~~~~~~~
+
+**Conversion**
+
+-
+-
+-
+
+**Indexing**
+
+-
+-
+-
+
+**I/O**
+
+-
+-
+-
+
+**Categorical**
+
+-
+-
+-
+
+**Timezones**
+
+-
+-
+-
+
+**Timedelta**
+
+-
+-
+-
+
+
+**Other**
+
+-
+-
+
+.. _whatsnew_0.241.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v0.24.0..v0.24.1
diff --git a/doc/source/whatsnew/v0.25.0.rst b/doc/source/whatsnew/v0.25.0.rst
new file mode 100644
index 0000000000000..fac42dbd9c7c8
--- /dev/null
+++ b/doc/source/whatsnew/v0.25.0.rst
@@ -0,0 +1,206 @@
+:orphan:
+
+.. _whatsnew_0250:
+
+What's New in 0.25.0 (April XX, 2019)
+-------------------------------------
+
+{{ header }}
+
+These are the changes in pandas 0.25.0. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+
+.. _whatsnew_0250.enhancements.other:
+
+Other Enhancements
+^^^^^^^^^^^^^^^^^^
+
+-
+-
+-
+
+
+.. _whatsnew_0250.api_breaking:
+
+Backwards incompatible API changes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. _whatsnew_0250.api.other:
+
+Other API Changes
+^^^^^^^^^^^^^^^^^
+
+-
+-
+-
+
+.. _whatsnew_0250.deprecations:
+
+Deprecations
+~~~~~~~~~~~~
+
+-
+-
+-
+
+
+.. _whatsnew_0250.prior_deprecations:
+
+Removal of prior version deprecations/changes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+-
+-
+-
+
+.. _whatsnew_0250.performance:
+
+Performance Improvements
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+-
+-
+-
+
+
+.. _whatsnew_0250.bug_fixes:
+
+Bug Fixes
+~~~~~~~~~
+
+Categorical
+^^^^^^^^^^^
+
+-
+-
+-
+
+Datetimelike
+^^^^^^^^^^^^
+
+-
+-
+-
+
+Timedelta
+^^^^^^^^^
+
+-
+-
+-
+
+Timezones
+^^^^^^^^^
+
+-
+-
+-
+
+Numeric
+^^^^^^^
+
+-
+-
+-
+
+
+Conversion
+^^^^^^^^^^
+
+-
+-
+-
+
+Strings
+^^^^^^^
+
+-
+-
+-
+
+
+Interval
+^^^^^^^^
+
+-
+-
+-
+
+Indexing
+^^^^^^^^
+
+-
+-
+-
+
+
+Missing
+^^^^^^^
+
+-
+-
+-
+
+MultiIndex
+^^^^^^^^^^
+
+-
+-
+-
+
+
+I/O
+^^^
+
+-
+-
+-
+
+
+Plotting
+^^^^^^^^
+
+-
+-
+-
+
+Groupby/Resample/Rolling
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+-
+-
+-
+
+
+Reshaping
+^^^^^^^^^
+
+-
+-
+-
+
+
+Sparse
+^^^^^^
+
+-
+-
+-
+
+
+Other
+^^^^^
+
+-
+-
+-
+
+
+.. _whatsnew_0.250.contributors:
+
+Contributors
+~~~~~~~~~~~~
+
+.. contributors:: v0.24.x..HEAD
+
| https://api.github.com/repos/pandas-dev/pandas/pulls/24848 | 2019-01-20T19:59:47Z | 2019-01-21T13:21:49Z | 2019-01-21T13:21:49Z | 2019-01-21T13:21:54Z | |
ERR/TST: Add pytest idiom to dtypes/test_cast.py | diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 4049b0321f221..ad62146dda268 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -354,7 +354,7 @@ def infer_dtype_from_scalar(val, pandas_dtype=False):
# a 1-element ndarray
if isinstance(val, np.ndarray):
- msg = "invalid ndarray passed to _infer_dtype_from_scalar"
+ msg = "invalid ndarray passed to infer_dtype_from_scalar"
if val.ndim != 0:
raise ValueError(msg)
diff --git a/pandas/tests/dtypes/cast/__init__.py b/pandas/tests/dtypes/cast/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/dtypes/cast/test_construct_from_scalar.py b/pandas/tests/dtypes/cast/test_construct_from_scalar.py
new file mode 100644
index 0000000000000..d0f58c811e34c
--- /dev/null
+++ b/pandas/tests/dtypes/cast/test_construct_from_scalar.py
@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+from pandas.core.dtypes.cast import construct_1d_arraylike_from_scalar
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+from pandas import Categorical
+from pandas.util import testing as tm
+
+
+def test_cast_1d_array_like_from_scalar_categorical():
+ # see gh-19565
+ #
+ # Categorical result from scalar did not maintain
+ # categories and ordering of the passed dtype.
+ cats = ["a", "b", "c"]
+ cat_type = CategoricalDtype(categories=cats, ordered=False)
+ expected = Categorical(["a", "a"], categories=cats)
+
+ result = construct_1d_arraylike_from_scalar("a", len(expected), cat_type)
+ tm.assert_categorical_equal(result, expected,
+ check_category_order=True,
+ check_dtype=True)
diff --git a/pandas/tests/dtypes/cast/test_construct_ndarray.py b/pandas/tests/dtypes/cast/test_construct_ndarray.py
new file mode 100644
index 0000000000000..aa2cb25e62d52
--- /dev/null
+++ b/pandas/tests/dtypes/cast/test_construct_ndarray.py
@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import construct_1d_ndarray_preserving_na
+
+from pandas.util import testing as tm
+
+
+@pytest.mark.parametrize('values, dtype, expected', [
+ ([1, 2, 3], None, np.array([1, 2, 3])),
+ (np.array([1, 2, 3]), None, np.array([1, 2, 3])),
+ (['1', '2', None], None, np.array(['1', '2', None])),
+ (['1', '2', None], np.dtype('str'), np.array(['1', '2', None])),
+ ([1, 2, None], np.dtype('str'), np.array(['1', '2', None])),
+])
+def test_construct_1d_ndarray_preserving_na(values, dtype, expected):
+ result = construct_1d_ndarray_preserving_na(values, dtype=dtype)
+ tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/dtypes/cast/test_construct_object_arr.py b/pandas/tests/dtypes/cast/test_construct_object_arr.py
new file mode 100644
index 0000000000000..61fc17880ed65
--- /dev/null
+++ b/pandas/tests/dtypes/cast/test_construct_object_arr.py
@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
+
+
+@pytest.mark.parametrize("datum1", [1, 2., "3", (4, 5), [6, 7], None])
+@pytest.mark.parametrize("datum2", [8, 9., "10", (11, 12), [13, 14], None])
+def test_cast_1d_array(datum1, datum2):
+ data = [datum1, datum2]
+ result = construct_1d_object_array_from_listlike(data)
+
+ # Direct comparison fails: https://github.com/numpy/numpy/issues/10218
+ assert result.dtype == "object"
+ assert list(result) == data
+
+
+@pytest.mark.parametrize("val", [1, 2., None])
+def test_cast_1d_array_invalid_scalar(val):
+ with pytest.raises(TypeError, match="has no len()"):
+ construct_1d_object_array_from_listlike(val)
diff --git a/pandas/tests/dtypes/cast/test_convert_objects.py b/pandas/tests/dtypes/cast/test_convert_objects.py
new file mode 100644
index 0000000000000..58ba4161e96a9
--- /dev/null
+++ b/pandas/tests/dtypes/cast/test_convert_objects.py
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import maybe_convert_objects
+
+
+@pytest.mark.parametrize("data", [[1, 2], ["apply", "banana"]])
+@pytest.mark.parametrize("copy", [True, False])
+def test_maybe_convert_objects_copy(data, copy):
+ arr = np.array(data)
+ out = maybe_convert_objects(arr, copy=copy)
+
+ assert (arr is out) is (not copy)
diff --git a/pandas/tests/dtypes/cast/test_downcast.py b/pandas/tests/dtypes/cast/test_downcast.py
new file mode 100644
index 0000000000000..41607c948b909
--- /dev/null
+++ b/pandas/tests/dtypes/cast/test_downcast.py
@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import maybe_downcast_to_dtype
+
+from pandas import DatetimeIndex, Series, Timestamp
+from pandas.util import testing as tm
+
+
+@pytest.mark.parametrize("arr,dtype,expected", [
+ (np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995]), "infer",
+ np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995])),
+
+ (np.array([8., 8., 8., 8., 8.9999999999995]), "infer",
+ np.array([8, 8, 8, 8, 9], dtype=np.int64)),
+
+ (np.array([8., 8., 8., 8., 9.0000000000005]), "infer",
+ np.array([8, 8, 8, 8, 9], dtype=np.int64)),
+])
+def test_downcast(arr, expected, dtype):
+ result = maybe_downcast_to_dtype(arr, dtype)
+ tm.assert_numpy_array_equal(result, expected)
+
+
+def test_downcast_booleans():
+ # see gh-16875: coercing of booleans.
+ ser = Series([True, True, False])
+ result = maybe_downcast_to_dtype(ser, np.dtype(np.float64))
+
+ expected = ser
+ tm.assert_series_equal(result, expected)
+
+
+def test_downcast_conversion_no_nan(any_real_dtype):
+ dtype = any_real_dtype
+ expected = np.array([1, 2])
+ arr = np.array([1.0, 2.0], dtype=dtype)
+
+ result = maybe_downcast_to_dtype(arr, "infer")
+ tm.assert_almost_equal(result, expected, check_dtype=False)
+
+
+def test_downcast_conversion_nan(float_dtype):
+ dtype = float_dtype
+ data = [1.0, 2.0, np.nan]
+
+ expected = np.array(data, dtype=dtype)
+ arr = np.array(data, dtype=dtype)
+
+ result = maybe_downcast_to_dtype(arr, "infer")
+ tm.assert_almost_equal(result, expected)
+
+
+def test_downcast_conversion_empty(any_real_dtype):
+ dtype = any_real_dtype
+ arr = np.array([], dtype=dtype)
+ result = maybe_downcast_to_dtype(arr, "int64")
+ tm.assert_numpy_array_equal(result, np.array([], dtype=np.int64))
+
+
+@pytest.mark.parametrize("klass", [np.datetime64, np.timedelta64])
+def test_datetime_likes_nan(klass):
+ dtype = klass.__name__ + "[ns]"
+ arr = np.array([1, 2, np.nan])
+
+ exp = np.array([1, 2, klass("NaT")], dtype)
+ res = maybe_downcast_to_dtype(arr, dtype)
+ tm.assert_numpy_array_equal(res, exp)
+
+
+@pytest.mark.parametrize("as_asi", [True, False])
+def test_datetime_with_timezone(as_asi):
+ # see gh-15426
+ ts = Timestamp("2016-01-01 12:00:00", tz="US/Pacific")
+ exp = DatetimeIndex([ts, ts])
+
+ obj = exp.asi8 if as_asi else exp
+ res = maybe_downcast_to_dtype(obj, exp.dtype)
+
+ tm.assert_index_equal(res, exp)
diff --git a/pandas/tests/dtypes/cast/test_find_common_type.py b/pandas/tests/dtypes/cast/test_find_common_type.py
new file mode 100644
index 0000000000000..d83c8d03e9e42
--- /dev/null
+++ b/pandas/tests/dtypes/cast/test_find_common_type.py
@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import find_common_type
+from pandas.core.dtypes.dtypes import (
+ CategoricalDtype, DatetimeTZDtype, PeriodDtype)
+
+
+@pytest.mark.parametrize("source_dtypes,expected_common_dtype", [
+ ((np.int64,), np.int64),
+ ((np.uint64,), np.uint64),
+ ((np.float32,), np.float32),
+ ((np.object,), np.object),
+
+ # Into ints.
+ ((np.int16, np.int64), np.int64),
+ ((np.int32, np.uint32), np.int64),
+ ((np.uint16, np.uint64), np.uint64),
+
+ # Into floats.
+ ((np.float16, np.float32), np.float32),
+ ((np.float16, np.int16), np.float32),
+ ((np.float32, np.int16), np.float32),
+ ((np.uint64, np.int64), np.float64),
+ ((np.int16, np.float64), np.float64),
+ ((np.float16, np.int64), np.float64),
+
+ # Into others.
+ ((np.complex128, np.int32), np.complex128),
+ ((np.object, np.float32), np.object),
+ ((np.object, np.int16), np.object),
+
+ # Bool with int.
+ ((np.dtype("bool"), np.int64), np.object),
+ ((np.dtype("bool"), np.int32), np.object),
+ ((np.dtype("bool"), np.int16), np.object),
+ ((np.dtype("bool"), np.int8), np.object),
+ ((np.dtype("bool"), np.uint64), np.object),
+ ((np.dtype("bool"), np.uint32), np.object),
+ ((np.dtype("bool"), np.uint16), np.object),
+ ((np.dtype("bool"), np.uint8), np.object),
+
+ # Bool with float.
+ ((np.dtype("bool"), np.float64), np.object),
+ ((np.dtype("bool"), np.float32), np.object),
+
+ ((np.dtype("datetime64[ns]"), np.dtype("datetime64[ns]")),
+ np.dtype("datetime64[ns]")),
+ ((np.dtype("timedelta64[ns]"), np.dtype("timedelta64[ns]")),
+ np.dtype("timedelta64[ns]")),
+
+ ((np.dtype("datetime64[ns]"), np.dtype("datetime64[ms]")),
+ np.dtype("datetime64[ns]")),
+ ((np.dtype("timedelta64[ms]"), np.dtype("timedelta64[ns]")),
+ np.dtype("timedelta64[ns]")),
+
+ ((np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]")), np.object),
+ ((np.dtype("datetime64[ns]"), np.int64), np.object)
+])
+def test_numpy_dtypes(source_dtypes, expected_common_dtype):
+ assert find_common_type(source_dtypes) == expected_common_dtype
+
+
+def test_raises_empty_input():
+ with pytest.raises(ValueError, match="no types given"):
+ find_common_type([])
+
+
+@pytest.mark.parametrize("dtypes,exp_type", [
+ ([CategoricalDtype()], "category"),
+ ([np.object, CategoricalDtype()], np.object),
+ ([CategoricalDtype(), CategoricalDtype()], "category"),
+])
+def test_categorical_dtype(dtypes, exp_type):
+ assert find_common_type(dtypes) == exp_type
+
+
+def test_datetimetz_dtype_match():
+ dtype = DatetimeTZDtype(unit="ns", tz="US/Eastern")
+ assert find_common_type([dtype, dtype]) == "datetime64[ns, US/Eastern]"
+
+
+@pytest.mark.parametrize("dtype2", [
+ DatetimeTZDtype(unit="ns", tz="Asia/Tokyo"),
+ np.dtype("datetime64[ns]"), np.object, np.int64
+])
+def test_datetimetz_dtype_mismatch(dtype2):
+ dtype = DatetimeTZDtype(unit="ns", tz="US/Eastern")
+ assert find_common_type([dtype, dtype2]) == np.object
+ assert find_common_type([dtype2, dtype]) == np.object
+
+
+def test_period_dtype_match():
+ dtype = PeriodDtype(freq="D")
+ assert find_common_type([dtype, dtype]) == "period[D]"
+
+
+@pytest.mark.parametrize("dtype2", [
+ DatetimeTZDtype(unit="ns", tz="Asia/Tokyo"),
+ PeriodDtype(freq="2D"), PeriodDtype(freq="H"),
+ np.dtype("datetime64[ns]"), np.object, np.int64
+])
+def test_period_dtype_mismatch(dtype2):
+ dtype = PeriodDtype(freq="D")
+ assert find_common_type([dtype, dtype2]) == np.object
+ assert find_common_type([dtype2, dtype]) == np.object
diff --git a/pandas/tests/dtypes/cast/test_infer_datetimelike.py b/pandas/tests/dtypes/cast/test_infer_datetimelike.py
new file mode 100644
index 0000000000000..b2d63a6bfbd1c
--- /dev/null
+++ b/pandas/tests/dtypes/cast/test_infer_datetimelike.py
@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame, NaT, Series, Timestamp
+
+
+@pytest.mark.parametrize("data,exp_size", [
+ # see gh-16362.
+ ([[NaT, "a", "b", 0], [NaT, "b", "c", 1]], 8),
+ ([[NaT, "a", 0], [NaT, "b", 1]], 6)
+])
+def test_maybe_infer_to_datetimelike_df_construct(data, exp_size):
+ result = DataFrame(np.array(data))
+ assert result.size == exp_size
+
+
+def test_maybe_infer_to_datetimelike_ser_construct():
+ # see gh-19671.
+ result = Series(["M1701", Timestamp("20130101")])
+ assert result.dtype.kind == "O"
diff --git a/pandas/tests/dtypes/cast/test_infer_dtype.py b/pandas/tests/dtypes/cast/test_infer_dtype.py
new file mode 100644
index 0000000000000..c7842ac591ed9
--- /dev/null
+++ b/pandas/tests/dtypes/cast/test_infer_dtype.py
@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+
+from datetime import date, datetime, timedelta
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import (
+ cast_scalar_to_array, infer_dtype_from_array, infer_dtype_from_scalar)
+from pandas.core.dtypes.common import is_dtype_equal
+
+from pandas import (
+ Categorical, Period, Series, Timedelta, Timestamp, date_range)
+from pandas.util import testing as tm
+
+
+@pytest.fixture(params=[True, False])
+def pandas_dtype(request):
+ return request.param
+
+
+def test_infer_dtype_from_int_scalar(any_int_dtype):
+ # Test that infer_dtype_from_scalar is
+ # returning correct dtype for int and float.
+ data = np.dtype(any_int_dtype).type(12)
+ dtype, val = infer_dtype_from_scalar(data)
+ assert dtype == type(data)
+
+
+def test_infer_dtype_from_float_scalar(float_dtype):
+ float_dtype = np.dtype(float_dtype).type
+ data = float_dtype(12)
+
+ dtype, val = infer_dtype_from_scalar(data)
+ assert dtype == float_dtype
+
+
+@pytest.mark.parametrize("data,exp_dtype", [
+ (12, np.int64), (np.float(12), np.float64)
+])
+def test_infer_dtype_from_python_scalar(data, exp_dtype):
+ dtype, val = infer_dtype_from_scalar(data)
+ assert dtype == exp_dtype
+
+
+@pytest.mark.parametrize("bool_val", [True, False])
+def test_infer_dtype_from_boolean(bool_val):
+ dtype, val = infer_dtype_from_scalar(bool_val)
+ assert dtype == np.bool_
+
+
+def test_infer_dtype_from_complex(complex_dtype):
+ data = np.dtype(complex_dtype).type(1)
+ dtype, val = infer_dtype_from_scalar(data)
+ assert dtype == np.complex_
+
+
+@pytest.mark.parametrize("data", [np.datetime64(1, "ns"), Timestamp(1),
+ datetime(2000, 1, 1, 0, 0)])
+def test_infer_dtype_from_datetime(data):
+ dtype, val = infer_dtype_from_scalar(data)
+ assert dtype == "M8[ns]"
+
+
+@pytest.mark.parametrize("data", [np.timedelta64(1, "ns"), Timedelta(1),
+ timedelta(1)])
+def test_infer_dtype_from_timedelta(data):
+ dtype, val = infer_dtype_from_scalar(data)
+ assert dtype == "m8[ns]"
+
+
+@pytest.mark.parametrize("freq", ["M", "D"])
+def test_infer_dtype_from_period(freq, pandas_dtype):
+ p = Period("2011-01-01", freq=freq)
+ dtype, val = infer_dtype_from_scalar(p, pandas_dtype=pandas_dtype)
+
+ if pandas_dtype:
+ exp_dtype = "period[{0}]".format(freq)
+ exp_val = p.ordinal
+ else:
+ exp_dtype = np.object_
+ exp_val = p
+
+ assert dtype == exp_dtype
+ assert val == exp_val
+
+
+@pytest.mark.parametrize("data", [date(2000, 1, 1), "foo",
+ Timestamp(1, tz="US/Eastern")])
+def test_infer_dtype_misc(data):
+ dtype, val = infer_dtype_from_scalar(data)
+ assert dtype == np.object_
+
+
+@pytest.mark.parametrize("tz", ["UTC", "US/Eastern", "Asia/Tokyo"])
+def test_infer_from_scalar_tz(tz, pandas_dtype):
+ dt = Timestamp(1, tz=tz)
+ dtype, val = infer_dtype_from_scalar(dt, pandas_dtype=pandas_dtype)
+
+ if pandas_dtype:
+ exp_dtype = "datetime64[ns, {0}]".format(tz)
+ exp_val = dt.value
+ else:
+ exp_dtype = np.object_
+ exp_val = dt
+
+ assert dtype == exp_dtype
+ assert val == exp_val
+
+
+def test_infer_dtype_from_scalar_errors():
+ msg = "invalid ndarray passed to infer_dtype_from_scalar"
+
+ with pytest.raises(ValueError, match=msg):
+ infer_dtype_from_scalar(np.array([1]))
+
+
+@pytest.mark.parametrize(
+ "arr, expected, pandas_dtype",
+ [("foo", np.object_, False),
+ (b"foo", np.object_, False),
+ (1, np.int_, False),
+ (1.5, np.float_, False),
+ ([1], np.int_, False),
+ (np.array([1], dtype=np.int64), np.int64, False),
+ ([np.nan, 1, ""], np.object_, False),
+ (np.array([[1.0, 2.0]]), np.float_, False),
+ (Categorical(list("aabc")), np.object_, False),
+ (Categorical([1, 2, 3]), np.int64, False),
+ (Categorical(list("aabc")), "category", True),
+ (Categorical([1, 2, 3]), "category", True),
+ (Timestamp("20160101"), np.object_, False),
+ (np.datetime64("2016-01-01"), np.dtype("=M8[D]"), False),
+ (date_range("20160101", periods=3),
+ np.dtype("=M8[ns]"), False),
+ (date_range("20160101", periods=3, tz="US/Eastern"),
+ "datetime64[ns, US/Eastern]", True),
+ (Series([1., 2, 3]), np.float64, False),
+ (Series(list("abc")), np.object_, False),
+ (Series(date_range("20160101", periods=3, tz="US/Eastern")),
+ "datetime64[ns, US/Eastern]", True)])
+def test_infer_dtype_from_array(arr, expected, pandas_dtype):
+ dtype, _ = infer_dtype_from_array(arr, pandas_dtype=pandas_dtype)
+ assert is_dtype_equal(dtype, expected)
+
+
+@pytest.mark.parametrize("obj,dtype", [
+ (1, np.int64), (1.1, np.float64),
+ (Timestamp("2011-01-01"), "datetime64[ns]"),
+ (Timestamp("2011-01-01", tz="US/Eastern"), np.object),
+ (Period("2011-01-01", freq="D"), np.object)
+])
+def test_cast_scalar_to_array(obj, dtype):
+ shape = (3, 2)
+
+ exp = np.empty(shape, dtype=dtype)
+ exp.fill(obj)
+
+ arr = cast_scalar_to_array(shape, obj, dtype=dtype)
+ tm.assert_numpy_array_equal(arr, exp)
diff --git a/pandas/tests/dtypes/test_cast.py b/pandas/tests/dtypes/test_cast.py
deleted file mode 100644
index 871e71ea2e4b0..0000000000000
--- a/pandas/tests/dtypes/test_cast.py
+++ /dev/null
@@ -1,395 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-These test the private routines in types/cast.py
-
-"""
-
-from datetime import date, datetime, timedelta
-
-import numpy as np
-import pytest
-
-from pandas.core.dtypes.cast import (
- cast_scalar_to_array, construct_1d_arraylike_from_scalar,
- construct_1d_ndarray_preserving_na,
- construct_1d_object_array_from_listlike, find_common_type,
- infer_dtype_from_array, infer_dtype_from_scalar, maybe_convert_objects,
- maybe_downcast_to_dtype)
-from pandas.core.dtypes.common import is_dtype_equal
-from pandas.core.dtypes.dtypes import (
- CategoricalDtype, DatetimeTZDtype, PeriodDtype)
-
-import pandas as pd
-from pandas import (
- DataFrame, DatetimeIndex, NaT, Period, Series, Timedelta, Timestamp)
-from pandas.util import testing as tm
-
-
-class TestMaybeDowncast(object):
-
- def test_downcast(self):
- # test downcasting
-
- arr = np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995])
- result = maybe_downcast_to_dtype(arr, 'infer')
- tm.assert_numpy_array_equal(result, arr)
-
- arr = np.array([8., 8., 8., 8., 8.9999999999995])
- result = maybe_downcast_to_dtype(arr, 'infer')
- expected = np.array([8, 8, 8, 8, 9], dtype=np.int64)
- tm.assert_numpy_array_equal(result, expected)
-
- arr = np.array([8., 8., 8., 8., 9.0000000000005])
- result = maybe_downcast_to_dtype(arr, 'infer')
- expected = np.array([8, 8, 8, 8, 9], dtype=np.int64)
- tm.assert_numpy_array_equal(result, expected)
-
- # see gh-16875: coercing of booleans.
- ser = Series([True, True, False])
- result = maybe_downcast_to_dtype(ser, np.dtype(np.float64))
- expected = ser
- tm.assert_series_equal(result, expected)
-
- @pytest.mark.parametrize("dtype", [np.float64, object, np.int64])
- def test_downcast_conversion_no_nan(self, dtype):
- expected = np.array([1, 2])
- arr = np.array([1.0, 2.0], dtype=dtype)
-
- result = maybe_downcast_to_dtype(arr, "infer")
- tm.assert_almost_equal(result, expected, check_dtype=False)
-
- @pytest.mark.parametrize("dtype", [np.float64, object])
- def test_downcast_conversion_nan(self, dtype):
- expected = np.array([1.0, 2.0, np.nan], dtype=dtype)
- arr = np.array([1.0, 2.0, np.nan], dtype=dtype)
-
- result = maybe_downcast_to_dtype(arr, "infer")
- tm.assert_almost_equal(result, expected)
-
- @pytest.mark.parametrize("dtype", [np.int32, np.float64, np.float32,
- np.bool_, np.int64, object])
- def test_downcast_conversion_empty(self, dtype):
- arr = np.array([], dtype=dtype)
- result = maybe_downcast_to_dtype(arr, "int64")
- tm.assert_numpy_array_equal(result, np.array([], dtype=np.int64))
-
- def test_datetimelikes_nan(self):
- arr = np.array([1, 2, np.nan])
- exp = np.array([1, 2, np.datetime64('NaT')], dtype='datetime64[ns]')
- res = maybe_downcast_to_dtype(arr, 'datetime64[ns]')
- tm.assert_numpy_array_equal(res, exp)
-
- exp = np.array([1, 2, np.timedelta64('NaT')], dtype='timedelta64[ns]')
- res = maybe_downcast_to_dtype(arr, 'timedelta64[ns]')
- tm.assert_numpy_array_equal(res, exp)
-
- def test_datetime_with_timezone(self):
- # GH 15426
- ts = Timestamp("2016-01-01 12:00:00", tz='US/Pacific')
- exp = DatetimeIndex([ts, ts])
- res = maybe_downcast_to_dtype(exp, exp.dtype)
- tm.assert_index_equal(res, exp)
-
- res = maybe_downcast_to_dtype(exp.asi8, exp.dtype)
- tm.assert_index_equal(res, exp)
-
-
-class TestInferDtype(object):
-
- def test_infer_dtype_from_int_scalar(self, any_int_dtype):
- # Test that infer_dtype_from_scalar is
- # returning correct dtype for int and float.
- data = np.dtype(any_int_dtype).type(12)
- dtype, val = infer_dtype_from_scalar(data)
- assert dtype == type(data)
-
- def test_infer_dtype_from_float_scalar(self, float_dtype):
- float_dtype = np.dtype(float_dtype).type
- data = float_dtype(12)
-
- dtype, val = infer_dtype_from_scalar(data)
- assert dtype == float_dtype
-
- def test_infer_dtype_from_python_scalar(self):
- data = 12
- dtype, val = infer_dtype_from_scalar(data)
- assert dtype == np.int64
-
- data = np.float(12)
- dtype, val = infer_dtype_from_scalar(data)
- assert dtype == np.float64
-
- @pytest.mark.parametrize("bool_val", [True, False])
- def test_infer_dtype_from_boolean(self, bool_val):
- dtype, val = infer_dtype_from_scalar(bool_val)
- assert dtype == np.bool_
-
- def test_infer_dtype_from_complex(self, complex_dtype):
- data = np.dtype(complex_dtype).type(1)
- dtype, val = infer_dtype_from_scalar(data)
- assert dtype == np.complex_
-
- @pytest.mark.parametrize("data", [np.datetime64(1, "ns"), Timestamp(1),
- datetime(2000, 1, 1, 0, 0)])
- def test_infer_dtype_from_datetime(self, data):
- dtype, val = infer_dtype_from_scalar(data)
- assert dtype == "M8[ns]"
-
- @pytest.mark.parametrize("data", [np.timedelta64(1, "ns"), Timedelta(1),
- timedelta(1)])
- def test_infer_dtype_from_timedelta(self, data):
- dtype, val = infer_dtype_from_scalar(data)
- assert dtype == "m8[ns]"
-
- @pytest.mark.parametrize("freq", ["M", "D"])
- def test_infer_dtype_from_period(self, freq):
- p = Period("2011-01-01", freq=freq)
- dtype, val = infer_dtype_from_scalar(p, pandas_dtype=True)
-
- assert dtype == "period[{0}]".format(freq)
- assert val == p.ordinal
-
- dtype, val = infer_dtype_from_scalar(p)
- assert dtype == np.object_
- assert val == p
-
- @pytest.mark.parametrize("data", [date(2000, 1, 1), "foo",
- Timestamp(1, tz="US/Eastern")])
- def test_infer_dtype_misc(self, data):
- dtype, val = infer_dtype_from_scalar(data)
- assert dtype == np.object_
-
- @pytest.mark.parametrize('tz', ['UTC', 'US/Eastern', 'Asia/Tokyo'])
- def test_infer_from_scalar_tz(self, tz):
- dt = Timestamp(1, tz=tz)
- dtype, val = infer_dtype_from_scalar(dt, pandas_dtype=True)
- assert dtype == 'datetime64[ns, {0}]'.format(tz)
- assert val == dt.value
-
- dtype, val = infer_dtype_from_scalar(dt)
- assert dtype == np.object_
- assert val == dt
-
- def test_infer_dtype_from_scalar_errors(self):
- with pytest.raises(ValueError):
- infer_dtype_from_scalar(np.array([1]))
-
- @pytest.mark.parametrize(
- "arr, expected, pandas_dtype",
- [('foo', np.object_, False),
- (b'foo', np.object_, False),
- (1, np.int_, False),
- (1.5, np.float_, False),
- ([1], np.int_, False),
- (np.array([1], dtype=np.int64), np.int64, False),
- ([np.nan, 1, ''], np.object_, False),
- (np.array([[1.0, 2.0]]), np.float_, False),
- (pd.Categorical(list('aabc')), np.object_, False),
- (pd.Categorical([1, 2, 3]), np.int64, False),
- (pd.Categorical(list('aabc')), 'category', True),
- (pd.Categorical([1, 2, 3]), 'category', True),
- (Timestamp('20160101'), np.object_, False),
- (np.datetime64('2016-01-01'), np.dtype('=M8[D]'), False),
- (pd.date_range('20160101', periods=3),
- np.dtype('=M8[ns]'), False),
- (pd.date_range('20160101', periods=3, tz='US/Eastern'),
- 'datetime64[ns, US/Eastern]', True),
- (pd.Series([1., 2, 3]), np.float64, False),
- (pd.Series(list('abc')), np.object_, False),
- (pd.Series(pd.date_range('20160101', periods=3, tz='US/Eastern')),
- 'datetime64[ns, US/Eastern]', True)])
- def test_infer_dtype_from_array(self, arr, expected, pandas_dtype):
-
- dtype, _ = infer_dtype_from_array(arr, pandas_dtype=pandas_dtype)
- assert is_dtype_equal(dtype, expected)
-
- def test_cast_scalar_to_array(self):
- arr = cast_scalar_to_array((3, 2), 1, dtype=np.int64)
- exp = np.ones((3, 2), dtype=np.int64)
- tm.assert_numpy_array_equal(arr, exp)
-
- arr = cast_scalar_to_array((3, 2), 1.1)
- exp = np.empty((3, 2), dtype=np.float64)
- exp.fill(1.1)
- tm.assert_numpy_array_equal(arr, exp)
-
- arr = cast_scalar_to_array((2, 3), Timestamp('2011-01-01'))
- exp = np.empty((2, 3), dtype='datetime64[ns]')
- exp.fill(np.datetime64('2011-01-01'))
- tm.assert_numpy_array_equal(arr, exp)
-
- # pandas dtype is stored as object dtype
- obj = Timestamp('2011-01-01', tz='US/Eastern')
- arr = cast_scalar_to_array((2, 3), obj)
- exp = np.empty((2, 3), dtype=np.object)
- exp.fill(obj)
- tm.assert_numpy_array_equal(arr, exp)
-
- obj = Period('2011-01-01', freq='D')
- arr = cast_scalar_to_array((2, 3), obj)
- exp = np.empty((2, 3), dtype=np.object)
- exp.fill(obj)
- tm.assert_numpy_array_equal(arr, exp)
-
-
-class TestMaybe(object):
-
- def test_maybe_infer_to_datetimelike(self):
- # GH16362
- # pandas=0.20.1 raises IndexError: tuple index out of range
- result = DataFrame(np.array([[NaT, 'a', 'b', 0],
- [NaT, 'b', 'c', 1]]))
- assert result.size == 8
- # this construction was fine
- result = DataFrame(np.array([[NaT, 'a', 0],
- [NaT, 'b', 1]]))
- assert result.size == 6
-
- # GH19671
- result = Series(['M1701', Timestamp('20130101')])
- assert result.dtype.kind == 'O'
-
-
-class TestConvert(object):
-
- def test_maybe_convert_objects_copy(self):
- values = np.array([1, 2])
-
- out = maybe_convert_objects(values, copy=False)
- assert values is out
-
- out = maybe_convert_objects(values, copy=True)
- assert values is not out
-
- values = np.array(['apply', 'banana'])
- out = maybe_convert_objects(values, copy=False)
- assert values is out
-
- out = maybe_convert_objects(values, copy=True)
- assert values is not out
-
-
-class TestCommonTypes(object):
-
- @pytest.mark.parametrize("source_dtypes,expected_common_dtype", [
- ((np.int64,), np.int64),
- ((np.uint64,), np.uint64),
- ((np.float32,), np.float32),
- ((np.object,), np.object),
-
- # into ints
- ((np.int16, np.int64), np.int64),
- ((np.int32, np.uint32), np.int64),
- ((np.uint16, np.uint64), np.uint64),
-
- # into floats
- ((np.float16, np.float32), np.float32),
- ((np.float16, np.int16), np.float32),
- ((np.float32, np.int16), np.float32),
- ((np.uint64, np.int64), np.float64),
- ((np.int16, np.float64), np.float64),
- ((np.float16, np.int64), np.float64),
-
- # into others
- ((np.complex128, np.int32), np.complex128),
- ((np.object, np.float32), np.object),
- ((np.object, np.int16), np.object),
-
- # bool with int
- ((np.dtype('bool'), np.int64), np.object),
- ((np.dtype('bool'), np.int32), np.object),
- ((np.dtype('bool'), np.int16), np.object),
- ((np.dtype('bool'), np.int8), np.object),
- ((np.dtype('bool'), np.uint64), np.object),
- ((np.dtype('bool'), np.uint32), np.object),
- ((np.dtype('bool'), np.uint16), np.object),
- ((np.dtype('bool'), np.uint8), np.object),
-
- # bool with float
- ((np.dtype('bool'), np.float64), np.object),
- ((np.dtype('bool'), np.float32), np.object),
-
- ((np.dtype('datetime64[ns]'), np.dtype('datetime64[ns]')),
- np.dtype('datetime64[ns]')),
- ((np.dtype('timedelta64[ns]'), np.dtype('timedelta64[ns]')),
- np.dtype('timedelta64[ns]')),
-
- ((np.dtype('datetime64[ns]'), np.dtype('datetime64[ms]')),
- np.dtype('datetime64[ns]')),
- ((np.dtype('timedelta64[ms]'), np.dtype('timedelta64[ns]')),
- np.dtype('timedelta64[ns]')),
-
- ((np.dtype('datetime64[ns]'), np.dtype('timedelta64[ns]')),
- np.object),
- ((np.dtype('datetime64[ns]'), np.int64), np.object)
- ])
- def test_numpy_dtypes(self, source_dtypes, expected_common_dtype):
- assert find_common_type(source_dtypes) == expected_common_dtype
-
- def test_raises_empty_input(self):
- with pytest.raises(ValueError):
- find_common_type([])
-
- def test_categorical_dtype(self):
- dtype = CategoricalDtype()
- assert find_common_type([dtype]) == 'category'
- assert find_common_type([dtype, dtype]) == 'category'
- assert find_common_type([np.object, dtype]) == np.object
-
- def test_datetimetz_dtype(self):
- dtype = DatetimeTZDtype(unit='ns', tz='US/Eastern')
- assert find_common_type([dtype, dtype]) == 'datetime64[ns, US/Eastern]'
-
- for dtype2 in [DatetimeTZDtype(unit='ns', tz='Asia/Tokyo'),
- np.dtype('datetime64[ns]'), np.object, np.int64]:
- assert find_common_type([dtype, dtype2]) == np.object
- assert find_common_type([dtype2, dtype]) == np.object
-
- def test_period_dtype(self):
- dtype = PeriodDtype(freq='D')
- assert find_common_type([dtype, dtype]) == 'period[D]'
-
- for dtype2 in [DatetimeTZDtype(unit='ns', tz='Asia/Tokyo'),
- PeriodDtype(freq='2D'), PeriodDtype(freq='H'),
- np.dtype('datetime64[ns]'), np.object, np.int64]:
- assert find_common_type([dtype, dtype2]) == np.object
- assert find_common_type([dtype2, dtype]) == np.object
-
- @pytest.mark.parametrize('datum1', [1, 2., "3", (4, 5), [6, 7], None])
- @pytest.mark.parametrize('datum2', [8, 9., "10", (11, 12), [13, 14], None])
- def test_cast_1d_array(self, datum1, datum2):
- data = [datum1, datum2]
- result = construct_1d_object_array_from_listlike(data)
-
- # Direct comparison fails: https://github.com/numpy/numpy/issues/10218
- assert result.dtype == 'object'
- assert list(result) == data
-
- @pytest.mark.parametrize('val', [1, 2., None])
- def test_cast_1d_array_invalid_scalar(self, val):
- pytest.raises(TypeError, construct_1d_object_array_from_listlike, val)
-
- def test_cast_1d_arraylike_from_scalar_categorical(self):
- # GH 19565 - Categorical result from scalar did not maintain categories
- # and ordering of the passed dtype
- cats = ['a', 'b', 'c']
- cat_type = CategoricalDtype(categories=cats, ordered=False)
- expected = pd.Categorical(['a', 'a'], categories=cats)
- result = construct_1d_arraylike_from_scalar('a', len(expected),
- cat_type)
- tm.assert_categorical_equal(result, expected,
- check_category_order=True,
- check_dtype=True)
-
-
-@pytest.mark.parametrize('values, dtype, expected', [
- ([1, 2, 3], None, np.array([1, 2, 3])),
- (np.array([1, 2, 3]), None, np.array([1, 2, 3])),
- (['1', '2', None], None, np.array(['1', '2', None])),
- (['1', '2', None], np.dtype('str'), np.array(['1', '2', None])),
- ([1, 2, None], np.dtype('str'), np.array(['1', '2', None])),
-])
-def test_construct_1d_ndarray_preserving_na(values, dtype, expected):
- result = construct_1d_ndarray_preserving_na(values, dtype=dtype)
- tm.assert_numpy_array_equal(result, expected)
| Also corrects error message in `infer_dtype_from_scalar`. | https://api.github.com/repos/pandas-dev/pandas/pulls/24847 | 2019-01-20T19:56:28Z | 2019-01-20T22:07:32Z | 2019-01-20T22:07:32Z | 2019-01-20T23:29:23Z |
DOC: Clean sort_values and sort_index docstrings | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index a0ee9cb253fef..63d16f7bcb78d 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -530,7 +530,7 @@ def set_axis(self, labels, axis=0, inplace=None):
The axis to update. The value 0 identifies the rows, and 1
identifies the columns.
- inplace : boolean, default None
+ inplace : bool, default None
Whether to return a new %(klass)s instance.
.. warning::
@@ -3966,35 +3966,37 @@ def add_suffix(self, suffix):
def sort_values(self, by=None, axis=0, ascending=True, inplace=False,
kind='quicksort', na_position='last'):
"""
- Sort by the values along either axis
+ Sort by the values along either axis.
Parameters
----------%(optional_by)s
axis : %(axes_single_arg)s, default 0
- Axis to be sorted
+ Axis to be sorted.
ascending : bool or list of bool, default True
Sort ascending vs. descending. Specify list for multiple sort
orders. If this is a list of bools, must match the length of
the by.
inplace : bool, default False
- if True, perform operation in-place
+ If True, perform operation in-place.
kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'
Choice of sorting algorithm. See also ndarray.np.sort for more
information. `mergesort` is the only stable algorithm. For
DataFrames, this option is only applied when sorting on a single
column or label.
na_position : {'first', 'last'}, default 'last'
- `first` puts NaNs at the beginning, `last` puts NaNs at the end
+ Puts NaNs at the beginning if `first`; `last` puts NaNs at the
+ end.
Returns
-------
- sorted_obj : %(klass)s
+ sorted_obj : DataFrame or None
+ DataFrame with sorted values if inplace=False, None otherwise.
Examples
--------
>>> df = pd.DataFrame({
- ... 'col1' : ['A', 'A', 'B', np.nan, 'D', 'C'],
- ... 'col2' : [2, 1, 9, 8, 7, 4],
+ ... 'col1': ['A', 'A', 'B', np.nan, 'D', 'C'],
+ ... 'col2': [2, 1, 9, 8, 7, 4],
... 'col3': [0, 1, 9, 4, 2, 3],
... })
>>> df
@@ -4056,32 +4058,35 @@ def sort_values(self, by=None, axis=0, ascending=True, inplace=False,
def sort_index(self, axis=0, level=None, ascending=True, inplace=False,
kind='quicksort', na_position='last', sort_remaining=True):
"""
- Sort object by labels (along an axis)
+ Sort object by labels (along an axis).
Parameters
----------
- axis : %(axes)s to direct sorting
+ axis : {0 or 'index', 1 or 'columns'}, default 0
+ The axis along which to sort. The value 0 identifies the rows,
+ and 1 identifies the columns.
level : int or level name or list of ints or list of level names
- if not None, sort on values in specified index level(s)
- ascending : boolean, default True
- Sort ascending vs. descending
+ If not None, sort on values in specified index level(s).
+ ascending : bool, default True
+ Sort ascending vs. descending.
inplace : bool, default False
- if True, perform operation in-place
+ If True, perform operation in-place.
kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'
- Choice of sorting algorithm. See also ndarray.np.sort for more
- information. `mergesort` is the only stable algorithm. For
- DataFrames, this option is only applied when sorting on a single
- column or label.
+ Choice of sorting algorithm. See also ndarray.np.sort for more
+ information. `mergesort` is the only stable algorithm. For
+ DataFrames, this option is only applied when sorting on a single
+ column or label.
na_position : {'first', 'last'}, default 'last'
- `first` puts NaNs at the beginning, `last` puts NaNs at the end.
- Not implemented for MultiIndex.
+ Puts NaNs at the beginning if `first`; `last` puts NaNs at the end.
+ Not implemented for MultiIndex.
sort_remaining : bool, default True
- if true and sorting by level and index is multilevel, sort by other
- levels too (in order) after sorting by specified level
+ If True and sorting by level and index is multilevel, sort by other
+ levels too (in order) after sorting by specified level.
Returns
-------
- sorted_obj : %(klass)s
+ sorted_obj : DataFrame or None
+ DataFrame with sorted index if inplace=False, None otherwise.
"""
inplace = validate_bool_kwarg(inplace, 'inplace')
axis = self._get_axis_number(axis)
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 0c8e697c572e8..a25aa86a47927 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -2857,13 +2857,13 @@ def sort_index(self, axis=0, level=None, ascending=True, inplace=False,
If 'first' puts NaNs at the beginning, 'last' puts NaNs at the end.
Not implemented for MultiIndex.
sort_remaining : bool, default True
- If true and sorting by level and index is multilevel, sort by other
+ If True and sorting by level and index is multilevel, sort by other
levels too (in order) after sorting by specified level.
Returns
-------
pandas.Series
- The original Series sorted by the labels
+ The original Series sorted by the labels.
See Also
--------
| Fixes some capitalization | https://api.github.com/repos/pandas-dev/pandas/pulls/24843 | 2019-01-20T00:57:42Z | 2019-01-27T03:05:47Z | 2019-01-27T03:05:47Z | 2019-01-27T03:13:54Z |
BUG-16807-1 SparseFrame fills with default_fill_value if data is None | diff --git a/doc/source/whatsnew/v0.25.0.rst b/doc/source/whatsnew/v0.25.0.rst
index 170e7f14da397..b1df419d15c1b 100644
--- a/doc/source/whatsnew/v0.25.0.rst
+++ b/doc/source/whatsnew/v0.25.0.rst
@@ -226,7 +226,7 @@ Sparse
^^^^^^
- Significant speedup in `SparseArray` initialization that benefits most operations, fixing performance regression introduced in v0.20.0 (:issue:`24985`)
--
+- Bug in :class:`SparseFrame` constructor where passing ``None`` as the data would cause ``default_fill_value`` to be ignored (:issue:`16807`)
-
diff --git a/pandas/core/sparse/frame.py b/pandas/core/sparse/frame.py
index e0af11d13774c..2d54b82a3c844 100644
--- a/pandas/core/sparse/frame.py
+++ b/pandas/core/sparse/frame.py
@@ -124,8 +124,8 @@ def __init__(self, data=None, index=None, columns=None, default_kind=None,
columns = Index([])
else:
for c in columns:
- data[c] = SparseArray(np.nan, index=index,
- kind=self._default_kind,
+ data[c] = SparseArray(self._default_fill_value,
+ index=index, kind=self._default_kind,
fill_value=self._default_fill_value)
mgr = to_manager(data, columns, index)
if dtype is not None:
diff --git a/pandas/tests/sparse/frame/test_frame.py b/pandas/tests/sparse/frame/test_frame.py
index bfb5103c97adc..d917c94e813cd 100644
--- a/pandas/tests/sparse/frame/test_frame.py
+++ b/pandas/tests/sparse/frame/test_frame.py
@@ -269,6 +269,19 @@ def test_type_coercion_at_construction(self):
default_fill_value=0)
tm.assert_sp_frame_equal(result, expected)
+ def test_default_dtype(self):
+ result = pd.SparseDataFrame(columns=list('ab'), index=range(2))
+ expected = pd.SparseDataFrame([[np.nan, np.nan], [np.nan, np.nan]],
+ columns=list('ab'), index=range(2))
+ tm.assert_sp_frame_equal(result, expected)
+
+ def test_nan_data_with_int_dtype_raises_error(self):
+ sdf = pd.SparseDataFrame([[np.nan, np.nan], [np.nan, np.nan]],
+ columns=list('ab'), index=range(2))
+ msg = "Cannot convert non-finite values"
+ with pytest.raises(ValueError, match=msg):
+ pd.SparseDataFrame(sdf, dtype=np.int64)
+
def test_dtypes(self):
df = DataFrame(np.random.randn(10000, 4))
df.loc[:9998] = np.nan
@@ -1246,6 +1259,14 @@ def test_notna(self):
'B': [True, False, True, True, False]})
tm.assert_frame_equal(res.to_dense(), exp)
+ def test_default_fill_value_with_no_data(self):
+ # GH 16807
+ expected = pd.SparseDataFrame([[1.0, 1.0], [1.0, 1.0]],
+ columns=list('ab'), index=range(2))
+ result = pd.SparseDataFrame(columns=list('ab'), index=range(2),
+ default_fill_value=1.0)
+ tm.assert_frame_equal(expected, result)
+
class TestSparseDataFrameArithmetic(object):
| - [ ] closes #16807
- [X] tests added / passed
- [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [X] whatsnew entry
Previously, the constructor for SparseFrame would default to `np.nan` if the data parameter was `None`, even if a `default_fill_value` is specified. This PR fixes this. | https://api.github.com/repos/pandas-dev/pandas/pulls/24842 | 2019-01-19T22:30:15Z | 2019-03-03T04:46:45Z | 2019-03-03T04:46:44Z | 2019-03-03T04:46:51Z |
Make DataFrame.to_html output full content | diff --git a/doc/source/whatsnew/v0.25.0.rst b/doc/source/whatsnew/v0.25.0.rst
index 4032dc20b2e19..617d65dbbde1d 100644
--- a/doc/source/whatsnew/v0.25.0.rst
+++ b/doc/source/whatsnew/v0.25.0.rst
@@ -154,6 +154,7 @@ MultiIndex
I/O
^^^
+- Bug in :func:`DataFrame.to_html()` where values were truncated using display options instead of outputting the full content (:issue:`17004`)
- Fixed bug in missing text when using :meth:`to_clipboard` if copying utf-16 characters in Python 3 on Windows (:issue:`25040`)
-
-
diff --git a/pandas/io/formats/html.py b/pandas/io/formats/html.py
index 456583509565e..66d13bf2668f9 100644
--- a/pandas/io/formats/html.py
+++ b/pandas/io/formats/html.py
@@ -12,7 +12,7 @@
from pandas.core.dtypes.generic import ABCMultiIndex
-from pandas import compat
+from pandas import compat, option_context
from pandas.core.config import get_option
from pandas.io.common import _is_url
@@ -320,9 +320,15 @@ def _write_header(self, indent):
self.write('</thead>', indent)
+ def _get_formatted_values(self):
+ with option_context('display.max_colwidth', 999999):
+ fmt_values = {i: self.fmt._format_col(i)
+ for i in range(self.ncols)}
+ return fmt_values
+
def _write_body(self, indent):
self.write('<tbody>', indent)
- fmt_values = {i: self.fmt._format_col(i) for i in range(self.ncols)}
+ fmt_values = self._get_formatted_values()
# write values
if self.fmt.index and isinstance(self.frame.index, ABCMultiIndex):
@@ -486,6 +492,9 @@ class NotebookFormatter(HTMLFormatter):
DataFrame._repr_html_() and DataFrame.to_html(notebook=True)
"""
+ def _get_formatted_values(self):
+ return {i: self.fmt._format_col(i) for i in range(self.ncols)}
+
def write_style(self):
# We use the "scoped" attribute here so that the desired
# style properties for the data frame are not then applied
diff --git a/pandas/tests/io/formats/test_to_html.py b/pandas/tests/io/formats/test_to_html.py
index 554cfd306e2a7..428f1411a10a6 100644
--- a/pandas/tests/io/formats/test_to_html.py
+++ b/pandas/tests/io/formats/test_to_html.py
@@ -15,6 +15,15 @@
import pandas.io.formats.format as fmt
+lorem_ipsum = (
+ "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod"
+ " tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim"
+ " veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex"
+ " ea commodo consequat. Duis aute irure dolor in reprehenderit in"
+ " voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur"
+ " sint occaecat cupidatat non proident, sunt in culpa qui officia"
+ " deserunt mollit anim id est laborum.")
+
def expected_html(datapath, name):
"""
@@ -600,3 +609,17 @@ def test_to_html_render_links(render_links, expected, datapath):
result = df.to_html(render_links=render_links)
expected = expected_html(datapath, expected)
assert result == expected
+
+
+@pytest.mark.parametrize('method,expected', [
+ ('to_html', lambda x:lorem_ipsum),
+ ('_repr_html_', lambda x:lorem_ipsum[:x - 4] + '...') # regression case
+])
+@pytest.mark.parametrize('max_colwidth', [10, 20, 50, 100])
+def test_ignore_display_max_colwidth(method, expected, max_colwidth):
+ # see gh-17004
+ df = DataFrame([lorem_ipsum])
+ with pd.option_context('display.max_colwidth', max_colwidth):
+ result = getattr(df, method)()
+ expected = expected(max_colwidth)
+ assert expected in result
| - [ ] closes #17004
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24841 | 2019-01-19T21:20:01Z | 2019-03-03T02:59:52Z | 2019-03-03T02:59:52Z | 2019-03-05T12:25:34Z |
STY: use pytest.raises context syntax (reshape) | diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 7861a122afdb6..e11847d2b8ce2 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -1087,7 +1087,7 @@ def _validate(self, validate):
elif validate in ["one_to_many", "1:m"]:
if not left_unique:
raise MergeError("Merge keys are not unique in left dataset;"
- "not a one-to-many merge")
+ " not a one-to-many merge")
elif validate in ["many_to_one", "m:1"]:
if not right_unique:
diff --git a/pandas/tests/reshape/merge/test_join.py b/pandas/tests/reshape/merge/test_join.py
index 8ee1e49f01ac1..e21f9d0291afa 100644
--- a/pandas/tests/reshape/merge/test_join.py
+++ b/pandas/tests/reshape/merge/test_join.py
@@ -195,38 +195,47 @@ def test_join_on(self):
assert np.isnan(joined['three']['c'])
# merge column not p resent
- pytest.raises(KeyError, target.join, source, on='E')
+ with pytest.raises(KeyError, match="^'E'$"):
+ target.join(source, on='E')
# overlap
source_copy = source.copy()
source_copy['A'] = 0
- pytest.raises(ValueError, target.join, source_copy, on='A')
+ msg = ("You are trying to merge on float64 and object columns. If"
+ " you wish to proceed you should use pd.concat")
+ with pytest.raises(ValueError, match=msg):
+ target.join(source_copy, on='A')
def test_join_on_fails_with_different_right_index(self):
- with pytest.raises(ValueError):
- df = DataFrame({'a': np.random.choice(['m', 'f'], size=3),
- 'b': np.random.randn(3)})
- df2 = DataFrame({'a': np.random.choice(['m', 'f'], size=10),
- 'b': np.random.randn(10)},
- index=tm.makeCustomIndex(10, 2))
+ df = DataFrame({'a': np.random.choice(['m', 'f'], size=3),
+ 'b': np.random.randn(3)})
+ df2 = DataFrame({'a': np.random.choice(['m', 'f'], size=10),
+ 'b': np.random.randn(10)},
+ index=tm.makeCustomIndex(10, 2))
+ msg = (r'len\(left_on\) must equal the number of levels in the index'
+ ' of "right"')
+ with pytest.raises(ValueError, match=msg):
merge(df, df2, left_on='a', right_index=True)
def test_join_on_fails_with_different_left_index(self):
- with pytest.raises(ValueError):
- df = DataFrame({'a': np.random.choice(['m', 'f'], size=3),
- 'b': np.random.randn(3)},
- index=tm.makeCustomIndex(10, 2))
- df2 = DataFrame({'a': np.random.choice(['m', 'f'], size=10),
- 'b': np.random.randn(10)})
+ df = DataFrame({'a': np.random.choice(['m', 'f'], size=3),
+ 'b': np.random.randn(3)},
+ index=tm.makeCustomIndex(3, 2))
+ df2 = DataFrame({'a': np.random.choice(['m', 'f'], size=10),
+ 'b': np.random.randn(10)})
+ msg = (r'len\(right_on\) must equal the number of levels in the index'
+ ' of "left"')
+ with pytest.raises(ValueError, match=msg):
merge(df, df2, right_on='b', left_index=True)
def test_join_on_fails_with_different_column_counts(self):
- with pytest.raises(ValueError):
- df = DataFrame({'a': np.random.choice(['m', 'f'], size=3),
- 'b': np.random.randn(3)})
- df2 = DataFrame({'a': np.random.choice(['m', 'f'], size=10),
- 'b': np.random.randn(10)},
- index=tm.makeCustomIndex(10, 2))
+ df = DataFrame({'a': np.random.choice(['m', 'f'], size=3),
+ 'b': np.random.randn(3)})
+ df2 = DataFrame({'a': np.random.choice(['m', 'f'], size=10),
+ 'b': np.random.randn(10)},
+ index=tm.makeCustomIndex(10, 2))
+ msg = r"len\(right_on\) must equal len\(left_on\)"
+ with pytest.raises(ValueError, match=msg):
merge(df, df2, right_on='a', left_on=['a', 'b'])
@pytest.mark.parametrize("wrong_type", [2, 'str', None, np.array([0, 1])])
@@ -237,9 +246,11 @@ def test_join_on_fails_with_wrong_object_type(self, wrong_type):
# Edited test to remove the Series object from test parameters
df = DataFrame({'a': [1, 1]})
- with pytest.raises(TypeError, match=str(type(wrong_type))):
+ msg = ("Can only merge Series or DataFrame objects, a {} was passed"
+ .format(str(type(wrong_type))))
+ with pytest.raises(TypeError, match=msg):
merge(wrong_type, df, left_on='a', right_on='a')
- with pytest.raises(TypeError, match=str(type(wrong_type))):
+ with pytest.raises(TypeError, match=msg):
merge(df, wrong_type, left_on='a', right_on='a')
def test_join_on_pass_vector(self):
@@ -603,7 +614,9 @@ def _check_diff_index(df_list, result, exp_index):
joined = df_list[0].join(df_list[1:], how='inner')
_check_diff_index(df_list, joined, df.index[2:8])
- pytest.raises(ValueError, df_list[0].join, df_list[1:], on='a')
+ msg = "Joining multiple DataFrames only supported for joining on index"
+ with pytest.raises(ValueError, match=msg):
+ df_list[0].join(df_list[1:], on='a')
def test_join_many_mixed(self):
df = DataFrame(np.random.randn(8, 4), columns=['A', 'B', 'C', 'D'])
@@ -725,10 +738,13 @@ def test_panel_join_many(self):
tm.assert_panel_equal(joined, expected)
# edge cases
- pytest.raises(ValueError, panels[0].join, panels[1:],
- how='outer', lsuffix='foo', rsuffix='bar')
- pytest.raises(ValueError, panels[0].join, panels[1:],
- how='right')
+ msg = "Suffixes not supported when passing multiple panels"
+ with pytest.raises(ValueError, match=msg):
+ panels[0].join(panels[1:], how='outer', lsuffix='foo',
+ rsuffix='bar')
+ msg = "Right join not supported with multiple panels"
+ with pytest.raises(ValueError, match=msg):
+ panels[0].join(panels[1:], how='right')
def test_join_multi_to_multi(self, join_type):
# GH 20475
@@ -749,10 +765,12 @@ def test_join_multi_to_multi(self, join_type):
)
assert_frame_equal(expected, result)
- with pytest.raises(ValueError):
+ msg = (r'len\(left_on\) must equal the number of levels in the index'
+ ' of "right"')
+ with pytest.raises(ValueError, match=msg):
left.join(right, on='xy', how=join_type)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
right.join(left, on=['abc', 'xy'], how=join_type)
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 2080fc542bc61..1d7c42b7328d0 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -119,25 +119,37 @@ def test_merge_index_singlekey_inner(self):
assert_frame_equal(result, expected.loc[:, result.columns])
def test_merge_misspecified(self):
- pytest.raises(ValueError, merge, self.left, self.right,
- left_index=True)
- pytest.raises(ValueError, merge, self.left, self.right,
- right_index=True)
-
- pytest.raises(ValueError, merge, self.left, self.left,
- left_on='key', on='key')
-
- pytest.raises(ValueError, merge, self.df, self.df2,
- left_on=['key1'], right_on=['key1', 'key2'])
+ msg = "Must pass right_on or right_index=True"
+ with pytest.raises(pd.errors.MergeError, match=msg):
+ merge(self.left, self.right, left_index=True)
+ msg = "Must pass left_on or left_index=True"
+ with pytest.raises(pd.errors.MergeError, match=msg):
+ merge(self.left, self.right, right_index=True)
+
+ msg = ('Can only pass argument "on" OR "left_on" and "right_on", not'
+ ' a combination of both')
+ with pytest.raises(pd.errors.MergeError, match=msg):
+ merge(self.left, self.left, left_on='key', on='key')
+
+ msg = r"len\(right_on\) must equal len\(left_on\)"
+ with pytest.raises(ValueError, match=msg):
+ merge(self.df, self.df2, left_on=['key1'],
+ right_on=['key1', 'key2'])
def test_index_and_on_parameters_confusion(self):
- pytest.raises(ValueError, merge, self.df, self.df2, how='left',
- left_index=False, right_index=['key1', 'key2'])
- pytest.raises(ValueError, merge, self.df, self.df2, how='left',
- left_index=['key1', 'key2'], right_index=False)
- pytest.raises(ValueError, merge, self.df, self.df2, how='left',
- left_index=['key1', 'key2'],
- right_index=['key1', 'key2'])
+ msg = ("right_index parameter must be of type bool, not"
+ r" <(class|type) 'list'>")
+ with pytest.raises(ValueError, match=msg):
+ merge(self.df, self.df2, how='left',
+ left_index=False, right_index=['key1', 'key2'])
+ msg = ("left_index parameter must be of type bool, not "
+ r"<(class|type) 'list'>")
+ with pytest.raises(ValueError, match=msg):
+ merge(self.df, self.df2, how='left',
+ left_index=['key1', 'key2'], right_index=False)
+ with pytest.raises(ValueError, match=msg):
+ merge(self.df, self.df2, how='left',
+ left_index=['key1', 'key2'], right_index=['key1', 'key2'])
def test_merge_overlap(self):
merged = merge(self.left, self.left, on='key')
@@ -269,7 +281,6 @@ def test_no_overlap_more_informative_error(self):
df1 = DataFrame({'x': ['a']}, index=[dt])
df2 = DataFrame({'y': ['b', 'c']}, index=[dt, dt])
- pytest.raises(MergeError, merge, df1, df2)
msg = ('No common columns to perform merge on. '
'Merge options: left_on={lon}, right_on={ron}, '
@@ -566,7 +577,10 @@ def test_overlapping_columns_error_message(self):
# #2649, #10639
df2.columns = ['key1', 'foo', 'foo']
- pytest.raises(ValueError, merge, df, df2)
+ msg = (r"Data columns not unique: Index\(\[u?'foo', u?'foo'\],"
+ r" dtype='object'\)")
+ with pytest.raises(MergeError, match=msg):
+ merge(df, df2)
def test_merge_on_datetime64tz(self):
@@ -717,9 +731,10 @@ def test_indicator(self):
assert_frame_equal(test_custom_name, df_result_custom_name)
# Check only accepts strings and booleans
- with pytest.raises(ValueError):
+ msg = "indicator option can only accept boolean or string arguments"
+ with pytest.raises(ValueError, match=msg):
merge(df1, df2, on='col1', how='outer', indicator=5)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
df1.merge(df2, on='col1', how='outer', indicator=5)
# Check result integrity
@@ -743,20 +758,25 @@ def test_indicator(self):
for i in ['_right_indicator', '_left_indicator', '_merge']:
df_badcolumn = DataFrame({'col1': [1, 2], i: [2, 2]})
- with pytest.raises(ValueError):
+ msg = ("Cannot use `indicator=True` option when data contains a"
+ " column named {}|"
+ "Cannot use name of an existing column for indicator"
+ " column").format(i)
+ with pytest.raises(ValueError, match=msg):
merge(df1, df_badcolumn, on='col1',
how='outer', indicator=True)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
df1.merge(df_badcolumn, on='col1', how='outer', indicator=True)
# Check for name conflict with custom name
df_badcolumn = DataFrame(
{'col1': [1, 2], 'custom_column_name': [2, 2]})
- with pytest.raises(ValueError):
+ msg = "Cannot use name of an existing column for indicator column"
+ with pytest.raises(ValueError, match=msg):
merge(df1, df_badcolumn, on='col1', how='outer',
indicator='custom_column_name')
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
df1.merge(df_badcolumn, on='col1', how='outer',
indicator='custom_column_name')
@@ -843,11 +863,13 @@ def test_validation(self):
merge(left, right_w_dups, left_index=True, right_index=True,
validate='one_to_many')
- with pytest.raises(MergeError):
+ msg = ("Merge keys are not unique in right dataset; not a one-to-one"
+ " merge")
+ with pytest.raises(MergeError, match=msg):
merge(left, right_w_dups, left_index=True, right_index=True,
validate='one_to_one')
- with pytest.raises(MergeError):
+ with pytest.raises(MergeError, match=msg):
merge(left, right_w_dups, on='a', validate='one_to_one')
# Dups on left
@@ -856,26 +878,33 @@ def test_validation(self):
merge(left_w_dups, right, left_index=True, right_index=True,
validate='many_to_one')
- with pytest.raises(MergeError):
+ msg = ("Merge keys are not unique in left dataset; not a one-to-one"
+ " merge")
+ with pytest.raises(MergeError, match=msg):
merge(left_w_dups, right, left_index=True, right_index=True,
validate='one_to_one')
- with pytest.raises(MergeError):
+ with pytest.raises(MergeError, match=msg):
merge(left_w_dups, right, on='a', validate='one_to_one')
# Dups on both
merge(left_w_dups, right_w_dups, on='a', validate='many_to_many')
- with pytest.raises(MergeError):
+ msg = ("Merge keys are not unique in right dataset; not a many-to-one"
+ " merge")
+ with pytest.raises(MergeError, match=msg):
merge(left_w_dups, right_w_dups, left_index=True,
right_index=True, validate='many_to_one')
- with pytest.raises(MergeError):
+ msg = ("Merge keys are not unique in left dataset; not a one-to-many"
+ " merge")
+ with pytest.raises(MergeError, match=msg):
merge(left_w_dups, right_w_dups, on='a',
validate='one_to_many')
# Check invalid arguments
- with pytest.raises(ValueError):
+ msg = "Not a valid argument for validate"
+ with pytest.raises(ValueError, match=msg):
merge(left, right, on='a', validate='jibberish')
# Two column merge, dups in both, but jointly no dups.
@@ -896,7 +925,9 @@ def test_validation(self):
'um... weasel noise?']},
index=range(3))
- with pytest.raises(MergeError):
+ msg = ("Merge keys are not unique in either left or right dataset;"
+ " not a one-to-one merge")
+ with pytest.raises(MergeError, match=msg):
merge(left, right, on='a', validate='1:1')
result = merge(left, right, on=['a', 'b'], validate='1:1')
@@ -1439,6 +1470,7 @@ def test_merge_series(on, left_on, right_on, left_index, right_index, nm):
left_index=left_index, right_index=right_index)
tm.assert_frame_equal(result, expected)
else:
- with pytest.raises(ValueError, match='a Series without a name'):
+ msg = "Cannot merge a Series without a name"
+ with pytest.raises(ValueError, match=msg):
result = pd.merge(a, b, on=on, left_on=left_on, right_on=right_on,
left_index=left_index, right_index=right_index)
diff --git a/pandas/tests/reshape/test_concat.py b/pandas/tests/reshape/test_concat.py
index 7814cbaba4a50..899daf488638a 100644
--- a/pandas/tests/reshape/test_concat.py
+++ b/pandas/tests/reshape/test_concat.py
@@ -777,7 +777,8 @@ def test_append(self, sort):
assert appended is not self.frame
# Overlap
- with pytest.raises(ValueError):
+ msg = "Indexes have overlapping values"
+ with pytest.raises(ValueError, match=msg):
self.frame.append(self.frame, verify_integrity=True)
# see gh-6129: new columns
@@ -960,13 +961,22 @@ def test_append_different_columns_types_raises(
df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=index_can_append)
ser = pd.Series([7, 8, 9], index=index_cannot_append_with_other,
name=2)
- with pytest.raises(TypeError):
+ msg = ("the other index needs to be an IntervalIndex too, but was"
+ r" type {}|"
+ r"object of type '(int|long|float|Timestamp)' has no len\(\)|"
+ "Expected tuple, got str")
+ with pytest.raises(TypeError, match=msg.format(
+ index_can_append.__class__.__name__)):
df.append(ser)
df = pd.DataFrame([[1, 2, 3], [4, 5, 6]],
columns=index_cannot_append_with_other)
ser = pd.Series([7, 8, 9], index=index_can_append, name=2)
- with pytest.raises(TypeError):
+ msg = (r"unorderable types: (Interval|int)\(\) > "
+ r"(int|long|float|str)\(\)|"
+ r"Expected tuple, got (int|long|float|str)|"
+ r"Cannot compare type 'Timestamp' with type '(int|long)'")
+ with pytest.raises(TypeError, match=msg):
df.append(ser)
def test_append_dtype_coerce(self, sort):
@@ -1291,11 +1301,15 @@ def test_concat_keys_levels_no_overlap(self):
df = DataFrame(np.random.randn(1, 3), index=['a'])
df2 = DataFrame(np.random.randn(1, 4), index=['b'])
- pytest.raises(ValueError, concat, [df, df],
- keys=['one', 'two'], levels=[['foo', 'bar', 'baz']])
+ msg = "Values not found in passed level"
+ with pytest.raises(ValueError, match=msg):
+ concat([df, df],
+ keys=['one', 'two'], levels=[['foo', 'bar', 'baz']])
- pytest.raises(ValueError, concat, [df, df2],
- keys=['one', 'two'], levels=[['foo', 'bar', 'baz']])
+ msg = "Key one not in level"
+ with pytest.raises(ValueError, match=msg):
+ concat([df, df2],
+ keys=['one', 'two'], levels=[['foo', 'bar', 'baz']])
def test_concat_rename_index(self):
a = DataFrame(np.random.rand(3, 3),
@@ -1488,7 +1502,10 @@ def test_concat_mixed_objs(self):
with catch_warnings(record=True):
simplefilter("ignore", FutureWarning)
panel = tm.makePanel()
- pytest.raises(ValueError, lambda: concat([panel, s1], axis=1))
+ msg = ("cannot concatenate unaligned mixed dimensional NDFrame"
+ " objects")
+ with pytest.raises(ValueError, match=msg):
+ concat([panel, s1], axis=1)
def test_empty_dtype_coerce(self):
@@ -1666,7 +1683,8 @@ def test_concat_exclude_none(self):
pieces = [df[:5], None, None, df[5:]]
result = concat(pieces)
tm.assert_frame_equal(result, df)
- pytest.raises(ValueError, concat, [None, None])
+ with pytest.raises(ValueError, match="All objects passed were None"):
+ concat([None, None])
def test_concat_datetime64_block(self):
from pandas.core.indexes.datetimes import date_range
@@ -1799,13 +1817,20 @@ def test_concat_invalid(self):
# trying to concat a ndframe with a non-ndframe
df1 = mkdf(10, 2)
+ msg = ('cannot concatenate object of type "{}";'
+ ' only pd.Series, pd.DataFrame, and pd.Panel'
+ r' \(deprecated\) objs are valid')
for obj in [1, dict(), [1, 2], (1, 2)]:
- pytest.raises(TypeError, lambda x: concat([df1, obj]))
+ with pytest.raises(TypeError, match=msg.format(type(obj))):
+ concat([df1, obj])
def test_concat_invalid_first_argument(self):
df1 = mkdf(10, 2)
df2 = mkdf(10, 2)
- pytest.raises(TypeError, concat, df1, df2)
+ msg = ('first argument must be an iterable of pandas '
+ 'objects, you passed an object of type "DataFrame"')
+ with pytest.raises(TypeError, match=msg):
+ concat(df1, df2)
# generator ok though
concat(DataFrame(np.random.rand(5, 5)) for _ in range(3))
@@ -2310,7 +2335,9 @@ def test_categorical_index_preserver(self):
# wrong catgories
df3 = DataFrame({'A': a, 'B': Categorical(b, categories=list('abe'))
}).set_index('B')
- pytest.raises(TypeError, lambda: pd.concat([df2, df3]))
+ msg = "categories must match existing categories when appending"
+ with pytest.raises(TypeError, match=msg):
+ pd.concat([df2, df3])
def test_concat_categoricalindex(self):
# GH 16111, categories that aren't lexsorted
diff --git a/pandas/tests/reshape/test_melt.py b/pandas/tests/reshape/test_melt.py
index 6b633d7e77f52..6bd1958633e25 100644
--- a/pandas/tests/reshape/test_melt.py
+++ b/pandas/tests/reshape/test_melt.py
@@ -116,9 +116,11 @@ def test_tuple_vars_fail_with_multiindex(self):
tuple_b = ('B', 'b')
list_b = [tuple_b]
+ msg = (r"(id|value)_vars must be a list of tuples when columns are"
+ " a MultiIndex")
for id_vars, value_vars in ((tuple_a, list_b), (list_a, tuple_b),
(tuple_a, tuple_b)):
- with pytest.raises(ValueError, match=r'MultiIndex'):
+ with pytest.raises(ValueError, match=msg):
self.df1.melt(id_vars=id_vars, value_vars=value_vars)
def test_custom_var_name(self):
@@ -352,7 +354,9 @@ def test_pairs(self):
spec = {'visitdt': ['visitdt%d' % i for i in range(1, 3)],
'wt': ['wt%d' % i for i in range(1, 4)]}
- pytest.raises(ValueError, lreshape, df, spec)
+ msg = "All column lists must be same length"
+ with pytest.raises(ValueError, match=msg):
+ lreshape(df, spec)
class TestWideToLong(object):
@@ -603,7 +607,8 @@ def test_non_unique_idvars(self):
'B_B1': [1, 2, 3, 4, 5],
'x': [1, 1, 1, 1, 1]
})
- with pytest.raises(ValueError):
+ msg = "the id variables need to uniquely identify each row"
+ with pytest.raises(ValueError, match=msg):
wide_to_long(df, ['A_A', 'B_B'], i='x', j='colname')
def test_cast_j_int(self):
@@ -639,7 +644,8 @@ def test_identical_stubnames(self):
'A2011': [3.0, 4.0],
'B2010': [5.0, 6.0],
'A': ['X1', 'X2']})
- with pytest.raises(ValueError):
+ msg = "stubname can't be identical to a column name"
+ with pytest.raises(ValueError, match=msg):
wide_to_long(df, ['A', 'B'], i='A', j='colname')
def test_nonnumeric_suffix(self):
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 7c70f8177d846..e4fbb204af533 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -526,7 +526,7 @@ def test_pivot_with_tuple_of_values(self, method):
'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
'baz': [1, 2, 3, 4, 5, 6],
'zoo': ['x', 'y', 'z', 'q', 'w', 't']})
- with pytest.raises(KeyError):
+ with pytest.raises(KeyError, match=r"^\('bar', 'baz'\)$"):
# tuple is seen as a single column name
if method:
df.pivot(index='zoo', columns='foo', values=('bar', 'baz'))
@@ -742,24 +742,27 @@ def test_margins_no_values_two_row_two_cols(self):
index=['A', 'B'], columns=['C', 'D'], aggfunc=len, margins=True)
assert result.All.tolist() == [3.0, 1.0, 4.0, 3.0, 11.0]
- def test_pivot_table_with_margins_set_margin_name(self):
+ @pytest.mark.parametrize(
+ 'margin_name', ['foo', 'one', 666, None, ['a', 'b']])
+ def test_pivot_table_with_margins_set_margin_name(self, margin_name):
# see gh-3335
- for margin_name in ['foo', 'one', 666, None, ['a', 'b']]:
- with pytest.raises(ValueError):
- # multi-index index
- pivot_table(self.data, values='D', index=['A', 'B'],
- columns=['C'], margins=True,
- margins_name=margin_name)
- with pytest.raises(ValueError):
- # multi-index column
- pivot_table(self.data, values='D', index=['C'],
- columns=['A', 'B'], margins=True,
- margins_name=margin_name)
- with pytest.raises(ValueError):
- # non-multi-index index/column
- pivot_table(self.data, values='D', index=['A'],
- columns=['B'], margins=True,
- margins_name=margin_name)
+ msg = (r'Conflicting name "{}" in margins|'
+ "margins_name argument must be a string").format(margin_name)
+ with pytest.raises(ValueError, match=msg):
+ # multi-index index
+ pivot_table(self.data, values='D', index=['A', 'B'],
+ columns=['C'], margins=True,
+ margins_name=margin_name)
+ with pytest.raises(ValueError, match=msg):
+ # multi-index column
+ pivot_table(self.data, values='D', index=['C'],
+ columns=['A', 'B'], margins=True,
+ margins_name=margin_name)
+ with pytest.raises(ValueError, match=msg):
+ # non-multi-index index/column
+ pivot_table(self.data, values='D', index=['A'],
+ columns=['B'], margins=True,
+ margins_name=margin_name)
def test_pivot_timegrouper(self):
df = DataFrame({
@@ -818,13 +821,14 @@ def test_pivot_timegrouper(self):
values='Quantity', aggfunc=np.sum)
tm.assert_frame_equal(result, expected.T)
- pytest.raises(KeyError, lambda: pivot_table(
- df, index=Grouper(freq='6MS', key='foo'),
- columns='Buyer', values='Quantity', aggfunc=np.sum))
- pytest.raises(KeyError, lambda: pivot_table(
- df, index='Buyer',
- columns=Grouper(freq='6MS', key='foo'),
- values='Quantity', aggfunc=np.sum))
+ msg = "'The grouper name foo is not found'"
+ with pytest.raises(KeyError, match=msg):
+ pivot_table(df, index=Grouper(freq='6MS', key='foo'),
+ columns='Buyer', values='Quantity', aggfunc=np.sum)
+ with pytest.raises(KeyError, match=msg):
+ pivot_table(df, index='Buyer',
+ columns=Grouper(freq='6MS', key='foo'),
+ values='Quantity', aggfunc=np.sum)
# passing the level
df = df.set_index('Date')
@@ -838,13 +842,14 @@ def test_pivot_timegrouper(self):
values='Quantity', aggfunc=np.sum)
tm.assert_frame_equal(result, expected.T)
- pytest.raises(ValueError, lambda: pivot_table(
- df, index=Grouper(freq='6MS', level='foo'),
- columns='Buyer', values='Quantity', aggfunc=np.sum))
- pytest.raises(ValueError, lambda: pivot_table(
- df, index='Buyer',
- columns=Grouper(freq='6MS', level='foo'),
- values='Quantity', aggfunc=np.sum))
+ msg = "The level foo is not valid"
+ with pytest.raises(ValueError, match=msg):
+ pivot_table(df, index=Grouper(freq='6MS', level='foo'),
+ columns='Buyer', values='Quantity', aggfunc=np.sum)
+ with pytest.raises(ValueError, match=msg):
+ pivot_table(df, index='Buyer',
+ columns=Grouper(freq='6MS', level='foo'),
+ values='Quantity', aggfunc=np.sum)
# double grouper
df = DataFrame({
@@ -1279,7 +1284,8 @@ def test_pivot_number_of_levels_larger_than_int32(self):
'ind2': np.arange(2 ** 16),
'count': 0})
- with pytest.raises(ValueError, match='int32 overflow'):
+ msg = "Unstacked DataFrame is too big, causing int32 overflow"
+ with pytest.raises(ValueError, match=msg):
df.pivot_table(index='ind1', columns='ind2',
values='count', aggfunc='count')
@@ -1421,8 +1427,9 @@ def test_crosstab_margins_set_margin_name(self):
exp_rows = exp_rows.fillna(0).astype(np.int64)
tm.assert_series_equal(all_rows, exp_rows)
+ msg = "margins_name argument must be a string"
for margins_name in [666, None, ['a', 'b']]:
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
crosstab(a, [b, c], rownames=['a'], colnames=('b', 'c'),
margins=True, margins_name=margins_name)
| xref #24332 | https://api.github.com/repos/pandas-dev/pandas/pulls/24838 | 2019-01-19T15:48:27Z | 2019-01-19T21:29:36Z | 2019-01-19T21:29:35Z | 2019-01-20T22:31:57Z |
Fix memory growth bug in read_csv | diff --git a/asv_bench/benchmarks/io/csv.py b/asv_bench/benchmarks/io/csv.py
index 771f2795334e1..d42a15d61fb0d 100644
--- a/asv_bench/benchmarks/io/csv.py
+++ b/asv_bench/benchmarks/io/csv.py
@@ -214,4 +214,23 @@ def time_baseline(self):
names=list(string.digits[:9]))
+class ReadCSVMemoryGrowth(BaseIO):
+
+ chunksize = 20
+ num_rows = 1000
+ fname = "__test__.csv"
+
+ def setup(self):
+ with open(self.fname, "w") as f:
+ for i in range(self.num_rows):
+ f.write("{i}\n".format(i=i))
+
+ def mem_parser_chunks(self):
+ # see gh-24805.
+ result = read_csv(self.fname, chunksize=self.chunksize)
+
+ for _ in result:
+ pass
+
+
from ..pandas_vb_common import setup # noqa: F401
diff --git a/pandas/_libs/src/parser/tokenizer.c b/pandas/_libs/src/parser/tokenizer.c
index 3a4058f37efc7..a86af7c5416de 100644
--- a/pandas/_libs/src/parser/tokenizer.c
+++ b/pandas/_libs/src/parser/tokenizer.c
@@ -300,7 +300,7 @@ static int make_stream_space(parser_t *self, size_t nbytes) {
* just because a recent chunk did not have as many words.
*/
if (self->words_len + nbytes < self->max_words_cap) {
- length = self->max_words_cap - nbytes;
+ length = self->max_words_cap - nbytes - 1;
} else {
length = self->words_len;
}
diff --git a/pandas/tests/io/parser/test_common.py b/pandas/tests/io/parser/test_common.py
index d87ef7cd15a64..05da171d7dc31 100644
--- a/pandas/tests/io/parser/test_common.py
+++ b/pandas/tests/io/parser/test_common.py
@@ -1916,6 +1916,24 @@ def test_filename_with_special_chars(all_parsers):
tm.assert_frame_equal(result, df)
+def test_read_csv_memory_growth_chunksize(all_parsers):
+ # see gh-24805
+ #
+ # Let's just make sure that we don't crash
+ # as we iteratively process all chunks.
+ parser = all_parsers
+
+ with tm.ensure_clean() as path:
+ with open(path, "w") as f:
+ for i in range(1000):
+ f.write(str(i) + "\n")
+
+ result = parser.read_csv(path, chunksize=20)
+
+ for _ in result:
+ pass
+
+
def test_read_table_deprecated(all_parsers):
# see gh-21948
parser = all_parsers
| The edge case where we hit powers of 2 every time during allocation can be painful.
Closes #24805.
xref #23527. | https://api.github.com/repos/pandas-dev/pandas/pulls/24837 | 2019-01-19T11:40:03Z | 2019-01-20T16:01:34Z | 2019-01-20T16:01:33Z | 2019-01-20T19:51:41Z |
fixed regression commit | diff --git a/asv_bench/asv.conf.json b/asv_bench/asv.conf.json
index 9c333f62810f4..fa098e2455683 100644
--- a/asv_bench/asv.conf.json
+++ b/asv_bench/asv.conf.json
@@ -118,9 +118,8 @@
// skipped for the matching benchmark.
//
"regressions_first_commits": {
- ".*": "v0.20.0"
+ ".*": "0409521665"
},
"regression_thresholds": {
- ".*": 0.05
}
}
| Fixes an issue with the ASV config.
It seems that ASV may not understand tags in the regressions_first_commit. I've replaced that tag with the commit for 0.23.4
I removed the regression threashold, as it's already the default. | https://api.github.com/repos/pandas-dev/pandas/pulls/24835 | 2019-01-19T04:57:35Z | 2019-01-19T13:41:44Z | 2019-01-19T13:41:44Z | 2019-01-19T13:41:47Z |
REF remove unused imports from tseries.frequencies; update imports elsewhere | diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 700e9edd89bd0..e0c71b5609096 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -4,7 +4,8 @@
import numpy as np
-from pandas._libs.tslibs import NaT, iNaT, period as libperiod
+from pandas._libs.tslibs import (
+ NaT, frequencies as libfrequencies, iNaT, period as libperiod)
from pandas._libs.tslibs.fields import isleapyear_arr
from pandas._libs.tslibs.period import (
DIFFERENT_FREQ, IncompatibleFrequency, Period, get_period_field_arr,
@@ -31,7 +32,7 @@
def _field_accessor(name, alias, docstring=None):
def f(self):
- base, mult = frequencies.get_freq_code(self.freq)
+ base, mult = libfrequencies.get_freq_code(self.freq)
result = get_period_field_arr(alias, self.asi8, base)
return result
@@ -348,12 +349,12 @@ def to_timestamp(self, freq=None, how='start'):
return (self + self.freq).to_timestamp(how='start') - adjust
if freq is None:
- base, mult = frequencies.get_freq_code(self.freq)
- freq = frequencies.get_to_timestamp_base(base)
+ base, mult = libfrequencies.get_freq_code(self.freq)
+ freq = libfrequencies.get_to_timestamp_base(base)
else:
freq = Period._maybe_convert_freq(freq)
- base, mult = frequencies.get_freq_code(freq)
+ base, mult = libfrequencies.get_freq_code(freq)
new_data = self.asfreq(freq, how=how)
new_data = libperiod.periodarr_to_dt64arr(new_data.asi8, base)
@@ -450,8 +451,8 @@ def asfreq(self, freq=None, how='E'):
freq = Period._maybe_convert_freq(freq)
- base1, mult1 = frequencies.get_freq_code(self.freq)
- base2, mult2 = frequencies.get_freq_code(freq)
+ base1, mult1 = libfrequencies.get_freq_code(self.freq)
+ base2, mult2 = libfrequencies.get_freq_code(freq)
asi8 = self.asi8
# mult1 can't be negative or 0
@@ -551,7 +552,7 @@ def _addsub_int_array(
def _add_offset(self, other):
assert not isinstance(other, Tick)
- base = frequencies.get_base_alias(other.rule_code)
+ base = libfrequencies.get_base_alias(other.rule_code)
if base != self.freq.rule_code:
_raise_on_incompatible(self, other)
@@ -855,7 +856,7 @@ def dt64arr_to_periodarr(data, freq, tz=None):
if isinstance(data, (ABCIndexClass, ABCSeries)):
data = data._values
- base, mult = frequencies.get_freq_code(freq)
+ base, mult = libfrequencies.get_freq_code(freq)
return libperiod.dt64arr_to_periodarr(data.view('i8'), base, tz), freq
@@ -865,7 +866,7 @@ def _get_ordinal_range(start, end, periods, freq, mult=1):
'exactly two must be specified')
if freq is not None:
- _, mult = frequencies.get_freq_code(freq)
+ _, mult = libfrequencies.get_freq_code(freq)
if start is not None:
start = Period(start, freq)
@@ -919,10 +920,10 @@ def _range_from_fields(year=None, month=None, quarter=None, day=None,
if quarter is not None:
if freq is None:
freq = 'Q'
- base = frequencies.FreqGroup.FR_QTR
+ base = libfrequencies.FreqGroup.FR_QTR
else:
- base, mult = frequencies.get_freq_code(freq)
- if base != frequencies.FreqGroup.FR_QTR:
+ base, mult = libfrequencies.get_freq_code(freq)
+ if base != libfrequencies.FreqGroup.FR_QTR:
raise AssertionError("base must equal FR_QTR")
year, quarter = _make_field_arrays(year, quarter)
@@ -931,7 +932,7 @@ def _range_from_fields(year=None, month=None, quarter=None, day=None,
val = libperiod.period_ordinal(y, m, 1, 1, 1, 1, 0, 0, base)
ordinals.append(val)
else:
- base, mult = frequencies.get_freq_code(freq)
+ base, mult = libfrequencies.get_freq_code(freq)
arrays = _make_field_arrays(year, month, day, hour, minute, second)
for y, mth, d, h, mn, s in compat.zip(*arrays):
ordinals.append(libperiod.period_ordinal(
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 5e4dd2998a3be..a4bd7f9017eb4 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -5,7 +5,8 @@
import numpy as np
from pandas._libs import index as libindex
-from pandas._libs.tslibs import NaT, iNaT, resolution
+from pandas._libs.tslibs import (
+ NaT, frequencies as libfrequencies, iNaT, resolution)
from pandas._libs.tslibs.period import (
DIFFERENT_FREQ, IncompatibleFrequency, Period)
from pandas.util._decorators import Appender, Substitution, cache_readonly
@@ -376,7 +377,7 @@ def _maybe_convert_timedelta(self, other):
return delta
elif isinstance(other, DateOffset):
freqstr = other.rule_code
- base = frequencies.get_base_alias(freqstr)
+ base = libfrequencies.get_base_alias(freqstr)
if base == self.freq.rule_code:
return other.n
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 25604b29f22f6..6822225273906 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -7,6 +7,7 @@
from pandas._libs import lib
from pandas._libs.tslibs import NaT, Timestamp
+from pandas._libs.tslibs.frequencies import is_subperiod, is_superperiod
from pandas._libs.tslibs.period import IncompatibleFrequency
import pandas.compat as compat
from pandas.compat.numpy import function as nv
@@ -28,7 +29,7 @@
from pandas.core.indexes.period import PeriodIndex
from pandas.core.indexes.timedeltas import TimedeltaIndex, timedelta_range
-from pandas.tseries.frequencies import is_subperiod, is_superperiod, to_offset
+from pandas.tseries.frequencies import to_offset
from pandas.tseries.offsets import (
DateOffset, Day, Nano, Tick, delta_to_nanoseconds)
diff --git a/pandas/plotting/_converter.py b/pandas/plotting/_converter.py
index 4c6b3b5132fec..aaa7aa04acf48 100644
--- a/pandas/plotting/_converter.py
+++ b/pandas/plotting/_converter.py
@@ -11,6 +11,7 @@
from pandas._libs import lib, tslibs
from pandas._libs.tslibs import resolution
+from pandas._libs.tslibs.frequencies import FreqGroup, get_freq
import pandas.compat as compat
from pandas.compat import lrange
@@ -25,9 +26,6 @@
from pandas.core.indexes.period import Period, PeriodIndex, period_range
import pandas.core.tools.datetimes as tools
-import pandas.tseries.frequencies as frequencies
-from pandas.tseries.frequencies import FreqGroup
-
# constants
HOURS_PER_DAY = 24.
MIN_PER_HOUR = 60.
@@ -955,7 +953,7 @@ def _annual_finder(vmin, vmax, freq):
def get_finder(freq):
if isinstance(freq, compat.string_types):
- freq = frequencies.get_freq(freq)
+ freq = get_freq(freq)
fgroup = resolution.get_freq_group(freq)
if fgroup == FreqGroup.FR_ANN:
@@ -992,7 +990,7 @@ class TimeSeries_DateLocator(Locator):
def __init__(self, freq, minor_locator=False, dynamic_mode=True,
base=1, quarter=1, month=1, day=1, plot_obj=None):
if isinstance(freq, compat.string_types):
- freq = frequencies.get_freq(freq)
+ freq = get_freq(freq)
self.freq = freq
self.base = base
(self.quarter, self.month, self.day) = (quarter, month, day)
@@ -1073,7 +1071,7 @@ class TimeSeries_DateFormatter(Formatter):
def __init__(self, freq, minor_locator=False, dynamic_mode=True,
plot_obj=None):
if isinstance(freq, compat.string_types):
- freq = frequencies.get_freq(freq)
+ freq = get_freq(freq)
self.format = None
self.freq = freq
self.locs = []
diff --git a/pandas/plotting/_timeseries.py b/pandas/plotting/_timeseries.py
index 49249ae446747..51b0629005942 100644
--- a/pandas/plotting/_timeseries.py
+++ b/pandas/plotting/_timeseries.py
@@ -5,6 +5,8 @@
from matplotlib import pylab
import numpy as np
+from pandas._libs.tslibs.frequencies import (
+ FreqGroup, get_base_alias, get_freq, is_subperiod, is_superperiod)
from pandas._libs.tslibs.period import Period
import pandas.compat as compat
@@ -73,7 +75,7 @@ def _maybe_resample(series, ax, kwargs):
series = series.to_period(freq=freq)
if ax_freq is not None and freq != ax_freq:
- if frequencies.is_superperiod(freq, ax_freq): # upsample input
+ if is_superperiod(freq, ax_freq): # upsample input
series = series.copy()
series.index = series.index.asfreq(ax_freq, how='s')
freq = ax_freq
@@ -82,7 +84,7 @@ def _maybe_resample(series, ax, kwargs):
series = getattr(series.resample('D'), how)().dropna()
series = getattr(series.resample(ax_freq), how)().dropna()
freq = ax_freq
- elif frequencies.is_subperiod(freq, ax_freq) or _is_sub(freq, ax_freq):
+ elif is_subperiod(freq, ax_freq) or _is_sub(freq, ax_freq):
_upsample_others(ax, freq, kwargs)
else: # pragma: no cover
raise ValueError('Incompatible frequency conversion')
@@ -90,13 +92,13 @@ def _maybe_resample(series, ax, kwargs):
def _is_sub(f1, f2):
- return ((f1.startswith('W') and frequencies.is_subperiod('D', f2)) or
- (f2.startswith('W') and frequencies.is_subperiod(f1, 'D')))
+ return ((f1.startswith('W') and is_subperiod('D', f2)) or
+ (f2.startswith('W') and is_subperiod(f1, 'D')))
def _is_sup(f1, f2):
- return ((f1.startswith('W') and frequencies.is_superperiod('D', f2)) or
- (f2.startswith('W') and frequencies.is_superperiod(f1, 'D')))
+ return ((f1.startswith('W') and is_superperiod('D', f2)) or
+ (f2.startswith('W') and is_superperiod(f1, 'D')))
def _upsample_others(ax, freq, kwargs):
@@ -209,7 +211,7 @@ def _get_freq(ax, series):
if isinstance(freq, DateOffset):
freq = freq.rule_code
else:
- freq = frequencies.get_base_alias(freq)
+ freq = get_base_alias(freq)
freq = frequencies.get_period_alias(freq)
return freq, ax_freq
@@ -231,7 +233,7 @@ def _use_dynamic_x(ax, data):
if isinstance(freq, DateOffset):
freq = freq.rule_code
else:
- freq = frequencies.get_base_alias(freq)
+ freq = get_base_alias(freq)
freq = frequencies.get_period_alias(freq)
if freq is None:
@@ -239,9 +241,9 @@ def _use_dynamic_x(ax, data):
# hack this for 0.10.1, creating more technical debt...sigh
if isinstance(data.index, ABCDatetimeIndex):
- base = frequencies.get_freq(freq)
+ base = get_freq(freq)
x = data.index
- if (base <= frequencies.FreqGroup.FR_DAY):
+ if (base <= FreqGroup.FR_DAY):
return x[:1].is_normalized
return Period(x[0], freq).to_timestamp(tz=x.tz) == x[0]
return True
@@ -275,7 +277,7 @@ def _maybe_convert_index(ax, data):
if freq is None:
raise ValueError('Could not get frequency alias for plotting')
- freq = frequencies.get_base_alias(freq)
+ freq = get_base_alias(freq)
freq = frequencies.get_period_alias(freq)
data = data.to_period(freq=freq)
diff --git a/pandas/tests/indexes/datetimes/test_construction.py b/pandas/tests/indexes/datetimes/test_construction.py
index 2768da0316aad..7c9ca9da89d53 100644
--- a/pandas/tests/indexes/datetimes/test_construction.py
+++ b/pandas/tests/indexes/datetimes/test_construction.py
@@ -366,8 +366,8 @@ def test_construction_with_ndarray(self):
dates = [datetime(2013, 10, 7),
datetime(2013, 10, 8),
datetime(2013, 10, 9)]
- data = DatetimeIndex(dates, freq=pd.tseries.frequencies.BDay()).values
- result = DatetimeIndex(data, freq=pd.tseries.frequencies.BDay())
+ data = DatetimeIndex(dates, freq=pd.offsets.BDay()).values
+ result = DatetimeIndex(data, freq=pd.offsets.BDay())
expected = DatetimeIndex(['2013-10-07',
'2013-10-08',
'2013-10-09'],
diff --git a/pandas/tests/series/test_dtypes.py b/pandas/tests/series/test_dtypes.py
index 5ec3f69e55fde..e29974f56967f 100644
--- a/pandas/tests/series/test_dtypes.py
+++ b/pandas/tests/series/test_dtypes.py
@@ -292,7 +292,7 @@ def test_astype_categorical_to_other(self):
tm.assert_series_equal(s.astype('category'), expected)
tm.assert_series_equal(s.astype(CategoricalDtype()), expected)
msg = (r"could not convert string to float: '(0 - 499|9500 - 9999)'|"
- r"invalid literal for float\(\): 9500 - 9999")
+ r"invalid literal for float\(\): (0 - 499|9500 - 9999)")
with pytest.raises(ValueError, match=msg):
s.astype('float64')
diff --git a/pandas/tests/tseries/test_frequencies.py b/pandas/tests/tseries/test_frequencies.py
index c0a3e998dc2e0..eb4e63654b47b 100644
--- a/pandas/tests/tseries/test_frequencies.py
+++ b/pandas/tests/tseries/test_frequencies.py
@@ -3,10 +3,10 @@
import numpy as np
import pytest
-from pandas._libs.tslibs import resolution
+from pandas._libs.tslibs import frequencies as libfrequencies, resolution
from pandas._libs.tslibs.ccalendar import MONTHS
from pandas._libs.tslibs.frequencies import (
- INVALID_FREQ_ERR_MSG, _period_code_map)
+ INVALID_FREQ_ERR_MSG, FreqGroup, _period_code_map, get_freq, get_freq_code)
import pandas.compat as compat
from pandas.compat import is_platform_windows, range
@@ -277,20 +277,20 @@ def test_rule_aliases():
class TestFrequencyCode(object):
def test_freq_code(self):
- assert frequencies.get_freq('A') == 1000
- assert frequencies.get_freq('3A') == 1000
- assert frequencies.get_freq('-1A') == 1000
+ assert get_freq('A') == 1000
+ assert get_freq('3A') == 1000
+ assert get_freq('-1A') == 1000
- assert frequencies.get_freq('Y') == 1000
- assert frequencies.get_freq('3Y') == 1000
- assert frequencies.get_freq('-1Y') == 1000
+ assert get_freq('Y') == 1000
+ assert get_freq('3Y') == 1000
+ assert get_freq('-1Y') == 1000
- assert frequencies.get_freq('W') == 4000
- assert frequencies.get_freq('W-MON') == 4001
- assert frequencies.get_freq('W-FRI') == 4005
+ assert get_freq('W') == 4000
+ assert get_freq('W-MON') == 4001
+ assert get_freq('W-FRI') == 4005
for freqstr, code in compat.iteritems(_period_code_map):
- result = frequencies.get_freq(freqstr)
+ result = get_freq(freqstr)
assert result == code
result = resolution.get_freq_group(freqstr)
@@ -324,24 +324,24 @@ def test_freq_group(self):
assert resolution.get_freq_group(offsets.Week(weekday=5)) == 4000
def test_get_to_timestamp_base(self):
- tsb = frequencies.get_to_timestamp_base
-
- assert (tsb(frequencies.get_freq_code('D')[0]) ==
- frequencies.get_freq_code('D')[0])
- assert (tsb(frequencies.get_freq_code('W')[0]) ==
- frequencies.get_freq_code('D')[0])
- assert (tsb(frequencies.get_freq_code('M')[0]) ==
- frequencies.get_freq_code('D')[0])
-
- assert (tsb(frequencies.get_freq_code('S')[0]) ==
- frequencies.get_freq_code('S')[0])
- assert (tsb(frequencies.get_freq_code('T')[0]) ==
- frequencies.get_freq_code('S')[0])
- assert (tsb(frequencies.get_freq_code('H')[0]) ==
- frequencies.get_freq_code('S')[0])
+ tsb = libfrequencies.get_to_timestamp_base
+
+ assert (tsb(get_freq_code('D')[0]) ==
+ get_freq_code('D')[0])
+ assert (tsb(get_freq_code('W')[0]) ==
+ get_freq_code('D')[0])
+ assert (tsb(get_freq_code('M')[0]) ==
+ get_freq_code('D')[0])
+
+ assert (tsb(get_freq_code('S')[0]) ==
+ get_freq_code('S')[0])
+ assert (tsb(get_freq_code('T')[0]) ==
+ get_freq_code('S')[0])
+ assert (tsb(get_freq_code('H')[0]) ==
+ get_freq_code('S')[0])
def test_freq_to_reso(self):
- Reso = frequencies.Resolution
+ Reso = resolution.Resolution
assert Reso.get_str_from_freq('A') == 'year'
assert Reso.get_str_from_freq('Q') == 'quarter'
@@ -365,7 +365,7 @@ def test_freq_to_reso(self):
def test_resolution_bumping(self):
# see gh-14378
- Reso = frequencies.Resolution
+ Reso = resolution.Resolution
assert Reso.get_stride_from_decimal(1.5, 'T') == (90, 'S')
assert Reso.get_stride_from_decimal(62.4, 'T') == (3744, 'S')
@@ -384,63 +384,63 @@ def test_resolution_bumping(self):
def test_get_freq_code(self):
# frequency str
- assert (frequencies.get_freq_code('A') ==
- (frequencies.get_freq('A'), 1))
- assert (frequencies.get_freq_code('3D') ==
- (frequencies.get_freq('D'), 3))
- assert (frequencies.get_freq_code('-2M') ==
- (frequencies.get_freq('M'), -2))
+ assert (get_freq_code('A') ==
+ (get_freq('A'), 1))
+ assert (get_freq_code('3D') ==
+ (get_freq('D'), 3))
+ assert (get_freq_code('-2M') ==
+ (get_freq('M'), -2))
# tuple
- assert (frequencies.get_freq_code(('D', 1)) ==
- (frequencies.get_freq('D'), 1))
- assert (frequencies.get_freq_code(('A', 3)) ==
- (frequencies.get_freq('A'), 3))
- assert (frequencies.get_freq_code(('M', -2)) ==
- (frequencies.get_freq('M'), -2))
+ assert (get_freq_code(('D', 1)) ==
+ (get_freq('D'), 1))
+ assert (get_freq_code(('A', 3)) ==
+ (get_freq('A'), 3))
+ assert (get_freq_code(('M', -2)) ==
+ (get_freq('M'), -2))
# numeric tuple
- assert frequencies.get_freq_code((1000, 1)) == (1000, 1)
+ assert get_freq_code((1000, 1)) == (1000, 1)
# offsets
- assert (frequencies.get_freq_code(offsets.Day()) ==
- (frequencies.get_freq('D'), 1))
- assert (frequencies.get_freq_code(offsets.Day(3)) ==
- (frequencies.get_freq('D'), 3))
- assert (frequencies.get_freq_code(offsets.Day(-2)) ==
- (frequencies.get_freq('D'), -2))
-
- assert (frequencies.get_freq_code(offsets.MonthEnd()) ==
- (frequencies.get_freq('M'), 1))
- assert (frequencies.get_freq_code(offsets.MonthEnd(3)) ==
- (frequencies.get_freq('M'), 3))
- assert (frequencies.get_freq_code(offsets.MonthEnd(-2)) ==
- (frequencies.get_freq('M'), -2))
-
- assert (frequencies.get_freq_code(offsets.Week()) ==
- (frequencies.get_freq('W'), 1))
- assert (frequencies.get_freq_code(offsets.Week(3)) ==
- (frequencies.get_freq('W'), 3))
- assert (frequencies.get_freq_code(offsets.Week(-2)) ==
- (frequencies.get_freq('W'), -2))
+ assert (get_freq_code(offsets.Day()) ==
+ (get_freq('D'), 1))
+ assert (get_freq_code(offsets.Day(3)) ==
+ (get_freq('D'), 3))
+ assert (get_freq_code(offsets.Day(-2)) ==
+ (get_freq('D'), -2))
+
+ assert (get_freq_code(offsets.MonthEnd()) ==
+ (get_freq('M'), 1))
+ assert (get_freq_code(offsets.MonthEnd(3)) ==
+ (get_freq('M'), 3))
+ assert (get_freq_code(offsets.MonthEnd(-2)) ==
+ (get_freq('M'), -2))
+
+ assert (get_freq_code(offsets.Week()) ==
+ (get_freq('W'), 1))
+ assert (get_freq_code(offsets.Week(3)) ==
+ (get_freq('W'), 3))
+ assert (get_freq_code(offsets.Week(-2)) ==
+ (get_freq('W'), -2))
# Monday is weekday=0
- assert (frequencies.get_freq_code(offsets.Week(weekday=1)) ==
- (frequencies.get_freq('W-TUE'), 1))
- assert (frequencies.get_freq_code(offsets.Week(3, weekday=0)) ==
- (frequencies.get_freq('W-MON'), 3))
- assert (frequencies.get_freq_code(offsets.Week(-2, weekday=4)) ==
- (frequencies.get_freq('W-FRI'), -2))
+ assert (get_freq_code(offsets.Week(weekday=1)) ==
+ (get_freq('W-TUE'), 1))
+ assert (get_freq_code(offsets.Week(3, weekday=0)) ==
+ (get_freq('W-MON'), 3))
+ assert (get_freq_code(offsets.Week(-2, weekday=4)) ==
+ (get_freq('W-FRI'), -2))
def test_frequency_misc(self):
assert (resolution.get_freq_group('T') ==
- frequencies.FreqGroup.FR_MIN)
+ FreqGroup.FR_MIN)
- code, stride = frequencies.get_freq_code(offsets.Hour())
- assert code == frequencies.FreqGroup.FR_HR
+ code, stride = get_freq_code(offsets.Hour())
+ assert code == FreqGroup.FR_HR
- code, stride = frequencies.get_freq_code((5, 'T'))
- assert code == frequencies.FreqGroup.FR_MIN
+ code, stride = get_freq_code((5, 'T'))
+ assert code == FreqGroup.FR_MIN
assert stride == 5
offset = offsets.Hour()
@@ -452,7 +452,7 @@ def test_frequency_misc(self):
assert result == expected
with pytest.raises(ValueError, match='Invalid frequency'):
- frequencies.get_freq_code((5, 'baz'))
+ get_freq_code((5, 'baz'))
with pytest.raises(ValueError, match='Invalid frequency'):
frequencies.to_offset('100foo')
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 8cdec31d7ce8a..c454db3bbdffc 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -11,10 +11,7 @@
from pandas._libs.tslibs.conversion import tz_convert
from pandas._libs.tslibs.fields import build_field_sarray
import pandas._libs.tslibs.frequencies as libfreqs
-from pandas._libs.tslibs.frequencies import ( # noqa, semi-public API
- FreqGroup, get_base_alias, get_freq, get_freq_code, get_to_timestamp_base,
- is_subperiod, is_superperiod)
-from pandas._libs.tslibs.offsets import _offset_to_period_map # noqa:E402
+from pandas._libs.tslibs.offsets import _offset_to_period_map
import pandas._libs.tslibs.resolution as libresolution
from pandas._libs.tslibs.resolution import Resolution
from pandas._libs.tslibs.timezones import UTC
@@ -28,19 +25,8 @@
from pandas.core.algorithms import unique
-from pandas.tseries.offsets import ( # noqa
- BDay, BMonthBegin, BMonthEnd, BQuarterBegin, BQuarterEnd, BYearBegin,
- BYearEnd, CDay, DateOffset, Day, Hour, Micro, Milli, Minute, MonthBegin,
- MonthEnd, Nano, QuarterBegin, QuarterEnd, Second, Week, YearBegin, YearEnd,
- prefix_mapping)
-
-RESO_NS = 0
-RESO_US = 1
-RESO_MS = 2
-RESO_SEC = 3
-RESO_MIN = 4
-RESO_HR = 5
-RESO_DAY = 6
+from pandas.tseries.offsets import (
+ DateOffset, Day, Hour, Micro, Milli, Minute, Nano, Second, prefix_mapping)
_ONE_MICRO = 1000
_ONE_MILLI = (_ONE_MICRO * 1000)
@@ -52,11 +38,6 @@
# ---------------------------------------------------------------------
# Offset names ("time rules") and related functions
-try:
- cday = CDay()
-except NotImplementedError:
- cday = None
-
#: cache of previously seen offsets
_offset_map = {}
@@ -216,8 +197,6 @@ def get_offset(name):
return _offset_map[name]
-getOffset = get_offset
-
# ---------------------------------------------------------------------
# Period codes
@@ -314,7 +293,7 @@ def is_unique(self):
def is_unique_asi8(self):
return len(self.deltas_asi8) == 1
- def get_freq(self): # noqa:F811
+ def get_freq(self):
"""
Find the appropriate frequency string to describe the inferred
frequency of self.values
| - [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24834 | 2019-01-19T00:04:49Z | 2019-01-19T21:34:05Z | 2019-01-19T21:34:05Z | 2019-01-19T22:29:23Z |
Implement+Test Tick.__rtruediv__ | diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index 856aa52f82cf5..e28462f7103b9 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -18,6 +18,7 @@ from numpy cimport int64_t
cnp.import_array()
+from pandas._libs.tslibs cimport util
from pandas._libs.tslibs.util cimport is_string_object, is_integer_object
from pandas._libs.tslibs.ccalendar import MONTHS, DAYS
@@ -408,6 +409,10 @@ class _BaseOffset(object):
return self.apply(other)
def __mul__(self, other):
+ if hasattr(other, "_typ"):
+ return NotImplemented
+ if util.is_array(other):
+ return np.array([self * x for x in other])
return type(self)(n=other * self.n, normalize=self.normalize,
**self.kwds)
@@ -458,6 +463,9 @@ class _BaseOffset(object):
TypeError if `int(n)` raises
ValueError if n != int(n)
"""
+ if util.is_timedelta64_object(n):
+ raise TypeError('`n` argument must be an integer, '
+ 'got {ntype}'.format(ntype=type(n)))
try:
nint = int(n)
except (ValueError, TypeError):
@@ -533,12 +541,20 @@ class _Tick(object):
can do isinstance checks on _Tick and avoid importing tseries.offsets
"""
+ # ensure that reversed-ops with numpy scalars return NotImplemented
+ __array_priority__ = 1000
+
def __truediv__(self, other):
result = self.delta.__truediv__(other)
return _wrap_timedelta_result(result)
+ def __rtruediv__(self, other):
+ result = self.delta.__rtruediv__(other)
+ return _wrap_timedelta_result(result)
+
if PY2:
__div__ = __truediv__
+ __rdiv__ = __rtruediv__
# ----------------------------------------------------------------------
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index ac3955970587f..621572da57541 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -257,6 +257,26 @@ def test_offset_n(self, offset_types):
mul_offset = offset * 3
assert mul_offset.n == 3
+ def test_offset_timedelta64_arg(self, offset_types):
+ # check that offset._validate_n raises TypeError on a timedelt64
+ # object
+ off = self._get_offset(offset_types)
+
+ td64 = np.timedelta64(4567, 's')
+ with pytest.raises(TypeError, match="argument must be an integer"):
+ type(off)(n=td64, **off.kwds)
+
+ def test_offset_mul_ndarray(self, offset_types):
+ off = self._get_offset(offset_types)
+
+ expected = np.array([[off, off * 2], [off * 3, off * 4]])
+
+ result = np.array([[1, 2], [3, 4]]) * off
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = off * np.array([[1, 2], [3, 4]])
+ tm.assert_numpy_array_equal(result, expected)
+
def test_offset_freqstr(self, offset_types):
offset = self._get_offset(offset_types)
diff --git a/pandas/tests/tseries/offsets/test_ticks.py b/pandas/tests/tseries/offsets/test_ticks.py
index f4b012ec1897f..9a8251201f75f 100644
--- a/pandas/tests/tseries/offsets/test_ticks.py
+++ b/pandas/tests/tseries/offsets/test_ticks.py
@@ -11,6 +11,7 @@
import pytest
from pandas import Timedelta, Timestamp
+import pandas.util.testing as tm
from pandas.tseries import offsets
from pandas.tseries.offsets import Hour, Micro, Milli, Minute, Nano, Second
@@ -262,6 +263,28 @@ def test_tick_division(cls):
assert result.delta == off.delta / .001
+@pytest.mark.parametrize('cls', tick_classes)
+def test_tick_rdiv(cls):
+ off = cls(10)
+ delta = off.delta
+ td64 = delta.to_timedelta64()
+
+ with pytest.raises(TypeError):
+ 2 / off
+ with pytest.raises(TypeError):
+ 2.0 / off
+
+ assert (td64 * 2.5) / off == 2.5
+
+ if cls is not Nano:
+ # skip pytimedelta for Nano since it gets dropped
+ assert (delta.to_pytimedelta() * 2) / off == 2
+
+ result = np.array([2 * td64, td64]) / off
+ expected = np.array([2., 1.])
+ tm.assert_numpy_array_equal(result, expected)
+
+
@pytest.mark.parametrize('cls1', tick_classes)
@pytest.mark.parametrize('cls2', tick_classes)
def test_tick_zero(cls1, cls2):
| - [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24832 | 2019-01-18T21:43:30Z | 2019-02-01T20:03:22Z | 2019-02-01T20:03:22Z | 2019-02-01T20:59:36Z |
Question regarding Series.argsort documentation #24816 | diff --git a/pandas/core/series.py b/pandas/core/series.py
index eb412add7bbbb..0c8e697c572e8 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -2992,11 +2992,13 @@ def argsort(self, axis=0, kind='quicksort', order=None):
Parameters
----------
- axis : int (can only be zero)
+ axis : int
+ Has no effect but is accepted for compatibility with numpy.
kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
Choice of sorting algorithm. See np.sort for more
information. 'mergesort' is the only stable algorithm
- order : ignored
+ order : None
+ Has no effect but is accepted for compatibility with numpy.
Returns
-------
| - [ ] closes #24816
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24830 | 2019-01-18T19:38:07Z | 2019-01-19T01:35:19Z | 2019-01-19T01:35:18Z | 2019-01-19T01:35:42Z |
Excel Reader Refactor - Base Class Introduction | diff --git a/pandas/io/excel.py b/pandas/io/excel.py
index 3a7c39ec65309..3d85ae7fd1f46 100644
--- a/pandas/io/excel.py
+++ b/pandas/io/excel.py
@@ -375,60 +375,25 @@ def read_excel(io,
**kwds)
-class _XlrdReader(object):
-
- def __init__(self, filepath_or_buffer):
- """Reader using xlrd engine.
-
- Parameters
- ----------
- filepath_or_buffer : string, path object or Workbook
- Object to be parsed.
- """
- err_msg = "Install xlrd >= 1.0.0 for Excel support"
-
- try:
- import xlrd
- except ImportError:
- raise ImportError(err_msg)
- else:
- if xlrd.__VERSION__ < LooseVersion("1.0.0"):
- raise ImportError(err_msg +
- ". Current version " + xlrd.__VERSION__)
+@add_metaclass(abc.ABCMeta)
+class _BaseExcelReader(object):
- # If filepath_or_buffer is a url, want to keep the data as bytes so
- # can't pass to get_filepath_or_buffer()
- if _is_url(filepath_or_buffer):
- filepath_or_buffer = _urlopen(filepath_or_buffer)
- elif not isinstance(filepath_or_buffer, (ExcelFile, xlrd.Book)):
- filepath_or_buffer, _, _, _ = get_filepath_or_buffer(
- filepath_or_buffer)
+ @property
+ @abc.abstractmethod
+ def sheet_names(self):
+ pass
- if isinstance(filepath_or_buffer, xlrd.Book):
- self.book = filepath_or_buffer
- elif not isinstance(filepath_or_buffer, xlrd.Book) and hasattr(
- filepath_or_buffer, "read"):
- # N.B. xlrd.Book has a read attribute too
- if hasattr(filepath_or_buffer, 'seek'):
- try:
- # GH 19779
- filepath_or_buffer.seek(0)
- except UnsupportedOperation:
- # HTTPResponse does not support seek()
- # GH 20434
- pass
+ @abc.abstractmethod
+ def get_sheet_by_name(self, name):
+ pass
- data = filepath_or_buffer.read()
- self.book = xlrd.open_workbook(file_contents=data)
- elif isinstance(filepath_or_buffer, compat.string_types):
- self.book = xlrd.open_workbook(filepath_or_buffer)
- else:
- raise ValueError('Must explicitly set engine if not passing in'
- ' buffer or path for io.')
+ @abc.abstractmethod
+ def get_sheet_by_index(self, index):
+ pass
- @property
- def sheet_names(self):
- return self.book.sheet_names()
+ @abc.abstractmethod
+ def get_sheet_data(self, sheet, convert_float):
+ pass
def parse(self,
sheet_name=0,
@@ -455,48 +420,6 @@ def parse(self,
_validate_header_arg(header)
- from xlrd import (xldate, XL_CELL_DATE,
- XL_CELL_ERROR, XL_CELL_BOOLEAN,
- XL_CELL_NUMBER)
-
- epoch1904 = self.book.datemode
-
- def _parse_cell(cell_contents, cell_typ):
- """converts the contents of the cell into a pandas
- appropriate object"""
-
- if cell_typ == XL_CELL_DATE:
-
- # Use the newer xlrd datetime handling.
- try:
- cell_contents = xldate.xldate_as_datetime(
- cell_contents, epoch1904)
- except OverflowError:
- return cell_contents
-
- # Excel doesn't distinguish between dates and time,
- # so we treat dates on the epoch as times only.
- # Also, Excel supports 1900 and 1904 epochs.
- year = (cell_contents.timetuple())[0:3]
- if ((not epoch1904 and year == (1899, 12, 31)) or
- (epoch1904 and year == (1904, 1, 1))):
- cell_contents = time(cell_contents.hour,
- cell_contents.minute,
- cell_contents.second,
- cell_contents.microsecond)
-
- elif cell_typ == XL_CELL_ERROR:
- cell_contents = np.nan
- elif cell_typ == XL_CELL_BOOLEAN:
- cell_contents = bool(cell_contents)
- elif convert_float and cell_typ == XL_CELL_NUMBER:
- # GH5394 - Excel 'numbers' are always floats
- # it's a minimal perf hit and less surprising
- val = int(cell_contents)
- if val == cell_contents:
- cell_contents = val
- return cell_contents
-
ret_dict = False
# Keep sheetname to maintain backwards compatibility.
@@ -504,7 +427,7 @@ def _parse_cell(cell_contents, cell_typ):
sheets = sheet_name
ret_dict = True
elif sheet_name is None:
- sheets = self.book.sheet_names()
+ sheets = self.sheet_names
ret_dict = True
else:
sheets = [sheet_name]
@@ -519,19 +442,13 @@ def _parse_cell(cell_contents, cell_typ):
print("Reading sheet {sheet}".format(sheet=asheetname))
if isinstance(asheetname, compat.string_types):
- sheet = self.book.sheet_by_name(asheetname)
+ sheet = self.get_sheet_by_name(asheetname)
else: # assume an integer if not a string
- sheet = self.book.sheet_by_index(asheetname)
+ sheet = self.get_sheet_by_index(asheetname)
- data = []
+ data = self.get_sheet_data(sheet, convert_float)
usecols = _maybe_convert_usecols(usecols)
- for i in range(sheet.nrows):
- row = [_parse_cell(value, typ)
- for value, typ in zip(sheet.row_values(i),
- sheet.row_types(i))]
- data.append(row)
-
if sheet.nrows == 0:
output[asheetname] = DataFrame()
continue
@@ -620,6 +537,120 @@ def _parse_cell(cell_contents, cell_typ):
return output[asheetname]
+class _XlrdReader(_BaseExcelReader):
+
+ def __init__(self, filepath_or_buffer):
+ """Reader using xlrd engine.
+
+ Parameters
+ ----------
+ filepath_or_buffer : string, path object or Workbook
+ Object to be parsed.
+ """
+ err_msg = "Install xlrd >= 1.0.0 for Excel support"
+
+ try:
+ import xlrd
+ except ImportError:
+ raise ImportError(err_msg)
+ else:
+ if xlrd.__VERSION__ < LooseVersion("1.0.0"):
+ raise ImportError(err_msg +
+ ". Current version " + xlrd.__VERSION__)
+
+ # If filepath_or_buffer is a url, want to keep the data as bytes so
+ # can't pass to get_filepath_or_buffer()
+ if _is_url(filepath_or_buffer):
+ filepath_or_buffer = _urlopen(filepath_or_buffer)
+ elif not isinstance(filepath_or_buffer, (ExcelFile, xlrd.Book)):
+ filepath_or_buffer, _, _, _ = get_filepath_or_buffer(
+ filepath_or_buffer)
+
+ if isinstance(filepath_or_buffer, xlrd.Book):
+ self.book = filepath_or_buffer
+ elif hasattr(filepath_or_buffer, "read"):
+ # N.B. xlrd.Book has a read attribute too
+ if hasattr(filepath_or_buffer, 'seek'):
+ try:
+ # GH 19779
+ filepath_or_buffer.seek(0)
+ except UnsupportedOperation:
+ # HTTPResponse does not support seek()
+ # GH 20434
+ pass
+
+ data = filepath_or_buffer.read()
+ self.book = xlrd.open_workbook(file_contents=data)
+ elif isinstance(filepath_or_buffer, compat.string_types):
+ self.book = xlrd.open_workbook(filepath_or_buffer)
+ else:
+ raise ValueError('Must explicitly set engine if not passing in'
+ ' buffer or path for io.')
+
+ @property
+ def sheet_names(self):
+ return self.book.sheet_names()
+
+ def get_sheet_by_name(self, name):
+ return self.book.sheet_by_name(name)
+
+ def get_sheet_by_index(self, index):
+ return self.book.sheet_by_index(index)
+
+ def get_sheet_data(self, sheet, convert_float):
+ from xlrd import (xldate, XL_CELL_DATE,
+ XL_CELL_ERROR, XL_CELL_BOOLEAN,
+ XL_CELL_NUMBER)
+
+ epoch1904 = self.book.datemode
+
+ def _parse_cell(cell_contents, cell_typ):
+ """converts the contents of the cell into a pandas
+ appropriate object"""
+
+ if cell_typ == XL_CELL_DATE:
+
+ # Use the newer xlrd datetime handling.
+ try:
+ cell_contents = xldate.xldate_as_datetime(
+ cell_contents, epoch1904)
+ except OverflowError:
+ return cell_contents
+
+ # Excel doesn't distinguish between dates and time,
+ # so we treat dates on the epoch as times only.
+ # Also, Excel supports 1900 and 1904 epochs.
+ year = (cell_contents.timetuple())[0:3]
+ if ((not epoch1904 and year == (1899, 12, 31)) or
+ (epoch1904 and year == (1904, 1, 1))):
+ cell_contents = time(cell_contents.hour,
+ cell_contents.minute,
+ cell_contents.second,
+ cell_contents.microsecond)
+
+ elif cell_typ == XL_CELL_ERROR:
+ cell_contents = np.nan
+ elif cell_typ == XL_CELL_BOOLEAN:
+ cell_contents = bool(cell_contents)
+ elif convert_float and cell_typ == XL_CELL_NUMBER:
+ # GH5394 - Excel 'numbers' are always floats
+ # it's a minimal perf hit and less surprising
+ val = int(cell_contents)
+ if val == cell_contents:
+ cell_contents = val
+ return cell_contents
+
+ data = []
+
+ for i in range(sheet.nrows):
+ row = [_parse_cell(value, typ)
+ for value, typ in zip(sheet.row_values(i),
+ sheet.row_types(i))]
+ data.append(row)
+
+ return data
+
+
class ExcelFile(object):
"""
Class for parsing tabular excel sheets into DataFrame objects.
| This is to provide further enablement of new Excel readers like openpyxl and potentially one for reading binary files.
The main goal here was the introduction of a base reader class which defines the properties / methods that any subclass needs to define to plug in to.
This ultimately could be refactored into a sub-directory which splits readers into it's own module | https://api.github.com/repos/pandas-dev/pandas/pulls/24829 | 2019-01-18T18:04:38Z | 2019-01-26T15:34:47Z | 2019-01-26T15:34:47Z | 2019-01-26T15:39:36Z |
STY: use pytest.raises context syntax (groupby) | diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index e52ab66ef9cb4..8766fdbc29755 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -438,7 +438,7 @@ def get_converter(s):
return [self.indices[name] for name in names]
except KeyError:
# turns out it wasn't a tuple
- msg = ("must supply a a same-length tuple to get_group"
+ msg = ("must supply a same-length tuple to get_group"
" with multiple grouping keys")
raise ValueError(msg)
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index d8df227d4911a..633a1643f6cdd 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -464,8 +464,8 @@ def _get_grouper(obj, key=None, axis=0, level=None, sort=True,
raise ValueError('level name {} is not the name of the '
'index'.format(level))
elif level > 0 or level < -1:
- raise ValueError('level > 0 or level < -1 only valid with '
- ' MultiIndex')
+ raise ValueError(
+ 'level > 0 or level < -1 only valid with MultiIndex')
# NOTE: `group_axis` and `group_axis.get_level_values(level)`
# are same in this section.
diff --git a/pandas/tests/groupby/test_bin_groupby.py b/pandas/tests/groupby/test_bin_groupby.py
index f33df5fb0eb98..d7ea9bdf9209b 100644
--- a/pandas/tests/groupby/test_bin_groupby.py
+++ b/pandas/tests/groupby/test_bin_groupby.py
@@ -73,15 +73,18 @@ def test_generate_bins(self):
bins = func(values, binner, closed='right')
assert ((bins == np.array([3, 6])).all())
- pytest.raises(ValueError, generate_bins_generic, values, [],
- 'right')
- pytest.raises(ValueError, generate_bins_generic, values[:0],
- binner, 'right')
-
- pytest.raises(ValueError, generate_bins_generic, values, [4],
- 'right')
- pytest.raises(ValueError, generate_bins_generic, values, [-3, -1],
- 'right')
+ msg = "Invalid length for values or for binner"
+ with pytest.raises(ValueError, match=msg):
+ generate_bins_generic(values, [], 'right')
+ with pytest.raises(ValueError, match=msg):
+ generate_bins_generic(values[:0], binner, 'right')
+
+ msg = "Values falls before first bin"
+ with pytest.raises(ValueError, match=msg):
+ generate_bins_generic(values, [4], 'right')
+ msg = "Values falls after last bin"
+ with pytest.raises(ValueError, match=msg):
+ generate_bins_generic(values, [-3, -1], 'right')
def test_group_ohlc():
diff --git a/pandas/tests/groupby/test_filters.py b/pandas/tests/groupby/test_filters.py
index 8195d36b7bfe9..4d386db735b57 100644
--- a/pandas/tests/groupby/test_filters.py
+++ b/pandas/tests/groupby/test_filters.py
@@ -116,8 +116,9 @@ def raise_if_sum_is_zero(x):
s = pd.Series([-1, 0, 1, 2])
grouper = s.apply(lambda x: x % 2)
grouped = s.groupby(grouper)
- pytest.raises(TypeError,
- lambda: grouped.filter(raise_if_sum_is_zero))
+ msg = "the filter must return a boolean result"
+ with pytest.raises(TypeError, match=msg):
+ grouped.filter(raise_if_sum_is_zero)
def test_filter_with_axis_in_groupby():
@@ -140,16 +141,28 @@ def test_filter_bad_shapes():
g_s = s.groupby(s)
f = lambda x: x
- pytest.raises(TypeError, lambda: g_df.filter(f))
- pytest.raises(TypeError, lambda: g_s.filter(f))
+ msg = "filter function returned a DataFrame, but expected a scalar bool"
+ with pytest.raises(TypeError, match=msg):
+ g_df.filter(f)
+ msg = "the filter must return a boolean result"
+ with pytest.raises(TypeError, match=msg):
+ g_s.filter(f)
f = lambda x: x == 1
- pytest.raises(TypeError, lambda: g_df.filter(f))
- pytest.raises(TypeError, lambda: g_s.filter(f))
+ msg = "filter function returned a DataFrame, but expected a scalar bool"
+ with pytest.raises(TypeError, match=msg):
+ g_df.filter(f)
+ msg = "the filter must return a boolean result"
+ with pytest.raises(TypeError, match=msg):
+ g_s.filter(f)
f = lambda x: np.outer(x, x)
- pytest.raises(TypeError, lambda: g_df.filter(f))
- pytest.raises(TypeError, lambda: g_s.filter(f))
+ msg = "can't multiply sequence by non-int of type 'str'"
+ with pytest.raises(TypeError, match=msg):
+ g_df.filter(f)
+ msg = "the filter must return a boolean result"
+ with pytest.raises(TypeError, match=msg):
+ g_s.filter(f)
def test_filter_nan_is_false():
diff --git a/pandas/tests/groupby/test_function.py b/pandas/tests/groupby/test_function.py
index 00714c3333bde..a884a37840f8a 100644
--- a/pandas/tests/groupby/test_function.py
+++ b/pandas/tests/groupby/test_function.py
@@ -761,8 +761,11 @@ def test_frame_describe_tupleindex():
'z': [100, 200, 300, 400, 500] * 3})
df1['k'] = [(0, 0, 1), (0, 1, 0), (1, 0, 0)] * 5
df2 = df1.rename(columns={'k': 'key'})
- pytest.raises(ValueError, lambda: df1.groupby('k').describe())
- pytest.raises(ValueError, lambda: df2.groupby('key').describe())
+ msg = "Names should be list-like for a MultiIndex"
+ with pytest.raises(ValueError, match=msg):
+ df1.groupby('k').describe()
+ with pytest.raises(ValueError, match=msg):
+ df2.groupby('key').describe()
def test_frame_describe_unstacked_format():
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 33cfb9a06a805..98c917a6eca3c 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -71,7 +71,10 @@ def test_basic(dtype):
assert agged[1] == 21
# corner cases
- pytest.raises(Exception, grouped.aggregate, lambda x: x * 2)
+ msg = "Must produce aggregated value"
+ # exception raised is type Exception
+ with pytest.raises(Exception, match=msg):
+ grouped.aggregate(lambda x: x * 2)
def test_groupby_nonobject_dtype(mframe, df_mixed_floats):
@@ -330,12 +333,17 @@ def f3(x):
assert_frame_equal(result1, result2)
# should fail (not the same number of levels)
- pytest.raises(AssertionError, df.groupby('a').apply, f2)
- pytest.raises(AssertionError, df2.groupby('a').apply, f2)
+ msg = "Cannot concat indices that do not have the same number of levels"
+ with pytest.raises(AssertionError, match=msg):
+ df.groupby('a').apply(f2)
+ with pytest.raises(AssertionError, match=msg):
+ df2.groupby('a').apply(f2)
# should fail (incorrect shape)
- pytest.raises(AssertionError, df.groupby('a').apply, f3)
- pytest.raises(AssertionError, df2.groupby('a').apply, f3)
+ with pytest.raises(AssertionError, match=msg):
+ df.groupby('a').apply(f3)
+ with pytest.raises(AssertionError, match=msg):
+ df2.groupby('a').apply(f3)
def test_attr_wrapper(ts):
@@ -356,7 +364,9 @@ def test_attr_wrapper(ts):
expected = grouped.agg(lambda x: x.dtype)
# make sure raises error
- pytest.raises(AttributeError, getattr, grouped, 'foo')
+ msg = "'SeriesGroupBy' object has no attribute 'foo'"
+ with pytest.raises(AttributeError, match=msg):
+ getattr(grouped, 'foo')
def test_frame_groupby(tsframe):
@@ -664,11 +674,13 @@ def test_groupby_as_index_series_scalar(df):
def test_groupby_as_index_corner(df, ts):
- pytest.raises(TypeError, ts.groupby, lambda x: x.weekday(),
- as_index=False)
+ msg = "as_index=False only valid with DataFrame"
+ with pytest.raises(TypeError, match=msg):
+ ts.groupby(lambda x: x.weekday(), as_index=False)
- pytest.raises(ValueError, df.groupby, lambda x: x.lower(),
- as_index=False, axis=1)
+ msg = "as_index=False only valid for axis=0"
+ with pytest.raises(ValueError, match=msg):
+ df.groupby(lambda x: x.lower(), as_index=False, axis=1)
def test_groupby_multiple_key(df):
@@ -722,8 +734,11 @@ def test_omit_nuisance(df):
# won't work with axis = 1
grouped = df.groupby({'A': 0, 'C': 0, 'D': 1, 'E': 1}, axis=1)
- result = pytest.raises(TypeError, grouped.agg,
- lambda x: x.sum(0, numeric_only=False))
+ msg = (r'\("unsupported operand type\(s\) for \+: '
+ "'Timestamp' and 'float'\""
+ r", u?'occurred at index 0'\)")
+ with pytest.raises(TypeError, match=msg):
+ grouped.agg(lambda x: x.sum(0, numeric_only=False))
def test_omit_nuisance_python_multiple(three_group):
@@ -756,7 +771,9 @@ def test_empty_groups_corner(mframe):
def test_nonsense_func():
df = DataFrame([0])
- pytest.raises(Exception, df.groupby, lambda x: x + 'foo')
+ msg = r"unsupported operand type\(s\) for \+: '(int|long)' and 'str'"
+ with pytest.raises(TypeError, match=msg):
+ df.groupby(lambda x: x + 'foo')
def test_wrap_aggregated_output_multindex(mframe):
@@ -823,12 +840,22 @@ def test_groupby_level_nonmulti():
result = s.groupby(level=[-1]).sum()
tm.assert_series_equal(result, expected)
- pytest.raises(ValueError, s.groupby, level=1)
- pytest.raises(ValueError, s.groupby, level=-2)
- pytest.raises(ValueError, s.groupby, level=[])
- pytest.raises(ValueError, s.groupby, level=[0, 0])
- pytest.raises(ValueError, s.groupby, level=[0, 1])
- pytest.raises(ValueError, s.groupby, level=[1])
+ msg = "level > 0 or level < -1 only valid with MultiIndex"
+ with pytest.raises(ValueError, match=msg):
+ s.groupby(level=1)
+ with pytest.raises(ValueError, match=msg):
+ s.groupby(level=-2)
+ msg = "No group keys passed!"
+ with pytest.raises(ValueError, match=msg):
+ s.groupby(level=[])
+ msg = "multiple levels only valid with MultiIndex"
+ with pytest.raises(ValueError, match=msg):
+ s.groupby(level=[0, 0])
+ with pytest.raises(ValueError, match=msg):
+ s.groupby(level=[0, 1])
+ msg = "level > 0 or level < -1 only valid with MultiIndex"
+ with pytest.raises(ValueError, match=msg):
+ s.groupby(level=[1])
def test_groupby_complex():
@@ -1101,7 +1128,8 @@ def test_groupby_list_infer_array_like(df):
expected = df.groupby(df['A']).mean()
assert_frame_equal(result, expected, check_names=False)
- pytest.raises(Exception, df.groupby, list(df['A'][:-1]))
+ with pytest.raises(KeyError, match=r"^'foo'$"):
+ df.groupby(list(df['A'][:-1]))
# pathological case of ambiguity
df = DataFrame({'foo': [0, 1],
@@ -1128,10 +1156,13 @@ def test_groupby_keys_same_size_as_index():
def test_groupby_one_row():
# GH 11741
+ msg = r"^'Z'$"
df1 = pd.DataFrame(np.random.randn(1, 4), columns=list('ABCD'))
- pytest.raises(KeyError, df1.groupby, 'Z')
+ with pytest.raises(KeyError, match=msg):
+ df1.groupby('Z')
df2 = pd.DataFrame(np.random.randn(2, 4), columns=list('ABCD'))
- pytest.raises(KeyError, df2.groupby, 'Z')
+ with pytest.raises(KeyError, match=msg):
+ df2.groupby('Z')
def test_groupby_nat_exclude():
@@ -1169,7 +1200,8 @@ def test_groupby_nat_exclude():
tm.assert_frame_equal(
grouped.get_group(Timestamp('2013-02-01')), df.iloc[[3, 5]])
- pytest.raises(KeyError, grouped.get_group, pd.NaT)
+ with pytest.raises(KeyError, match=r"^NaT$"):
+ grouped.get_group(pd.NaT)
nan_df = DataFrame({'nan': [np.nan, np.nan, np.nan],
'nat': [pd.NaT, pd.NaT, pd.NaT]})
@@ -1181,8 +1213,10 @@ def test_groupby_nat_exclude():
assert grouped.groups == {}
assert grouped.ngroups == 0
assert grouped.indices == {}
- pytest.raises(KeyError, grouped.get_group, np.nan)
- pytest.raises(KeyError, grouped.get_group, pd.NaT)
+ with pytest.raises(KeyError, match=r"^nan$"):
+ grouped.get_group(np.nan)
+ with pytest.raises(KeyError, match=r"^NaT$"):
+ grouped.get_group(pd.NaT)
@pytest.mark.filterwarnings("ignore:\\nPanel:FutureWarning")
@@ -1643,7 +1677,7 @@ def test_pivot_table_values_key_error():
df['year'] = df.set_index('eventDate').index.year
df['month'] = df.set_index('eventDate').index.month
- with pytest.raises(KeyError):
+ with pytest.raises(KeyError, match="'badname'"):
df.reset_index().pivot_table(index='year', columns='month',
values='badname', aggfunc='count')
@@ -1689,7 +1723,7 @@ def test_tuple_correct_keyerror():
df = pd.DataFrame(1, index=range(3),
columns=pd.MultiIndex.from_product([[1, 2],
[3, 4]]))
- with pytest.raises(KeyError, match="(7, 8)"):
+ with pytest.raises(KeyError, match=r"^\(7, 8\)$"):
df.groupby((7, 8)).mean()
diff --git a/pandas/tests/groupby/test_grouping.py b/pandas/tests/groupby/test_grouping.py
index 55d9cee0376f1..a509a7cb57c97 100644
--- a/pandas/tests/groupby/test_grouping.py
+++ b/pandas/tests/groupby/test_grouping.py
@@ -26,9 +26,9 @@ class TestSelection(object):
def test_select_bad_cols(self):
df = DataFrame([[1, 2]], columns=['A', 'B'])
g = df.groupby('A')
- pytest.raises(KeyError, g.__getitem__, ['C']) # g[['C']]
+ with pytest.raises(KeyError, match='"Columns not found: \'C\'"'):
+ g[['C']]
- pytest.raises(KeyError, g.__getitem__, ['A', 'C']) # g[['A', 'C']]
with pytest.raises(KeyError, match='^[^A]+$'):
# A should not be referenced as a bad column...
# will have to rethink regex if you change message!
@@ -39,8 +39,11 @@ def test_groupby_duplicated_column_errormsg(self):
df = DataFrame(columns=['A', 'B', 'A', 'C'],
data=[range(4), range(2, 6), range(0, 8, 2)])
- pytest.raises(ValueError, df.groupby, 'A')
- pytest.raises(ValueError, df.groupby, ['A', 'B'])
+ msg = "Grouper for 'A' not 1-dimensional"
+ with pytest.raises(ValueError, match=msg):
+ df.groupby('A')
+ with pytest.raises(ValueError, match=msg):
+ df.groupby(['A', 'B'])
grouped = df.groupby('B')
c = grouped.count()
@@ -304,7 +307,8 @@ def test_grouper_iter(self, df):
def test_empty_groups(self, df):
# see gh-1048
- pytest.raises(ValueError, df.groupby, [])
+ with pytest.raises(ValueError, match="No group keys passed!"):
+ df.groupby([])
def test_groupby_grouper(self, df):
grouped = df.groupby('A')
@@ -345,11 +349,15 @@ def test_groupby_grouper_f_sanity_checked(self):
# when the elements are Timestamp.
# the result is Index[0:6], very confusing.
- pytest.raises(AssertionError, ts.groupby, lambda key: key[0:6])
+ msg = r"Grouper result violates len\(labels\) == len\(data\)"
+ with pytest.raises(AssertionError, match=msg):
+ ts.groupby(lambda key: key[0:6])
def test_grouping_error_on_multidim_input(self, df):
- pytest.raises(ValueError,
- Grouping, df.index, df[['A', 'A']])
+ msg = ("Grouper for '<class 'pandas.core.frame.DataFrame'>'"
+ " not 1-dimensional")
+ with pytest.raises(ValueError, match=msg):
+ Grouping(df.index, df[['A', 'A']])
def test_multiindex_passthru(self):
@@ -470,14 +478,18 @@ def test_groupby_level(self, sort, mframe, df):
assert_frame_equal(result1, expected1.T)
# raise exception for non-MultiIndex
- pytest.raises(ValueError, df.groupby, level=1)
+ msg = "level > 0 or level < -1 only valid with MultiIndex"
+ with pytest.raises(ValueError, match=msg):
+ df.groupby(level=1)
def test_groupby_level_index_names(self):
# GH4014 this used to raise ValueError since 'exp'>1 (in py2)
df = DataFrame({'exp': ['A'] * 3 + ['B'] * 3,
'var1': lrange(6), }).set_index('exp')
df.groupby(level='exp')
- pytest.raises(ValueError, df.groupby, level='foo')
+ msg = "level name foo is not the name of the index"
+ with pytest.raises(ValueError, match=msg):
+ df.groupby(level='foo')
@pytest.mark.parametrize('sort', [True, False])
def test_groupby_level_with_nas(self, sort):
@@ -588,10 +600,15 @@ def test_get_group(self):
assert_frame_equal(result1, result3)
# must pass a same-length tuple with multiple keys
- pytest.raises(ValueError, lambda: g.get_group('foo'))
- pytest.raises(ValueError, lambda: g.get_group(('foo')))
- pytest.raises(ValueError,
- lambda: g.get_group(('foo', 'bar', 'baz')))
+ msg = "must supply a tuple to get_group with multiple grouping keys"
+ with pytest.raises(ValueError, match=msg):
+ g.get_group('foo')
+ with pytest.raises(ValueError, match=msg):
+ g.get_group(('foo'))
+ msg = ("must supply a same-length tuple to get_group with multiple"
+ " grouping keys")
+ with pytest.raises(ValueError, match=msg):
+ g.get_group(('foo', 'bar', 'baz'))
def test_get_group_empty_bins(self, observed):
@@ -605,7 +622,9 @@ def test_get_group_empty_bins(self, observed):
expected = DataFrame([3, 1], index=[0, 1])
assert_frame_equal(result, expected)
- pytest.raises(KeyError, lambda: g.get_group(pd.Interval(10, 15)))
+ msg = r"Interval\(10, 15, closed='right'\)"
+ with pytest.raises(KeyError, match=msg):
+ g.get_group(pd.Interval(10, 15))
def test_get_group_grouped_by_tuple(self):
# GH 8121
diff --git a/pandas/tests/groupby/test_transform.py b/pandas/tests/groupby/test_transform.py
index 465ae67fd7318..f120402e6e8ca 100644
--- a/pandas/tests/groupby/test_transform.py
+++ b/pandas/tests/groupby/test_transform.py
@@ -637,8 +637,11 @@ def test_cython_transform_frame(op, args, targop):
for c in df:
if c not in ['float', 'int', 'float_missing'
] and op != 'shift':
- pytest.raises(DataError, gb[c].transform, op)
- pytest.raises(DataError, getattr(gb[c], op))
+ msg = "No numeric types to aggregate"
+ with pytest.raises(DataError, match=msg):
+ gb[c].transform(op)
+ with pytest.raises(DataError, match=msg):
+ getattr(gb[c], op)()
else:
expected = gb[c].apply(targop)
expected.name = c
| xref #24332 | https://api.github.com/repos/pandas-dev/pandas/pulls/24828 | 2019-01-18T17:37:27Z | 2019-01-20T18:44:06Z | 2019-01-20T18:44:06Z | 2019-01-20T22:33:50Z |
TST: remove patches to pandas.util.testing.N | diff --git a/pandas/tests/indexing/multiindex/conftest.py b/pandas/tests/indexing/multiindex/conftest.py
index 046fc19c0d9c8..545e092d9ce65 100644
--- a/pandas/tests/indexing/multiindex/conftest.py
+++ b/pandas/tests/indexing/multiindex/conftest.py
@@ -21,8 +21,7 @@ def multiindex_dataframe_random_data():
def multiindex_year_month_day_dataframe_random_data():
"""DataFrame with 3 level MultiIndex (year, month, day) covering
first 100 business days from 2000-01-01 with random data"""
- tm.N = 100
- tdf = tm.makeTimeDataFrame()
+ tdf = tm.makeTimeDataFrame(100)
ymd = tdf.groupby([lambda x: x.year, lambda x: x.month,
lambda x: x.day]).sum()
# use Int64Index, to make sure things work
diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py
index c78ab41d2fae4..ad79cc97f8b77 100644
--- a/pandas/tests/plotting/test_datetimelike.py
+++ b/pandas/tests/plotting/test_datetimelike.py
@@ -313,10 +313,7 @@ def test_business_freq(self):
@pytest.mark.slow
def test_business_freq_convert(self):
- n = tm.N
- tm.N = 300
- bts = tm.makeTimeSeries().asfreq('BM')
- tm.N = n
+ bts = tm.makeTimeSeries(300).asfreq('BM')
ts = bts.to_period('M')
_, ax = self.plt.subplots()
bts.plot(ax=ax)
diff --git a/pandas/tests/series/test_alter_axes.py b/pandas/tests/series/test_alter_axes.py
index cd4c0a7924d39..04c54bcf8c22c 100644
--- a/pandas/tests/series/test_alter_axes.py
+++ b/pandas/tests/series/test_alter_axes.py
@@ -22,8 +22,8 @@ def test_setindex(self, string_series):
string_series.index = None
# wrong length
- msg = (r"Length mismatch: Expected axis has (30|100) elements, new"
- r" values have (29|99) elements")
+ msg = ("Length mismatch: Expected axis has 30 elements, new"
+ " values have 29 elements")
with pytest.raises(ValueError, match=msg):
string_series.index = np.arange(len(string_series) - 1)
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index b5023c376dedd..a7bbbbb5033ac 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -47,8 +47,7 @@ def setup_method(self, method):
s[3] = np.NaN
self.series = s
- tm.N = 100
- self.tdf = tm.makeTimeDataFrame()
+ self.tdf = tm.makeTimeDataFrame(100)
self.ymd = self.tdf.groupby([lambda x: x.year, lambda x: x.month,
lambda x: x.day]).sum()
| xref https://github.com/pandas-dev/pandas/pull/24769#issuecomment-455326819 | https://api.github.com/repos/pandas-dev/pandas/pulls/24826 | 2019-01-18T09:23:19Z | 2019-01-18T19:01:45Z | 2019-01-18T19:01:45Z | 2019-01-18T22:16:46Z |
DOC/CLN: Timezone section in timeseries.rst | diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index f56ad710973dd..5841125817d03 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -2129,11 +2129,13 @@ These can easily be converted to a ``PeriodIndex``:
Time Zone Handling
------------------
-Pandas provides rich support for working with timestamps in different time
-zones using ``pytz`` and ``dateutil`` libraries. ``dateutil`` currently is only
-supported for fixed offset and tzfile zones. The default library is ``pytz``.
-Support for ``dateutil`` is provided for compatibility with other
-applications e.g. if you use ``dateutil`` in other Python packages.
+pandas provides rich support for working with timestamps in different time
+zones using the ``pytz`` and ``dateutil`` libraries.
+
+.. note::
+
+ pandas does not yet support ``datetime.timezone`` objects from the standard
+ library.
Working with Time Zones
~~~~~~~~~~~~~~~~~~~~~~~
@@ -2145,13 +2147,16 @@ By default, pandas objects are time zone unaware:
rng = pd.date_range('3/6/2012 00:00', periods=15, freq='D')
rng.tz is None
-To supply the time zone, you can use the ``tz`` keyword to ``date_range`` and
-other functions. Dateutil time zone strings are distinguished from ``pytz``
-time zones by starting with ``dateutil/``.
+To localize these dates to a time zone (assign a particular time zone to a naive date),
+you can use the ``tz_localize`` method or the ``tz`` keyword argument in
+:func:`date_range`, :class:`Timestamp`, or :class:`DatetimeIndex`.
+You can either pass ``pytz`` or ``dateutil`` time zone objects or Olson time zone database strings.
+Olson time zone strings will return ``pytz`` time zone objects by default.
+To return ``dateutil`` time zone objects, append ``dateutil/`` before the string.
* In ``pytz`` you can find a list of common (and less common) time zones using
``from pytz import common_timezones, all_timezones``.
-* ``dateutil`` uses the OS timezones so there isn't a fixed list available. For
+* ``dateutil`` uses the OS time zones so there isn't a fixed list available. For
common zones, the names are the same as ``pytz``.
.. ipython:: python
@@ -2159,23 +2164,23 @@ time zones by starting with ``dateutil/``.
import dateutil
# pytz
- rng_pytz = pd.date_range('3/6/2012 00:00', periods=10, freq='D',
+ rng_pytz = pd.date_range('3/6/2012 00:00', periods=3, freq='D',
tz='Europe/London')
rng_pytz.tz
# dateutil
- rng_dateutil = pd.date_range('3/6/2012 00:00', periods=10, freq='D',
- tz='dateutil/Europe/London')
+ rng_dateutil = pd.date_range('3/6/2012 00:00', periods=3, freq='D')
+ rng_dateutil = rng_dateutil.tz_localize('dateutil/Europe/London')
rng_dateutil.tz
# dateutil - utc special case
- rng_utc = pd.date_range('3/6/2012 00:00', periods=10, freq='D',
+ rng_utc = pd.date_range('3/6/2012 00:00', periods=3, freq='D',
tz=dateutil.tz.tzutc())
rng_utc.tz
-Note that the ``UTC`` timezone is a special case in ``dateutil`` and should be constructed explicitly
-as an instance of ``dateutil.tz.tzutc``. You can also construct other timezones explicitly first,
-which gives you more control over which time zone is used:
+Note that the ``UTC`` time zone is a special case in ``dateutil`` and should be constructed explicitly
+as an instance of ``dateutil.tz.tzutc``. You can also construct other time
+zones objects explicitly first.
.. ipython:: python
@@ -2183,56 +2188,46 @@ which gives you more control over which time zone is used:
# pytz
tz_pytz = pytz.timezone('Europe/London')
- rng_pytz = pd.date_range('3/6/2012 00:00', periods=10, freq='D',
- tz=tz_pytz)
+ rng_pytz = pd.date_range('3/6/2012 00:00', periods=3, freq='D')
+ rng_pytz = rng_pytz.tz_localize(tz_pytz)
rng_pytz.tz == tz_pytz
# dateutil
tz_dateutil = dateutil.tz.gettz('Europe/London')
- rng_dateutil = pd.date_range('3/6/2012 00:00', periods=10, freq='D',
+ rng_dateutil = pd.date_range('3/6/2012 00:00', periods=3, freq='D',
tz=tz_dateutil)
rng_dateutil.tz == tz_dateutil
-Timestamps, like Python's ``datetime.datetime`` object can be either time zone
-naive or time zone aware. Naive time series and ``DatetimeIndex`` objects can be
-*localized* using ``tz_localize``:
-
-.. ipython:: python
-
- ts = pd.Series(np.random.randn(len(rng)), rng)
-
- ts_utc = ts.tz_localize('UTC')
- ts_utc
-
-Again, you can explicitly construct the timezone object first.
-You can use the ``tz_convert`` method to convert pandas objects to convert
-tz-aware data to another time zone:
+To convert a time zone aware pandas object from one time zone to another,
+you can use the ``tz_convert`` method.
.. ipython:: python
- ts_utc.tz_convert('US/Eastern')
+ rng_pytz.tz_convert('US/Eastern')
.. warning::
- Be wary of conversions between libraries. For some zones ``pytz`` and ``dateutil`` have different
- definitions of the zone. This is more of a problem for unusual timezones than for
+ Be wary of conversions between libraries. For some time zones, ``pytz`` and ``dateutil`` have different
+ definitions of the zone. This is more of a problem for unusual time zones than for
'standard' zones like ``US/Eastern``.
.. warning::
- Be aware that a timezone definition across versions of timezone libraries may not
- be considered equal. This may cause problems when working with stored data that
- is localized using one version and operated on with a different version.
- See :ref:`here<io.hdf5-notes>` for how to handle such a situation.
+ Be aware that a time zone definition across versions of time zone libraries may not
+ be considered equal. This may cause problems when working with stored data that
+ is localized using one version and operated on with a different version.
+ See :ref:`here<io.hdf5-notes>` for how to handle such a situation.
.. warning::
- It is incorrect to pass a timezone directly into the ``datetime.datetime`` constructor (e.g.,
- ``datetime.datetime(2011, 1, 1, tz=timezone('US/Eastern'))``. Instead, the datetime
- needs to be localized using the localize method on the timezone.
+ For ``pytz`` time zones, it is incorrect to pass a time zone object directly into
+ the ``datetime.datetime`` constructor
+ (e.g., ``datetime.datetime(2011, 1, 1, tz=pytz.timezone('US/Eastern'))``.
+ Instead, the datetime needs to be localized using the ``localize`` method
+ on the ``pytz`` time zone object.
-Under the hood, all timestamps are stored in UTC. Scalar values from a
-``DatetimeIndex`` with a time zone will have their fields (day, hour, minute)
+Under the hood, all timestamps are stored in UTC. Values from a time zone aware
+:class:`DatetimeIndex` or :class:`Timestamp` will have their fields (day, hour, minute, etc.)
localized to the time zone. However, timestamps with the same UTC value are
still considered to be equal even if they are in different time zones:
@@ -2241,51 +2236,35 @@ still considered to be equal even if they are in different time zones:
rng_eastern = rng_utc.tz_convert('US/Eastern')
rng_berlin = rng_utc.tz_convert('Europe/Berlin')
- rng_eastern[5]
- rng_berlin[5]
- rng_eastern[5] == rng_berlin[5]
-
-Like ``Series``, ``DataFrame``, and ``DatetimeIndex``; ``Timestamp`` objects
-can be converted to other time zones using ``tz_convert``:
-
-.. ipython:: python
-
- rng_eastern[5]
- rng_berlin[5]
- rng_eastern[5].tz_convert('Europe/Berlin')
-
-Localization of ``Timestamp`` functions just like ``DatetimeIndex`` and ``Series``:
-
-.. ipython:: python
-
- rng[5]
- rng[5].tz_localize('Asia/Shanghai')
-
+ rng_eastern[2]
+ rng_berlin[2]
+ rng_eastern[2] == rng_berlin[2]
-Operations between ``Series`` in different time zones will yield UTC
-``Series``, aligning the data on the UTC timestamps:
+Operations between :class:`Series` in different time zones will yield UTC
+:class:`Series`, aligning the data on the UTC timestamps:
.. ipython:: python
+ ts_utc = pd.Series(range(3), pd.date_range('20130101', periods=3, tz='UTC'))
eastern = ts_utc.tz_convert('US/Eastern')
berlin = ts_utc.tz_convert('Europe/Berlin')
result = eastern + berlin
result
result.index
-To remove timezone from tz-aware ``DatetimeIndex``, use ``tz_localize(None)`` or ``tz_convert(None)``.
-``tz_localize(None)`` will remove timezone holding local time representations.
-``tz_convert(None)`` will remove timezone after converting to UTC time.
+To remove time zone information, use ``tz_localize(None)`` or ``tz_convert(None)``.
+``tz_localize(None)`` will remove the time zone yielding the local time representation.
+``tz_convert(None)`` will remove the time zone after converting to UTC time.
.. ipython:: python
didx = pd.date_range(start='2014-08-01 09:00', freq='H',
- periods=10, tz='US/Eastern')
+ periods=3, tz='US/Eastern')
didx
didx.tz_localize(None)
didx.tz_convert(None)
- # tz_convert(None) is identical with tz_convert('UTC').tz_localize(None)
+ # tz_convert(None) is identical to tz_convert('UTC').tz_localize(None)
didx.tz_convert('UTC').tz_localize(None)
.. _timeseries.timezone_ambiguous:
@@ -2293,54 +2272,34 @@ To remove timezone from tz-aware ``DatetimeIndex``, use ``tz_localize(None)`` or
Ambiguous Times when Localizing
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-In some cases, localize cannot determine the DST and non-DST hours when there are
-duplicates. This often happens when reading files or database records that simply
-duplicate the hours. Passing ``ambiguous='infer'`` into ``tz_localize`` will
-attempt to determine the right offset. Below the top example will fail as it
-contains ambiguous times and the bottom will infer the right offset.
+``tz_localize`` may not be able to determine the UTC offset of a timestamp
+because daylight savings time (DST) in a local time zone causes some times to occur
+twice within one day ("clocks fall back"). The following options are available:
+
+* ``'raise'``: Raises a ``pytz.AmbiguousTimeError`` (the default behavior)
+* ``'infer'``: Attempt to determine the correct offset base on the monotonicity of the timestamps
+* ``'NaT'``: Replaces ambiguous times with ``NaT``
+* ``bool``: ``True`` represents a DST time, ``False`` represents non-DST time. An array-like of ``bool`` values is supported for a sequence of times.
.. ipython:: python
rng_hourly = pd.DatetimeIndex(['11/06/2011 00:00', '11/06/2011 01:00',
- '11/06/2011 01:00', '11/06/2011 02:00',
- '11/06/2011 03:00'])
+ '11/06/2011 01:00', '11/06/2011 02:00'])
-This will fail as there are ambiguous times
+This will fail as there are ambiguous times (``'11/06/2011 01:00'``)
.. code-block:: ipython
In [2]: rng_hourly.tz_localize('US/Eastern')
AmbiguousTimeError: Cannot infer dst time from Timestamp('2011-11-06 01:00:00'), try using the 'ambiguous' argument
-Infer the ambiguous times
-
-.. ipython:: python
-
- rng_hourly_eastern = rng_hourly.tz_localize('US/Eastern', ambiguous='infer')
- rng_hourly_eastern.to_list()
-
-In addition to 'infer', there are several other arguments supported. Passing
-an array-like of bools or 0s/1s where True represents a DST hour and False a
-non-DST hour, allows for distinguishing more than one DST
-transition (e.g., if you have multiple records in a database each with their
-own DST transition). Or passing 'NaT' will fill in transition times
-with not-a-time values. These methods are available in the ``DatetimeIndex``
-constructor as well as ``tz_localize``.
+Handle these ambiguous times by specifying the following.
.. ipython:: python
- rng_hourly_dst = np.array([1, 1, 0, 0, 0])
- rng_hourly.tz_localize('US/Eastern', ambiguous=rng_hourly_dst).to_list()
- rng_hourly.tz_localize('US/Eastern', ambiguous='NaT').to_list()
-
- didx = pd.date_range(start='2014-08-01 09:00', freq='H',
- periods=10, tz='US/Eastern')
- didx
- didx.tz_localize(None)
- didx.tz_convert(None)
-
- # tz_convert(None) is identical with tz_convert('UTC').tz_localize(None)
- didx.tz_convert('UCT').tz_localize(None)
+ rng_hourly.tz_localize('US/Eastern', ambiguous='infer')
+ rng_hourly.tz_localize('US/Eastern', ambiguous='NaT')
+ rng_hourly.tz_localize('US/Eastern', ambiguous=[True, True, False, False])
.. _timeseries.timezone_nonexistent:
@@ -2348,7 +2307,7 @@ Nonexistent Times when Localizing
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A DST transition may also shift the local time ahead by 1 hour creating nonexistent
-local times. The behavior of localizing a timeseries with nonexistent times
+local times ("clocks spring forward"). The behavior of localizing a timeseries with nonexistent times
can be controlled by the ``nonexistent`` argument. The following options are available:
* ``'raise'``: Raises a ``pytz.NonExistentTimeError`` (the default behavior)
@@ -2382,58 +2341,61 @@ Transform nonexistent times to ``NaT`` or shift the times.
.. _timeseries.timezone_series:
-TZ Aware Dtypes
-~~~~~~~~~~~~~~~
+Time Zone Series Operations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
-``Series/DatetimeIndex`` with a timezone **naive** value are represented with a dtype of ``datetime64[ns]``.
+A :class:`Series` with time zone **naive** values is
+represented with a dtype of ``datetime64[ns]``.
.. ipython:: python
s_naive = pd.Series(pd.date_range('20130101', periods=3))
s_naive
-``Series/DatetimeIndex`` with a timezone **aware** value are represented with a dtype of ``datetime64[ns, tz]``.
+A :class:`Series` with a time zone **aware** values is
+represented with a dtype of ``datetime64[ns, tz]`` where ``tz`` is the time zone
.. ipython:: python
s_aware = pd.Series(pd.date_range('20130101', periods=3, tz='US/Eastern'))
s_aware
-Both of these ``Series`` can be manipulated via the ``.dt`` accessor, see :ref:`here <basics.dt_accessors>`.
+Both of these :class:`Series` time zone information
+can be manipulated via the ``.dt`` accessor, see :ref:`the dt accessor section <basics.dt_accessors>`.
-For example, to localize and convert a naive stamp to timezone aware.
+For example, to localize and convert a naive stamp to time zone aware.
.. ipython:: python
s_naive.dt.tz_localize('UTC').dt.tz_convert('US/Eastern')
-
-Further more you can ``.astype(...)`` timezone aware (and naive). This operation is effectively a localize AND convert on a naive stamp, and
-a convert on an aware stamp.
+Time zone information can also be manipulated using the ``astype`` method.
+This method can localize and convert time zone naive timestamps or
+convert time zone aware timestamps.
.. ipython:: python
- # localize and convert a naive timezone
+ # localize and convert a naive time zone
s_naive.astype('datetime64[ns, US/Eastern]')
# make an aware tz naive
s_aware.astype('datetime64[ns]')
- # convert to a new timezone
+ # convert to a new time zone
s_aware.astype('datetime64[ns, CET]')
.. note::
Using :meth:`Series.to_numpy` on a ``Series``, returns a NumPy array of the data.
- NumPy does not currently support timezones (even though it is *printing* in the local timezone!),
- therefore an object array of Timestamps is returned for timezone aware data:
+ NumPy does not currently support time zones (even though it is *printing* in the local time zone!),
+ therefore an object array of Timestamps is returned for time zone aware data:
.. ipython:: python
s_naive.to_numpy()
s_aware.to_numpy()
- By converting to an object array of Timestamps, it preserves the timezone
+ By converting to an object array of Timestamps, it preserves the time zone
information. For example, when converting back to a Series:
.. ipython:: python
| - Shortened some of the examples to show the minimum, necessary functionality
- Removed some redundant examples
- Refactored the ambiguous times handling section
- Showcase `tz_localize` more in the beginning of the section & noted that pandas doesn't support `datetime.timezone` objects yet
| https://api.github.com/repos/pandas-dev/pandas/pulls/24825 | 2019-01-18T06:22:09Z | 2019-02-03T20:34:54Z | 2019-02-03T20:34:54Z | 2019-02-03T21:36:41Z |
avoid non-standard imports | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 3e62a08975dad..c8bfc564e7573 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -112,6 +112,7 @@ if [[ -z "$CHECK" || "$CHECK" == "patterns" ]]; then
# Check for imports from pandas.core.common instead of `import pandas.core.common as com`
MSG='Check for non-standard imports' ; echo $MSG
invgrep -R --include="*.py*" -E "from pandas.core.common import " pandas
+ # invgrep -R --include="*.py*" -E "from numpy import nan " pandas # GH#24822 not yet implemented since the offending imports have not all been removed
RET=$(($RET + $?)) ; echo $MSG "DONE"
MSG='Check for pytest warns' ; echo $MSG
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index 244e8f83bea37..f2c3f50c291c3 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -6,8 +6,6 @@
import warnings
import numpy as np
-from numpy import nan
-from numpy.random import randn
import pytest
from pandas.compat import PY35, lrange
@@ -240,22 +238,22 @@ class TestDataFrameAnalytics():
@td.skip_if_no_scipy
def test_corr_pearson(self, float_frame):
- float_frame['A'][:5] = nan
- float_frame['B'][5:10] = nan
+ float_frame['A'][:5] = np.nan
+ float_frame['B'][5:10] = np.nan
self._check_method(float_frame, 'pearson')
@td.skip_if_no_scipy
def test_corr_kendall(self, float_frame):
- float_frame['A'][:5] = nan
- float_frame['B'][5:10] = nan
+ float_frame['A'][:5] = np.nan
+ float_frame['B'][5:10] = np.nan
self._check_method(float_frame, 'kendall')
@td.skip_if_no_scipy
def test_corr_spearman(self, float_frame):
- float_frame['A'][:5] = nan
- float_frame['B'][5:10] = nan
+ float_frame['A'][:5] = np.nan
+ float_frame['B'][5:10] = np.nan
self._check_method(float_frame, 'spearman')
@@ -266,8 +264,8 @@ def _check_method(self, frame, method='pearson'):
@td.skip_if_no_scipy
def test_corr_non_numeric(self, float_frame, float_string_frame):
- float_frame['A'][:5] = nan
- float_frame['B'][5:10] = nan
+ float_frame['A'][:5] = np.nan
+ float_frame['B'][5:10] = np.nan
# exclude non-numeric types
result = float_string_frame.corr()
@@ -351,16 +349,16 @@ def test_cov(self, float_frame, float_string_frame):
# with NAs
frame = float_frame.copy()
- frame['A'][:5] = nan
- frame['B'][5:10] = nan
+ frame['A'][:5] = np.nan
+ frame['B'][5:10] = np.nan
result = float_frame.cov(min_periods=len(float_frame) - 8)
expected = float_frame.cov()
expected.loc['A', 'B'] = np.nan
expected.loc['B', 'A'] = np.nan
# regular
- float_frame['A'][:5] = nan
- float_frame['B'][:10] = nan
+ float_frame['A'][:5] = np.nan
+ float_frame['B'][:10] = np.nan
cov = float_frame.cov()
tm.assert_almost_equal(cov['A']['C'],
@@ -385,7 +383,7 @@ def test_cov(self, float_frame, float_string_frame):
def test_corrwith(self, datetime_frame):
a = datetime_frame
- noise = Series(randn(len(a)), index=a.index)
+ noise = Series(np.random.randn(len(a)), index=a.index)
b = datetime_frame.add(noise, axis=0)
@@ -409,8 +407,9 @@ def test_corrwith(self, datetime_frame):
# non time-series data
index = ['a', 'b', 'c', 'd', 'e']
columns = ['one', 'two', 'three', 'four']
- df1 = DataFrame(randn(5, 4), index=index, columns=columns)
- df2 = DataFrame(randn(4, 4), index=index[:4], columns=columns)
+ df1 = DataFrame(np.random.randn(5, 4), index=index, columns=columns)
+ df2 = DataFrame(np.random.randn(4, 4),
+ index=index[:4], columns=columns)
correls = df1.corrwith(df2, axis=1)
for row in index[:4]:
tm.assert_almost_equal(correls[row],
@@ -823,9 +822,9 @@ def test_min(self, float_frame_with_na, int_frame,
assert_stat_op_api('min', float_frame, float_string_frame)
def test_cummin(self, datetime_frame):
- datetime_frame.loc[5:10, 0] = nan
- datetime_frame.loc[10:15, 1] = nan
- datetime_frame.loc[15:, 2] = nan
+ datetime_frame.loc[5:10, 0] = np.nan
+ datetime_frame.loc[10:15, 1] = np.nan
+ datetime_frame.loc[15:, 2] = np.nan
# axis = 0
cummin = datetime_frame.cummin()
@@ -846,9 +845,9 @@ def test_cummin(self, datetime_frame):
assert np.shape(cummin_xs) == np.shape(datetime_frame)
def test_cummax(self, datetime_frame):
- datetime_frame.loc[5:10, 0] = nan
- datetime_frame.loc[10:15, 1] = nan
- datetime_frame.loc[15:, 2] = nan
+ datetime_frame.loc[5:10, 0] = np.nan
+ datetime_frame.loc[10:15, 1] = np.nan
+ datetime_frame.loc[15:, 2] = np.nan
# axis = 0
cummax = datetime_frame.cummax()
@@ -950,9 +949,9 @@ def test_mixed_ops(self, op):
assert len(result) == 2
def test_cumsum(self, datetime_frame):
- datetime_frame.loc[5:10, 0] = nan
- datetime_frame.loc[10:15, 1] = nan
- datetime_frame.loc[15:, 2] = nan
+ datetime_frame.loc[5:10, 0] = np.nan
+ datetime_frame.loc[10:15, 1] = np.nan
+ datetime_frame.loc[15:, 2] = np.nan
# axis = 0
cumsum = datetime_frame.cumsum()
@@ -973,9 +972,9 @@ def test_cumsum(self, datetime_frame):
assert np.shape(cumsum_xs) == np.shape(datetime_frame)
def test_cumprod(self, datetime_frame):
- datetime_frame.loc[5:10, 0] = nan
- datetime_frame.loc[10:15, 1] = nan
- datetime_frame.loc[15:, 2] = nan
+ datetime_frame.loc[5:10, 0] = np.nan
+ datetime_frame.loc[10:15, 1] = np.nan
+ datetime_frame.loc[15:, 2] = np.nan
# axis = 0
cumprod = datetime_frame.cumprod()
@@ -1753,7 +1752,7 @@ def test_round(self):
expected_neg_rounded)
# nan in Series round
- nan_round_Series = Series({'col1': nan, 'col2': 1})
+ nan_round_Series = Series({'col1': np.nan, 'col2': 1})
# TODO(wesm): unused?
expected_nan_round = DataFrame({ # noqa
@@ -2084,8 +2083,10 @@ def test_dot(self):
result = A.dot(b)
# unaligned
- df = DataFrame(randn(3, 4), index=[1, 2, 3], columns=lrange(4))
- df2 = DataFrame(randn(5, 3), index=lrange(5), columns=[1, 2, 3])
+ df = DataFrame(np.random.randn(3, 4),
+ index=[1, 2, 3], columns=lrange(4))
+ df2 = DataFrame(np.random.randn(5, 3),
+ index=lrange(5), columns=[1, 2, 3])
with pytest.raises(ValueError, match='aligned'):
df.dot(df2)
@@ -2144,8 +2145,10 @@ def test_matmul(self):
tm.assert_frame_equal(result, expected)
# unaligned
- df = DataFrame(randn(3, 4), index=[1, 2, 3], columns=lrange(4))
- df2 = DataFrame(randn(5, 3), index=lrange(5), columns=[1, 2, 3])
+ df = DataFrame(np.random.randn(3, 4),
+ index=[1, 2, 3], columns=lrange(4))
+ df2 = DataFrame(np.random.randn(5, 3),
+ index=lrange(5), columns=[1, 2, 3])
with pytest.raises(ValueError, match='aligned'):
operator.matmul(df, df2)
diff --git a/pandas/tests/frame/test_api.py b/pandas/tests/frame/test_api.py
index c1be64829c303..0934dd20638e4 100644
--- a/pandas/tests/frame/test_api.py
+++ b/pandas/tests/frame/test_api.py
@@ -7,7 +7,6 @@
import pydoc
import numpy as np
-from numpy.random import randn
import pytest
from pandas.compat import long, lrange, range
@@ -149,8 +148,8 @@ def test_not_hashable(self, empty_frame):
pytest.raises(TypeError, hash, empty_frame)
def test_new_empty_index(self):
- df1 = self.klass(randn(0, 3))
- df2 = self.klass(randn(0, 3))
+ df1 = self.klass(np.random.randn(0, 3))
+ df2 = self.klass(np.random.randn(0, 3))
df1.index.name = 'foo'
assert df2.index.name is None
diff --git a/pandas/tests/frame/test_axis_select_reindex.py b/pandas/tests/frame/test_axis_select_reindex.py
index 508a68d44bb04..dea925dcde676 100644
--- a/pandas/tests/frame/test_axis_select_reindex.py
+++ b/pandas/tests/frame/test_axis_select_reindex.py
@@ -5,7 +5,6 @@
from datetime import datetime
import numpy as np
-from numpy import random
import pytest
from pandas.compat import lrange, lzip, u
@@ -289,7 +288,7 @@ def test_reindex_nan(self):
assert_frame_equal(left, right)
def test_reindex_name_remains(self):
- s = Series(random.rand(10))
+ s = Series(np.random.rand(10))
df = DataFrame(s, index=np.arange(len(s)))
i = Series(np.arange(10), name='iname')
@@ -299,7 +298,7 @@ def test_reindex_name_remains(self):
df = df.reindex(Index(np.arange(10), name='tmpname'))
assert df.index.name == 'tmpname'
- s = Series(random.rand(10))
+ s = Series(np.random.rand(10))
df = DataFrame(s.T, index=np.arange(len(s)))
i = Series(np.arange(10), name='iname')
df = df.reindex(columns=i)
diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py
index 67f27948343f7..5419f4d5127f6 100644
--- a/pandas/tests/frame/test_block_internals.py
+++ b/pandas/tests/frame/test_block_internals.py
@@ -6,7 +6,6 @@
import itertools
import numpy as np
-from numpy import nan
import pytest
from pandas.compat import StringIO
@@ -216,7 +215,7 @@ def test_construction_with_mixed(self, float_string_frame):
# test construction edge cases with mixed types
# f7u12, this does not work without extensive workaround
- data = [[datetime(2001, 1, 5), nan, datetime(2001, 1, 2)],
+ data = [[datetime(2001, 1, 5), np.nan, datetime(2001, 1, 2)],
[datetime(2000, 1, 2), datetime(2000, 1, 3),
datetime(2000, 1, 1)]]
df = DataFrame(data)
@@ -558,18 +557,18 @@ def test_get_X_columns(self):
def test_strange_column_corruption_issue(self):
# (wesm) Unclear how exactly this is related to internal matters
df = DataFrame(index=[0, 1])
- df[0] = nan
+ df[0] = np.nan
wasCol = {}
# uncommenting these makes the results match
# for col in xrange(100, 200):
# wasCol[col] = 1
- # df[col] = nan
+ # df[col] = np.nan
for i, dt in enumerate(df.index):
for col in range(100, 200):
if col not in wasCol:
wasCol[col] = 1
- df[col] = nan
+ df[col] = np.nan
df[col][dt] = i
myid = 100
diff --git a/pandas/tests/frame/test_combine_concat.py b/pandas/tests/frame/test_combine_concat.py
index b38acbf5dd72f..59497153c8524 100644
--- a/pandas/tests/frame/test_combine_concat.py
+++ b/pandas/tests/frame/test_combine_concat.py
@@ -5,7 +5,6 @@
from datetime import datetime
import numpy as np
-from numpy import nan
import pytest
from pandas.compat import lrange
@@ -247,20 +246,20 @@ def test_append_dtypes(self):
assert_frame_equal(result, expected)
def test_update(self):
- df = DataFrame([[1.5, nan, 3.],
- [1.5, nan, 3.],
- [1.5, nan, 3],
- [1.5, nan, 3]])
+ df = DataFrame([[1.5, np.nan, 3.],
+ [1.5, np.nan, 3.],
+ [1.5, np.nan, 3],
+ [1.5, np.nan, 3]])
other = DataFrame([[3.6, 2., np.nan],
[np.nan, np.nan, 7]], index=[1, 3])
df.update(other)
- expected = DataFrame([[1.5, nan, 3],
+ expected = DataFrame([[1.5, np.nan, 3],
[3.6, 2, 3],
- [1.5, nan, 3],
- [1.5, nan, 7.]])
+ [1.5, np.nan, 3],
+ [1.5, np.nan, 7.]])
assert_frame_equal(df, expected)
def test_update_dtypes(self):
@@ -277,37 +276,37 @@ def test_update_dtypes(self):
assert_frame_equal(df, expected)
def test_update_nooverwrite(self):
- df = DataFrame([[1.5, nan, 3.],
- [1.5, nan, 3.],
- [1.5, nan, 3],
- [1.5, nan, 3]])
+ df = DataFrame([[1.5, np.nan, 3.],
+ [1.5, np.nan, 3.],
+ [1.5, np.nan, 3],
+ [1.5, np.nan, 3]])
other = DataFrame([[3.6, 2., np.nan],
[np.nan, np.nan, 7]], index=[1, 3])
df.update(other, overwrite=False)
- expected = DataFrame([[1.5, nan, 3],
+ expected = DataFrame([[1.5, np.nan, 3],
[1.5, 2, 3],
- [1.5, nan, 3],
- [1.5, nan, 3.]])
+ [1.5, np.nan, 3],
+ [1.5, np.nan, 3.]])
assert_frame_equal(df, expected)
def test_update_filtered(self):
- df = DataFrame([[1.5, nan, 3.],
- [1.5, nan, 3.],
- [1.5, nan, 3],
- [1.5, nan, 3]])
+ df = DataFrame([[1.5, np.nan, 3.],
+ [1.5, np.nan, 3.],
+ [1.5, np.nan, 3],
+ [1.5, np.nan, 3]])
other = DataFrame([[3.6, 2., np.nan],
[np.nan, np.nan, 7]], index=[1, 3])
df.update(other, filter_func=lambda x: x > 2)
- expected = DataFrame([[1.5, nan, 3],
- [1.5, nan, 3],
- [1.5, nan, 3],
- [1.5, nan, 7.]])
+ expected = DataFrame([[1.5, np.nan, 3],
+ [1.5, np.nan, 3],
+ [1.5, np.nan, 3],
+ [1.5, np.nan, 7.]])
assert_frame_equal(df, expected)
@pytest.mark.parametrize('bad_kwarg, exception, msg', [
@@ -322,12 +321,12 @@ def test_update_raise_bad_parameter(self, bad_kwarg, exception, msg):
def test_update_raise_on_overlap(self):
df = DataFrame([[1.5, 1, 3.],
- [1.5, nan, 3.],
- [1.5, nan, 3],
- [1.5, nan, 3]])
+ [1.5, np.nan, 3.],
+ [1.5, np.nan, 3],
+ [1.5, np.nan, 3]])
- other = DataFrame([[2., nan],
- [nan, 7]], index=[1, 3], columns=[1, 2])
+ other = DataFrame([[2., np.nan],
+ [np.nan, 7]], index=[1, 3], columns=[1, 2])
with pytest.raises(ValueError, match="Data overlaps"):
df.update(other, errors='raise')
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 4e0143c368e10..4f6a2e2bfbebf 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -8,8 +8,6 @@
import numpy as np
import numpy.ma as ma
-import numpy.ma.mrecords as mrecords
-from numpy.random import randn
import pytest
from pandas.compat import (
@@ -489,7 +487,7 @@ def test_constructor_dict_cast(self):
# can't cast to float
test_data = {
'A': dict(zip(range(20), tm.makeStringIndex(20))),
- 'B': dict(zip(range(15), randn(15)))
+ 'B': dict(zip(range(15), np.random.randn(15)))
}
frame = DataFrame(test_data, dtype=float)
assert len(frame) == 20
@@ -605,7 +603,7 @@ def test_constructor_period(self):
def test_nested_dict_frame_constructor(self):
rng = pd.period_range('1/1/2000', periods=5)
- df = DataFrame(randn(10, 5), columns=rng)
+ df = DataFrame(np.random.randn(10, 5), columns=rng)
data = {}
for col in df.columns:
@@ -812,7 +810,7 @@ def test_constructor_mrecarray(self):
# call assert_frame_equal for all selections of 3 arrays
for comb in itertools.combinations(arrays, 3):
names, data = zip(*comb)
- mrecs = mrecords.fromarrays(data, names=names)
+ mrecs = ma.mrecords.fromarrays(data, names=names)
# fill the comb
comb = {k: (v.filled() if hasattr(v, 'filled') else v)
@@ -859,7 +857,7 @@ def test_constructor_scalar_inference(self):
assert df['object'].dtype == np.object_
def test_constructor_arrays_and_scalars(self):
- df = DataFrame({'a': randn(10), 'b': True})
+ df = DataFrame({'a': np.random.randn(10), 'b': True})
exp = DataFrame({'a': df['a'].values, 'b': [True] * 10})
tm.assert_frame_equal(df, exp)
@@ -875,11 +873,11 @@ def test_constructor_DataFrame(self):
def test_constructor_more(self):
# used to be in test_matrix.py
- arr = randn(10)
+ arr = np.random.randn(10)
dm = DataFrame(arr, columns=['A'], index=np.arange(10))
assert dm.values.ndim == 2
- arr = randn(0)
+ arr = np.random.randn(0)
dm = DataFrame(arr)
assert dm.values.ndim == 2
assert dm.values.ndim == 2
@@ -1140,8 +1138,8 @@ class CustomDict(dict):
tm.assert_frame_equal(result, result_custom)
def test_constructor_ragged(self):
- data = {'A': randn(10),
- 'B': randn(8)}
+ data = {'A': np.random.randn(10),
+ 'B': np.random.randn(8)}
with pytest.raises(ValueError, match='arrays must all be same length'):
DataFrame(data)
diff --git a/pandas/tests/frame/test_indexing.py b/pandas/tests/frame/test_indexing.py
index f113140261aea..19b8ae4eb6e0f 100644
--- a/pandas/tests/frame/test_indexing.py
+++ b/pandas/tests/frame/test_indexing.py
@@ -6,8 +6,6 @@
from warnings import catch_warnings, simplefilter
import numpy as np
-from numpy import nan
-from numpy.random import randn
import pytest
from pandas._libs.tslib import iNaT
@@ -50,9 +48,9 @@ def test_getitem(self):
self.frame['random']
df = self.frame.copy()
- df['$10'] = randn(len(df))
+ df['$10'] = np.random.randn(len(df))
- ad = randn(len(df))
+ ad = np.random.randn(len(df))
df['@awesome_domain'] = ad
with pytest.raises(KeyError):
@@ -103,7 +101,7 @@ def test_getitem_listlike(self, idx_type, levels):
frame, missing = self.frame, 'food'
else:
# MultiIndex columns
- frame = DataFrame(randn(8, 3),
+ frame = DataFrame(np.random.randn(8, 3),
columns=Index([('foo', 'bar'), ('baz', 'qux'),
('peek', 'aboo')],
name=('sth', 'sth2')))
@@ -338,7 +336,7 @@ def _checkit(lst):
_checkit([False, False, False])
def test_getitem_boolean_iadd(self):
- arr = randn(5, 5)
+ arr = np.random.randn(5, 5)
df = DataFrame(arr.copy(), columns=['A', 'B', 'C', 'D', 'E'])
@@ -419,7 +417,8 @@ def test_getitem_setitem_ix_negative_integers(self):
df.ix[:, [-1]]
# #1942
- a = DataFrame(randn(20, 2), index=[chr(x + 65) for x in range(20)])
+ a = DataFrame(np.random.randn(20, 2),
+ index=[chr(x + 65) for x in range(20)])
with catch_warnings(record=True):
simplefilter("ignore", DeprecationWarning)
a.ix[-1] = a.ix[-2]
@@ -459,10 +458,10 @@ def test_setitem(self):
tm.assert_series_equal(series, self.frame['col6'], check_names=False)
with pytest.raises(KeyError):
- self.frame[randn(len(self.frame) + 1)] = 1
+ self.frame[np.random.randn(len(self.frame) + 1)] = 1
# set ndarray
- arr = randn(len(self.frame))
+ arr = np.random.randn(len(self.frame))
self.frame['col9'] = arr
assert (self.frame['col9'] == arr).all()
@@ -497,7 +496,7 @@ def test_setitem(self):
@pytest.mark.parametrize("dtype", ["int32", "int64", "float32", "float64"])
def test_setitem_dtype(self, dtype):
- arr = randn(len(self.frame))
+ arr = np.random.randn(len(self.frame))
self.frame[dtype] = np.array(arr, dtype=dtype)
assert self.frame[dtype].dtype.name == dtype
@@ -511,7 +510,7 @@ def test_setitem_always_copy(self):
s = self.frame['A'].copy()
self.frame['E'] = s
- self.frame['E'][5:10] = nan
+ self.frame['E'][5:10] = np.nan
assert notna(s[5:10]).all()
def test_setitem_boolean(self):
@@ -554,8 +553,8 @@ def test_setitem_boolean(self):
# index with DataFrame
mask = df > np.abs(df)
expected = df.copy()
- df[df > np.abs(df)] = nan
- expected.values[mask.values] = nan
+ df[df > np.abs(df)] = np.nan
+ expected.values[mask.values] = np.nan
assert_frame_equal(df, expected)
# set from DataFrame
@@ -911,7 +910,7 @@ def test_setitem_fancy_2d(self):
expected = frame.copy()
subidx = self.frame.index[[5, 4, 1]]
- values = randn(3, 2)
+ values = np.random.randn(3, 2)
with catch_warnings(record=True):
simplefilter("ignore", DeprecationWarning)
@@ -937,7 +936,7 @@ def test_setitem_fancy_2d(self):
with catch_warnings(record=True):
simplefilter("ignore", DeprecationWarning)
expected2 = self.frame.copy()
- arr = randn(5, len(frame.columns))
+ arr = np.random.randn(5, len(frame.columns))
frame.ix[5:10] = arr
expected2.values[5:10] = arr
assert_frame_equal(frame, expected2)
@@ -958,7 +957,7 @@ def test_setitem_fancy_2d(self):
frame2 = self.frame.copy()
expected = self.frame.copy()
- values = randn(5, 2)
+ values = np.random.randn(5, 2)
frame.ix[:5, ['A', 'B']] = values
expected['A'][:5] = values[:, 0]
@@ -1128,8 +1127,8 @@ def test_setitem_fancy_mixed_2d(self):
assert_frame_equal(df, expected)
def test_ix_align(self):
- b = Series(randn(10), name=0).sort_values()
- df_orig = DataFrame(randn(10, 4))
+ b = Series(np.random.randn(10), name=0).sort_values()
+ df_orig = DataFrame(np.random.randn(10, 4))
df = df_orig.copy()
with catch_warnings(record=True):
@@ -1174,7 +1173,7 @@ def test_ix_align(self):
def test_ix_frame_align(self):
b = DataFrame(np.random.randn(3, 4))
- df_orig = DataFrame(randn(10, 4))
+ df_orig = DataFrame(np.random.randn(10, 4))
df = df_orig.copy()
with catch_warnings(record=True):
@@ -1355,7 +1354,7 @@ def test_setitem_fancy_1d(self):
with catch_warnings(record=True):
simplefilter("ignore", DeprecationWarning)
- vals = randn(5)
+ vals = np.random.randn(5)
expected.values[5:10, 2] = vals
frame.ix[5:10, 2] = vals
assert_frame_equal(frame, expected)
@@ -1412,7 +1411,7 @@ def test_setitem_fancy_scalar(self):
ts = f[col] # noqa
for idx in f.index[::5]:
i = f.index.get_loc(idx)
- val = randn()
+ val = np.random.randn()
expected.values[i, j] = val
ix[idx, col] = val
@@ -1588,15 +1587,16 @@ def test_getitem_setitem_float_labels(self):
assert (result == 0).values.all()
def test_setitem_single_column_mixed(self):
- df = DataFrame(randn(5, 3), index=['a', 'b', 'c', 'd', 'e'],
+ df = DataFrame(np.random.randn(5, 3), index=['a', 'b', 'c', 'd', 'e'],
columns=['foo', 'bar', 'baz'])
df['str'] = 'qux'
- df.loc[df.index[::2], 'str'] = nan
- expected = np.array([nan, 'qux', nan, 'qux', nan], dtype=object)
+ df.loc[df.index[::2], 'str'] = np.nan
+ expected = np.array([np.nan, 'qux', np.nan, 'qux', np.nan],
+ dtype=object)
assert_almost_equal(df['str'].values, expected)
def test_setitem_single_column_mixed_datetime(self):
- df = DataFrame(randn(5, 3), index=['a', 'b', 'c', 'd', 'e'],
+ df = DataFrame(np.random.randn(5, 3), index=['a', 'b', 'c', 'd', 'e'],
columns=['foo', 'bar', 'baz'])
df['timestamp'] = Timestamp('20010102')
@@ -1611,17 +1611,17 @@ def test_setitem_single_column_mixed_datetime(self):
assert isna(df.loc['b', 'timestamp'])
# allow this syntax
- df.loc['c', 'timestamp'] = nan
+ df.loc['c', 'timestamp'] = np.nan
assert isna(df.loc['c', 'timestamp'])
# allow this syntax
- df.loc['d', :] = nan
+ df.loc['d', :] = np.nan
assert not isna(df.loc['c', :]).all()
# as of GH 3216 this will now work!
# try to set with a list like item
# pytest.raises(
- # Exception, df.loc.__setitem__, ('d', 'timestamp'), [nan])
+ # Exception, df.loc.__setitem__, ('d', 'timestamp'), [np.nan])
def test_setitem_mixed_datetime(self):
# GH 9336
@@ -1852,7 +1852,8 @@ def test_set_value_resize(self):
pytest.raises(ValueError, res3.set_value, 'foobar', 'baz', 'sam')
def test_set_value_with_index_dtype_change(self):
- df_orig = DataFrame(randn(3, 3), index=lrange(3), columns=list('ABC'))
+ df_orig = DataFrame(np.random.randn(3, 3),
+ index=lrange(3), columns=list('ABC'))
# this is actually ambiguous as the 2 is interpreted as a positional
# so column is not created
@@ -2365,7 +2366,7 @@ def test_setitem_datetimeindex_tz(self, idxer, tz_naive_fixture):
def test_at_time_between_time_datetimeindex(self):
index = date_range("2012-01-01", "2012-01-05", freq='30min')
- df = DataFrame(randn(len(index), 5), index=index)
+ df = DataFrame(np.random.randn(len(index), 5), index=index)
akey = time(12, 0, 0)
bkey = slice(time(13, 0, 0), time(14, 0, 0))
ainds = [24, 72, 120, 168]
@@ -2463,7 +2464,7 @@ def test_xs_corner(self):
assert_series_equal(result, expected)
def test_xs_duplicates(self):
- df = DataFrame(randn(5, 2), index=['b', 'b', 'c', 'b', 'a'])
+ df = DataFrame(np.random.randn(5, 2), index=['b', 'b', 'c', 'b', 'a'])
cross = df.xs('c')
exp = df.iloc[2]
@@ -3119,7 +3120,7 @@ def test_mask_edge_case_1xN_frame(self):
# GH4071
df = DataFrame([[1, 2]])
res = df.mask(DataFrame([[True, False]]))
- expec = DataFrame([[nan, 2]])
+ expec = DataFrame([[np.nan, 2]])
assert_frame_equal(res, expec)
def test_mask_callable(self):
diff --git a/pandas/tests/frame/test_missing.py b/pandas/tests/frame/test_missing.py
index ac4b380034366..77a3d4785d295 100644
--- a/pandas/tests/frame/test_missing.py
+++ b/pandas/tests/frame/test_missing.py
@@ -7,7 +7,6 @@
import dateutil
import numpy as np
-from numpy import nan, random
import pytest
from pandas.compat import lrange
@@ -39,8 +38,8 @@ class TestDataFrameMissingData(TestData):
def test_dropEmptyRows(self):
N = len(self.frame.index)
- mat = random.randn(N)
- mat[:5] = nan
+ mat = np.random.randn(N)
+ mat[:5] = np.nan
frame = DataFrame({'foo': mat}, index=self.frame.index)
original = Series(mat, index=self.frame.index, name='foo')
@@ -61,8 +60,8 @@ def test_dropEmptyRows(self):
def test_dropIncompleteRows(self):
N = len(self.frame.index)
- mat = random.randn(N)
- mat[:5] = nan
+ mat = np.random.randn(N)
+ mat[:5] = np.nan
frame = DataFrame({'foo': mat}, index=self.frame.index)
frame['bar'] = 5
@@ -86,7 +85,7 @@ def test_dropIncompleteRows(self):
def test_dropna(self):
df = DataFrame(np.random.randn(6, 4))
- df[2][:2] = nan
+ df[2][:2] = np.nan
dropped = df.dropna(axis=1)
expected = df.loc[:, [0, 1, 3]]
@@ -134,7 +133,7 @@ def test_dropna(self):
dropped = df.dropna(axis=1, how='all')
assert_frame_equal(dropped, df)
- df[2] = nan
+ df[2] = np.nan
dropped = df.dropna(axis=1, how='all')
expected = df.loc[:, [0, 1, 3]]
assert_frame_equal(dropped, expected)
@@ -209,8 +208,8 @@ def test_dropna_tz_aware_datetime(self):
def test_fillna(self):
tf = self.tsframe
- tf.loc[tf.index[:5], 'A'] = nan
- tf.loc[tf.index[-5:], 'A'] = nan
+ tf.loc[tf.index[:5], 'A'] = np.nan
+ tf.loc[tf.index[-5:], 'A'] = np.nan
zero_filled = self.tsframe.fillna(0)
assert (zero_filled.loc[zero_filled.index[:5], 'A'] == 0).all()
@@ -222,8 +221,8 @@ def test_fillna(self):
# mixed type
mf = self.mixed_frame
- mf.loc[mf.index[5:20], 'foo'] = nan
- mf.loc[mf.index[-10:], 'A'] = nan
+ mf.loc[mf.index[5:20], 'foo'] = np.nan
+ mf.loc[mf.index[-10:], 'A'] = np.nan
result = self.mixed_frame.fillna(value=0)
result = self.mixed_frame.fillna(method='pad')
@@ -232,7 +231,7 @@ def test_fillna(self):
# mixed numeric (but no float16)
mf = self.mixed_float.reindex(columns=['A', 'B', 'D'])
- mf.loc[mf.index[-10:], 'A'] = nan
+ mf.loc[mf.index[-10:], 'A'] = np.nan
result = mf.fillna(value=0)
_check_mixed_float(result, dtype=dict(C=None))
@@ -453,15 +452,15 @@ def test_fillna_datetime_columns(self):
tm.assert_frame_equal(result, expected)
def test_ffill(self):
- self.tsframe['A'][:5] = nan
- self.tsframe['A'][-5:] = nan
+ self.tsframe['A'][:5] = np.nan
+ self.tsframe['A'][-5:] = np.nan
assert_frame_equal(self.tsframe.ffill(),
self.tsframe.fillna(method='ffill'))
def test_bfill(self):
- self.tsframe['A'][:5] = nan
- self.tsframe['A'][-5:] = nan
+ self.tsframe['A'][:5] = np.nan
+ self.tsframe['A'][-5:] = np.nan
assert_frame_equal(self.tsframe.bfill(),
self.tsframe.fillna(method='bfill'))
@@ -531,9 +530,9 @@ def test_fillna_inplace(self):
tm.assert_frame_equal(df, expected)
def test_fillna_dict_series(self):
- df = DataFrame({'a': [nan, 1, 2, nan, nan],
- 'b': [1, 2, 3, nan, nan],
- 'c': [nan, 1, 2, 3, 4]})
+ df = DataFrame({'a': [np.nan, 1, 2, np.nan, np.nan],
+ 'b': [1, 2, 3, np.nan, np.nan],
+ 'c': [np.nan, 1, 2, 3, 4]})
result = df.fillna({'a': 0, 'b': 5})
@@ -556,13 +555,13 @@ def test_fillna_dict_series(self):
def test_fillna_dataframe(self):
# GH 8377
- df = DataFrame({'a': [nan, 1, 2, nan, nan],
- 'b': [1, 2, 3, nan, nan],
- 'c': [nan, 1, 2, 3, 4]},
+ df = DataFrame({'a': [np.nan, 1, 2, np.nan, np.nan],
+ 'b': [1, 2, 3, np.nan, np.nan],
+ 'c': [np.nan, 1, 2, 3, 4]},
index=list('VWXYZ'))
# df2 may have different index and columns
- df2 = DataFrame({'a': [nan, 10, 20, 30, 40],
+ df2 = DataFrame({'a': [np.nan, 10, 20, 30, 40],
'b': [50, 60, 70, 80, 90],
'foo': ['bar'] * 5},
index=list('VWXuZ'))
@@ -570,9 +569,9 @@ def test_fillna_dataframe(self):
result = df.fillna(df2)
# only those columns and indices which are shared get filled
- expected = DataFrame({'a': [nan, 1, 2, nan, 40],
- 'b': [1, 2, 3, nan, 90],
- 'c': [nan, 1, 2, 3, 4]},
+ expected = DataFrame({'a': [np.nan, 1, 2, np.nan, 40],
+ 'b': [1, 2, 3, np.nan, 90],
+ 'c': [np.nan, 1, 2, 3, 4]},
index=list('VWXYZ'))
assert_frame_equal(result, expected)
@@ -611,8 +610,8 @@ def test_fillna_col_reordering(self):
def test_fill_corner(self):
mf = self.mixed_frame
- mf.loc[mf.index[5:20], 'foo'] = nan
- mf.loc[mf.index[-10:], 'A'] = nan
+ mf.loc[mf.index[5:20], 'foo'] = np.nan
+ mf.loc[mf.index[-10:], 'A'] = np.nan
filled = self.mixed_frame.fillna(value=0)
assert (filled.loc[filled.index[5:20], 'foo'] == 0).all()
diff --git a/pandas/tests/frame/test_period.py b/pandas/tests/frame/test_period.py
index d9392b68c8ce1..8b37d4ff2cf9e 100644
--- a/pandas/tests/frame/test_period.py
+++ b/pandas/tests/frame/test_period.py
@@ -1,7 +1,6 @@
from datetime import timedelta
import numpy as np
-from numpy.random import randn
import pytest
import pandas as pd
@@ -19,7 +18,7 @@ class TestPeriodIndex(object):
def test_as_frame_columns(self):
rng = period_range('1/1/2000', periods=5)
- df = DataFrame(randn(10, 5), columns=rng)
+ df = DataFrame(np.random.randn(10, 5), columns=rng)
ts = df[rng[0]]
tm.assert_series_equal(ts, df.iloc[:, 0])
@@ -32,7 +31,7 @@ def test_as_frame_columns(self):
def test_frame_setitem(self):
rng = period_range('1/1/2000', periods=5, name='index')
- df = DataFrame(randn(5, 3), index=rng)
+ df = DataFrame(np.random.randn(5, 3), index=rng)
df['Index'] = rng
rs = Index(df['Index'])
@@ -47,7 +46,7 @@ def test_frame_setitem(self):
def test_frame_to_time_stamp(self):
K = 5
index = period_range(freq='A', start='1/1/2001', end='12/1/2009')
- df = DataFrame(randn(len(index), K), index=index)
+ df = DataFrame(np.random.randn(len(index), K), index=index)
df['mix'] = 'a'
exp_index = date_range('1/1/2001', end='12/31/2009', freq='A-DEC')
diff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py
index 1e06d5cad1374..9c4d306ea5720 100644
--- a/pandas/tests/frame/test_query_eval.py
+++ b/pandas/tests/frame/test_query_eval.py
@@ -5,7 +5,6 @@
import operator
import numpy as np
-from numpy.random import randn
import pytest
from pandas.compat import StringIO, lrange, range, zip
@@ -153,7 +152,7 @@ def test_query_empty_string(self):
def test_eval_resolvers_as_list(self):
# GH 14095
- df = DataFrame(randn(10, 2), columns=list('ab'))
+ df = DataFrame(np.random.randn(10, 2), columns=list('ab'))
dict1 = {'a': 1}
dict2 = {'b': 2}
assert (df.eval('a + b', resolvers=[dict1, dict2]) ==
@@ -169,7 +168,7 @@ def test_query_with_named_multiindex(self, parser, engine):
a = np.random.choice(['red', 'green'], size=10)
b = np.random.choice(['eggs', 'ham'], size=10)
index = MultiIndex.from_arrays([a, b], names=['color', 'food'])
- df = DataFrame(randn(10, 2), index=index)
+ df = DataFrame(np.random.randn(10, 2), index=index)
ind = Series(df.index.get_level_values('color').values, index=index,
name='color')
@@ -218,7 +217,7 @@ def test_query_with_unnamed_multiindex(self, parser, engine):
a = np.random.choice(['red', 'green'], size=10)
b = np.random.choice(['eggs', 'ham'], size=10)
index = MultiIndex.from_arrays([a, b])
- df = DataFrame(randn(10, 2), index=index)
+ df = DataFrame(np.random.randn(10, 2), index=index)
ind = Series(df.index.get_level_values(0).values, index=index)
res1 = df.query('ilevel_0 == "red"', parser=parser, engine=engine)
@@ -309,7 +308,7 @@ def test_query_with_partially_named_multiindex(self, parser, engine):
b = np.arange(10)
index = MultiIndex.from_arrays([a, b])
index.names = [None, 'rating']
- df = DataFrame(randn(10, 2), index=index)
+ df = DataFrame(np.random.randn(10, 2), index=index)
res = df.query('rating == 1', parser=parser, engine=engine)
ind = Series(df.index.get_level_values('rating').values, index=index,
name='rating')
@@ -379,7 +378,7 @@ def teardown_class(cls):
def test_date_query_with_attribute_access(self):
engine, parser = self.engine, self.parser
skip_if_no_pandas_parser(parser)
- df = DataFrame(randn(5, 3))
+ df = DataFrame(np.random.randn(5, 3))
df['dates1'] = date_range('1/1/2012', periods=5)
df['dates2'] = date_range('1/1/2013', periods=5)
df['dates3'] = date_range('1/1/2014', periods=5)
@@ -390,7 +389,7 @@ def test_date_query_with_attribute_access(self):
def test_date_query_no_attribute_access(self):
engine, parser = self.engine, self.parser
- df = DataFrame(randn(5, 3))
+ df = DataFrame(np.random.randn(5, 3))
df['dates1'] = date_range('1/1/2012', periods=5)
df['dates2'] = date_range('1/1/2013', periods=5)
df['dates3'] = date_range('1/1/2014', periods=5)
@@ -402,7 +401,7 @@ def test_date_query_no_attribute_access(self):
def test_date_query_with_NaT(self):
engine, parser = self.engine, self.parser
n = 10
- df = DataFrame(randn(n, 3))
+ df = DataFrame(np.random.randn(n, 3))
df['dates1'] = date_range('1/1/2012', periods=n)
df['dates2'] = date_range('1/1/2013', periods=n)
df['dates3'] = date_range('1/1/2014', periods=n)
@@ -416,7 +415,7 @@ def test_date_query_with_NaT(self):
def test_date_index_query(self):
engine, parser = self.engine, self.parser
n = 10
- df = DataFrame(randn(n, 3))
+ df = DataFrame(np.random.randn(n, 3))
df['dates1'] = date_range('1/1/2012', periods=n)
df['dates3'] = date_range('1/1/2014', periods=n)
df.set_index('dates1', inplace=True, drop=True)
@@ -428,7 +427,7 @@ def test_date_index_query(self):
def test_date_index_query_with_NaT(self):
engine, parser = self.engine, self.parser
n = 10
- df = DataFrame(randn(n, 3))
+ df = DataFrame(np.random.randn(n, 3))
df['dates1'] = date_range('1/1/2012', periods=n)
df['dates3'] = date_range('1/1/2014', periods=n)
df.iloc[0, 0] = pd.NaT
@@ -603,7 +602,7 @@ def test_local_syntax(self):
skip_if_no_pandas_parser(self.parser)
engine, parser = self.engine, self.parser
- df = DataFrame(randn(100, 10), columns=list('abcdefghij'))
+ df = DataFrame(np.random.randn(100, 10), columns=list('abcdefghij'))
b = 1
expect = df[df.a < b]
result = df.query('a < @b', engine=engine, parser=parser)
@@ -617,7 +616,7 @@ def test_chained_cmp_and_in(self):
skip_if_no_pandas_parser(self.parser)
engine, parser = self.engine, self.parser
cols = list('abc')
- df = DataFrame(randn(100, len(cols)), columns=cols)
+ df = DataFrame(np.random.randn(100, len(cols)), columns=cols)
res = df.query('a < b < c and a not in b not in c', engine=engine,
parser=parser)
ind = (df.a < df.b) & (df.b < df.c) & ~df.b.isin(df.a) & ~df.c.isin(df.b) # noqa
@@ -712,7 +711,7 @@ def setup_class(cls):
def test_date_query_no_attribute_access(self):
engine, parser = self.engine, self.parser
- df = DataFrame(randn(5, 3))
+ df = DataFrame(np.random.randn(5, 3))
df['dates1'] = date_range('1/1/2012', periods=5)
df['dates2'] = date_range('1/1/2013', periods=5)
df['dates3'] = date_range('1/1/2014', periods=5)
@@ -724,7 +723,7 @@ def test_date_query_no_attribute_access(self):
def test_date_query_with_NaT(self):
engine, parser = self.engine, self.parser
n = 10
- df = DataFrame(randn(n, 3))
+ df = DataFrame(np.random.randn(n, 3))
df['dates1'] = date_range('1/1/2012', periods=n)
df['dates2'] = date_range('1/1/2013', periods=n)
df['dates3'] = date_range('1/1/2014', periods=n)
@@ -738,7 +737,7 @@ def test_date_query_with_NaT(self):
def test_date_index_query(self):
engine, parser = self.engine, self.parser
n = 10
- df = DataFrame(randn(n, 3))
+ df = DataFrame(np.random.randn(n, 3))
df['dates1'] = date_range('1/1/2012', periods=n)
df['dates3'] = date_range('1/1/2014', periods=n)
df.set_index('dates1', inplace=True, drop=True)
@@ -750,7 +749,7 @@ def test_date_index_query(self):
def test_date_index_query_with_NaT(self):
engine, parser = self.engine, self.parser
n = 10
- df = DataFrame(randn(n, 3))
+ df = DataFrame(np.random.randn(n, 3))
df['dates1'] = date_range('1/1/2012', periods=n)
df['dates3'] = date_range('1/1/2014', periods=n)
df.iloc[0, 0] = pd.NaT
@@ -763,7 +762,7 @@ def test_date_index_query_with_NaT(self):
def test_date_index_query_with_NaT_duplicates(self):
engine, parser = self.engine, self.parser
n = 10
- df = DataFrame(randn(n, 3))
+ df = DataFrame(np.random.randn(n, 3))
df['dates1'] = date_range('1/1/2012', periods=n)
df['dates3'] = date_range('1/1/2014', periods=n)
df.loc[np.random.rand(n) > 0.5, 'dates1'] = pd.NaT
@@ -845,7 +844,7 @@ def test_query_builtin(self):
class TestDataFrameQueryStrings(object):
def test_str_query_method(self, parser, engine):
- df = DataFrame(randn(10, 1), columns=['b'])
+ df = DataFrame(np.random.randn(10, 1), columns=['b'])
df['strings'] = Series(list('aabbccddee'))
expect = df[df.strings == 'a']
@@ -881,7 +880,7 @@ def test_str_query_method(self, parser, engine):
assert_frame_equal(res, df[~df.strings.isin(['a'])])
def test_str_list_query_method(self, parser, engine):
- df = DataFrame(randn(10, 1), columns=['b'])
+ df = DataFrame(np.random.randn(10, 1), columns=['b'])
df['strings'] = Series(list('aabbccddee'))
expect = df[df.strings.isin(['a', 'b'])]
@@ -1017,7 +1016,7 @@ def test_query_string_scalar_variable(self, parser, engine):
class TestDataFrameEvalWithFrame(object):
def setup_method(self, method):
- self.frame = DataFrame(randn(10, 3), columns=list('abc'))
+ self.frame = DataFrame(np.random.randn(10, 3), columns=list('abc'))
def teardown_method(self, method):
del self.frame
diff --git a/pandas/tests/frame/test_rank.py b/pandas/tests/frame/test_rank.py
index 0a9801ea8ed61..10c42e0d1a1cf 100644
--- a/pandas/tests/frame/test_rank.py
+++ b/pandas/tests/frame/test_rank.py
@@ -3,7 +3,6 @@
from distutils.version import LooseVersion
import numpy as np
-from numpy import nan
import pytest
from pandas import DataFrame, Series
@@ -13,16 +12,16 @@
class TestRank(TestData):
- s = Series([1, 3, 4, 2, nan, 2, 1, 5, nan, 3])
+ s = Series([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3])
df = DataFrame({'A': s, 'B': s})
results = {
- 'average': np.array([1.5, 5.5, 7.0, 3.5, nan,
- 3.5, 1.5, 8.0, nan, 5.5]),
- 'min': np.array([1, 5, 7, 3, nan, 3, 1, 8, nan, 5]),
- 'max': np.array([2, 6, 7, 4, nan, 4, 2, 8, nan, 6]),
- 'first': np.array([1, 5, 7, 3, nan, 4, 2, 8, nan, 6]),
- 'dense': np.array([1, 3, 4, 2, nan, 2, 1, 5, nan, 3]),
+ 'average': np.array([1.5, 5.5, 7.0, 3.5, np.nan,
+ 3.5, 1.5, 8.0, np.nan, 5.5]),
+ 'min': np.array([1, 5, 7, 3, np.nan, 3, 1, 8, np.nan, 5]),
+ 'max': np.array([2, 6, 7, 4, np.nan, 4, 2, 8, np.nan, 6]),
+ 'first': np.array([1, 5, 7, 3, np.nan, 4, 2, 8, np.nan, 6]),
+ 'dense': np.array([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3]),
}
@pytest.fixture(params=['average', 'min', 'max', 'first', 'dense'])
@@ -87,27 +86,27 @@ def test_rank2(self):
tm.assert_frame_equal(result, expected)
df = DataFrame([['b', np.nan, 'a'], ['a', 'c', 'b']])
- expected = DataFrame([[2.0, nan, 1.0], [1.0, 3.0, 2.0]])
+ expected = DataFrame([[2.0, np.nan, 1.0], [1.0, 3.0, 2.0]])
result = df.rank(1, numeric_only=False)
tm.assert_frame_equal(result, expected)
- expected = DataFrame([[2.0, nan, 1.0], [1.0, 1.0, 2.0]])
+ expected = DataFrame([[2.0, np.nan, 1.0], [1.0, 1.0, 2.0]])
result = df.rank(0, numeric_only=False)
tm.assert_frame_equal(result, expected)
# f7u12, this does not work without extensive workaround
- data = [[datetime(2001, 1, 5), nan, datetime(2001, 1, 2)],
+ data = [[datetime(2001, 1, 5), np.nan, datetime(2001, 1, 2)],
[datetime(2000, 1, 2), datetime(2000, 1, 3),
datetime(2000, 1, 1)]]
df = DataFrame(data)
# check the rank
- expected = DataFrame([[2., nan, 1.],
+ expected = DataFrame([[2., np.nan, 1.],
[2., 3., 1.]])
result = df.rank(1, numeric_only=False, ascending=True)
tm.assert_frame_equal(result, expected)
- expected = DataFrame([[1., nan, 2.],
+ expected = DataFrame([[1., np.nan, 2.],
[2., 1., 3.]])
result = df.rank(1, numeric_only=False, ascending=False)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_replace.py b/pandas/tests/frame/test_replace.py
index 87fd5f2e74a9a..219f7a1585fc2 100644
--- a/pandas/tests/frame/test_replace.py
+++ b/pandas/tests/frame/test_replace.py
@@ -6,7 +6,6 @@
import re
import numpy as np
-from numpy import nan
import pytest
from pandas.compat import StringIO, lrange, range, zip
@@ -20,24 +19,24 @@
class TestDataFrameReplace(TestData):
def test_replace_inplace(self):
- self.tsframe['A'][:5] = nan
- self.tsframe['A'][-5:] = nan
+ self.tsframe['A'][:5] = np.nan
+ self.tsframe['A'][-5:] = np.nan
tsframe = self.tsframe.copy()
- tsframe.replace(nan, 0, inplace=True)
+ tsframe.replace(np.nan, 0, inplace=True)
assert_frame_equal(tsframe, self.tsframe.fillna(0))
# mixed type
mf = self.mixed_frame
- mf.iloc[5:20, mf.columns.get_loc('foo')] = nan
- mf.iloc[-10:, mf.columns.get_loc('A')] = nan
+ mf.iloc[5:20, mf.columns.get_loc('foo')] = np.nan
+ mf.iloc[-10:, mf.columns.get_loc('A')] = np.nan
result = self.mixed_frame.replace(np.nan, 0)
expected = self.mixed_frame.fillna(value=0)
assert_frame_equal(result, expected)
tsframe = self.tsframe.copy()
- tsframe.replace([nan], [0], inplace=True)
+ tsframe.replace([np.nan], [0], inplace=True)
assert_frame_equal(tsframe, self.tsframe.fillna(0))
def test_regex_replace_scalar(self):
@@ -49,11 +48,11 @@ def test_regex_replace_scalar(self):
# simplest cases
# regex -> value
# obj frame
- res = dfobj.replace(r'\s*\.\s*', nan, regex=True)
+ res = dfobj.replace(r'\s*\.\s*', np.nan, regex=True)
assert_frame_equal(dfobj, res.fillna('.'))
# mixed
- res = dfmix.replace(r'\s*\.\s*', nan, regex=True)
+ res = dfmix.replace(r'\s*\.\s*', np.nan, regex=True)
assert_frame_equal(dfmix, res.fillna('.'))
# regex -> regex
@@ -72,11 +71,11 @@ def test_regex_replace_scalar(self):
assert_frame_equal(res, expec)
# everything with compiled regexs as well
- res = dfobj.replace(re.compile(r'\s*\.\s*'), nan, regex=True)
+ res = dfobj.replace(re.compile(r'\s*\.\s*'), np.nan, regex=True)
assert_frame_equal(dfobj, res.fillna('.'))
# mixed
- res = dfmix.replace(re.compile(r'\s*\.\s*'), nan, regex=True)
+ res = dfmix.replace(re.compile(r'\s*\.\s*'), np.nan, regex=True)
assert_frame_equal(dfmix, res.fillna('.'))
# regex -> regex
@@ -116,12 +115,12 @@ def test_regex_replace_scalar_inplace(self):
# regex -> value
# obj frame
res = dfobj.copy()
- res.replace(r'\s*\.\s*', nan, regex=True, inplace=True)
+ res.replace(r'\s*\.\s*', np.nan, regex=True, inplace=True)
assert_frame_equal(dfobj, res.fillna('.'))
# mixed
res = dfmix.copy()
- res.replace(r'\s*\.\s*', nan, regex=True, inplace=True)
+ res.replace(r'\s*\.\s*', np.nan, regex=True, inplace=True)
assert_frame_equal(dfmix, res.fillna('.'))
# regex -> regex
@@ -143,12 +142,12 @@ def test_regex_replace_scalar_inplace(self):
# everything with compiled regexs as well
res = dfobj.copy()
- res.replace(re.compile(r'\s*\.\s*'), nan, regex=True, inplace=True)
+ res.replace(re.compile(r'\s*\.\s*'), np.nan, regex=True, inplace=True)
assert_frame_equal(dfobj, res.fillna('.'))
# mixed
res = dfmix.copy()
- res.replace(re.compile(r'\s*\.\s*'), nan, regex=True, inplace=True)
+ res.replace(re.compile(r'\s*\.\s*'), np.nan, regex=True, inplace=True)
assert_frame_equal(dfmix, res.fillna('.'))
# regex -> regex
@@ -171,12 +170,12 @@ def test_regex_replace_scalar_inplace(self):
assert_frame_equal(res, expec)
res = dfobj.copy()
- res.replace(regex=r'\s*\.\s*', value=nan, inplace=True)
+ res.replace(regex=r'\s*\.\s*', value=np.nan, inplace=True)
assert_frame_equal(dfobj, res.fillna('.'))
# mixed
res = dfmix.copy()
- res.replace(regex=r'\s*\.\s*', value=nan, inplace=True)
+ res.replace(regex=r'\s*\.\s*', value=np.nan, inplace=True)
assert_frame_equal(dfmix, res.fillna('.'))
# regex -> regex
@@ -198,12 +197,12 @@ def test_regex_replace_scalar_inplace(self):
# everything with compiled regexs as well
res = dfobj.copy()
- res.replace(regex=re.compile(r'\s*\.\s*'), value=nan, inplace=True)
+ res.replace(regex=re.compile(r'\s*\.\s*'), value=np.nan, inplace=True)
assert_frame_equal(dfobj, res.fillna('.'))
# mixed
res = dfmix.copy()
- res.replace(regex=re.compile(r'\s*\.\s*'), value=nan, inplace=True)
+ res.replace(regex=re.compile(r'\s*\.\s*'), value=np.nan, inplace=True)
assert_frame_equal(dfmix, res.fillna('.'))
# regex -> regex
@@ -232,9 +231,9 @@ def test_regex_replace_list_obj(self):
# lists of regexes and values
# list of [re1, re2, ..., reN] -> [v1, v2, ..., vN]
to_replace_res = [r'\s*\.\s*', r'e|f|g']
- values = [nan, 'crap']
+ values = [np.nan, 'crap']
res = dfobj.replace(to_replace_res, values, regex=True)
- expec = DataFrame({'a': ['a', 'b', nan, nan], 'b': ['crap'] * 3 +
+ expec = DataFrame({'a': ['a', 'b', np.nan, np.nan], 'b': ['crap'] * 3 +
['h'], 'c': ['h', 'crap', 'l', 'o']})
assert_frame_equal(res, expec)
@@ -276,10 +275,10 @@ def test_regex_replace_list_obj_inplace(self):
# lists of regexes and values
# list of [re1, re2, ..., reN] -> [v1, v2, ..., vN]
to_replace_res = [r'\s*\.\s*', r'e|f|g']
- values = [nan, 'crap']
+ values = [np.nan, 'crap']
res = dfobj.copy()
res.replace(to_replace_res, values, inplace=True, regex=True)
- expec = DataFrame({'a': ['a', 'b', nan, nan], 'b': ['crap'] * 3 +
+ expec = DataFrame({'a': ['a', 'b', np.nan, np.nan], 'b': ['crap'] * 3 +
['h'], 'c': ['h', 'crap', 'l', 'o']})
assert_frame_equal(res, expec)
@@ -323,11 +322,11 @@ def test_regex_replace_list_mixed(self):
# lists of regexes and values
# list of [re1, re2, ..., reN] -> [v1, v2, ..., vN]
to_replace_res = [r'\s*\.\s*', r'a']
- values = [nan, 'crap']
+ values = [np.nan, 'crap']
mix2 = {'a': lrange(4), 'b': list('ab..'), 'c': list('halo')}
dfmix2 = DataFrame(mix2)
res = dfmix2.replace(to_replace_res, values, regex=True)
- expec = DataFrame({'a': mix2['a'], 'b': ['crap', 'b', nan, nan],
+ expec = DataFrame({'a': mix2['a'], 'b': ['crap', 'b', np.nan, np.nan],
'c': ['h', 'crap', 'l', 'o']})
assert_frame_equal(res, expec)
@@ -361,10 +360,10 @@ def test_regex_replace_list_mixed_inplace(self):
# lists of regexes and values
# list of [re1, re2, ..., reN] -> [v1, v2, ..., vN]
to_replace_res = [r'\s*\.\s*', r'a']
- values = [nan, 'crap']
+ values = [np.nan, 'crap']
res = dfmix.copy()
res.replace(to_replace_res, values, inplace=True, regex=True)
- expec = DataFrame({'a': mix['a'], 'b': ['crap', 'b', nan, nan]})
+ expec = DataFrame({'a': mix['a'], 'b': ['crap', 'b', np.nan, np.nan]})
assert_frame_equal(res, expec)
# list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
@@ -394,7 +393,7 @@ def test_regex_replace_list_mixed_inplace(self):
assert_frame_equal(res, expec)
def test_regex_replace_dict_mixed(self):
- mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', nan, 'd']}
+ mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
dfmix = DataFrame(mix)
# dicts
@@ -403,10 +402,11 @@ def test_regex_replace_dict_mixed(self):
# list of dicts {re1: v1, re2: v2, ..., re3: v3}, search the whole
# frame
- res = dfmix.replace({'b': r'\s*\.\s*'}, {'b': nan}, regex=True)
+ res = dfmix.replace({'b': r'\s*\.\s*'}, {'b': np.nan}, regex=True)
res2 = dfmix.copy()
- res2.replace({'b': r'\s*\.\s*'}, {'b': nan}, inplace=True, regex=True)
- expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', nan, nan], 'c':
+ res2.replace({'b': r'\s*\.\s*'}, {'b': np.nan},
+ inplace=True, regex=True)
+ expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', np.nan, np.nan], 'c':
mix['c']})
assert_frame_equal(res, expec)
assert_frame_equal(res2, expec)
@@ -433,33 +433,33 @@ def test_regex_replace_dict_mixed(self):
# scalar -> dict
# to_replace regex, {value: value}
- expec = DataFrame({'a': mix['a'], 'b': [nan, 'b', '.', '.'], 'c':
+ expec = DataFrame({'a': mix['a'], 'b': [np.nan, 'b', '.', '.'], 'c':
mix['c']})
- res = dfmix.replace('a', {'b': nan}, regex=True)
+ res = dfmix.replace('a', {'b': np.nan}, regex=True)
res2 = dfmix.copy()
- res2.replace('a', {'b': nan}, regex=True, inplace=True)
+ res2.replace('a', {'b': np.nan}, regex=True, inplace=True)
assert_frame_equal(res, expec)
assert_frame_equal(res2, expec)
- res = dfmix.replace('a', {'b': nan}, regex=True)
+ res = dfmix.replace('a', {'b': np.nan}, regex=True)
res2 = dfmix.copy()
- res2.replace(regex='a', value={'b': nan}, inplace=True)
- expec = DataFrame({'a': mix['a'], 'b': [nan, 'b', '.', '.'], 'c':
+ res2.replace(regex='a', value={'b': np.nan}, inplace=True)
+ expec = DataFrame({'a': mix['a'], 'b': [np.nan, 'b', '.', '.'], 'c':
mix['c']})
assert_frame_equal(res, expec)
assert_frame_equal(res2, expec)
def test_regex_replace_dict_nested(self):
# nested dicts will not work until this is implemented for Series
- mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', nan, 'd']}
+ mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
dfmix = DataFrame(mix)
- res = dfmix.replace({'b': {r'\s*\.\s*': nan}}, regex=True)
+ res = dfmix.replace({'b': {r'\s*\.\s*': np.nan}}, regex=True)
res2 = dfmix.copy()
res4 = dfmix.copy()
- res2.replace({'b': {r'\s*\.\s*': nan}}, inplace=True, regex=True)
- res3 = dfmix.replace(regex={'b': {r'\s*\.\s*': nan}})
- res4.replace(regex={'b': {r'\s*\.\s*': nan}}, inplace=True)
- expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', nan, nan], 'c':
+ res2.replace({'b': {r'\s*\.\s*': np.nan}}, inplace=True, regex=True)
+ res3 = dfmix.replace(regex={'b': {r'\s*\.\s*': np.nan}})
+ res4.replace(regex={'b': {r'\s*\.\s*': np.nan}}, inplace=True)
+ expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', np.nan, np.nan], 'c':
mix['c']})
assert_frame_equal(res, expec)
assert_frame_equal(res2, expec)
@@ -473,23 +473,23 @@ def test_regex_replace_dict_nested_gh4115(self):
assert_frame_equal(result, expected)
def test_regex_replace_list_to_scalar(self):
- mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', nan, 'd']}
+ mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
df = DataFrame(mix)
- expec = DataFrame({'a': mix['a'], 'b': np.array([nan] * 4),
- 'c': [nan, nan, nan, 'd']})
+ expec = DataFrame({'a': mix['a'], 'b': np.array([np.nan] * 4),
+ 'c': [np.nan, np.nan, np.nan, 'd']})
- res = df.replace([r'\s*\.\s*', 'a|b'], nan, regex=True)
+ res = df.replace([r'\s*\.\s*', 'a|b'], np.nan, regex=True)
res2 = df.copy()
res3 = df.copy()
- res2.replace([r'\s*\.\s*', 'a|b'], nan, regex=True, inplace=True)
- res3.replace(regex=[r'\s*\.\s*', 'a|b'], value=nan, inplace=True)
+ res2.replace([r'\s*\.\s*', 'a|b'], np.nan, regex=True, inplace=True)
+ res3.replace(regex=[r'\s*\.\s*', 'a|b'], value=np.nan, inplace=True)
assert_frame_equal(res, expec)
assert_frame_equal(res2, expec)
assert_frame_equal(res3, expec)
def test_regex_replace_str_to_numeric(self):
# what happens when you try to replace a numeric value with a regex?
- mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', nan, 'd']}
+ mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
df = DataFrame(mix)
res = df.replace(r'\s*\.\s*', 0, regex=True)
res2 = df.copy()
@@ -503,7 +503,7 @@ def test_regex_replace_str_to_numeric(self):
assert_frame_equal(res3, expec)
def test_regex_replace_regex_list_to_numeric(self):
- mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', nan, 'd']}
+ mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
df = DataFrame(mix)
res = df.replace([r'\s*\.\s*', 'b'], 0, regex=True)
res2 = df.copy()
@@ -511,30 +511,30 @@ def test_regex_replace_regex_list_to_numeric(self):
res3 = df.copy()
res3.replace(regex=[r'\s*\.\s*', 'b'], value=0, inplace=True)
expec = DataFrame({'a': mix['a'], 'b': ['a', 0, 0, 0], 'c': ['a', 0,
- nan,
+ np.nan,
'd']})
assert_frame_equal(res, expec)
assert_frame_equal(res2, expec)
assert_frame_equal(res3, expec)
def test_regex_replace_series_of_regexes(self):
- mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', nan, 'd']}
+ mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
df = DataFrame(mix)
s1 = Series({'b': r'\s*\.\s*'})
- s2 = Series({'b': nan})
+ s2 = Series({'b': np.nan})
res = df.replace(s1, s2, regex=True)
res2 = df.copy()
res2.replace(s1, s2, inplace=True, regex=True)
res3 = df.copy()
res3.replace(regex=s1, value=s2, inplace=True)
- expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', nan, nan], 'c':
+ expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', np.nan, np.nan], 'c':
mix['c']})
assert_frame_equal(res, expec)
assert_frame_equal(res2, expec)
assert_frame_equal(res3, expec)
def test_regex_replace_numeric_to_object_conversion(self):
- mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', nan, 'd']}
+ mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
df = DataFrame(mix)
expec = DataFrame({'a': ['a', 1, 2, 3], 'b': mix['b'], 'c': mix['c']})
res = df.replace(0, 'a')
@@ -549,15 +549,15 @@ def test_replace_regex_metachar(self, metachar):
assert_frame_equal(result, expected)
def test_replace(self):
- self.tsframe['A'][:5] = nan
- self.tsframe['A'][-5:] = nan
+ self.tsframe['A'][:5] = np.nan
+ self.tsframe['A'][-5:] = np.nan
- zero_filled = self.tsframe.replace(nan, -1e8)
+ zero_filled = self.tsframe.replace(np.nan, -1e8)
assert_frame_equal(zero_filled, self.tsframe.fillna(-1e8))
- assert_frame_equal(zero_filled.replace(-1e8, nan), self.tsframe)
+ assert_frame_equal(zero_filled.replace(-1e8, np.nan), self.tsframe)
- self.tsframe['A'][:5] = nan
- self.tsframe['A'][-5:] = nan
+ self.tsframe['A'][:5] = np.nan
+ self.tsframe['A'][-5:] = np.nan
self.tsframe['B'][:5] = -1e8
# empty
@@ -580,9 +580,9 @@ def test_replace_list(self):
# lists of regexes and values
# list of [v1, v2, ..., vN] -> [v1, v2, ..., vN]
to_replace_res = [r'.', r'e']
- values = [nan, 'crap']
+ values = [np.nan, 'crap']
res = dfobj.replace(to_replace_res, values)
- expec = DataFrame({'a': ['a', 'b', nan, nan],
+ expec = DataFrame({'a': ['a', 'b', np.nan, np.nan],
'b': ['crap', 'f', 'g', 'h'], 'c': ['h', 'crap',
'l', 'o']})
assert_frame_equal(res, expec)
@@ -644,18 +644,18 @@ def test_replace_convert(self):
def test_replace_mixed(self):
mf = self.mixed_frame
- mf.iloc[5:20, mf.columns.get_loc('foo')] = nan
- mf.iloc[-10:, mf.columns.get_loc('A')] = nan
+ mf.iloc[5:20, mf.columns.get_loc('foo')] = np.nan
+ mf.iloc[-10:, mf.columns.get_loc('A')] = np.nan
result = self.mixed_frame.replace(np.nan, -18)
expected = self.mixed_frame.fillna(value=-18)
assert_frame_equal(result, expected)
- assert_frame_equal(result.replace(-18, nan), self.mixed_frame)
+ assert_frame_equal(result.replace(-18, np.nan), self.mixed_frame)
result = self.mixed_frame.replace(np.nan, -1e8)
expected = self.mixed_frame.fillna(value=-1e8)
assert_frame_equal(result, expected)
- assert_frame_equal(result.replace(-1e8, nan), self.mixed_frame)
+ assert_frame_equal(result.replace(-1e8, np.nan), self.mixed_frame)
# int block upcasting
df = DataFrame({'A': Series([1.0, 2.0], dtype='float64'),
@@ -726,14 +726,14 @@ def test_replace_value_is_none(self):
orig_value = self.tsframe.iloc[0, 0]
orig2 = self.tsframe.iloc[1, 0]
- self.tsframe.iloc[0, 0] = nan
+ self.tsframe.iloc[0, 0] = np.nan
self.tsframe.iloc[1, 0] = 1
- result = self.tsframe.replace(to_replace={nan: 0})
- expected = self.tsframe.T.replace(to_replace={nan: 0}).T
+ result = self.tsframe.replace(to_replace={np.nan: 0})
+ expected = self.tsframe.T.replace(to_replace={np.nan: 0}).T
assert_frame_equal(result, expected)
- result = self.tsframe.replace(to_replace={nan: 0, 1: -1e8})
+ result = self.tsframe.replace(to_replace={np.nan: 0, 1: -1e8})
tsframe = self.tsframe.copy()
tsframe.iloc[0, 0] = 0
tsframe.iloc[1, 0] = -1e8
@@ -746,19 +746,19 @@ def test_replace_for_new_dtypes(self):
# dtypes
tsframe = self.tsframe.copy().astype(np.float32)
- tsframe['A'][:5] = nan
- tsframe['A'][-5:] = nan
+ tsframe['A'][:5] = np.nan
+ tsframe['A'][-5:] = np.nan
- zero_filled = tsframe.replace(nan, -1e8)
+ zero_filled = tsframe.replace(np.nan, -1e8)
assert_frame_equal(zero_filled, tsframe.fillna(-1e8))
- assert_frame_equal(zero_filled.replace(-1e8, nan), tsframe)
+ assert_frame_equal(zero_filled.replace(-1e8, np.nan), tsframe)
- tsframe['A'][:5] = nan
- tsframe['A'][-5:] = nan
+ tsframe['A'][:5] = np.nan
+ tsframe['A'][-5:] = np.nan
tsframe['B'][:5] = -1e8
b = tsframe['B']
- b[b == -1e8] = nan
+ b[b == -1e8] = np.nan
tsframe['B'] = b
result = tsframe.fillna(method='bfill')
assert_frame_equal(result, tsframe.fillna(method='bfill'))
@@ -875,10 +875,10 @@ def test_replace_series_no_regex(self):
assert_series_equal(result, expected)
def test_replace_dict_tuple_list_ordering_remains_the_same(self):
- df = DataFrame(dict(A=[nan, 1]))
- res1 = df.replace(to_replace={nan: 0, 1: -1e8})
- res2 = df.replace(to_replace=(1, nan), value=[-1e8, 0])
- res3 = df.replace(to_replace=[1, nan], value=[-1e8, 0])
+ df = DataFrame(dict(A=[np.nan, 1]))
+ res1 = df.replace(to_replace={np.nan: 0, 1: -1e8})
+ res2 = df.replace(to_replace=(1, np.nan), value=[-1e8, 0])
+ res3 = df.replace(to_replace=[1, np.nan], value=[-1e8, 0])
expected = DataFrame({'A': [0, -1e8]})
assert_frame_equal(res1, res2)
@@ -1062,7 +1062,7 @@ def test_replace_datetimetz(self):
def test_replace_with_empty_dictlike(self):
# GH 15289
- mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', nan, 'd']}
+ mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
df = DataFrame(mix)
assert_frame_equal(df, df.replace({}))
assert_frame_equal(df, df.replace(Series([])))
@@ -1072,31 +1072,31 @@ def test_replace_with_empty_dictlike(self):
@pytest.mark.parametrize("to_replace, method, expected", [
(0, 'bfill', {'A': [1, 1, 2],
- 'B': [5, nan, 7],
+ 'B': [5, np.nan, 7],
'C': ['a', 'b', 'c']}),
- (nan, 'bfill', {'A': [0, 1, 2],
- 'B': [5.0, 7.0, 7.0],
- 'C': ['a', 'b', 'c']}),
+ (np.nan, 'bfill', {'A': [0, 1, 2],
+ 'B': [5.0, 7.0, 7.0],
+ 'C': ['a', 'b', 'c']}),
('d', 'ffill', {'A': [0, 1, 2],
- 'B': [5, nan, 7],
+ 'B': [5, np.nan, 7],
'C': ['a', 'b', 'c']}),
([0, 2], 'bfill', {'A': [1, 1, 2],
- 'B': [5, nan, 7],
+ 'B': [5, np.nan, 7],
'C': ['a', 'b', 'c']}),
([1, 2], 'pad', {'A': [0, 0, 0],
- 'B': [5, nan, 7],
+ 'B': [5, np.nan, 7],
'C': ['a', 'b', 'c']}),
((1, 2), 'bfill', {'A': [0, 2, 2],
- 'B': [5, nan, 7],
+ 'B': [5, np.nan, 7],
'C': ['a', 'b', 'c']}),
(['b', 'c'], 'ffill', {'A': [0, 1, 2],
- 'B': [5, nan, 7],
+ 'B': [5, np.nan, 7],
'C': ['a', 'a', 'a']}),
])
def test_replace_method(self, to_replace, method, expected):
# GH 19632
df = DataFrame({'A': [0, 1, 2],
- 'B': [5, nan, 7],
+ 'B': [5, np.nan, 7],
'C': ['a', 'b', 'c']})
result = df.replace(to_replace=to_replace, value=None, method=method)
diff --git a/pandas/tests/frame/test_reshape.py b/pandas/tests/frame/test_reshape.py
index f2f6944a21e03..28222a82945be 100644
--- a/pandas/tests/frame/test_reshape.py
+++ b/pandas/tests/frame/test_reshape.py
@@ -7,8 +7,6 @@
from warnings import catch_warnings, simplefilter
import numpy as np
-from numpy import nan
-from numpy.random import randn
import pytest
from pandas.compat import u
@@ -388,7 +386,7 @@ def test_stack_mixed_levels(self):
('A', 'dog', 'short'), ('B', 'dog', 'short')],
names=['exp', 'animal', 'hair_length']
)
- df = DataFrame(randn(4, 4), columns=columns)
+ df = DataFrame(np.random.randn(4, 4), columns=columns)
animal_hair_stacked = df.stack(level=['animal', 'hair_length'])
exp_hair_stacked = df.stack(level=['exp', 'hair_length'])
@@ -420,7 +418,7 @@ def test_stack_int_level_names(self):
('A', 'dog', 'short'), ('B', 'dog', 'short')],
names=['exp', 'animal', 'hair_length']
)
- df = DataFrame(randn(4, 4), columns=columns)
+ df = DataFrame(np.random.randn(4, 4), columns=columns)
exp_animal_stacked = df.stack(level=['exp', 'animal'])
animal_hair_stacked = df.stack(level=['animal', 'hair_length'])
@@ -634,7 +632,6 @@ def test_unstack_unused_level(self, cols):
def test_unstack_nan_index(self): # GH7466
cast = lambda val: '{0:1}'.format('' if val != val else val)
- nan = np.nan
def verify(df):
mk_list = lambda a: list(a) if isinstance(a, tuple) else [a]
@@ -645,7 +642,7 @@ def verify(df):
right = sorted(list(map(cast, right)))
assert left == right
- df = DataFrame({'jim': ['a', 'b', nan, 'd'],
+ df = DataFrame({'jim': ['a', 'b', np.nan, 'd'],
'joe': ['w', 'x', 'y', 'z'],
'jolie': ['a.w', 'b.x', ' .y', 'd.z']})
@@ -660,10 +657,10 @@ def verify(df):
assert udf.notna().values.sum() == len(df)
verify(udf['jolie'])
- df = DataFrame({'1st': ['d'] * 3 + [nan] * 5 + ['a'] * 2 +
+ df = DataFrame({'1st': ['d'] * 3 + [np.nan] * 5 + ['a'] * 2 +
['c'] * 3 + ['e'] * 2 + ['b'] * 5,
- '2nd': ['y'] * 2 + ['w'] * 3 + [nan] * 3 +
- ['z'] * 4 + [nan] * 3 + ['x'] * 3 + [nan] * 2,
+ '2nd': ['y'] * 2 + ['w'] * 3 + [np.nan] * 3 +
+ ['z'] * 4 + [np.nan] * 3 + ['x'] * 3 + [np.nan] * 2,
'3rd': [67, 39, 53, 72, 57, 80, 31, 18, 11, 30, 59,
50, 62, 59, 76, 52, 14, 53, 60, 51]})
@@ -685,10 +682,10 @@ def verify(df):
df.iloc[3, 1] = np.NaN
left = df.set_index(['A', 'B']).unstack(0)
- vals = [[3, 0, 1, 2, nan, nan, nan, nan],
- [nan, nan, nan, nan, 4, 5, 6, 7]]
+ vals = [[3, 0, 1, 2, np.nan, np.nan, np.nan, np.nan],
+ [np.nan, np.nan, np.nan, np.nan, 4, 5, 6, 7]]
vals = list(map(list, zip(*vals)))
- idx = Index([nan, 0, 1, 2, 4, 5, 6, 7], name='B')
+ idx = Index([np.nan, 0, 1, 2, 4, 5, 6, 7], name='B')
cols = MultiIndex(levels=[['C'], ['a', 'b']],
codes=[[0, 0], [0, 1]],
names=[None, 'A'])
@@ -701,11 +698,11 @@ def verify(df):
df.iloc[2, 1] = np.NaN
left = df.set_index(['A', 'B']).unstack(0)
- vals = [[2, nan], [0, 4], [1, 5], [nan, 6], [3, 7]]
+ vals = [[2, np.nan], [0, 4], [1, 5], [np.nan, 6], [3, 7]]
cols = MultiIndex(levels=[['C'], ['a', 'b']],
codes=[[0, 0], [0, 1]],
names=[None, 'A'])
- idx = Index([nan, 0, 1, 2, 3], name='B')
+ idx = Index([np.nan, 0, 1, 2, 3], name='B')
right = DataFrame(vals, columns=cols, index=idx)
assert_frame_equal(left, right)
@@ -714,11 +711,11 @@ def verify(df):
df.iloc[3, 1] = np.NaN
left = df.set_index(['A', 'B']).unstack(0)
- vals = [[3, nan], [0, 4], [1, 5], [2, 6], [nan, 7]]
+ vals = [[3, np.nan], [0, 4], [1, 5], [2, 6], [np.nan, 7]]
cols = MultiIndex(levels=[['C'], ['a', 'b']],
codes=[[0, 0], [0, 1]],
names=[None, 'A'])
- idx = Index([nan, 0, 1, 2, 3], name='B')
+ idx = Index([np.nan, 0, 1, 2, 3], name='B')
right = DataFrame(vals, columns=cols, index=idx)
assert_frame_equal(left, right)
@@ -731,7 +728,7 @@ def verify(df):
df.iloc[3, 1] = np.NaN
left = df.set_index(['A', 'B']).unstack()
- vals = np.array([[3, 0, 1, 2, nan, 4], [nan, 5, 6, 7, 8, 9]])
+ vals = np.array([[3, 0, 1, 2, np.nan, 4], [np.nan, 5, 6, 7, 8, 9]])
idx = Index(['a', 'b'], name='A')
cols = MultiIndex(levels=[['C'], date_range('2012-01-01', periods=5)],
codes=[[0, 0, 0, 0, 0, 0], [-1, 0, 1, 2, 3, 4]],
@@ -741,9 +738,9 @@ def verify(df):
assert_frame_equal(left, right)
# GH4862
- vals = [['Hg', nan, nan, 680585148],
- ['U', 0.0, nan, 680585148],
- ['Pb', 7.07e-06, nan, 680585148],
+ vals = [['Hg', np.nan, np.nan, 680585148],
+ ['U', 0.0, np.nan, 680585148],
+ ['Pb', 7.07e-06, np.nan, 680585148],
['Sn', 2.3614e-05, 0.0133, 680607017],
['Ag', 0.0, 0.0133, 680607017],
['Hg', -0.00015, 0.0133, 680607017]]
@@ -752,8 +749,8 @@ def verify(df):
left = df.copy().set_index(['s_id', 'dosage', 'agent']).unstack()
- vals = [[nan, nan, 7.07e-06, nan, 0.0],
- [0.0, -0.00015, nan, 2.3614e-05, nan]]
+ vals = [[np.nan, np.nan, 7.07e-06, np.nan, 0.0],
+ [0.0, -0.00015, np.nan, 2.3614e-05, np.nan]]
idx = MultiIndex(levels=[[680585148, 680607017], [0.0133]],
codes=[[0, 1], [-1, 0]],
@@ -777,8 +774,8 @@ def verify(df):
'joe': (np.random.randn(6) * 10).round(2)})
df['3rd'] = df['2nd'] - pd.Timestamp('2014-02-02')
- df.loc[1, '2nd'] = df.loc[3, '2nd'] = nan
- df.loc[1, '3rd'] = df.loc[4, '3rd'] = nan
+ df.loc[1, '2nd'] = df.loc[3, '2nd'] = np.nan
+ df.loc[1, '3rd'] = df.loc[4, '3rd'] = np.nan
left = df.set_index(['1st', '2nd', '3rd']).unstack(['2nd', '3rd'])
assert left.notna().values.sum() == 2 * len(df)
@@ -845,7 +842,7 @@ def _test_stack_with_multiindex(multiindex):
df = DataFrame(np.arange(6).reshape(2, 3),
columns=full_multiindex[[0, 1, 3]])
result = df.stack(dropna=False)
- expected = DataFrame([[0, 2], [1, nan], [3, 5], [4, nan]],
+ expected = DataFrame([[0, 2], [1, np.nan], [3, 5], [4, np.nan]],
index=MultiIndex(
levels=[[0, 1], ['u', 'x', 'y', 'z']],
codes=[[0, 0, 1, 1],
diff --git a/pandas/tests/frame/test_timeseries.py b/pandas/tests/frame/test_timeseries.py
index 75a8c834e3af6..bc37317f72802 100644
--- a/pandas/tests/frame/test_timeseries.py
+++ b/pandas/tests/frame/test_timeseries.py
@@ -5,7 +5,6 @@
from datetime import datetime, time
import numpy as np
-from numpy.random import randn
import pytest
from pandas.compat import product
@@ -530,7 +529,7 @@ def test_asfreq_fillvalue(self):
def test_first_last_valid(self, data, idx,
expected_first, expected_last):
N = len(self.frame.index)
- mat = randn(N)
+ mat = np.random.randn(N)
mat[:5] = np.nan
mat[-5:] = np.nan
@@ -812,7 +811,7 @@ def test_frame_to_period(self):
dr = date_range('1/1/2000', '1/1/2001')
pr = period_range('1/1/2000', '1/1/2001')
- df = DataFrame(randn(len(dr), K), index=dr)
+ df = DataFrame(np.random.randn(len(dr), K), index=dr)
df['mix'] = 'a'
pts = df.to_period()
| - [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24822 | 2019-01-18T02:31:12Z | 2019-01-19T21:27:08Z | 2019-01-19T21:27:08Z | 2019-01-19T22:28:30Z |
use Timedelta instead of convert_to_timedelta64 | diff --git a/pandas/_libs/tslibs/timedeltas.pxd b/pandas/_libs/tslibs/timedeltas.pxd
index c02a840281266..097309b17823b 100644
--- a/pandas/_libs/tslibs/timedeltas.pxd
+++ b/pandas/_libs/tslibs/timedeltas.pxd
@@ -5,4 +5,4 @@ from numpy cimport int64_t
# Exposed for tslib, not intended for outside use.
cdef int64_t cast_from_unit(object ts, object unit) except? -1
cpdef int64_t delta_to_nanoseconds(delta) except? -1
-cpdef convert_to_timedelta64(object ts, object unit)
+cdef convert_to_timedelta64(object ts, object unit)
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 0476ba1c78efc..0a19d8749fc7c 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -149,7 +149,7 @@ cpdef int64_t delta_to_nanoseconds(delta) except? -1:
raise TypeError(type(delta))
-cpdef convert_to_timedelta64(object ts, object unit):
+cdef convert_to_timedelta64(object ts, object unit):
"""
Convert an incoming object to a timedelta64 if possible.
Before calling, unit must be standardized to avoid repeated unit conversion
@@ -178,16 +178,12 @@ cpdef convert_to_timedelta64(object ts, object unit):
if ts == NPY_NAT:
return np.timedelta64(NPY_NAT)
else:
- if util.is_array(ts):
- ts = ts.astype('int64').item()
if unit in ['Y', 'M', 'W']:
ts = np.timedelta64(ts, unit)
else:
ts = cast_from_unit(ts, unit)
ts = np.timedelta64(ts)
elif is_float_object(ts):
- if util.is_array(ts):
- ts = ts.astype('int64').item()
if unit in ['Y', 'M', 'W']:
ts = np.timedelta64(int(ts), unit)
else:
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index 6bcf56c306e6a..e3428146b91d8 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -4,9 +4,7 @@
import numpy as np
-from pandas._libs import tslibs
-from pandas._libs.tslibs.timedeltas import (
- convert_to_timedelta64, parse_timedelta_unit)
+from pandas._libs.tslibs.timedeltas import Timedelta, parse_timedelta_unit
from pandas.core.dtypes.common import is_list_like
from pandas.core.dtypes.generic import ABCIndexClass, ABCSeries
@@ -120,7 +118,9 @@ def _coerce_scalar_to_timedelta_type(r, unit='ns', box=True, errors='raise'):
"""Convert string 'r' to a timedelta object."""
try:
- result = convert_to_timedelta64(r, unit)
+ result = Timedelta(r, unit)
+ if not box:
+ result = result.asm8
except ValueError:
if errors == 'raise':
raise
@@ -130,8 +130,6 @@ def _coerce_scalar_to_timedelta_type(r, unit='ns', box=True, errors='raise'):
# coerce
result = pd.NaT
- if box:
- result = tslibs.Timedelta(result)
return result
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index bc753c45c803a..9b5fdfb06a9fa 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -10,7 +10,6 @@
import pandas as pd
from pandas import (
Series, Timedelta, TimedeltaIndex, timedelta_range, to_timedelta)
-from pandas.core.tools.timedeltas import _coerce_scalar_to_timedelta_type as ct
import pandas.util.testing as tm
@@ -373,21 +372,21 @@ def test_unit_parser(self, units, np_unit, wrapper):
assert result == expected
def test_numeric_conversions(self):
- assert ct(0) == np.timedelta64(0, 'ns')
- assert ct(10) == np.timedelta64(10, 'ns')
- assert ct(10, unit='ns') == np.timedelta64(10, 'ns').astype('m8[ns]')
+ assert Timedelta(0) == np.timedelta64(0, 'ns')
+ assert Timedelta(10) == np.timedelta64(10, 'ns')
+ assert Timedelta(10, unit='ns') == np.timedelta64(10, 'ns')
- assert ct(10, unit='us') == np.timedelta64(10, 'us').astype('m8[ns]')
- assert ct(10, unit='ms') == np.timedelta64(10, 'ms').astype('m8[ns]')
- assert ct(10, unit='s') == np.timedelta64(10, 's').astype('m8[ns]')
- assert ct(10, unit='d') == np.timedelta64(10, 'D').astype('m8[ns]')
+ assert Timedelta(10, unit='us') == np.timedelta64(10, 'us')
+ assert Timedelta(10, unit='ms') == np.timedelta64(10, 'ms')
+ assert Timedelta(10, unit='s') == np.timedelta64(10, 's')
+ assert Timedelta(10, unit='d') == np.timedelta64(10, 'D')
def test_timedelta_conversions(self):
- assert (ct(timedelta(seconds=1)) ==
+ assert (Timedelta(timedelta(seconds=1)) ==
np.timedelta64(1, 's').astype('m8[ns]'))
- assert (ct(timedelta(microseconds=1)) ==
+ assert (Timedelta(timedelta(microseconds=1)) ==
np.timedelta64(1, 'us').astype('m8[ns]'))
- assert (ct(timedelta(days=1)) ==
+ assert (Timedelta(timedelta(days=1)) ==
np.timedelta64(1, 'D').astype('m8[ns]'))
def test_round(self):
@@ -493,47 +492,49 @@ def test_short_format_converters(self):
def conv(v):
return v.astype('m8[ns]')
- assert ct('10') == np.timedelta64(10, 'ns')
- assert ct('10ns') == np.timedelta64(10, 'ns')
- assert ct('100') == np.timedelta64(100, 'ns')
- assert ct('100ns') == np.timedelta64(100, 'ns')
-
- assert ct('1000') == np.timedelta64(1000, 'ns')
- assert ct('1000ns') == np.timedelta64(1000, 'ns')
- assert ct('1000NS') == np.timedelta64(1000, 'ns')
-
- assert ct('10us') == np.timedelta64(10000, 'ns')
- assert ct('100us') == np.timedelta64(100000, 'ns')
- assert ct('1000us') == np.timedelta64(1000000, 'ns')
- assert ct('1000Us') == np.timedelta64(1000000, 'ns')
- assert ct('1000uS') == np.timedelta64(1000000, 'ns')
-
- assert ct('1ms') == np.timedelta64(1000000, 'ns')
- assert ct('10ms') == np.timedelta64(10000000, 'ns')
- assert ct('100ms') == np.timedelta64(100000000, 'ns')
- assert ct('1000ms') == np.timedelta64(1000000000, 'ns')
-
- assert ct('-1s') == -np.timedelta64(1000000000, 'ns')
- assert ct('1s') == np.timedelta64(1000000000, 'ns')
- assert ct('10s') == np.timedelta64(10000000000, 'ns')
- assert ct('100s') == np.timedelta64(100000000000, 'ns')
- assert ct('1000s') == np.timedelta64(1000000000000, 'ns')
-
- assert ct('1d') == conv(np.timedelta64(1, 'D'))
- assert ct('-1d') == -conv(np.timedelta64(1, 'D'))
- assert ct('1D') == conv(np.timedelta64(1, 'D'))
- assert ct('10D') == conv(np.timedelta64(10, 'D'))
- assert ct('100D') == conv(np.timedelta64(100, 'D'))
- assert ct('1000D') == conv(np.timedelta64(1000, 'D'))
- assert ct('10000D') == conv(np.timedelta64(10000, 'D'))
+ assert Timedelta('10') == np.timedelta64(10, 'ns')
+ assert Timedelta('10ns') == np.timedelta64(10, 'ns')
+ assert Timedelta('100') == np.timedelta64(100, 'ns')
+ assert Timedelta('100ns') == np.timedelta64(100, 'ns')
+
+ assert Timedelta('1000') == np.timedelta64(1000, 'ns')
+ assert Timedelta('1000ns') == np.timedelta64(1000, 'ns')
+ assert Timedelta('1000NS') == np.timedelta64(1000, 'ns')
+
+ assert Timedelta('10us') == np.timedelta64(10000, 'ns')
+ assert Timedelta('100us') == np.timedelta64(100000, 'ns')
+ assert Timedelta('1000us') == np.timedelta64(1000000, 'ns')
+ assert Timedelta('1000Us') == np.timedelta64(1000000, 'ns')
+ assert Timedelta('1000uS') == np.timedelta64(1000000, 'ns')
+
+ assert Timedelta('1ms') == np.timedelta64(1000000, 'ns')
+ assert Timedelta('10ms') == np.timedelta64(10000000, 'ns')
+ assert Timedelta('100ms') == np.timedelta64(100000000, 'ns')
+ assert Timedelta('1000ms') == np.timedelta64(1000000000, 'ns')
+
+ assert Timedelta('-1s') == -np.timedelta64(1000000000, 'ns')
+ assert Timedelta('1s') == np.timedelta64(1000000000, 'ns')
+ assert Timedelta('10s') == np.timedelta64(10000000000, 'ns')
+ assert Timedelta('100s') == np.timedelta64(100000000000, 'ns')
+ assert Timedelta('1000s') == np.timedelta64(1000000000000, 'ns')
+
+ assert Timedelta('1d') == conv(np.timedelta64(1, 'D'))
+ assert Timedelta('-1d') == -conv(np.timedelta64(1, 'D'))
+ assert Timedelta('1D') == conv(np.timedelta64(1, 'D'))
+ assert Timedelta('10D') == conv(np.timedelta64(10, 'D'))
+ assert Timedelta('100D') == conv(np.timedelta64(100, 'D'))
+ assert Timedelta('1000D') == conv(np.timedelta64(1000, 'D'))
+ assert Timedelta('10000D') == conv(np.timedelta64(10000, 'D'))
# space
- assert ct(' 10000D ') == conv(np.timedelta64(10000, 'D'))
- assert ct(' - 10000D ') == -conv(np.timedelta64(10000, 'D'))
+ assert Timedelta(' 10000D ') == conv(np.timedelta64(10000, 'D'))
+ assert Timedelta(' - 10000D ') == -conv(np.timedelta64(10000, 'D'))
# invalid
- pytest.raises(ValueError, ct, '1foo')
- pytest.raises(ValueError, ct, 'foo')
+ with pytest.raises(ValueError):
+ Timedelta('1foo')
+ with pytest.raises(ValueError):
+ Timedelta('foo')
def test_full_format_converters(self):
def conv(v):
@@ -541,25 +542,27 @@ def conv(v):
d1 = np.timedelta64(1, 'D')
- assert ct('1days') == conv(d1)
- assert ct('1days,') == conv(d1)
- assert ct('- 1days,') == -conv(d1)
+ assert Timedelta('1days') == conv(d1)
+ assert Timedelta('1days,') == conv(d1)
+ assert Timedelta('- 1days,') == -conv(d1)
- assert ct('00:00:01') == conv(np.timedelta64(1, 's'))
- assert ct('06:00:01') == conv(np.timedelta64(6 * 3600 + 1, 's'))
- assert ct('06:00:01.0') == conv(np.timedelta64(6 * 3600 + 1, 's'))
- assert ct('06:00:01.01') == conv(np.timedelta64(
+ assert Timedelta('00:00:01') == conv(np.timedelta64(1, 's'))
+ assert Timedelta('06:00:01') == conv(np.timedelta64(6 * 3600 + 1, 's'))
+ assert Timedelta('06:00:01.0') == conv(
+ np.timedelta64(6 * 3600 + 1, 's'))
+ assert Timedelta('06:00:01.01') == conv(np.timedelta64(
1000 * (6 * 3600 + 1) + 10, 'ms'))
- assert (ct('- 1days, 00:00:01') ==
+ assert (Timedelta('- 1days, 00:00:01') ==
conv(-d1 + np.timedelta64(1, 's')))
- assert (ct('1days, 06:00:01') ==
+ assert (Timedelta('1days, 06:00:01') ==
conv(d1 + np.timedelta64(6 * 3600 + 1, 's')))
- assert (ct('1days, 06:00:01.01') ==
+ assert (Timedelta('1days, 06:00:01.01') ==
conv(d1 + np.timedelta64(1000 * (6 * 3600 + 1) + 10, 'ms')))
# invalid
- pytest.raises(ValueError, ct, '- 1days, 00')
+ with pytest.raises(ValueError):
+ Timedelta('- 1days, 00')
def test_overflow(self):
# GH 9442
| - [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24821 | 2019-01-18T02:14:53Z | 2019-01-18T22:40:07Z | 2019-01-18T22:40:07Z | 2019-01-18T22:41:14Z |
BUG: DataFrame.merge(suffixes=) does not respect None | diff --git a/doc/source/whatsnew/v0.25.0.rst b/doc/source/whatsnew/v0.25.0.rst
index 09626be713c4f..80c76d14a5938 100644
--- a/doc/source/whatsnew/v0.25.0.rst
+++ b/doc/source/whatsnew/v0.25.0.rst
@@ -181,6 +181,7 @@ Groupby/Resample/Rolling
Reshaping
^^^^^^^^^
+- Bug in :func:`pandas.merge` adds a string of ``None`` if ``None`` is assigned in suffixes instead of remain the column name as-is (:issue:`24782`).
- Bug in :func:`merge` when merging by index name would sometimes result in an incorrectly numbered index (:issue:`24212`)
- :func:`to_records` now accepts dtypes to its `column_dtypes` parameter (:issue:`24895`)
-
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index 050c3d3e87fc6..5cae6e1a89170 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -1971,16 +1971,28 @@ def items_overlap_with_suffix(left, lsuffix, right, rsuffix):
raise ValueError('columns overlap but no suffix specified: '
'{rename}'.format(rename=to_rename))
- def lrenamer(x):
- if x in to_rename:
- return '{x}{lsuffix}'.format(x=x, lsuffix=lsuffix)
- return x
+ def renamer(x, suffix):
+ """Rename the left and right indices.
+
+ If there is overlap, and suffix is not None, add
+ suffix, otherwise, leave it as-is.
+
+ Parameters
+ ----------
+ x : original column name
+ suffix : str or None
- def rrenamer(x):
- if x in to_rename:
- return '{x}{rsuffix}'.format(x=x, rsuffix=rsuffix)
+ Returns
+ -------
+ x : renamed column name
+ """
+ if x in to_rename and suffix is not None:
+ return '{x}{suffix}'.format(x=x, suffix=suffix)
return x
+ lrenamer = partial(renamer, suffix=lsuffix)
+ rrenamer = partial(renamer, suffix=rsuffix)
+
return (_transform_index(left, lrenamer),
_transform_index(right, rrenamer))
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 1dd19a7c1514e..ad3327e694b67 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -159,9 +159,15 @@ def merge_ordered(left, right, on=None,
left DataFrame
fill_method : {'ffill', None}, default None
Interpolation method for data
- suffixes : 2-length sequence (tuple, list, ...)
- Suffix to apply to overlapping column names in the left and right
- side, respectively
+ suffixes : Sequence, default is ("_x", "_y")
+ A length-2 sequence where each element is optionally a string
+ indicating the suffix to add to overlapping column names in
+ `left` and `right` respectively. Pass a value of `None` instead
+ of a string to indicate that the column name from `left` or
+ `right` should be left as-is, with no suffix. At least one of the
+ values must not be None.
+
+ .. versionchanged:: 0.25.0
how : {'left', 'right', 'outer', 'inner'}, default 'outer'
* left: use only keys from left frame (SQL: left outer join)
* right: use only keys from right frame (SQL: right outer join)
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index a0a20d1da6cef..25487ccc76e62 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -1526,3 +1526,65 @@ def test_merge_series(on, left_on, right_on, left_index, right_index, nm):
with pytest.raises(ValueError, match=msg):
result = pd.merge(a, b, on=on, left_on=left_on, right_on=right_on,
left_index=left_index, right_index=right_index)
+
+
+@pytest.mark.parametrize("col1, col2, kwargs, expected_cols", [
+ (0, 0, dict(suffixes=("", "_dup")), ["0", "0_dup"]),
+ (0, 0, dict(suffixes=(None, "_dup")), [0, "0_dup"]),
+ (0, 0, dict(suffixes=("_x", "_y")), ["0_x", "0_y"]),
+ ("a", 0, dict(suffixes=(None, "_y")), ["a", 0]),
+ (0.0, 0.0, dict(suffixes=("_x", None)), ["0.0_x", 0.0]),
+ ("b", "b", dict(suffixes=(None, "_y")), ["b", "b_y"]),
+ ("a", "a", dict(suffixes=("_x", None)), ["a_x", "a"]),
+ ("a", "b", dict(suffixes=("_x", None)), ["a", "b"]),
+ ("a", "a", dict(suffixes=[None, "_x"]), ["a", "a_x"]),
+ (0, 0, dict(suffixes=["_a", None]), ["0_a", 0]),
+ ("a", "a", dict(), ["a_x", "a_y"]),
+ (0, 0, dict(), ["0_x", "0_y"])
+])
+def test_merge_suffix(col1, col2, kwargs, expected_cols):
+ # issue: 24782
+ a = pd.DataFrame({col1: [1, 2, 3]})
+ b = pd.DataFrame({col2: [4, 5, 6]})
+
+ expected = pd.DataFrame([[1, 4], [2, 5], [3, 6]],
+ columns=expected_cols)
+
+ result = a.merge(b, left_index=True, right_index=True, **kwargs)
+ tm.assert_frame_equal(result, expected)
+
+ result = pd.merge(a, b, left_index=True, right_index=True, **kwargs)
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("col1, col2, suffixes", [
+ ("a", "a", [None, None]),
+ ("a", "a", (None, None)),
+ ("a", "a", ("", None)),
+ (0, 0, [None, None]),
+ (0, 0, (None, ""))
+])
+def test_merge_suffix_error(col1, col2, suffixes):
+ # issue: 24782
+ a = pd.DataFrame({col1: [1, 2, 3]})
+ b = pd.DataFrame({col2: [3, 4, 5]})
+
+ # TODO: might reconsider current raise behaviour, see issue 24782
+ msg = "columns overlap but no suffix specified"
+ with pytest.raises(ValueError, match=msg):
+ pd.merge(a, b, left_index=True, right_index=True, suffixes=suffixes)
+
+
+@pytest.mark.parametrize("col1, col2, suffixes", [
+ ("a", "a", None),
+ (0, 0, None)
+])
+def test_merge_suffix_none_error(col1, col2, suffixes):
+ # issue: 24782
+ a = pd.DataFrame({col1: [1, 2, 3]})
+ b = pd.DataFrame({col2: [3, 4, 5]})
+
+ # TODO: might reconsider current raise behaviour, see GH24782
+ msg = "iterable"
+ with pytest.raises(TypeError, match=msg):
+ pd.merge(a, b, left_index=True, right_index=True, suffixes=suffixes)
| - [ ] closes #24782
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24819 | 2019-01-17T20:28:06Z | 2019-02-06T03:51:07Z | 2019-02-06T03:51:06Z | 2019-02-09T16:05:25Z |
BUG: Format mismatch doesn't coerce to NaT | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 3685a24d60e74..673a1b8a8581f 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1548,6 +1548,7 @@ Datetimelike
- Bug in :meth:`DatetimeIndex.astype`, :meth:`PeriodIndex.astype` and :meth:`TimedeltaIndex.astype` ignoring the sign of the ``dtype`` for unsigned integer dtypes (:issue:`24405`).
- Fixed bug in :meth:`Series.max` with ``datetime64[ns]``-dtype failing to return ``NaT`` when nulls are present and ``skipna=False`` is passed (:issue:`24265`)
- Bug in :func:`to_datetime` where arrays of ``datetime`` objects containing both timezone-aware and timezone-naive ``datetimes`` would fail to raise ``ValueError`` (:issue:`24569`)
+- Bug in :func:`to_datetime` with invalid datetime format doesn't coerce input to ``NaT`` even if ``errors='coerce'`` (:issue:`24763`)
Timedelta
^^^^^^^^^
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index 5b540ee88a3f3..e6478da400d76 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -265,7 +265,12 @@ def _convert_listlike_datetimes(arg, box, format, name=None, tz=None,
except tslibs.OutOfBoundsDatetime:
if errors == 'raise':
raise
- result = arg
+ elif errors == 'coerce':
+ result = np.empty(arg.shape, dtype='M8[ns]')
+ iresult = result.view('i8')
+ iresult.fill(tslibs.iNaT)
+ else:
+ result = arg
except ValueError:
# if format was inferred, try falling back
# to array_to_datetime - terminate here
@@ -273,7 +278,12 @@ def _convert_listlike_datetimes(arg, box, format, name=None, tz=None,
if not infer_datetime_format:
if errors == 'raise':
raise
- result = arg
+ elif errors == 'coerce':
+ result = np.empty(arg.shape, dtype='M8[ns]')
+ iresult = result.view('i8')
+ iresult.fill(tslibs.iNaT)
+ else:
+ result = arg
except ValueError as e:
# Fallback to try to convert datetime objects if timezone-aware
# datetime objects are found without passing `utc=True`
diff --git a/pandas/tests/indexes/datetimes/test_tools.py b/pandas/tests/indexes/datetimes/test_tools.py
index 50c8f8d4c1f4c..bec2fa66c43cd 100644
--- a/pandas/tests/indexes/datetimes/test_tools.py
+++ b/pandas/tests/indexes/datetimes/test_tools.py
@@ -555,6 +555,63 @@ def test_datetime_invalid_datatype(self):
with pytest.raises(TypeError):
pd.to_datetime(pd.to_datetime)
+ @pytest.mark.parametrize('value', ["a", "00:01:99"])
+ @pytest.mark.parametrize('infer', [True, False])
+ @pytest.mark.parametrize('format', [None, 'H%:M%:S%'])
+ def test_datetime_invalid_scalar(self, value, format, infer):
+ # GH24763
+ res = pd.to_datetime(value, errors='ignore', format=format,
+ infer_datetime_format=infer)
+ assert res == value
+
+ res = pd.to_datetime(value, errors='coerce', format=format,
+ infer_datetime_format=infer)
+ assert res is pd.NaT
+
+ with pytest.raises(ValueError):
+ pd.to_datetime(value, errors='raise', format=format,
+ infer_datetime_format=infer)
+
+ @pytest.mark.parametrize('value', ["3000/12/11 00:00:00"])
+ @pytest.mark.parametrize('infer', [True, False])
+ @pytest.mark.parametrize('format', [None, 'H%:M%:S%'])
+ def test_datetime_outofbounds_scalar(self, value, format, infer):
+ # GH24763
+ res = pd.to_datetime(value, errors='ignore', format=format,
+ infer_datetime_format=infer)
+ assert res == value
+
+ res = pd.to_datetime(value, errors='coerce', format=format,
+ infer_datetime_format=infer)
+ assert res is pd.NaT
+
+ if format is not None:
+ with pytest.raises(ValueError):
+ pd.to_datetime(value, errors='raise', format=format,
+ infer_datetime_format=infer)
+ else:
+ with pytest.raises(OutOfBoundsDatetime):
+ pd.to_datetime(value, errors='raise', format=format,
+ infer_datetime_format=infer)
+
+ @pytest.mark.parametrize('values', [["a"], ["00:01:99"],
+ ["a", "b", "99:00:00"]])
+ @pytest.mark.parametrize('infer', [True, False])
+ @pytest.mark.parametrize('format', [None, 'H%:M%:S%'])
+ def test_datetime_invalid_index(self, values, format, infer):
+ # GH24763
+ res = pd.to_datetime(values, errors='ignore', format=format,
+ infer_datetime_format=infer)
+ tm.assert_index_equal(res, pd.Index(values))
+
+ res = pd.to_datetime(values, errors='coerce', format=format,
+ infer_datetime_format=infer)
+ tm.assert_index_equal(res, pd.DatetimeIndex([pd.NaT] * len(values)))
+
+ with pytest.raises(ValueError):
+ pd.to_datetime(values, errors='raise', format=format,
+ infer_datetime_format=infer)
+
@pytest.mark.parametrize("utc", [True, None])
@pytest.mark.parametrize("format", ['%Y%m%d %H:%M:%S', None])
@pytest.mark.parametrize("box", [True, False])
| - [x] closes #24763
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24815 | 2019-01-17T11:55:31Z | 2019-01-21T14:19:56Z | 2019-01-21T14:19:56Z | 2019-01-22T08:49:49Z |
STY: use pytest.raises context syntax (series) | diff --git a/pandas/tests/series/test_alter_axes.py b/pandas/tests/series/test_alter_axes.py
index 99a4f0c424ce9..cd4c0a7924d39 100644
--- a/pandas/tests/series/test_alter_axes.py
+++ b/pandas/tests/series/test_alter_axes.py
@@ -16,11 +16,16 @@ class TestSeriesAlterAxes(object):
def test_setindex(self, string_series):
# wrong type
- pytest.raises(TypeError, setattr, string_series, 'index', None)
+ msg = (r"Index\(\.\.\.\) must be called with a collection of some"
+ r" kind, None was passed")
+ with pytest.raises(TypeError, match=msg):
+ string_series.index = None
# wrong length
- pytest.raises(Exception, setattr, string_series, 'index',
- np.arange(len(string_series) - 1))
+ msg = (r"Length mismatch: Expected axis has (30|100) elements, new"
+ r" values have (29|99) elements")
+ with pytest.raises(ValueError, match=msg):
+ string_series.index = np.arange(len(string_series) - 1)
# works
string_series.index = np.arange(len(string_series))
diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py
index b5140a5319c01..6811e370726b2 100644
--- a/pandas/tests/series/test_analytics.py
+++ b/pandas/tests/series/test_analytics.py
@@ -97,8 +97,10 @@ def test_argsort_stable(self):
check_dtype=False)
tm.assert_series_equal(qindexer, Series(qexpected),
check_dtype=False)
- pytest.raises(AssertionError, tm.assert_numpy_array_equal,
- qindexer, mindexer)
+ msg = (r"ndarray Expected type <(class|type) 'numpy\.ndarray'>,"
+ r" found <class 'pandas\.core\.series\.Series'> instead")
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_numpy_array_equal(qindexer, mindexer)
def test_cumsum(self, datetime_series):
self._check_accum_op('cumsum', datetime_series)
@@ -476,8 +478,13 @@ def test_dot(self):
assert_almost_equal(a.dot(b['1']), expected['1'])
assert_almost_equal(a.dot(b2['1']), expected['1'])
- pytest.raises(Exception, a.dot, a.values[:3])
- pytest.raises(ValueError, a.dot, b.T)
+ msg = r"Dot product shape mismatch, \(4L?,\) vs \(3L?,\)"
+ # exception raised is of type Exception
+ with pytest.raises(Exception, match=msg):
+ a.dot(a.values[:3])
+ msg = "matrices are not aligned"
+ with pytest.raises(ValueError, match=msg):
+ a.dot(b.T)
@pytest.mark.skipif(not PY35,
reason='matmul supported for Python>=3.5')
@@ -541,8 +548,13 @@ def test_matmul(self):
index=['1', '2', '3'])
assert_series_equal(result, expected)
- pytest.raises(Exception, a.dot, a.values[:3])
- pytest.raises(ValueError, a.dot, b.T)
+ msg = r"Dot product shape mismatch, \(4,\) vs \(3,\)"
+ # exception raised is of type Exception
+ with pytest.raises(Exception, match=msg):
+ a.dot(a.values[:3])
+ msg = "matrices are not aligned"
+ with pytest.raises(ValueError, match=msg):
+ a.dot(b.T)
def test_clip(self, datetime_series):
val = datetime_series.median()
@@ -697,11 +709,13 @@ def test_isin(self):
def test_isin_with_string_scalar(self):
# GH4763
s = Series(['A', 'B', 'C', 'a', 'B', 'B', 'A', 'C'])
- with pytest.raises(TypeError):
+ msg = (r"only list-like objects are allowed to be passed to isin\(\),"
+ r" you passed a \[str\]")
+ with pytest.raises(TypeError, match=msg):
s.isin('a')
- with pytest.raises(TypeError):
- s = Series(['aaa', 'b', 'c'])
+ s = Series(['aaa', 'b', 'c'])
+ with pytest.raises(TypeError, match=msg):
s.isin('aaa')
def test_isin_with_i8(self):
@@ -771,18 +785,21 @@ def test_ptp(self):
with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
tm.assert_series_equal(s.ptp(level=0, skipna=False), expected)
- with pytest.raises(ValueError):
+ msg = r"No axis named 1 for object type <(class|type) 'type'>"
+ with pytest.raises(ValueError, match=msg):
with tm.assert_produces_warning(FutureWarning,
check_stacklevel=False):
s.ptp(axis=1)
s = pd.Series(['a', 'b', 'c', 'd', 'e'])
- with pytest.raises(TypeError):
+ msg = r"unsupported operand type\(s\) for -: 'str' and 'str'"
+ with pytest.raises(TypeError, match=msg):
with tm.assert_produces_warning(FutureWarning,
check_stacklevel=False):
s.ptp()
- with pytest.raises(NotImplementedError):
+ msg = r"Series\.ptp does not implement numeric_only\."
+ with pytest.raises(NotImplementedError, match=msg):
with tm.assert_produces_warning(FutureWarning,
check_stacklevel=False):
s.ptp(numeric_only=True)
@@ -1103,20 +1120,27 @@ def test_validate_any_all_out_keepdims_raises(self, kwargs, func):
param = list(kwargs)[0]
name = func.__name__
- msg = "the '{}' parameter .* {}".format(param, name)
+ msg = (r"the '{arg}' parameter is not "
+ r"supported in the pandas "
+ r"implementation of {fname}\(\)").format(arg=param, fname=name)
with pytest.raises(ValueError, match=msg):
func(s, **kwargs)
@td.skip_if_np_lt_115
def test_validate_sum_initial(self):
s = pd.Series([1, 2])
- with pytest.raises(ValueError, match="the 'initial' .* sum"):
+ msg = (r"the 'initial' parameter is not "
+ r"supported in the pandas "
+ r"implementation of sum\(\)")
+ with pytest.raises(ValueError, match=msg):
np.sum(s, initial=10)
def test_validate_median_initial(self):
s = pd.Series([1, 2])
- with pytest.raises(ValueError,
- match="the 'overwrite_input' .* median"):
+ msg = (r"the 'overwrite_input' parameter is not "
+ r"supported in the pandas "
+ r"implementation of median\(\)")
+ with pytest.raises(ValueError, match=msg):
# It seems like np.median doesn't dispatch, so we use the
# method instead of the ufunc.
s.median(overwrite_input=True)
@@ -1124,8 +1148,10 @@ def test_validate_median_initial(self):
@td.skip_if_np_lt_115
def test_validate_stat_keepdims(self):
s = pd.Series([1, 2])
- with pytest.raises(ValueError,
- match="the 'keepdims'"):
+ msg = (r"the 'keepdims' parameter is not "
+ r"supported in the pandas "
+ r"implementation of sum\(\)")
+ with pytest.raises(ValueError, match=msg):
np.sum(s, keepdims=True)
diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py
index c95cf125e22f7..1f2e2b179c687 100644
--- a/pandas/tests/series/test_api.py
+++ b/pandas/tests/series/test_api.py
@@ -289,8 +289,11 @@ def test_index_tab_completion(self, index):
def test_not_hashable(self):
s_empty = Series()
s = Series([1])
- pytest.raises(TypeError, hash, s_empty)
- pytest.raises(TypeError, hash, s)
+ msg = "'Series' objects are mutable, thus they cannot be hashed"
+ with pytest.raises(TypeError, match=msg):
+ hash(s_empty)
+ with pytest.raises(TypeError, match=msg):
+ hash(s)
def test_contains(self):
tm.assert_contains_all(self.ts.index, self.ts)
@@ -333,7 +336,8 @@ def test_items(self):
def test_raise_on_info(self):
s = Series(np.random.randn(10))
- with pytest.raises(AttributeError):
+ msg = "'Series' object has no attribute 'info'"
+ with pytest.raises(AttributeError, match=msg):
s.info()
def test_copy(self):
@@ -555,15 +559,17 @@ def test_cat_accessor_updates_on_inplace(self):
def test_categorical_delegations(self):
# invalid accessor
- pytest.raises(AttributeError, lambda: Series([1, 2, 3]).cat)
- with pytest.raises(AttributeError,
- match=(r"Can only use .cat accessor "
- r"with a 'category' dtype")):
+ msg = r"Can only use \.cat accessor with a 'category' dtype"
+ with pytest.raises(AttributeError, match=msg):
+ Series([1, 2, 3]).cat
+ with pytest.raises(AttributeError, match=msg):
Series([1, 2, 3]).cat()
- pytest.raises(AttributeError, lambda: Series(['a', 'b', 'c']).cat)
- pytest.raises(AttributeError, lambda: Series(np.arange(5.)).cat)
- pytest.raises(AttributeError,
- lambda: Series([Timestamp('20130101')]).cat)
+ with pytest.raises(AttributeError, match=msg):
+ Series(['a', 'b', 'c']).cat
+ with pytest.raises(AttributeError, match=msg):
+ Series(np.arange(5.)).cat
+ with pytest.raises(AttributeError, match=msg):
+ Series([Timestamp('20130101')]).cat
# Series should delegate calls to '.categories', '.codes', '.ordered'
# and the methods '.set_categories()' 'drop_unused_categories()' to the
@@ -605,10 +611,10 @@ def test_categorical_delegations(self):
# This method is likely to be confused, so test that it raises an error
# on wrong inputs:
- def f():
+ msg = "'Series' object has no attribute 'set_categories'"
+ with pytest.raises(AttributeError, match=msg):
s.set_categories([4, 3, 2, 1])
- pytest.raises(Exception, f)
# right: s.cat.set_categories([4,3,2,1])
# GH18862 (let Series.cat.rename_categories take callables)
diff --git a/pandas/tests/series/test_combine_concat.py b/pandas/tests/series/test_combine_concat.py
index e13cb9edffe2b..45e3dffde60f7 100644
--- a/pandas/tests/series/test_combine_concat.py
+++ b/pandas/tests/series/test_combine_concat.py
@@ -25,8 +25,9 @@ def test_append(self, datetime_series, string_series, object_series):
else:
raise AssertionError("orphaned index!")
- pytest.raises(ValueError, datetime_series.append, datetime_series,
- verify_integrity=True)
+ msg = "Indexes have overlapping values:"
+ with pytest.raises(ValueError, match=msg):
+ datetime_series.append(datetime_series, verify_integrity=True)
def test_append_many(self, datetime_series):
pieces = [datetime_series[:5], datetime_series[5:10],
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index fa303c904440c..d92ca48751d0a 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -65,8 +65,10 @@ def test_constructor(self, datetime_series, empty_series):
assert not empty_series.index.is_all_dates
assert not Series({}).index.is_all_dates
- pytest.raises(Exception, Series, np.random.randn(3, 3),
- index=np.arange(3))
+
+ # exception raised is of type Exception
+ with pytest.raises(Exception, match="Data must be 1-dimensional"):
+ Series(np.random.randn(3, 3), index=np.arange(3))
mixed.name = 'Series'
rs = Series(mixed).name
@@ -75,7 +77,9 @@ def test_constructor(self, datetime_series, empty_series):
# raise on MultiIndex GH4187
m = MultiIndex.from_arrays([[1, 2], [3, 4]])
- pytest.raises(NotImplementedError, Series, m)
+ msg = "initializing a Series from a MultiIndex is not supported"
+ with pytest.raises(NotImplementedError, match=msg):
+ Series(m)
@pytest.mark.parametrize('input_class', [list, dict, OrderedDict])
def test_constructor_empty(self, input_class):
@@ -495,7 +499,9 @@ def test_constructor_broadcast_list(self):
# GH 19342
# construction with single-element container and index
# should raise
- pytest.raises(ValueError, Series, ['foo'], index=['a', 'b', 'c'])
+ msg = "Length of passed values is 1, index implies 3"
+ with pytest.raises(ValueError, match=msg):
+ Series(['foo'], index=['a', 'b', 'c'])
def test_constructor_corner(self):
df = tm.makeTimeDataFrame()
@@ -675,10 +681,17 @@ def test_constructor_dtype_datetime64(self):
assert s.dtype == 'M8[ns]'
# GH3414 related
+ # msg = (r"cannot astype a datetimelike from \[datetime64\[ns\]\] to"
+ # r" \[int32\]")
+ # with pytest.raises(TypeError, match=msg):
+ # Series(Series(dates).astype('int') / 1000000, dtype='M8[ms]')
pytest.raises(TypeError, lambda x: Series(
Series(dates).astype('int') / 1000000, dtype='M8[ms]'))
- pytest.raises(TypeError,
- lambda x: Series(dates, dtype='datetime64'))
+
+ msg = (r"The 'datetime64' dtype has no unit\. Please pass in"
+ r" 'datetime64\[ns\]' instead\.")
+ with pytest.raises(ValueError, match=msg):
+ Series(dates, dtype='datetime64')
# invalid dates can be help as object
result = Series([datetime(2, 1, 1)])
@@ -984,9 +997,11 @@ def test_constructor_dict_of_tuples(self):
def test_constructor_set(self):
values = {1, 2, 3, 4, 5}
- pytest.raises(TypeError, Series, values)
+ with pytest.raises(TypeError, match="'set' type is unordered"):
+ Series(values)
values = frozenset(values)
- pytest.raises(TypeError, Series, values)
+ with pytest.raises(TypeError, match="'frozenset' type is unordered"):
+ Series(values)
# https://github.com/pandas-dev/pandas/issues/22698
@pytest.mark.filterwarnings("ignore:elementwise comparison:FutureWarning")
@@ -1081,14 +1096,16 @@ def test_constructor_dtype_timedelta64(self):
td.astype('int64')
# invalid casting
- pytest.raises(TypeError, td.astype, 'int32')
+ msg = (r"cannot astype a timedelta from \[timedelta64\[ns\]\] to"
+ r" \[int32\]")
+ with pytest.raises(TypeError, match=msg):
+ td.astype('int32')
# this is an invalid casting
- def f():
+ msg = "Could not convert object to NumPy timedelta"
+ with pytest.raises(ValueError, match=msg):
Series([timedelta(days=1), 'foo'], dtype='m8[ns]')
- pytest.raises(Exception, f)
-
# leave as object here
td = Series([timedelta(days=i) for i in range(3)] + ['foo'])
assert td.dtype == 'object'
@@ -1134,9 +1151,11 @@ def test_constructor_name_hashable(self):
assert s.name == n
def test_constructor_name_unhashable(self):
+ msg = r"Series\.name must be a hashable type"
for n in [['name_list'], np.ones(2), {1: 2}]:
for data in [['name_list'], np.ones(2), {1: 2}]:
- pytest.raises(TypeError, Series, data, name=n)
+ with pytest.raises(TypeError, match=msg):
+ Series(data, name=n)
def test_auto_conversion(self):
series = Series(list(date_range('1/1/2000', periods=10)))
diff --git a/pandas/tests/series/test_dtypes.py b/pandas/tests/series/test_dtypes.py
index 2bc009c5a2fc8..5ec3f69e55fde 100644
--- a/pandas/tests/series/test_dtypes.py
+++ b/pandas/tests/series/test_dtypes.py
@@ -74,7 +74,8 @@ def test_astype_cast_nan_inf_int(self, dtype, value):
@pytest.mark.parametrize("dtype", [int, np.int8, np.int64])
def test_astype_cast_object_int_fail(self, dtype):
arr = Series(["car", "house", "tree", "1"])
- with pytest.raises(ValueError):
+ msg = r"invalid literal for (int|long)\(\) with base 10: 'car'"
+ with pytest.raises(ValueError, match=msg):
arr.astype(dtype)
def test_astype_cast_object_int(self):
@@ -213,17 +214,19 @@ def test_astype_dict_like(self, dtype_class):
tm.assert_series_equal(result, expected)
dt3 = dtype_class({'abc': str, 'def': str})
- with pytest.raises(KeyError):
+ msg = ("Only the Series name can be used for the key in Series dtype"
+ r" mappings\.")
+ with pytest.raises(KeyError, match=msg):
s.astype(dt3)
dt4 = dtype_class({0: str})
- with pytest.raises(KeyError):
+ with pytest.raises(KeyError, match=msg):
s.astype(dt4)
# GH16717
# if dtypes provided is empty, it should error
dt5 = dtype_class({})
- with pytest.raises(KeyError):
+ with pytest.raises(KeyError, match=msg):
s.astype(dt5)
def test_astype_categories_deprecation(self):
@@ -288,7 +291,10 @@ def test_astype_categorical_to_other(self):
expected = s
tm.assert_series_equal(s.astype('category'), expected)
tm.assert_series_equal(s.astype(CategoricalDtype()), expected)
- pytest.raises(ValueError, lambda: s.astype('float64'))
+ msg = (r"could not convert string to float: '(0 - 499|9500 - 9999)'|"
+ r"invalid literal for float\(\): 9500 - 9999")
+ with pytest.raises(ValueError, match=msg):
+ s.astype('float64')
cat = Series(Categorical(['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c']))
exp = Series(['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c'])
@@ -324,9 +330,12 @@ def cmp(a, b):
tm.assert_series_equal(result, s, check_categorical=False)
# invalid conversion (these are NOT a dtype)
+ msg = (r"invalid type <class 'pandas\.core\.arrays\.categorical\."
+ "Categorical'> for astype")
for invalid in [lambda x: x.astype(Categorical),
lambda x: x.astype('object').astype(Categorical)]:
- pytest.raises(TypeError, lambda: invalid(s))
+ with pytest.raises(TypeError, match=msg):
+ invalid(s)
@pytest.mark.parametrize('name', [None, 'foo'])
@pytest.mark.parametrize('dtype_ordered', [True, False])
@@ -387,11 +396,14 @@ def test_astype_categoricaldtype_with_args(self):
s = Series(['a', 'b'])
type_ = CategoricalDtype(['a', 'b'])
- with pytest.raises(TypeError):
+ msg = (r"Cannot specify a CategoricalDtype and also `categories` or"
+ r" `ordered`\. Use `dtype=CategoricalDtype\(categories,"
+ r" ordered\)` instead\.")
+ with pytest.raises(TypeError, match=msg):
s.astype(type_, ordered=True)
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
s.astype(type_, categories=['a', 'b'])
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
s.astype(type_, categories=['a', 'b'], ordered=False)
@pytest.mark.parametrize("dtype", [
@@ -435,7 +447,9 @@ def test_arg_for_errors_in_astype(self):
# see gh-14878
s = Series([1, 2, 3])
- with pytest.raises(ValueError):
+ msg = (r"Expected value of kwarg 'errors' to be one of \['raise',"
+ r" 'ignore'\]\. Supplied value is 'False'")
+ with pytest.raises(ValueError, match=msg):
s.astype(np.float64, errors=False)
s.astype(np.int8, errors='raise')
diff --git a/pandas/tests/series/test_internals.py b/pandas/tests/series/test_internals.py
index 772617c494aef..26b868872ee0d 100644
--- a/pandas/tests/series/test_internals.py
+++ b/pandas/tests/series/test_internals.py
@@ -293,7 +293,9 @@ def test_convert(self):
def test_convert_no_arg_error(self):
s = Series(['1.0', '2'])
- pytest.raises(ValueError, s._convert)
+ msg = r"At least one of datetime, numeric or timedelta must be True\."
+ with pytest.raises(ValueError, match=msg):
+ s._convert()
def test_convert_preserve_bool(self):
s = Series([1, True, 3, 5], dtype=object)
diff --git a/pandas/tests/series/test_missing.py b/pandas/tests/series/test_missing.py
index f4f16ff2d3ac1..985288c439917 100644
--- a/pandas/tests/series/test_missing.py
+++ b/pandas/tests/series/test_missing.py
@@ -360,14 +360,24 @@ def test_fillna_int(self):
def test_fillna_raise(self):
s = Series(np.random.randint(-100, 100, 50))
- pytest.raises(TypeError, s.fillna, [1, 2])
- pytest.raises(TypeError, s.fillna, (1, 2))
+ msg = ('"value" parameter must be a scalar or dict, but you passed a'
+ ' "list"')
+ with pytest.raises(TypeError, match=msg):
+ s.fillna([1, 2])
+
+ msg = ('"value" parameter must be a scalar or dict, but you passed a'
+ ' "tuple"')
+ with pytest.raises(TypeError, match=msg):
+ s.fillna((1, 2))
# related GH 9217, make sure limit is an int and greater than 0
s = Series([1, 2, 3, None])
+ msg = (r"Cannot specify both 'value' and 'method'\.|"
+ r"Limit must be greater than 0|"
+ "Limit must be an integer")
for limit in [-1, 0, 1., 2.]:
for method in ['backfill', 'bfill', 'pad', 'ffill', None]:
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
s.fillna(1, limit=limit, method=method)
def test_categorical_nan_equality(self):
@@ -508,9 +518,13 @@ def test_fillna(self, datetime_series):
exp = Series([0., 1., 5., 3., 4.], index=ts.index)
tm.assert_series_equal(ts.fillna(value=5), exp)
- pytest.raises(ValueError, ts.fillna)
- pytest.raises(ValueError, datetime_series.fillna, value=0,
- method='ffill')
+ msg = "Must specify a fill 'value' or 'method'"
+ with pytest.raises(ValueError, match=msg):
+ ts.fillna()
+
+ msg = "Cannot specify both 'value' and 'method'"
+ with pytest.raises(ValueError, match=msg):
+ datetime_series.fillna(value=0, method='ffill')
# GH 5703
s1 = Series([np.nan])
@@ -647,7 +661,9 @@ def test_dropna_empty(self):
assert len(s) == 0
# invalid axis
- pytest.raises(ValueError, s.dropna, axis=1)
+ msg = r"No axis named 1 for object type <(class|type) 'type'>"
+ with pytest.raises(ValueError, match=msg):
+ s.dropna(axis=1)
def test_datetime64_tz_dropna(self):
# DatetimeBlock
@@ -736,7 +752,9 @@ def test_pad_require_monotonicity(self):
# neither monotonic increasing or decreasing
rng2 = rng[[1, 0, 2]]
- pytest.raises(ValueError, rng2.get_indexer, rng, method='pad')
+ msg = "index must be monotonic increasing or decreasing"
+ with pytest.raises(ValueError, match=msg):
+ rng2.get_indexer(rng, method='pad')
def test_dropna_preserve_name(self, datetime_series):
datetime_series[:5] = np.nan
@@ -861,7 +879,10 @@ def test_interpolate(self, datetime_series, string_series):
# Only raises ValueError if there are NaNs.
non_ts = string_series.copy()
non_ts[0] = np.NaN
- pytest.raises(ValueError, non_ts.interpolate, method='time')
+ msg = ("time-weighted interpolation only works on Series or DataFrames"
+ " with a DatetimeIndex")
+ with pytest.raises(ValueError, match=msg):
+ non_ts.interpolate(method='time')
@td.skip_if_no_scipy
def test_interpolate_pchip(self):
@@ -956,7 +977,9 @@ def test_interpolate_index_values(self):
def test_interpolate_non_ts(self):
s = Series([1, 3, np.nan, np.nan, np.nan, 11])
- with pytest.raises(ValueError):
+ msg = ("time-weighted interpolation only works on Series or DataFrames"
+ " with a DatetimeIndex")
+ with pytest.raises(ValueError, match=msg):
s.interpolate(method='time')
@pytest.mark.parametrize("kwargs", [
@@ -1044,9 +1067,14 @@ def test_interp_limit(self):
'polynomial', 'spline', 'piecewise_polynomial', None,
'from_derivatives', 'pchip', 'akima']
s = pd.Series([1, 2, np.nan, np.nan, 5])
+ msg = (r"Limit must be greater than 0|"
+ "time-weighted interpolation only works on Series or"
+ r" DataFrames with a DatetimeIndex|"
+ r"invalid method '(polynomial|spline|None)' to interpolate|"
+ "Limit must be an integer")
for limit in [-1, 0, 1., 2.]:
for method in methods:
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
s.interpolate(limit=limit, method=method)
def test_interp_limit_forward(self):
@@ -1084,12 +1112,14 @@ def test_interp_unlimited(self):
def test_interp_limit_bad_direction(self):
s = Series([1, 3, np.nan, np.nan, np.nan, 11])
- pytest.raises(ValueError, s.interpolate, method='linear', limit=2,
- limit_direction='abc')
+ msg = (r"Invalid limit_direction: expecting one of \['forward',"
+ r" 'backward', 'both'\], got 'abc'")
+ with pytest.raises(ValueError, match=msg):
+ s.interpolate(method='linear', limit=2, limit_direction='abc')
# raises an error even if no limit is specified.
- pytest.raises(ValueError, s.interpolate, method='linear',
- limit_direction='abc')
+ with pytest.raises(ValueError, match=msg):
+ s.interpolate(method='linear', limit_direction='abc')
# limit_area introduced GH #16284
def test_interp_limit_area(self):
@@ -1127,8 +1157,10 @@ def test_interp_limit_area(self):
direction='backward')
# raises an error even if limit type is wrong.
- pytest.raises(ValueError, s.interpolate, method='linear',
- limit_area='abc')
+ msg = (r"Invalid limit_area: expecting one of \['inside', 'outside'\],"
+ " got abc")
+ with pytest.raises(ValueError, match=msg):
+ s.interpolate(method='linear', limit_area='abc')
def test_interp_limit_direction(self):
# These tests are for issue #9218 -- fill NaNs in both directions.
@@ -1214,14 +1246,16 @@ def test_interp_multiIndex(self, check_scipy):
result = s.interpolate()
assert_series_equal(result, expected)
+ msg = "Only `method=linear` interpolation is supported on MultiIndexes"
if check_scipy:
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
s.interpolate(method='polynomial', order=1)
@td.skip_if_no_scipy
def test_interp_nonmono_raise(self):
s = Series([1, np.nan, 3], index=[0, 2, 1])
- with pytest.raises(ValueError):
+ msg = "krogh interpolation requires that the index be monotonic"
+ with pytest.raises(ValueError, match=msg):
s.interpolate(method='krogh')
@td.skip_if_no_scipy
@@ -1243,7 +1277,8 @@ def test_interp_limit_no_nans(self):
@pytest.mark.parametrize("method", ['polynomial', 'spline'])
def test_no_order(self, method):
s = Series([0, 1, np.nan, 3])
- with pytest.raises(ValueError):
+ msg = "invalid method '{}' to interpolate".format(method)
+ with pytest.raises(ValueError, match=msg):
s.interpolate(method=method)
@td.skip_if_no_scipy
@@ -1283,10 +1318,12 @@ def test_spline_error(self):
# see gh-10633
s = pd.Series(np.arange(10) ** 2)
s[np.random.randint(0, 9, 3)] = np.nan
- with pytest.raises(ValueError):
+ msg = "invalid method 'spline' to interpolate"
+ with pytest.raises(ValueError, match=msg):
s.interpolate(method='spline')
- with pytest.raises(ValueError):
+ msg = "order needs to be specified and greater than 0"
+ with pytest.raises(ValueError, match=msg):
s.interpolate(method='spline', order=0)
def test_interp_timedelta64(self):
diff --git a/pandas/tests/series/test_rank.py b/pandas/tests/series/test_rank.py
index da414a577ae0b..510a51e002918 100644
--- a/pandas/tests/series/test_rank.py
+++ b/pandas/tests/series/test_rank.py
@@ -206,7 +206,9 @@ def test_rank_categorical(self):
def test_rank_signature(self):
s = Series([0, 1])
s.rank(method='average')
- pytest.raises(ValueError, s.rank, 'average')
+ msg = r"No axis named average for object type <(class|type) 'type'>"
+ with pytest.raises(ValueError, match=msg):
+ s.rank('average')
@pytest.mark.parametrize('contents,dtype', [
([-np.inf, -50, -1, -1e-20, -1e-25, -1e-50, 0, 1e-40, 1e-20, 1e-10,
diff --git a/pandas/tests/series/test_replace.py b/pandas/tests/series/test_replace.py
index 3a9c210017625..40b28047080da 100644
--- a/pandas/tests/series/test_replace.py
+++ b/pandas/tests/series/test_replace.py
@@ -73,7 +73,9 @@ def test_replace(self):
tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
# malformed
- pytest.raises(ValueError, ser.replace, [1, 2, 3], [np.nan, 0])
+ msg = r"Replacement lists must match in length\. Expecting 3 got 2"
+ with pytest.raises(ValueError, match=msg):
+ ser.replace([1, 2, 3], [np.nan, 0])
# make sure that we aren't just masking a TypeError because bools don't
# implement indexing
@@ -125,7 +127,9 @@ def test_replace_with_single_list(self):
# make sure things don't get corrupted when fillna call fails
s = ser.copy()
- with pytest.raises(ValueError):
+ msg = (r"Invalid fill method\. Expecting pad \(ffill\) or backfill"
+ r" \(bfill\)\. Got crash_cymbal")
+ with pytest.raises(ValueError, match=msg):
s.replace([1, 2, 3], inplace=True, method='crash_cymbal')
tm.assert_series_equal(s, ser)
diff --git a/pandas/tests/series/test_sorting.py b/pandas/tests/series/test_sorting.py
index ef6998c1a3e12..216f84c8f077a 100644
--- a/pandas/tests/series/test_sorting.py
+++ b/pandas/tests/series/test_sorting.py
@@ -55,16 +55,21 @@ def test_sort_values(self):
expected = ts.sort_values(ascending=False, na_position='first')
assert_series_equal(expected, ordered)
- pytest.raises(ValueError,
- lambda: ts.sort_values(ascending=None))
- pytest.raises(ValueError,
- lambda: ts.sort_values(ascending=[]))
- pytest.raises(ValueError,
- lambda: ts.sort_values(ascending=[1, 2, 3]))
- pytest.raises(ValueError,
- lambda: ts.sort_values(ascending=[False, False]))
- pytest.raises(ValueError,
- lambda: ts.sort_values(ascending='foobar'))
+ msg = "ascending must be boolean"
+ with pytest.raises(ValueError, match=msg):
+ ts.sort_values(ascending=None)
+ msg = r"Length of ascending \(0\) must be 1 for Series"
+ with pytest.raises(ValueError, match=msg):
+ ts.sort_values(ascending=[])
+ msg = r"Length of ascending \(3\) must be 1 for Series"
+ with pytest.raises(ValueError, match=msg):
+ ts.sort_values(ascending=[1, 2, 3])
+ msg = r"Length of ascending \(2\) must be 1 for Series"
+ with pytest.raises(ValueError, match=msg):
+ ts.sort_values(ascending=[False, False])
+ msg = "ascending must be boolean"
+ with pytest.raises(ValueError, match=msg):
+ ts.sort_values(ascending='foobar')
# inplace=True
ts = self.ts.copy()
@@ -78,11 +83,11 @@ def test_sort_values(self):
df = DataFrame(np.random.randn(10, 4))
s = df.iloc[:, 0]
- def f():
+ msg = ("This Series is a view of some other array, to sort in-place"
+ " you must create a copy")
+ with pytest.raises(ValueError, match=msg):
s.sort_values(inplace=True)
- pytest.raises(ValueError, f)
-
def test_sort_index(self):
rindex = list(self.ts.index)
random.shuffle(rindex)
@@ -104,13 +109,15 @@ def test_sort_index(self):
sorted_series = random_order.sort_index(axis=0)
assert_series_equal(sorted_series, self.ts)
- pytest.raises(ValueError, lambda: random_order.sort_values(axis=1))
+ msg = r"No axis named 1 for object type <(class|type) 'type'>"
+ with pytest.raises(ValueError, match=msg):
+ random_order.sort_values(axis=1)
sorted_series = random_order.sort_index(level=0, axis=0)
assert_series_equal(sorted_series, self.ts)
- pytest.raises(ValueError,
- lambda: random_order.sort_index(level=0, axis=1))
+ with pytest.raises(ValueError, match=msg):
+ random_order.sort_index(level=0, axis=1)
def test_sort_index_inplace(self):
diff --git a/pandas/tests/series/test_timeseries.py b/pandas/tests/series/test_timeseries.py
index 07808008c081c..d082b023e1f27 100644
--- a/pandas/tests/series/test_timeseries.py
+++ b/pandas/tests/series/test_timeseries.py
@@ -7,6 +7,7 @@
import pytest
from pandas._libs.tslib import iNaT
+from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime
from pandas.compat import StringIO, lrange, product
from pandas.errors import NullFrequencyError
import pandas.util._test_decorators as td
@@ -78,7 +79,8 @@ def test_shift(self):
assert_series_equal(shifted2, shifted3)
assert_series_equal(ps, shifted2.shift(-1, 'B'))
- with pytest.raises(ValueError):
+ msg = "Given freq D does not match PeriodIndex freq B"
+ with pytest.raises(ValueError, match=msg):
ps.shift(freq='D')
# legacy support
@@ -110,7 +112,9 @@ def test_shift(self):
# incompat tz
s2 = Series(date_range('2000-01-01 09:00:00', periods=5,
tz='CET'), name='foo')
- with pytest.raises(TypeError):
+ msg = ("DatetimeArray subtraction must have the same timezones or no"
+ " timezones")
+ with pytest.raises(TypeError, match=msg):
s - s2
def test_shift2(self):
@@ -127,7 +131,9 @@ def test_shift2(self):
tm.assert_index_equal(result.index, exp_index)
idx = DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-04'])
- pytest.raises(NullFrequencyError, idx.shift, 1)
+ msg = "Cannot shift with no freq"
+ with pytest.raises(NullFrequencyError, match=msg):
+ idx.shift(1)
def test_shift_fill_value(self):
# GH #24128
@@ -158,7 +164,8 @@ def test_categorical_shift_fill_value(self):
tm.assert_equal(res, expected)
# check for incorrect fill_value
- with pytest.raises(ValueError):
+ msg = "'fill_value=f' is not present in this Categorical's categories"
+ with pytest.raises(ValueError, match=msg):
ts.shift(1, fill_value='f')
def test_shift_dst(self):
@@ -202,7 +209,8 @@ def test_tshift(self):
shifted3 = ps.tshift(freq=BDay())
assert_series_equal(shifted, shifted3)
- with pytest.raises(ValueError):
+ msg = "Given freq M does not match PeriodIndex freq B"
+ with pytest.raises(ValueError, match=msg):
ps.tshift(freq='M')
# DatetimeIndex
@@ -222,7 +230,8 @@ def test_tshift(self):
assert_series_equal(unshifted, inferred_ts)
no_freq = self.ts[[0, 5, 7]]
- with pytest.raises(ValueError):
+ msg = "Freq was not given and was not set in the index"
+ with pytest.raises(ValueError, match=msg):
no_freq.tshift()
def test_truncate(self):
@@ -271,9 +280,10 @@ def test_truncate(self):
truncated = ts.truncate(before=self.ts.index[-1] + offset)
assert (len(truncated) == 0)
- pytest.raises(ValueError, ts.truncate,
- before=self.ts.index[-1] + offset,
- after=self.ts.index[0] - offset)
+ msg = "Truncate: 1999-12-31 00:00:00 must be after 2000-02-14 00:00:00"
+ with pytest.raises(ValueError, match=msg):
+ ts.truncate(before=self.ts.index[-1] + offset,
+ after=self.ts.index[0] - offset)
def test_truncate_nonsortedindex(self):
# GH 17935
@@ -553,9 +563,11 @@ def test_to_datetime_unit(self):
Timestamp('1970-01-03')] + ['NaT'] * 3)
tm.assert_index_equal(result, expected)
- with pytest.raises(ValueError):
+ msg = "non convertible value foo with the unit 'D'"
+ with pytest.raises(ValueError, match=msg):
to_datetime([1, 2, 'foo'], unit='D')
- with pytest.raises(ValueError):
+ msg = "cannot convert input 111111111 with the unit 'D'"
+ with pytest.raises(OutOfBoundsDatetime, match=msg):
to_datetime([1, 2, 111111111], unit='D')
# coerce we can process
@@ -660,7 +672,8 @@ def test_first_subset(self):
def test_first_raises(self):
# GH20725
ser = pd.Series('a b c'.split())
- with pytest.raises(TypeError): # index is not a DatetimeIndex
+ msg = "'first' only supports a DatetimeIndex index"
+ with pytest.raises(TypeError, match=msg):
ser.first('1D')
def test_last_subset(self):
@@ -686,7 +699,8 @@ def test_last_subset(self):
def test_last_raises(self):
# GH20725
ser = pd.Series('a b c'.split())
- with pytest.raises(TypeError): # index is not a DatetimeIndex
+ msg = "'last' only supports a DatetimeIndex index"
+ with pytest.raises(TypeError, match=msg):
ser.last('1D')
def test_format_pre_1900_dates(self):
@@ -740,7 +754,8 @@ def test_at_time(self):
def test_at_time_raises(self):
# GH20725
ser = pd.Series('a b c'.split())
- with pytest.raises(TypeError): # index is not a DatetimeIndex
+ msg = "Index must be DatetimeIndex"
+ with pytest.raises(TypeError, match=msg):
ser.at_time('00:00')
def test_between(self):
@@ -814,23 +829,26 @@ def test_between_time(self):
def test_between_time_raises(self):
# GH20725
ser = pd.Series('a b c'.split())
- with pytest.raises(TypeError): # index is not a DatetimeIndex
+ msg = "Index must be DatetimeIndex"
+ with pytest.raises(TypeError, match=msg):
ser.between_time(start_time='00:00', end_time='12:00')
def test_between_time_types(self):
# GH11818
rng = date_range('1/1/2000', '1/5/2000', freq='5min')
- with pytest.raises(ValueError):
+ msg = (r"Cannot convert arg \[datetime\.datetime\(2010, 1, 2, 1, 0\)\]"
+ " to a time")
+ with pytest.raises(ValueError, match=msg):
rng.indexer_between_time(datetime(2010, 1, 2, 1),
datetime(2010, 1, 2, 5))
frame = DataFrame({'A': 0}, index=rng)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
frame.between_time(datetime(2010, 1, 2, 1),
datetime(2010, 1, 2, 5))
series = Series(0, index=rng)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
series.between_time(datetime(2010, 1, 2, 1),
datetime(2010, 1, 2, 5))
@@ -858,7 +876,9 @@ def test_between_time_axis(self):
assert len(ts.between_time(stime, etime)) == expected_length
assert len(ts.between_time(stime, etime, axis=0)) == expected_length
- pytest.raises(ValueError, ts.between_time, stime, etime, axis=1)
+ msg = r"No axis named 1 for object type <(class|type) 'type'>"
+ with pytest.raises(ValueError, match=msg):
+ ts.between_time(stime, etime, axis=1)
def test_to_period(self):
from pandas.core.indexes.period import period_range
| xref #24332 | https://api.github.com/repos/pandas-dev/pandas/pulls/24812 | 2019-01-17T00:44:31Z | 2019-01-17T12:48:42Z | 2019-01-17T12:48:42Z | 2019-01-20T22:35:09Z |
BUG: Offset-based rolling window, with only one raw in dataframe and closed='left', max and min functions make python crash | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 5213120b33f06..bcd1abba30a67 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1808,6 +1808,7 @@ Plotting
Groupby/Resample/Rolling
^^^^^^^^^^^^^^^^^^^^^^^^
+- Bug in :func:`pandas.core.window.Rolling.min` and :func:`pandas.core.window.Rolling.max` with ``closed='left'``, a datetime-like index and only one entry in the series leading to segfault (:issue:`24718`)
- Bug in :func:`pandas.core.groupby.GroupBy.first` and :func:`pandas.core.groupby.GroupBy.last` with ``as_index=False`` leading to the loss of timezone information (:issue:`15884`)
- Bug in :meth:`DateFrame.resample` when downsampling across a DST boundary (:issue:`8531`)
- Bug in date anchoring for :meth:`DateFrame.resample` with offset :class:`Day` when n > 1 (:issue:`24127`)
diff --git a/pandas/_libs/window.pyx b/pandas/_libs/window.pyx
index 5f2c0233a0f13..e8f3de64c3823 100644
--- a/pandas/_libs/window.pyx
+++ b/pandas/_libs/window.pyx
@@ -1339,7 +1339,10 @@ cdef _roll_min_max_variable(ndarray[numeric] values,
Q.push_back(i)
W.push_back(i)
- output[N-1] = calc_mm(minp, nobs, values[Q.front()])
+ if not Q.empty():
+ output[N-1] = calc_mm(minp, nobs, values[Q.front()])
+ else:
+ output[N-1] = NaN
return output
diff --git a/pandas/tests/test_window.py b/pandas/tests/test_window.py
index 412f70a3cb516..e816d4c04344a 100644
--- a/pandas/tests/test_window.py
+++ b/pandas/tests/test_window.py
@@ -520,6 +520,26 @@ def test_closed(self):
with pytest.raises(ValueError):
df.rolling(window=3, closed='neither')
+ @pytest.mark.parametrize("func", ['min', 'max'])
+ def test_closed_one_entry(self, func):
+ # GH24718
+ ser = pd.Series(data=[2], index=pd.date_range('2000', periods=1))
+ result = getattr(ser.rolling('10D', closed='left'), func)()
+ tm.assert_series_equal(result, pd.Series([np.nan], index=ser.index))
+
+ @pytest.mark.parametrize("func", ['min', 'max'])
+ def test_closed_one_entry_groupby(self, func):
+ # GH24718
+ ser = pd.DataFrame(data={'A': [1, 1, 2], 'B': [3, 2, 1]},
+ index=pd.date_range('2000', periods=3))
+ result = getattr(
+ ser.groupby('A', sort=False)['B'].rolling('10D', closed='left'),
+ func)()
+ exp_idx = pd.MultiIndex.from_arrays(arrays=[[1, 1, 2], ser.index],
+ names=('A', None))
+ expected = pd.Series(data=[np.nan, 3, np.nan], index=exp_idx, name='B')
+ tm.assert_series_equal(result, expected)
+
@pytest.mark.parametrize("input_dtype", ['int', 'float'])
@pytest.mark.parametrize("func,closed,expected", [
('min', 'right', [0.0, 0, 0, 1, 2, 3, 4, 5, 6, 7]),
| - [ ] closes #24718
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24811 | 2019-01-17T00:14:12Z | 2019-01-18T12:22:46Z | 2019-01-18T12:22:46Z | 2019-01-21T23:18:19Z |
TST/CLN: follow-up to #24750 | diff --git a/pandas/tests/series/indexing/test_boolean.py b/pandas/tests/series/indexing/test_boolean.py
index 89b481b92b73f..9017d13051b88 100644
--- a/pandas/tests/series/indexing/test_boolean.py
+++ b/pandas/tests/series/indexing/test_boolean.py
@@ -160,28 +160,22 @@ def test_where_unsafe_float(float_dtype):
assert_series_equal(s, expected)
-@pytest.mark.parametrize("dtype", [np.int64, np.float64])
-def test_where_unsafe_upcast(dtype):
- s = Series(np.arange(10), dtype=dtype)
- values = [2.5, 3.5, 4.5, 5.5, 6.5]
-
- mask = s < 5
- expected = Series(values + lrange(5, 10), dtype="float64")
-
- s[mask] = values
- assert_series_equal(s, expected)
-
-
-@pytest.mark.parametrize("dtype", [
- np.int8, np.int16, np.int32, np.float32
+@pytest.mark.parametrize("dtype,expected_dtype", [
+ (np.int8, np.float64),
+ (np.int16, np.float64),
+ (np.int32, np.float64),
+ (np.int64, np.float64),
+ (np.float32, np.float32),
+ (np.float64, np.float64)
])
-def test_where_upcast(dtype):
+def test_where_unsafe_upcast(dtype, expected_dtype):
# see gh-9743
s = Series(np.arange(10), dtype=dtype)
- mask = s < 5
-
values = [2.5, 3.5, 4.5, 5.5, 6.5]
+ mask = s < 5
+ expected = Series(values + lrange(5, 10), dtype=expected_dtype)
s[mask] = values
+ assert_series_equal(s, expected)
def test_where_unsafe():
| cc @jreback
`test_where_unsafe_itemsize_fail` changed to `test_where_upcast` in #24750
this follow-on PR merges `test_where_upcast` into `test_where_unsafe_upcast` to avoid duplication.
| https://api.github.com/repos/pandas-dev/pandas/pulls/24810 | 2019-01-16T21:44:38Z | 2019-01-17T12:55:12Z | 2019-01-17T12:55:12Z | 2019-01-20T22:36:01Z |
DEPR/API: Non-ns precision in Index constructors | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index fbc3c4fe4ce92..ff4aa9968f294 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1159,6 +1159,7 @@ Other API Changes
- :meth:`CategoricalIndex.reindex` now raises a ``ValueError`` if the target index is non-unique and not equal to the current index. It previously only raised if the target index was not of a categorical dtype (:issue:`23963`).
- :func:`Series.to_list` and :func:`Index.to_list` are now aliases of ``Series.tolist`` respectively ``Index.tolist`` (:issue:`8826`)
- The result of ``SparseSeries.unstack`` is now a :class:`DataFrame` with sparse values, rather than a :class:`SparseDataFrame` (:issue:`24372`).
+- :class:`DatetimeIndex` and :class:`TimedeltaIndex` no longer ignore the dtype precision. Passing a non-nanosecond resolution dtype will raise a ``ValueError`` (:issue:`24753`)
.. _whatsnew_0240.api.extension:
@@ -1259,6 +1260,7 @@ Deprecations
- :meth:`Series.nonzero` is deprecated and will be removed in a future version (:issue:`18262`)
- Passing an integer to :meth:`Series.fillna` and :meth:`DataFrame.fillna` with ``timedelta64[ns]`` dtypes is deprecated, will raise ``TypeError`` in a future version. Use ``obj.fillna(pd.Timedelta(...))`` instead (:issue:`24694`)
- ``Series.cat.categorical``, ``Series.cat.name`` and ``Sersies.cat.index`` have been deprecated. Use the attributes on ``Series.cat`` or ``Series`` directly. (:issue:`24751`).
+- Passing a dtype without a precision like ``np.dtype('datetime64')`` or ``timedelta64`` to :class:`Index`, :class:`DatetimeIndex` and :class:`TimedeltaIndex` is now deprecated. Use the nanosecond-precision dtype instead (:issue:`24753`).
.. _whatsnew_0240.deprecations.datetimelike_int_ops:
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index a2d67efbecbba..f2aeb1c1309de 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -1,5 +1,6 @@
# -*- coding: utf-8 -*-
from datetime import datetime, time, timedelta
+import textwrap
import warnings
import numpy as np
@@ -1986,6 +1987,15 @@ def _validate_dt64_dtype(dtype):
"""
if dtype is not None:
dtype = pandas_dtype(dtype)
+ if is_dtype_equal(dtype, np.dtype("M8")):
+ # no precision, warn
+ dtype = _NS_DTYPE
+ msg = textwrap.dedent("""\
+ Passing in 'datetime64' dtype with no precision is deprecated
+ and will raise in a future version. Please pass in
+ 'datetime64[ns]' instead.""")
+ warnings.warn(msg, FutureWarning, stacklevel=5)
+
if ((isinstance(dtype, np.dtype) and dtype != _NS_DTYPE)
or not isinstance(dtype, (np.dtype, DatetimeTZDtype))):
raise ValueError("Unexpected value for 'dtype': '{dtype}'. "
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index be1a7097b0e0d..910cb96a86216 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -2,6 +2,7 @@
from __future__ import division
from datetime import timedelta
+import textwrap
import warnings
import numpy as np
@@ -15,8 +16,8 @@
from pandas.util._decorators import Appender
from pandas.core.dtypes.common import (
- _NS_DTYPE, _TD_DTYPE, ensure_int64, is_datetime64_dtype, is_float_dtype,
- is_integer_dtype, is_list_like, is_object_dtype, is_scalar,
+ _NS_DTYPE, _TD_DTYPE, ensure_int64, is_datetime64_dtype, is_dtype_equal,
+ is_float_dtype, is_integer_dtype, is_list_like, is_object_dtype, is_scalar,
is_string_dtype, is_timedelta64_dtype, is_timedelta64_ns_dtype,
pandas_dtype)
from pandas.core.dtypes.dtypes import DatetimeTZDtype
@@ -160,16 +161,8 @@ def __init__(self, values, dtype=_TD_DTYPE, freq=None, copy=False):
# nanosecond UTC (or tz-naive) unix timestamps
values = values.view(_TD_DTYPE)
- if values.dtype != _TD_DTYPE:
- raise TypeError(_BAD_DTYPE.format(dtype=values.dtype))
-
- try:
- dtype_mismatch = dtype != _TD_DTYPE
- except TypeError:
- raise TypeError(_BAD_DTYPE.format(dtype=dtype))
- else:
- if dtype_mismatch:
- raise TypeError(_BAD_DTYPE.format(dtype=dtype))
+ _validate_td64_dtype(values.dtype)
+ dtype = _validate_td64_dtype(dtype)
if freq == "infer":
msg = (
@@ -204,9 +197,8 @@ def _simple_new(cls, values, freq=None, dtype=_TD_DTYPE):
@classmethod
def _from_sequence(cls, data, dtype=_TD_DTYPE, copy=False,
freq=None, unit=None):
- if dtype != _TD_DTYPE:
- raise ValueError("Only timedelta64[ns] dtype is valid.")
-
+ if dtype:
+ _validate_td64_dtype(dtype)
freq, freq_infer = dtl.maybe_infer_freq(freq)
data, inferred_freq = sequence_to_td64ns(data, copy=copy, unit=unit)
@@ -997,6 +989,22 @@ def objects_to_td64ns(data, unit="ns", errors="raise"):
return result.view('timedelta64[ns]')
+def _validate_td64_dtype(dtype):
+ dtype = pandas_dtype(dtype)
+ if is_dtype_equal(dtype, np.dtype("timedelta64")):
+ dtype = _TD_DTYPE
+ msg = textwrap.dedent("""\
+ Passing in 'timedelta' dtype with no precision is deprecated
+ and will raise in a future version. Please pass in
+ 'timedelta64[ns]' instead.""")
+ warnings.warn(msg, FutureWarning, stacklevel=4)
+
+ if not is_dtype_equal(dtype, _TD_DTYPE):
+ raise ValueError(_BAD_DTYPE.format(dtype=dtype))
+
+ return dtype
+
+
def _generate_regular_range(start, end, periods, offset):
stride = offset.nanos
if periods is None:
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 93091f5125b7c..767da81c5c43a 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -311,10 +311,14 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None,
elif (is_timedelta64_dtype(data) or
(dtype is not None and is_timedelta64_dtype(dtype))):
from pandas import TimedeltaIndex
- result = TimedeltaIndex(data, copy=copy, name=name, **kwargs)
- if dtype is not None and _o_dtype == dtype:
- return Index(result.to_pytimedelta(), dtype=_o_dtype)
+ if dtype is not None and is_dtype_equal(_o_dtype, dtype):
+ # Note we can pass copy=False because the .astype below
+ # will always make a copy
+ result = TimedeltaIndex(data, copy=False, name=name, **kwargs)
+ return result.astype(object)
else:
+ result = TimedeltaIndex(data, copy=copy, name=name,
+ dtype=dtype, **kwargs)
return result
elif is_period_dtype(data) and not is_object_dtype(dtype):
diff --git a/pandas/tests/arrays/test_timedeltas.py b/pandas/tests/arrays/test_timedeltas.py
index a8745f78392ca..6b4662ca02e80 100644
--- a/pandas/tests/arrays/test_timedeltas.py
+++ b/pandas/tests/arrays/test_timedeltas.py
@@ -23,18 +23,18 @@ def test_non_array_raises(self):
TimedeltaArray([1, 2, 3])
def test_other_type_raises(self):
- with pytest.raises(TypeError,
+ with pytest.raises(ValueError,
match="dtype bool cannot be converted"):
TimedeltaArray(np.array([1, 2, 3], dtype='bool'))
def test_incorrect_dtype_raises(self):
# TODO: why TypeError for 'category' but ValueError for i8?
- with pytest.raises(TypeError,
+ with pytest.raises(ValueError,
match=r'category cannot be converted '
r'to timedelta64\[ns\]'):
TimedeltaArray(np.array([1, 2, 3], dtype='i8'), dtype='category')
- with pytest.raises(TypeError,
+ with pytest.raises(ValueError,
match=r"dtype int64 cannot be converted "
r"to timedelta64\[ns\]"):
TimedeltaArray(np.array([1, 2, 3], dtype='i8'),
@@ -52,7 +52,7 @@ def test_copy(self):
class TestTimedeltaArray(object):
def test_from_sequence_dtype(self):
- msg = r"Only timedelta64\[ns\] dtype is valid"
+ msg = "dtype .*object.* cannot be converted to timedelta64"
with pytest.raises(ValueError, match=msg):
TimedeltaArray._from_sequence([], dtype=object)
diff --git a/pandas/tests/indexes/datetimes/test_construction.py b/pandas/tests/indexes/datetimes/test_construction.py
index 7c9ca9da89d53..7ebebbf6dee28 100644
--- a/pandas/tests/indexes/datetimes/test_construction.py
+++ b/pandas/tests/indexes/datetimes/test_construction.py
@@ -634,6 +634,23 @@ def test_construction_with_nat_and_tzlocal(self):
expected = DatetimeIndex([Timestamp('2018', tz=tz), pd.NaT])
tm.assert_index_equal(result, expected)
+ def test_constructor_no_precision_warns(self):
+ # GH-24753, GH-24739
+ expected = pd.DatetimeIndex(['2000'], dtype='datetime64[ns]')
+
+ # we set the stacklevel for DatetimeIndex
+ with tm.assert_produces_warning(FutureWarning):
+ result = pd.DatetimeIndex(['2000'], dtype='datetime64')
+ tm.assert_index_equal(result, expected)
+
+ with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+ result = pd.Index(['2000'], dtype='datetime64')
+ tm.assert_index_equal(result, expected)
+
+ def test_constructor_wrong_precision_raises(self):
+ with pytest.raises(ValueError):
+ pd.DatetimeIndex(['2000'], dtype='datetime64[us]')
+
class TestTimeSeries(object):
diff --git a/pandas/tests/indexes/timedeltas/test_construction.py b/pandas/tests/indexes/timedeltas/test_construction.py
index 76f79e86e6f11..3938d6acad2f0 100644
--- a/pandas/tests/indexes/timedeltas/test_construction.py
+++ b/pandas/tests/indexes/timedeltas/test_construction.py
@@ -180,3 +180,20 @@ def test_constructor_name(self):
# GH10025
idx2 = TimedeltaIndex(idx, name='something else')
assert idx2.name == 'something else'
+
+ def test_constructor_no_precision_warns(self):
+ # GH-24753, GH-24739
+ expected = pd.TimedeltaIndex(['2000'], dtype='timedelta64[ns]')
+
+ # we set the stacklevel for DatetimeIndex
+ with tm.assert_produces_warning(FutureWarning):
+ result = pd.TimedeltaIndex(['2000'], dtype='timedelta64')
+ tm.assert_index_equal(result, expected)
+
+ with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+ result = pd.Index(['2000'], dtype='timedelta64')
+ tm.assert_index_equal(result, expected)
+
+ def test_constructor_wrong_precision_raises(self):
+ with pytest.raises(ValueError):
+ pd.TimedeltaIndex(['2000'], dtype='timedelta64[us]')
| This deprecates passing dtypes without a precision to DatetimeIndex
and TimedeltaIndex
```python
In [2]: pd.DatetimeIndex(['2000'], dtype='datetime64')
/Users/taugspurger/.virtualenvs/pandas-dev/bin/ipython:1: FutureWarning: Passing in 'datetime64' dtype with no precision is deprecated
and will raise in a future version. Please pass in
'datetime64[ns]' instead.
#!/Users/taugspurger/Envs/pandas-dev/bin/python3
Out[2]: DatetimeIndex(['2000-01-01'], dtype='datetime64[ns]', freq=None)
```
Closes https://github.com/pandas-dev/pandas/issues/24739
Closes https://github.com/pandas-dev/pandas/issues/24753
- [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24806 | 2019-01-16T16:13:26Z | 2019-01-21T14:18:15Z | 2019-01-21T14:18:14Z | 2019-01-21T14:18:18Z |
Revert unnecessary changes from 22019 | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index d69e948e31e33..868c5e280d2c3 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1163,36 +1163,6 @@ data is incompatible with a passed ``dtype=`` (:issue:`15832`)
...
OverflowError: Trying to coerce negative values to unsigned integers
-.. _whatsnew_0240.api.crosstab_dtypes:
-
-Crosstab Preserves Dtypes
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-:func:`crosstab` will preserve now dtypes in some cases that previously would
-cast from integer dtype to floating dtype (:issue:`22019`)
-
-*Previous Behavior*:
-
-.. code-block:: ipython
-
- In [3]: df = pd.DataFrame({'a': [1, 2, 2, 2, 2], 'b': [3, 3, 4, 4, 4],
- ...: 'c': [1, 1, np.nan, 1, 1]})
- In [4]: pd.crosstab(df.a, df.b, normalize='columns')
- Out[4]:
- b 3 4
- a
- 1 0.5 0.0
- 2 0.5 1.0
-
-*New Behavior*:
-
-.. code-block:: ipython
-
- In [3]: df = pd.DataFrame({'a': [1, 2, 2, 2, 2],
- ...: 'b': [3, 3, 4, 4, 4],
- ...: 'c': [1, 1, np.nan, 1, 1]})
- In [4]: pd.crosstab(df.a, df.b, normalize='columns')
-
.. _whatsnew_0240.api.concat_categorical:
Concatenation Changes
diff --git a/pandas/tests/frame/test_axis_select_reindex.py b/pandas/tests/frame/test_axis_select_reindex.py
index 96f52e5dd17a3..508a68d44bb04 100644
--- a/pandas/tests/frame/test_axis_select_reindex.py
+++ b/pandas/tests/frame/test_axis_select_reindex.py
@@ -717,7 +717,7 @@ def test_align_int_fill_bug(self):
result = df1 - df1.mean()
expected = df2 - df2.mean()
- assert_frame_equal(result.astype('f8'), expected)
+ assert_frame_equal(result, expected)
def test_align_multiindex(self):
# GH 10665
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index f0d1ad57ba829..7c70f8177d846 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -1573,9 +1573,8 @@ def test_crosstab_normalize(self):
full_normal)
tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize='index'),
row_normal)
- tm.assert_frame_equal(
- pd.crosstab(df.a, df.b, normalize='columns').astype('f8'),
- col_normal)
+ tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize='columns'),
+ col_normal)
tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize=1),
pd.crosstab(df.a, df.b, normalize='columns'))
tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize=0),
@@ -1608,7 +1607,7 @@ def test_crosstab_normalize(self):
tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize='index',
margins=True), row_normal_margins)
tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize='columns',
- margins=True).astype('f8'),
+ margins=True),
col_normal_margins)
tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize=True,
margins=True), all_normal_margins)
| At the time, https://github.com/pandas-dev/pandas/pull/22019 seemed to
break API in a few places. Since then, those API breaking changes have
disappeared, so the changes to the tests and the release note are no
longer necessary.
This restores the tests to the 0.23.4 version.
Closes https://github.com/pandas-dev/pandas/issues/24789 | https://api.github.com/repos/pandas-dev/pandas/pulls/24802 | 2019-01-16T14:31:03Z | 2019-01-16T16:02:00Z | 2019-01-16T16:01:59Z | 2019-01-16T16:02:04Z |
Whatsnew reorganization | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 868c5e280d2c3..3685a24d60e74 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -10,92 +10,16 @@ What's New in 0.24.0 (January XX, 2019)
{{ header }}
-
These are the changes in pandas 0.24.0. See :ref:`release` for a full changelog
including other versions of pandas.
-.. _whatsnew_0240.enhancements:
+Highlights include
-New features
-~~~~~~~~~~~~
-- :func:`merge` now directly allows merge between objects of type ``DataFrame`` and named ``Series``, without the need to convert the ``Series`` object into a ``DataFrame`` beforehand (:issue:`21220`)
-- ``ExcelWriter`` now accepts ``mode`` as a keyword argument, enabling append to existing workbooks when using the ``openpyxl`` engine (:issue:`3441`)
-- ``FrozenList`` has gained the ``.union()`` and ``.difference()`` methods. This functionality greatly simplifies groupby's that rely on explicitly excluding certain columns. See :ref:`Splitting an object into groups <groupby.split>` for more information (:issue:`15475`, :issue:`15506`).
-- :func:`DataFrame.to_parquet` now accepts ``index`` as an argument, allowing
- the user to override the engine's default behavior to include or omit the
- dataframe's indexes from the resulting Parquet file. (:issue:`20768`)
-- :meth:`DataFrame.corr` and :meth:`Series.corr` now accept a callable for generic calculation methods of correlation, e.g. histogram intersection (:issue:`22684`)
-- :func:`DataFrame.to_string` now accepts ``decimal`` as an argument, allowing the user to specify which decimal separator should be used in the output. (:issue:`23614`)
-- :func:`read_feather` now accepts ``columns`` as an argument, allowing the user to specify which columns should be read. (:issue:`24025`)
-- :func:`DataFrame.to_html` now accepts ``render_links`` as an argument, allowing the user to generate HTML with links to any URLs that appear in the DataFrame.
- See the :ref:`section on writing HTML <io.html>` in the IO docs for example usage. (:issue:`2679`)
-- :func:`pandas.read_csv` now supports pandas extension types as an argument to ``dtype``, allowing the user to use pandas extension types when reading CSVs. (:issue:`23228`)
-- :meth:`DataFrame.shift` :meth:`Series.shift`, :meth:`ExtensionArray.shift`, :meth:`SparseArray.shift`, :meth:`Period.shift`, :meth:`GroupBy.shift`, :meth:`Categorical.shift`, :meth:`NDFrame.shift` and :meth:`Block.shift` now accept `fill_value` as an argument, allowing the user to specify a value which will be used instead of NA/NaT in the empty periods. (:issue:`15486`)
-
-.. _whatsnew_0240.values_api:
-
-Accessing the values in a Series or Index
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-:attr:`Series.array` and :attr:`Index.array` have been added for extracting the array backing a
-``Series`` or ``Index``. (:issue:`19954`, :issue:`23623`)
-
-.. ipython:: python
-
- idx = pd.period_range('2000', periods=4)
- idx.array
- pd.Series(idx).array
-
-Historically, this would have been done with ``series.values``, but with
-``.values`` it was unclear whether the returned value would be the actual array,
-some transformation of it, or one of pandas custom arrays (like
-``Categorical``). For example, with :class:`PeriodIndex`, ``.values`` generates
-a new ndarray of period objects each time.
-
-.. ipython:: python
-
- id(idx.values)
- id(idx.values)
-
-If you need an actual NumPy array, use :meth:`Series.to_numpy` or :meth:`Index.to_numpy`.
-
-.. ipython:: python
-
- idx.to_numpy()
- pd.Series(idx).to_numpy()
-
-For Series and Indexes backed by normal NumPy arrays, :attr:`Series.array` will return a
-new :class:`arrays.PandasArray`, which is a thin (no-copy) wrapper around a
-:class:`numpy.ndarray`. :class:`arrays.PandasArray` isn't especially useful on its own,
-but it does provide the same interface as any extension array defined in pandas or by
-a third-party library.
-
-.. ipython:: python
-
- ser = pd.Series([1, 2, 3])
- ser.array
- ser.to_numpy()
-
-We haven't removed or deprecated :attr:`Series.values` or :attr:`DataFrame.values`, but we
-highly recommend and using ``.array`` or ``.to_numpy()`` instead.
-
-See :ref:`Dtypes <basics.dtypes>` and :ref:`Attributes and Underlying Data <basics.attrs>` for more.
-
-.. _whatsnew_0240.enhancements.extension_array_operators:
-
-``ExtensionArray`` operator support
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-A ``Series`` based on an ``ExtensionArray`` now supports arithmetic and comparison
-operators (:issue:`19577`). There are two approaches for providing operator support for an ``ExtensionArray``:
-
-1. Define each of the operators on your ``ExtensionArray`` subclass.
-2. Use an operator implementation from pandas that depends on operators that are already defined
- on the underlying elements (scalars) of the ``ExtensionArray``.
-
-See the :ref:`ExtensionArray Operator Support
-<extending.extension.operator>` documentation section for details on both
-ways of adding operator support.
+* :ref:`Optional Nullable Integer Support <whatsnew_0240.enhancements.intna>`
+* :ref:`New APIs for accessing the array backing a Series or Index <whatsnew_0240.values_api>`
+* :ref:`A new top-level method for creating arrays <whatsnew_0240.enhancements.array>`
+* :ref:`Store Interval and Period data in a Series or DataFrame <whatsnew_0240.enhancements.interval>`
+* :ref:`Support for joining on two MultiIndexes <whatsnew_0240.enhancements.join_with_two_multiindexes>`
.. _whatsnew_0240.enhancements.intna:
@@ -162,6 +86,57 @@ Reduction and groupby operations such as ``sum`` work.
See :ref:`integer_na` for more.
+
+.. _whatsnew_0240.values_api:
+
+Accessing the values in a Series or Index
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:attr:`Series.array` and :attr:`Index.array` have been added for extracting the array backing a
+``Series`` or ``Index``. (:issue:`19954`, :issue:`23623`)
+
+.. ipython:: python
+
+ idx = pd.period_range('2000', periods=4)
+ idx.array
+ pd.Series(idx).array
+
+Historically, this would have been done with ``series.values``, but with
+``.values`` it was unclear whether the returned value would be the actual array,
+some transformation of it, or one of pandas custom arrays (like
+``Categorical``). For example, with :class:`PeriodIndex`, ``.values`` generates
+a new ndarray of period objects each time.
+
+.. ipython:: python
+
+ id(idx.values)
+ id(idx.values)
+
+If you need an actual NumPy array, use :meth:`Series.to_numpy` or :meth:`Index.to_numpy`.
+
+.. ipython:: python
+
+ idx.to_numpy()
+ pd.Series(idx).to_numpy()
+
+For Series and Indexes backed by normal NumPy arrays, :attr:`Series.array` will return a
+new :class:`arrays.PandasArray`, which is a thin (no-copy) wrapper around a
+:class:`numpy.ndarray`. :class:`arrays.PandasArray` isn't especially useful on its own,
+but it does provide the same interface as any extension array defined in pandas or by
+a third-party library.
+
+.. ipython:: python
+
+ ser = pd.Series([1, 2, 3])
+ ser.array
+ ser.to_numpy()
+
+We haven't removed or deprecated :attr:`Series.values` or :attr:`DataFrame.values`, but we
+highly recommend and using ``.array`` or ``.to_numpy()`` instead.
+
+See :ref:`Dtypes <basics.dtypes>` and :ref:`Attributes and Underlying Data <basics.attrs>` for more.
+
+
.. _whatsnew_0240.enhancements.array:
Array
@@ -200,46 +175,6 @@ is a float.
pd.array([1, 2, np.nan])
-.. _whatsnew_0240.enhancements.read_html:
-
-``read_html`` Enhancements
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-:func:`read_html` previously ignored ``colspan`` and ``rowspan`` attributes.
-Now it understands them, treating them as sequences of cells with the same
-value. (:issue:`17054`)
-
-.. ipython:: python
-
- result = pd.read_html("""
- <table>
- <thead>
- <tr>
- <th>A</th><th>B</th><th>C</th>
- </tr>
- </thead>
- <tbody>
- <tr>
- <td colspan="2">1</td><td>2</td>
- </tr>
- </tbody>
- </table>""")
-
-*Previous Behavior*:
-
-.. code-block:: ipython
-
- In [13]: result
- Out [13]:
- [ A B C
- 0 1 2 NaN]
-
-*New Behavior*:
-
-.. ipython:: python
-
- result
-
.. _whatsnew_0240.enhancements.interval:
@@ -286,27 +221,6 @@ from the ``Series``:
for more.
-New ``Styler.pipe()`` method
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-The :class:`~pandas.io.formats.style.Styler` class has gained a
-:meth:`~pandas.io.formats.style.Styler.pipe` method. This provides a
-convenient way to apply users' predefined styling functions, and can help reduce
-"boilerplate" when using DataFrame styling functionality repeatedly within a notebook. (:issue:`23229`)
-
-.. ipython:: python
-
- df = pd.DataFrame({'N': [1250, 1500, 1750], 'X': [0.25, 0.35, 0.50]})
-
- def format_and_align(styler):
- return (styler.format({'N': '{:,}', 'X': '{:.1%}'})
- .set_properties(**{'text-align': 'right'}))
-
- df.style.pipe(format_and_align).set_caption('Summary of results.')
-
-Similar methods already exist for other classes in pandas, including :meth:`DataFrame.pipe`,
-:meth:`pandas.core.groupby.GroupBy.pipe`, and :meth:`pandas.core.resample.Resampler.pipe`.
-
-
.. _whatsnew_0240.enhancements.join_with_two_multiindexes:
Joining with two multi-indexes
@@ -343,6 +257,83 @@ For earlier versions this can be done using the following.
on=['key'], how='inner').set_index(['key', 'X', 'Y'])
+.. _whatsnew_0240.enhancements.extension_array_operators:
+
+``ExtensionArray`` operator support
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A ``Series`` based on an ``ExtensionArray`` now supports arithmetic and comparison
+operators (:issue:`19577`). There are two approaches for providing operator support for an ``ExtensionArray``:
+
+1. Define each of the operators on your ``ExtensionArray`` subclass.
+2. Use an operator implementation from pandas that depends on operators that are already defined
+ on the underlying elements (scalars) of the ``ExtensionArray``.
+
+See the :ref:`ExtensionArray Operator Support
+<extending.extension.operator>` documentation section for details on both
+ways of adding operator support.
+
+.. _whatsnew_0240.enhancements.read_html:
+
+``read_html`` Enhancements
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:func:`read_html` previously ignored ``colspan`` and ``rowspan`` attributes.
+Now it understands them, treating them as sequences of cells with the same
+value. (:issue:`17054`)
+
+.. ipython:: python
+
+ result = pd.read_html("""
+ <table>
+ <thead>
+ <tr>
+ <th>A</th><th>B</th><th>C</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td colspan="2">1</td><td>2</td>
+ </tr>
+ </tbody>
+ </table>""")
+
+*Previous Behavior*:
+
+.. code-block:: ipython
+
+ In [13]: result
+ Out [13]:
+ [ A B C
+ 0 1 2 NaN]
+
+*New Behavior*:
+
+.. ipython:: python
+
+ result
+
+
+New ``Styler.pipe()`` method
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+The :class:`~pandas.io.formats.style.Styler` class has gained a
+:meth:`~pandas.io.formats.style.Styler.pipe` method. This provides a
+convenient way to apply users' predefined styling functions, and can help reduce
+"boilerplate" when using DataFrame styling functionality repeatedly within a notebook. (:issue:`23229`)
+
+.. ipython:: python
+
+ df = pd.DataFrame({'N': [1250, 1500, 1750], 'X': [0.25, 0.35, 0.50]})
+
+ def format_and_align(styler):
+ return (styler.format({'N': '{:,}', 'X': '{:.1%}'})
+ .set_properties(**{'text-align': 'right'}))
+
+ df.style.pipe(format_and_align).set_caption('Summary of results.')
+
+Similar methods already exist for other classes in pandas, including :meth:`DataFrame.pipe`,
+:meth:`pandas.core.groupby.GroupBy.pipe`, and :meth:`pandas.core.resample.Resampler.pipe`.
+
.. _whatsnew_0240.enhancements.rename_axis:
Renaming names in a MultiIndex
@@ -366,12 +357,24 @@ Example:
See the :ref:`Advanced documentation on renaming<advanced.index_names>` for more details.
-
.. _whatsnew_0240.enhancements.other:
Other Enhancements
^^^^^^^^^^^^^^^^^^
+- :func:`merge` now directly allows merge between objects of type ``DataFrame`` and named ``Series``, without the need to convert the ``Series`` object into a ``DataFrame`` beforehand (:issue:`21220`)
+- ``ExcelWriter`` now accepts ``mode`` as a keyword argument, enabling append to existing workbooks when using the ``openpyxl`` engine (:issue:`3441`)
+- ``FrozenList`` has gained the ``.union()`` and ``.difference()`` methods. This functionality greatly simplifies groupby's that rely on explicitly excluding certain columns. See :ref:`Splitting an object into groups <groupby.split>` for more information (:issue:`15475`, :issue:`15506`).
+- :func:`DataFrame.to_parquet` now accepts ``index`` as an argument, allowing
+ the user to override the engine's default behavior to include or omit the
+ dataframe's indexes from the resulting Parquet file. (:issue:`20768`)
+- :meth:`DataFrame.corr` and :meth:`Series.corr` now accept a callable for generic calculation methods of correlation, e.g. histogram intersection (:issue:`22684`)
+- :func:`DataFrame.to_string` now accepts ``decimal`` as an argument, allowing the user to specify which decimal separator should be used in the output. (:issue:`23614`)
+- :func:`read_feather` now accepts ``columns`` as an argument, allowing the user to specify which columns should be read. (:issue:`24025`)
+- :func:`DataFrame.to_html` now accepts ``render_links`` as an argument, allowing the user to generate HTML with links to any URLs that appear in the DataFrame.
+ See the :ref:`section on writing HTML <io.html>` in the IO docs for example usage. (:issue:`2679`)
+- :func:`pandas.read_csv` now supports pandas extension types as an argument to ``dtype``, allowing the user to use pandas extension types when reading CSVs. (:issue:`23228`)
+- :meth:`DataFrame.shift` :meth:`Series.shift`, :meth:`ExtensionArray.shift`, :meth:`SparseArray.shift`, :meth:`Period.shift`, :meth:`GroupBy.shift`, :meth:`Categorical.shift`, :meth:`NDFrame.shift` and :meth:`Block.shift` now accept `fill_value` as an argument, allowing the user to specify a value which will be used instead of NA/NaT in the empty periods. (:issue:`15486`)
- :func:`to_datetime` now supports the ``%Z`` and ``%z`` directive when passed into ``format`` (:issue:`13486`)
- :func:`Series.mode` and :func:`DataFrame.mode` now support the ``dropna`` parameter which can be used to specify whether ``NaN``/``NaT`` values should be considered (:issue:`17534`)
- :func:`DataFrame.to_csv` and :func:`Series.to_csv` now support the ``compression`` keyword when a file handle is passed. (:issue:`21227`)
@@ -427,42 +430,8 @@ Other Enhancements
Backwards incompatible API changes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- A newly constructed empty :class:`DataFrame` with integer as the ``dtype`` will now only be cast to ``float64`` if ``index`` is specified (:issue:`22858`)
-- :meth:`Series.str.cat` will now raise if ``others`` is a ``set`` (:issue:`23009`)
-- Passing scalar values to :class:`DatetimeIndex` or :class:`TimedeltaIndex` will now raise ``TypeError`` instead of ``ValueError`` (:issue:`23539`)
-- ``max_rows`` and ``max_cols`` parameters removed from :class:`HTMLFormatter` since truncation is handled by :class:`DataFrameFormatter` (:issue:`23818`)
-- :func:`read_csv` will now raise a ``ValueError`` if a column with missing values is declared as having dtype ``bool`` (:issue:`20591`)
-- The column order of the resultant :class:`DataFrame` from :meth:`MultiIndex.to_frame` is now guaranteed to match the :attr:`MultiIndex.names` order. (:issue:`22420`)
-- Incorrectly passing a :class:`DatetimeIndex` to :meth:`MultiIndex.from_tuples`, rather than a sequence of tuples, now raises a ``TypeError`` rather than a ``ValueError`` (:issue:`24024`)
-- :func:`pd.offsets.generate_range` argument ``time_rule`` has been removed; use ``offset`` instead (:issue:`24157`)
-- In 0.23.x, pandas would raise a ``ValueError`` on a merge of a numeric column (e.g. ``int`` dtyped column) and an ``object`` dtyped column (:issue:`9780`). We have re-enabled the ability to merge ``object`` and other dtypes; pandas will still raise on a merge between a numeric and an ``object`` dtyped column that is composed only of strings (:issue:`21681`)
-
-Percentage change on groupby
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Fixed a bug where calling :func:`pancas.core.groupby.SeriesGroupBy.pct_change` or :func:`pandas.core.groupby.DataFrameGroupBy.pct_change` would previously work across groups when calculating the percent change, where it now correctly works per group (:issue:`21200`, :issue:`21235`).
-
-.. ipython:: python
-
- df = pd.DataFrame({'grp': ['a', 'a', 'b'], 'foo': [1.0, 1.1, 2.2]})
- df
-
-Previous behavior:
+Pandas 0.24.0 includes a number of API breaking changes.
-.. code-block:: ipython
-
- In [1]: df.groupby('grp').pct_change()
- Out[1]:
- foo
- 0 NaN
- 1 0.1
- 2 1.0
-
-New behavior:
-
-.. ipython:: python
-
- df.groupby('grp').pct_change()
.. _whatsnew_0240.api_breaking.deps:
@@ -716,8 +685,8 @@ is the case with :attr:`Period.end_time`, for example
.. _whatsnew_0240.api_breaking.datetime_unique:
-Datetime w/tz and unique
-^^^^^^^^^^^^^^^^^^^^^^^^
+Series.unique for Timezone-Aware Data
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The return type of :meth:`Series.unique` for datetime with timezone values has changed
from an :class:`numpy.ndarray` of :class:`Timestamp` objects to a :class:`arrays.DatetimeArray` (:issue:`24024`).
@@ -1086,57 +1055,6 @@ broadcast. (:issue:`23000`)
df + arr[[0], :] # 1 row, 2 columns
df + arr[:, [1]] # 1 column, 3 rows
-
-.. _whatsnew_0240.api.extension:
-
-ExtensionType Changes
-^^^^^^^^^^^^^^^^^^^^^
-
- **Equality and Hashability**
-
-Pandas now requires that extension dtypes be hashable. The base class implements
-a default ``__eq__`` and ``__hash__``. If you have a parametrized dtype, you should
-update the ``ExtensionDtype._metadata`` tuple to match the signature of your
-``__init__`` method. See :class:`pandas.api.extensions.ExtensionDtype` for more (:issue:`22476`).
-
-**Reshaping changes**
-
-- :meth:`~pandas.api.types.ExtensionArray.dropna` has been added (:issue:`21185`)
-- :meth:`~pandas.api.types.ExtensionArray.repeat` has been added (:issue:`24349`)
-- The ``ExtensionArray`` constructor, ``_from_sequence`` now take the keyword arg ``copy=False`` (:issue:`21185`)
-- :meth:`pandas.api.extensions.ExtensionArray.shift` added as part of the basic ``ExtensionArray`` interface (:issue:`22387`).
-- :meth:`~pandas.api.types.ExtensionArray.searchsorted` has been added (:issue:`24350`)
-- Support for reduction operations such as ``sum``, ``mean`` via opt-in base class method override (:issue:`22762`)
-- :func:`ExtensionArray.isna` is allowed to return an ``ExtensionArray`` (:issue:`22325`).
-
-**Dtype changes**
-
-- ``ExtensionDtype`` has gained the ability to instantiate from string dtypes, e.g. ``decimal`` would instantiate a registered ``DecimalDtype``; furthermore
- the ``ExtensionDtype`` has gained the method ``construct_array_type`` (:issue:`21185`)
-- Added ``ExtensionDtype._is_numeric`` for controlling whether an extension dtype is considered numeric (:issue:`22290`).
-- Added :meth:`pandas.api.types.register_extension_dtype` to register an extension type with pandas (:issue:`22664`)
-- Updated the ``.type`` attribute for ``PeriodDtype``, ``DatetimeTZDtype``, and ``IntervalDtype`` to be instances of the dtype (``Period``, ``Timestamp``, and ``Interval`` respectively) (:issue:`22938`)
-
-**Other changes**
-
-- A default repr for :class:`pandas.api.extensions.ExtensionArray` is now provided (:issue:`23601`).
-- An ``ExtensionArray`` with a boolean dtype now works correctly as a boolean indexer. :meth:`pandas.api.types.is_bool_dtype` now properly considers them boolean (:issue:`22326`)
-
-**Bug Fixes**
-
-- Bug in :meth:`Series.get` for ``Series`` using ``ExtensionArray`` and integer index (:issue:`21257`)
-- :meth:`~Series.shift` now dispatches to :meth:`ExtensionArray.shift` (:issue:`22386`)
-- :meth:`Series.combine()` works correctly with :class:`~pandas.api.extensions.ExtensionArray` inside of :class:`Series` (:issue:`20825`)
-- :meth:`Series.combine()` with scalar argument now works for any function type (:issue:`21248`)
-- :meth:`Series.astype` and :meth:`DataFrame.astype` now dispatch to :meth:`ExtensionArray.astype` (:issue:`21185`).
-- Slicing a single row of a ``DataFrame`` with multiple ExtensionArrays of the same type now preserves the dtype, rather than coercing to object (:issue:`22784`)
-- Bug when concatenating multiple ``Series`` with different extension dtypes not casting to object dtype (:issue:`22994`)
-- Series backed by an ``ExtensionArray`` now work with :func:`util.hash_pandas_object` (:issue:`23066`)
-- :meth:`DataFrame.stack` no longer converts to object dtype for DataFrames where each column has the same extension dtype. The output Series will have the same dtype as the columns (:issue:`23077`).
-- :meth:`Series.unstack` and :meth:`DataFrame.unstack` no longer convert extension arrays to object-dtype ndarrays. Each column in the output ``DataFrame`` will now have the same dtype as the input (:issue:`23077`).
-- Bug when grouping :meth:`Dataframe.groupby()` and aggregating on ``ExtensionArray`` it was not returning the actual ``ExtensionArray`` dtype (:issue:`23227`).
-- Bug in :func:`pandas.merge` when merging on an extension array-backed column (:issue:`23020`).
-
.. _whatsnew_0240.api.incompatibilities:
Series and Index Data-Dtype Incompatibilities
@@ -1212,6 +1130,15 @@ Datetimelike API Changes
Other API Changes
^^^^^^^^^^^^^^^^^
+- A newly constructed empty :class:`DataFrame` with integer as the ``dtype`` will now only be cast to ``float64`` if ``index`` is specified (:issue:`22858`)
+- :meth:`Series.str.cat` will now raise if ``others`` is a ``set`` (:issue:`23009`)
+- Passing scalar values to :class:`DatetimeIndex` or :class:`TimedeltaIndex` will now raise ``TypeError`` instead of ``ValueError`` (:issue:`23539`)
+- ``max_rows`` and ``max_cols`` parameters removed from :class:`HTMLFormatter` since truncation is handled by :class:`DataFrameFormatter` (:issue:`23818`)
+- :func:`read_csv` will now raise a ``ValueError`` if a column with missing values is declared as having dtype ``bool`` (:issue:`20591`)
+- The column order of the resultant :class:`DataFrame` from :meth:`MultiIndex.to_frame` is now guaranteed to match the :attr:`MultiIndex.names` order. (:issue:`22420`)
+- Incorrectly passing a :class:`DatetimeIndex` to :meth:`MultiIndex.from_tuples`, rather than a sequence of tuples, now raises a ``TypeError`` rather than a ``ValueError`` (:issue:`24024`)
+- :func:`pd.offsets.generate_range` argument ``time_rule`` has been removed; use ``offset`` instead (:issue:`24157`)
+- In 0.23.x, pandas would raise a ``ValueError`` on a merge of a numeric column (e.g. ``int`` dtyped column) and an ``object`` dtyped column (:issue:`9780`). We have re-enabled the ability to merge ``object`` and other dtypes; pandas will still raise on a merge between a numeric and an ``object`` dtyped column that is composed only of strings (:issue:`21681`)
- Accessing a level of a ``MultiIndex`` with a duplicate name (e.g. in
:meth:`~MultiIndex.get_level_values`) now raises a ``ValueError`` instead of a ``KeyError`` (:issue:`21678`).
- Invalid construction of ``IntervalDtype`` will now always raise a ``TypeError`` rather than a ``ValueError`` if the subdtype is invalid (:issue:`21185`)
@@ -1233,6 +1160,58 @@ Other API Changes
- :func:`Series.to_list` and :func:`Index.to_list` are now aliases of ``Series.tolist`` respectively ``Index.tolist`` (:issue:`8826`)
- The result of ``SparseSeries.unstack`` is now a :class:`DataFrame` with sparse values, rather than a :class:`SparseDataFrame` (:issue:`24372`).
+
+.. _whatsnew_0240.api.extension:
+
+ExtensionType Changes
+^^^^^^^^^^^^^^^^^^^^^
+
+**Equality and Hashability**
+
+Pandas now requires that extension dtypes be hashable. The base class implements
+a default ``__eq__`` and ``__hash__``. If you have a parametrized dtype, you should
+update the ``ExtensionDtype._metadata`` tuple to match the signature of your
+``__init__`` method. See :class:`pandas.api.extensions.ExtensionDtype` for more (:issue:`22476`).
+
+**Reshaping changes**
+
+- :meth:`~pandas.api.types.ExtensionArray.dropna` has been added (:issue:`21185`)
+- :meth:`~pandas.api.types.ExtensionArray.repeat` has been added (:issue:`24349`)
+- The ``ExtensionArray`` constructor, ``_from_sequence`` now take the keyword arg ``copy=False`` (:issue:`21185`)
+- :meth:`pandas.api.extensions.ExtensionArray.shift` added as part of the basic ``ExtensionArray`` interface (:issue:`22387`).
+- :meth:`~pandas.api.types.ExtensionArray.searchsorted` has been added (:issue:`24350`)
+- Support for reduction operations such as ``sum``, ``mean`` via opt-in base class method override (:issue:`22762`)
+- :func:`ExtensionArray.isna` is allowed to return an ``ExtensionArray`` (:issue:`22325`).
+
+**Dtype changes**
+
+- ``ExtensionDtype`` has gained the ability to instantiate from string dtypes, e.g. ``decimal`` would instantiate a registered ``DecimalDtype``; furthermore
+ the ``ExtensionDtype`` has gained the method ``construct_array_type`` (:issue:`21185`)
+- Added ``ExtensionDtype._is_numeric`` for controlling whether an extension dtype is considered numeric (:issue:`22290`).
+- Added :meth:`pandas.api.types.register_extension_dtype` to register an extension type with pandas (:issue:`22664`)
+- Updated the ``.type`` attribute for ``PeriodDtype``, ``DatetimeTZDtype``, and ``IntervalDtype`` to be instances of the dtype (``Period``, ``Timestamp``, and ``Interval`` respectively) (:issue:`22938`)
+
+**Other changes**
+
+- A default repr for :class:`pandas.api.extensions.ExtensionArray` is now provided (:issue:`23601`).
+- An ``ExtensionArray`` with a boolean dtype now works correctly as a boolean indexer. :meth:`pandas.api.types.is_bool_dtype` now properly considers them boolean (:issue:`22326`)
+
+**Bug Fixes**
+
+- Bug in :meth:`Series.get` for ``Series`` using ``ExtensionArray`` and integer index (:issue:`21257`)
+- :meth:`~Series.shift` now dispatches to :meth:`ExtensionArray.shift` (:issue:`22386`)
+- :meth:`Series.combine()` works correctly with :class:`~pandas.api.extensions.ExtensionArray` inside of :class:`Series` (:issue:`20825`)
+- :meth:`Series.combine()` with scalar argument now works for any function type (:issue:`21248`)
+- :meth:`Series.astype` and :meth:`DataFrame.astype` now dispatch to :meth:`ExtensionArray.astype` (:issue:`21185`).
+- Slicing a single row of a ``DataFrame`` with multiple ExtensionArrays of the same type now preserves the dtype, rather than coercing to object (:issue:`22784`)
+- Bug when concatenating multiple ``Series`` with different extension dtypes not casting to object dtype (:issue:`22994`)
+- Series backed by an ``ExtensionArray`` now work with :func:`util.hash_pandas_object` (:issue:`23066`)
+- :meth:`DataFrame.stack` no longer converts to object dtype for DataFrames where each column has the same extension dtype. The output Series will have the same dtype as the columns (:issue:`23077`).
+- :meth:`Series.unstack` and :meth:`DataFrame.unstack` no longer convert extension arrays to object-dtype ndarrays. Each column in the output ``DataFrame`` will now have the same dtype as the input (:issue:`23077`).
+- Bug when grouping :meth:`Dataframe.groupby()` and aggregating on ``ExtensionArray`` it was not returning the actual ``ExtensionArray`` dtype (:issue:`23227`).
+- Bug in :func:`pandas.merge` when merging on an extension array-backed column (:issue:`23020`).
+
+
.. _whatsnew_0240.deprecations:
Deprecations
@@ -1800,6 +1779,7 @@ Groupby/Resample/Rolling
- Calling :meth:`pandas.core.groupby.GroupBy.rank` with empty groups and ``pct=True`` was raising a ``ZeroDivisionError`` (:issue:`22519`)
- Bug in :meth:`DataFrame.resample` when resampling ``NaT`` in ``TimeDeltaIndex`` (:issue:`13223`).
- Bug in :meth:`DataFrame.groupby` did not respect the ``observed`` argument when selecting a column and instead always used ``observed=False`` (:issue:`23970`)
+- Bug in :func:`pandas.core.groupby.SeriesGroupBy.pct_change` or :func:`pandas.core.groupby.DataFrameGroupBy.pct_change` would previously work across groups when calculating the percent change, where it now correctly works per group (:issue:`21200`, :issue:`21235`).
- Bug preventing hash table creation with very large number (2^32) of rows (:issue:`22805`)
Reshaping
| Changes
1. Adds a highlights section (open to suggestions on what should be added / removed from here)
2. Reorders the enhcancements section to be
1. Highlighted features
2. Other features (sections)
3. List of other new features (one-liners)
3. Reorders the "Backwards incompatible changes" section. We had two lists of "other incompatible changes" that I've merged into one at the end of the section.
4. Moved extension type changes out of the "Backwards incompatible changes section".
cc @jorisvandenbossche | https://api.github.com/repos/pandas-dev/pandas/pulls/24799 | 2019-01-16T13:23:18Z | 2019-01-16T16:23:25Z | 2019-01-16T16:23:25Z | 2019-01-24T14:42:06Z |
TST: Add test for C parser handling binary mode | diff --git a/pandas/tests/io/parser/test_c_parser_only.py b/pandas/tests/io/parser/test_c_parser_only.py
index a405617b4132d..c089a189ae551 100644
--- a/pandas/tests/io/parser/test_c_parser_only.py
+++ b/pandas/tests/io/parser/test_c_parser_only.py
@@ -575,3 +575,17 @@ def test_file_handles_mmap(c_parser_only, csv1):
if PY3:
assert not m.closed
m.close()
+
+
+def test_file_binary_mode(c_parser_only):
+ # see gh-23779
+ parser = c_parser_only
+ expected = DataFrame([[1, 2, 3], [4, 5, 6]])
+
+ with tm.ensure_clean() as path:
+ with open(path, "w") as f:
+ f.write("1,2,3\n4,5,6")
+
+ with open(path, "rb") as f:
+ result = parser.read_csv(f, header=None)
+ tm.assert_frame_equal(result, expected)
| Python's native CSV library doesn't accept such files, but we do for the C parser.
Closes #23779. | https://api.github.com/repos/pandas-dev/pandas/pulls/24797 | 2019-01-16T10:49:52Z | 2019-01-16T21:28:51Z | 2019-01-16T21:28:50Z | 2019-01-16T21:28:51Z |
Avoid unnecessary use of _coerce_scalar_to_timedelta_type | diff --git a/pandas/core/computation/pytables.py b/pandas/core/computation/pytables.py
index db409b215a78d..00de29b07c75d 100644
--- a/pandas/core/computation/pytables.py
+++ b/pandas/core/computation/pytables.py
@@ -16,7 +16,6 @@
from pandas.core.computation.common import _ensure_decoded
from pandas.core.computation.expr import BaseExprVisitor
from pandas.core.computation.ops import UndefinedVariableError, is_term
-from pandas.core.tools.timedeltas import _coerce_scalar_to_timedelta_type
from pandas.io.formats.printing import pprint_thing, pprint_thing_encoded
@@ -191,7 +190,7 @@ def stringify(value):
v = v.tz_convert('UTC')
return TermValue(v, v.value, kind)
elif kind == u('timedelta64') or kind == u('timedelta'):
- v = _coerce_scalar_to_timedelta_type(v, unit='s').value
+ v = pd.Timedelta(v, unit='s').value
return TermValue(int(v), v, kind)
elif meta == u('category'):
metadata = com.values_from_object(self.metadata)
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index bd6094596c5e1..4049b0321f221 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -569,8 +569,6 @@ def coerce_to_dtypes(result, dtypes):
if len(result) != len(dtypes):
raise AssertionError("_coerce_to_dtypes requires equal len arrays")
- from pandas.core.tools.timedeltas import _coerce_scalar_to_timedelta_type
-
def conv(r, dtype):
try:
if isna(r):
@@ -578,7 +576,7 @@ def conv(r, dtype):
elif dtype == _NS_DTYPE:
r = tslibs.Timestamp(r)
elif dtype == _TD_DTYPE:
- r = _coerce_scalar_to_timedelta_type(r)
+ r = tslibs.Timedelta(r)
elif dtype == np.bool_:
# messy. non 0/1 integers do not get converted.
if is_integer(r) and r not in [0, 1]:
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 893926cc076ab..cbe5ae198838f 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -26,7 +26,6 @@
wrap_arithmetic_op)
from pandas.core.indexes.numeric import Int64Index
from pandas.core.ops import get_op_result_name
-from pandas.core.tools.timedeltas import _coerce_scalar_to_timedelta_type
from pandas.tseries.frequencies import to_offset
@@ -582,7 +581,7 @@ def _maybe_cast_slice_bound(self, label, side, kind):
assert kind in ['ix', 'loc', 'getitem', None]
if isinstance(label, compat.string_types):
- parsed = _coerce_scalar_to_timedelta_type(label, box=True)
+ parsed = Timedelta(label)
lbound = parsed.round(parsed.resolution)
if side == 'left':
return lbound
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index 9f64b71ea455c..244e8f83bea37 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -1,7 +1,5 @@
# -*- coding: utf-8 -*-
-from __future__ import print_function
-
from datetime import timedelta
import operator
from string import ascii_lowercase
@@ -1128,7 +1126,6 @@ def test_mode_sortwarning(self):
tm.assert_frame_equal(result, expected)
def test_operators_timedelta64(self):
- from datetime import timedelta
df = DataFrame(dict(A=date_range('2012-1-1', periods=3, freq='D'),
B=date_range('2012-1-2', periods=3, freq='D'),
C=Timestamp('20120101') -
@@ -1169,12 +1166,9 @@ def test_operators_timedelta64(self):
mixed['F'] = Timestamp('20130101')
# results in an object array
- from pandas.core.tools.timedeltas import (
- _coerce_scalar_to_timedelta_type as _coerce)
-
result = mixed.min()
- expected = Series([_coerce(timedelta(seconds=5 * 60 + 5)),
- _coerce(timedelta(days=-1)),
+ expected = Series([pd.Timedelta(timedelta(seconds=5 * 60 + 5)),
+ pd.Timedelta(timedelta(days=-1)),
'foo', 1, 1.0,
Timestamp('20130101')],
index=mixed.columns)
| In nearly all the places where its used, we can just use `Timedelta` instead. Way simpler, avoids using a private function. | https://api.github.com/repos/pandas-dev/pandas/pulls/24793 | 2019-01-16T03:02:00Z | 2019-01-17T12:56:54Z | 2019-01-17T12:56:54Z | 2019-01-17T15:41:13Z |
PERF: avoid object-dtype comparisons | diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 20881972c068a..df764aa4ba666 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -2465,6 +2465,12 @@ def setitem(self, indexer, value):
klass=ObjectBlock,)
return newb.setitem(indexer, value)
+ def equals(self, other):
+ # override for significant performance improvement
+ if self.dtype != other.dtype or self.shape != other.shape:
+ return False
+ return (self.values.view('i8') == other.values.view('i8')).all()
+
class TimeDeltaBlock(DatetimeLikeBlockMixin, IntBlock):
__slots__ = ()
diff --git a/pandas/util/testing.py b/pandas/util/testing.py
index 2df43cd678764..f441dd20f3982 100644
--- a/pandas/util/testing.py
+++ b/pandas/util/testing.py
@@ -1199,6 +1199,11 @@ def assert_extension_array_equal(left, right, check_dtype=True,
if check_dtype:
assert_attr_equal('dtype', left, right, obj='ExtensionArray')
+ if hasattr(left, "asi8") and type(right) == type(left):
+ # Avoid slow object-dtype comparisons
+ assert_numpy_array_equal(left.asi8, right.asi8)
+ return
+
left_na = np.asarray(left.isna())
right_na = np.asarray(right.isna())
assert_numpy_array_equal(left_na, right_na, obj='ExtensionArray NA mask')
| Looking at the --durations=10 results in the tests, one that stands out is
```
7.08s call pandas/tests/series/test_datetime_values.py::TestSeriesDatetimeValues::test_dt_namespace_accessor
```
It turns out all but about 0.15 seconds of this is spent in a `tm.assert_series_equal` call for a Datetime64TZ Series. Tracking that down, its in array_equivalent, which casts to object-dtype before comparing. This avoids that casting, shaves almost 7 seconds off that test. | https://api.github.com/repos/pandas-dev/pandas/pulls/24792 | 2019-01-16T00:02:24Z | 2019-01-16T01:34:54Z | 2019-01-16T01:34:54Z | 2019-01-16T02:57:35Z |
DOC: IntervalArray and IntervalIndex minor doc fixes | diff --git a/doc/source/api/indexing.rst b/doc/source/api/indexing.rst
index b324bb4854f38..d27b05322c1f2 100644
--- a/doc/source/api/indexing.rst
+++ b/doc/source/api/indexing.rst
@@ -258,6 +258,7 @@ IntervalIndex Components
IntervalIndex.get_indexer
IntervalIndex.set_closed
IntervalIndex.overlaps
+ IntervalIndex.to_tuples
.. _api.multiindex:
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 2e7216108a23e..45470e03c041a 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -71,7 +71,6 @@
closed
mid
length
-values
is_non_overlapping_monotonic
%(extra_attributes)s\
@@ -936,13 +935,16 @@ def mid(self):
# datetime safe version
return self.left + 0.5 * self.length
- @property
- def is_non_overlapping_monotonic(self):
- """
- Return True if the IntervalArray is non-overlapping (no Intervals share
+ _interval_shared_docs['is_non_overlapping_monotonic'] = """
+ Return True if the %(klass)s is non-overlapping (no Intervals share
points) and is either monotonic increasing or monotonic decreasing,
else False
"""
+
+ @property
+ @Appender(_interval_shared_docs['is_non_overlapping_monotonic']
+ % _shared_docs_kwargs)
+ def is_non_overlapping_monotonic(self):
# must be increasing (e.g., [0, 1), [1, 2), [2, 3), ... )
# or decreasing (e.g., [-1, 0), [-2, -1), [-3, -2), ...)
# we already require left <= right
@@ -986,7 +988,7 @@ def __array__(self, dtype=None):
Returns NA as a tuple if True, ``(nan, nan)``, or just as the NA
value itself if False, ``nan``.
- ..versionadded:: 0.23.0
+ .. versionadded:: 0.23.0
Returns
-------
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index c2aca197c55f6..f4c37413260b5 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -102,7 +102,7 @@ def _new_IntervalIndex(cls, d):
summary="Immutable index of intervals that are closed on the same side.",
name=_index_doc_kwargs['name'],
versionadded="0.20.0",
- extra_attributes="is_overlapping\n",
+ extra_attributes="is_overlapping\nvalues\n",
extra_methods="contains\n",
examples=textwrap.dedent("""\
Examples
@@ -465,6 +465,8 @@ def is_unique(self):
return self._multiindex.is_unique
@cache_readonly
+ @Appender(_interval_shared_docs['is_non_overlapping_monotonic']
+ % _index_doc_kwargs)
def is_non_overlapping_monotonic(self):
return self._data.is_non_overlapping_monotonic
| Some minor fixes for things that aren't rendering correctly for `IntervalArray` and `IntervalIndex`. I've built the docs locally and the changes look good.
For [`IntervalArray` ](https://pandas-docs.github.io/pandas-docs-travis/api/generated/pandas.IntervalArray.html):
- `IntervalArray.values` doesn't exist, so removing it.
For [`IntervalIndex`](https://pandas-docs.github.io/pandas-docs-travis/api/generated/pandas.IntervalIndex.html):
- `IntervalIndex.is_non_overlapping_monotonic` lost it's docstring, so adding it back via shared docs
- `IntervalIndex.to_tuples` isn't being generated, so now generating it. Also fixed versionadded directive.
| https://api.github.com/repos/pandas-dev/pandas/pulls/24780 | 2019-01-15T06:04:51Z | 2019-01-15T12:09:12Z | 2019-01-15T12:09:12Z | 2019-01-15T15:55:56Z |
TST/REF: Collect Reduction, Arithmetic Tests | diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index 6694946902836..da1b3f1da5322 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -1055,3 +1055,22 @@ def test_numeric_compat2(self):
(pd.RangeIndex(-100, -200, 3), 2, pd.RangeIndex(0))]
for idx, div, expected in cases_exact:
tm.assert_index_equal(idx // div, expected, exact=True)
+
+ @pytest.mark.parametrize('dtype', [np.int64, np.float64])
+ @pytest.mark.parametrize('delta', [1, 0, -1])
+ def test_addsub_arithmetic(self, dtype, delta):
+ # GH#8142
+ delta = dtype(delta)
+ index = pd.Index([10, 11, 12], dtype=dtype)
+ result = index + delta
+ expected = pd.Index(index.values + delta, dtype=dtype)
+ tm.assert_index_equal(result, expected)
+
+ # this subtraction used to fail
+ result = index - delta
+ expected = pd.Index(index.values - delta, dtype=dtype)
+ tm.assert_index_equal(result, expected)
+
+ tm.assert_index_equal(index + index, 2 * index)
+ tm.assert_index_equal(index - index, 0 * index)
+ assert not (index - index).empty
diff --git a/pandas/tests/arithmetic/test_object.py b/pandas/tests/arithmetic/test_object.py
index 9917c45ef6d12..29063ae3f50e3 100644
--- a/pandas/tests/arithmetic/test_object.py
+++ b/pandas/tests/arithmetic/test_object.py
@@ -2,6 +2,7 @@
# Arithmetc tests for DataFrame/Series/Index/Array classes that should
# behave identically.
# Specifically for object dtype
+from decimal import Decimal
import operator
import numpy as np
@@ -224,3 +225,90 @@ def test_mixed_timezone_series_ops_object(self):
name='xxx')
tm.assert_series_equal(ser + pd.Timedelta('00:30:00'), exp)
tm.assert_series_equal(pd.Timedelta('00:30:00') + ser, exp)
+
+ # TODO: cleanup & parametrize over box
+ def test_iadd_preserves_name(self):
+ # GH#17067, GH#19723 __iadd__ and __isub__ should preserve index name
+ ser = pd.Series([1, 2, 3])
+ ser.index.name = 'foo'
+
+ ser.index += 1
+ assert ser.index.name == "foo"
+
+ ser.index -= 1
+ assert ser.index.name == "foo"
+
+ def test_add_string(self):
+ # from bug report
+ index = pd.Index(['a', 'b', 'c'])
+ index2 = index + 'foo'
+
+ assert 'a' not in index2
+ assert 'afoo' in index2
+
+ def test_iadd_string(self):
+ index = pd.Index(['a', 'b', 'c'])
+ # doesn't fail test unless there is a check before `+=`
+ assert 'a' in index
+
+ index += '_x'
+ assert 'a_x' in index
+
+ def test_add(self):
+ index = tm.makeStringIndex(100)
+ expected = pd.Index(index.values * 2)
+ tm.assert_index_equal(index + index, expected)
+ tm.assert_index_equal(index + index.tolist(), expected)
+ tm.assert_index_equal(index.tolist() + index, expected)
+
+ # test add and radd
+ index = pd.Index(list('abc'))
+ expected = pd.Index(['a1', 'b1', 'c1'])
+ tm.assert_index_equal(index + '1', expected)
+ expected = pd.Index(['1a', '1b', '1c'])
+ tm.assert_index_equal('1' + index, expected)
+
+ def test_sub_fail(self):
+ index = tm.makeStringIndex(100)
+ with pytest.raises(TypeError):
+ index - 'a'
+ with pytest.raises(TypeError):
+ index - index
+ with pytest.raises(TypeError):
+ index - index.tolist()
+ with pytest.raises(TypeError):
+ index.tolist() - index
+
+ def test_sub_object(self):
+ # GH#19369
+ index = pd.Index([Decimal(1), Decimal(2)])
+ expected = pd.Index([Decimal(0), Decimal(1)])
+
+ result = index - Decimal(1)
+ tm.assert_index_equal(result, expected)
+
+ result = index - pd.Index([Decimal(1), Decimal(1)])
+ tm.assert_index_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ index - 'foo'
+
+ with pytest.raises(TypeError):
+ index - np.array([2, 'foo'])
+
+ def test_rsub_object(self):
+ # GH#19369
+ index = pd.Index([Decimal(1), Decimal(2)])
+ expected = pd.Index([Decimal(1), Decimal(0)])
+
+ result = Decimal(2) - index
+ tm.assert_index_equal(result, expected)
+
+ result = np.array([Decimal(2), Decimal(2)]) - index
+ tm.assert_index_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ 'foo' - index
+
+ with pytest.raises(TypeError):
+ np.array([True, pd.Timestamp.now()]) - index
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index 4be4372f65dcc..2a546af79931e 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -47,59 +47,6 @@ def test_ops_properties_basic(self):
assert s.day == 10
pytest.raises(AttributeError, lambda: s.weekday)
- def test_minmax_tz(self, tz_naive_fixture):
- tz = tz_naive_fixture
- # monotonic
- idx1 = pd.DatetimeIndex(['2011-01-01', '2011-01-02',
- '2011-01-03'], tz=tz)
- assert idx1.is_monotonic
-
- # non-monotonic
- idx2 = pd.DatetimeIndex(['2011-01-01', pd.NaT, '2011-01-03',
- '2011-01-02', pd.NaT], tz=tz)
- assert not idx2.is_monotonic
-
- for idx in [idx1, idx2]:
- assert idx.min() == Timestamp('2011-01-01', tz=tz)
- assert idx.max() == Timestamp('2011-01-03', tz=tz)
- assert idx.argmin() == 0
- assert idx.argmax() == 2
-
- @pytest.mark.parametrize('op', ['min', 'max'])
- def test_minmax_nat(self, op):
- # Return NaT
- obj = DatetimeIndex([])
- assert pd.isna(getattr(obj, op)())
-
- obj = DatetimeIndex([pd.NaT])
- assert pd.isna(getattr(obj, op)())
-
- obj = DatetimeIndex([pd.NaT, pd.NaT, pd.NaT])
- assert pd.isna(getattr(obj, op)())
-
- def test_numpy_minmax(self):
- dr = pd.date_range(start='2016-01-15', end='2016-01-20')
-
- assert np.min(dr) == Timestamp('2016-01-15 00:00:00', freq='D')
- assert np.max(dr) == Timestamp('2016-01-20 00:00:00', freq='D')
-
- errmsg = "the 'out' parameter is not supported"
- with pytest.raises(ValueError, match=errmsg):
- np.min(dr, out=0)
-
- with pytest.raises(ValueError, match=errmsg):
- np.max(dr, out=0)
-
- assert np.argmin(dr) == 0
- assert np.argmax(dr) == 5
-
- errmsg = "the 'out' parameter is not supported"
- with pytest.raises(ValueError, match=errmsg):
- np.argmin(dr, out=0)
-
- with pytest.raises(ValueError, match=errmsg):
- np.argmax(dr, out=0)
-
def test_repeat_range(self, tz_naive_fixture):
tz = tz_naive_fixture
rng = date_range('1/1/2000', '1/1/2001')
diff --git a/pandas/tests/indexes/period/test_ops.py b/pandas/tests/indexes/period/test_ops.py
index eebff39fdf46f..8b022268897b6 100644
--- a/pandas/tests/indexes/period/test_ops.py
+++ b/pandas/tests/indexes/period/test_ops.py
@@ -3,7 +3,7 @@
import pytest
import pandas as pd
-from pandas import DatetimeIndex, Index, NaT, Period, PeriodIndex, Series
+from pandas import DatetimeIndex, Index, NaT, PeriodIndex, Series
from pandas.core.arrays import PeriodArray
from pandas.tests.test_base import Ops
import pandas.util.testing as tm
@@ -24,61 +24,6 @@ def test_ops_properties(self):
self.check_ops_properties(PeriodArray._object_ops, f)
self.check_ops_properties(PeriodArray._bool_ops, f)
- def test_minmax(self):
-
- # monotonic
- idx1 = pd.PeriodIndex([NaT, '2011-01-01', '2011-01-02',
- '2011-01-03'], freq='D')
- assert idx1.is_monotonic
-
- # non-monotonic
- idx2 = pd.PeriodIndex(['2011-01-01', NaT, '2011-01-03',
- '2011-01-02', NaT], freq='D')
- assert not idx2.is_monotonic
-
- for idx in [idx1, idx2]:
- assert idx.min() == pd.Period('2011-01-01', freq='D')
- assert idx.max() == pd.Period('2011-01-03', freq='D')
- assert idx1.argmin() == 1
- assert idx2.argmin() == 0
- assert idx1.argmax() == 3
- assert idx2.argmax() == 2
-
- for op in ['min', 'max']:
- # Return NaT
- obj = PeriodIndex([], freq='M')
- result = getattr(obj, op)()
- assert result is NaT
-
- obj = PeriodIndex([NaT], freq='M')
- result = getattr(obj, op)()
- assert result is NaT
-
- obj = PeriodIndex([NaT, NaT, NaT], freq='M')
- result = getattr(obj, op)()
- assert result is NaT
-
- def test_numpy_minmax(self):
- pr = pd.period_range(start='2016-01-15', end='2016-01-20')
-
- assert np.min(pr) == Period('2016-01-15', freq='D')
- assert np.max(pr) == Period('2016-01-20', freq='D')
-
- errmsg = "the 'out' parameter is not supported"
- with pytest.raises(ValueError, match=errmsg):
- np.min(pr, out=0)
- with pytest.raises(ValueError, match=errmsg):
- np.max(pr, out=0)
-
- assert np.argmin(pr) == 0
- assert np.argmax(pr) == 5
-
- errmsg = "the 'out' parameter is not supported"
- with pytest.raises(ValueError, match=errmsg):
- np.argmin(pr, out=0)
- with pytest.raises(ValueError, match=errmsg):
- np.argmax(pr, out=0)
-
def test_resolution(self):
for freq, expected in zip(['A', 'Q', 'M', 'D', 'H',
'T', 'S', 'L', 'U'],
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index d75800b763cb9..7f6b76f7442af 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -2,7 +2,6 @@
from collections import defaultdict
from datetime import datetime, timedelta
-from decimal import Decimal
import math
import sys
@@ -834,61 +833,6 @@ def test_union_dt_as_obj(self):
tm.assert_contains_all(self.strIndex, secondCat)
tm.assert_contains_all(self.dateIndex, firstCat)
- def test_add(self):
- index = self.strIndex
- expected = Index(self.strIndex.values * 2)
- tm.assert_index_equal(index + index, expected)
- tm.assert_index_equal(index + index.tolist(), expected)
- tm.assert_index_equal(index.tolist() + index, expected)
-
- # test add and radd
- index = Index(list('abc'))
- expected = Index(['a1', 'b1', 'c1'])
- tm.assert_index_equal(index + '1', expected)
- expected = Index(['1a', '1b', '1c'])
- tm.assert_index_equal('1' + index, expected)
-
- def test_sub_fail(self):
- index = self.strIndex
- pytest.raises(TypeError, lambda: index - 'a')
- pytest.raises(TypeError, lambda: index - index)
- pytest.raises(TypeError, lambda: index - index.tolist())
- pytest.raises(TypeError, lambda: index.tolist() - index)
-
- def test_sub_object(self):
- # GH#19369
- index = pd.Index([Decimal(1), Decimal(2)])
- expected = pd.Index([Decimal(0), Decimal(1)])
-
- result = index - Decimal(1)
- tm.assert_index_equal(result, expected)
-
- result = index - pd.Index([Decimal(1), Decimal(1)])
- tm.assert_index_equal(result, expected)
-
- with pytest.raises(TypeError):
- index - 'foo'
-
- with pytest.raises(TypeError):
- index - np.array([2, 'foo'])
-
- def test_rsub_object(self):
- # GH#19369
- index = pd.Index([Decimal(1), Decimal(2)])
- expected = pd.Index([Decimal(1), Decimal(0)])
-
- result = Decimal(2) - index
- tm.assert_index_equal(result, expected)
-
- result = np.array([Decimal(2), Decimal(2)]) - index
- tm.assert_index_equal(result, expected)
-
- with pytest.raises(TypeError):
- 'foo' - index
-
- with pytest.raises(TypeError):
- np.array([True, pd.Timestamp.now()]) - index
-
def test_map_identity_mapping(self):
# GH 12766
# TODO: replace with fixture
@@ -1008,22 +952,6 @@ def test_append_empty_preserve_name(self, name, expected):
result = left.append(right)
assert result.name == expected
- def test_add_string(self):
- # from bug report
- index = Index(['a', 'b', 'c'])
- index2 = index + 'foo'
-
- assert 'a' not in index2
- assert 'afoo' in index2
-
- def test_iadd_string(self):
- index = pd.Index(['a', 'b', 'c'])
- # doesn't fail test unless there is a check before `+=`
- assert 'a' in index
-
- index += '_x'
- assert 'a_x' in index
-
@pytest.mark.parametrize("second_name,expected", [
(None, None), ('name', 'name')])
@pytest.mark.parametrize("sort", [True, False])
@@ -2146,36 +2074,6 @@ def test_string_index_repr_with_unicode_option_compat(self, index,
result = unicode(index) # noqa
assert result == expected
- @pytest.mark.parametrize('dtype', [np.int64, np.float64])
- @pytest.mark.parametrize('delta', [1, 0, -1])
- def test_addsub_arithmetic(self, dtype, delta):
- # GH 8142
- delta = dtype(delta)
- index = pd.Index([10, 11, 12], dtype=dtype)
- result = index + delta
- expected = pd.Index(index.values + delta, dtype=dtype)
- tm.assert_index_equal(result, expected)
-
- # this subtraction used to fail
- result = index - delta
- expected = pd.Index(index.values - delta, dtype=dtype)
- tm.assert_index_equal(result, expected)
-
- tm.assert_index_equal(index + index, 2 * index)
- tm.assert_index_equal(index - index, 0 * index)
- assert not (index - index).empty
-
- def test_iadd_preserves_name(self):
- # GH#17067, GH#19723 __iadd__ and __isub__ should preserve index name
- ser = pd.Series([1, 2, 3])
- ser.index.name = 'foo'
-
- ser.index += 1
- assert ser.index.name == "foo"
-
- ser.index -= 1
- assert ser.index.name == "foo"
-
def test_cached_properties_not_settable(self):
index = pd.Index([1, 2, 3])
with pytest.raises(AttributeError, match="Can't set attribute"):
diff --git a/pandas/tests/indexes/test_category.py b/pandas/tests/indexes/test_category.py
index d85568ce67d16..582d466c6178e 100644
--- a/pandas/tests/indexes/test_category.py
+++ b/pandas/tests/indexes/test_category.py
@@ -251,17 +251,6 @@ def test_contains(self):
list('aabbca') + [np.nan], categories=list('cabdef'))
assert np.nan in ci
- def test_min_max(self):
-
- ci = self.create_index(ordered=False)
- pytest.raises(TypeError, lambda: ci.min())
- pytest.raises(TypeError, lambda: ci.max())
-
- ci = self.create_index(ordered=True)
-
- assert ci.min() == 'c'
- assert ci.max() == 'b'
-
def test_map(self):
ci = pd.CategoricalIndex(list('ABABC'), categories=list('CBA'),
ordered=True)
diff --git a/pandas/tests/indexes/test_range.py b/pandas/tests/indexes/test_range.py
index 7cb62c275e621..30822975a3ea0 100644
--- a/pandas/tests/indexes/test_range.py
+++ b/pandas/tests/indexes/test_range.py
@@ -8,7 +8,7 @@
from pandas.compat import PY3, range, u
import pandas as pd
-from pandas import Float64Index, Index, Int64Index, RangeIndex, Series, isna
+from pandas import Float64Index, Index, Int64Index, RangeIndex, Series
import pandas.util.testing as tm
from .test_numeric import Numeric
@@ -884,30 +884,3 @@ def test_append(self):
# Append single item rather than list
result2 = indices[0].append(indices[1])
tm.assert_index_equal(result2, expected, exact=True)
-
- @pytest.mark.parametrize('start,stop,step',
- [(0, 400, 3), (500, 0, -6), (-10**6, 10**6, 4),
- (10**6, -10**6, -4), (0, 10, 20)])
- def test_max_min(self, start, stop, step):
- # GH17607
- idx = RangeIndex(start, stop, step)
- expected = idx._int64index.max()
- result = idx.max()
- assert result == expected
-
- # skipna should be irrelevant since RangeIndex should never have NAs
- result2 = idx.max(skipna=False)
- assert result2 == expected
-
- expected = idx._int64index.min()
- result = idx.min()
- assert result == expected
-
- # skipna should be irrelevant since RangeIndex should never have NAs
- result2 = idx.min(skipna=False)
- assert result2 == expected
-
- # empty
- idx = RangeIndex(start, stop, -step)
- assert isna(idx.max())
- assert isna(idx.min())
diff --git a/pandas/tests/indexes/timedeltas/test_ops.py b/pandas/tests/indexes/timedeltas/test_ops.py
index 97898dd8942f8..40377e4362b75 100644
--- a/pandas/tests/indexes/timedeltas/test_ops.py
+++ b/pandas/tests/indexes/timedeltas/test_ops.py
@@ -1,4 +1,3 @@
-from datetime import timedelta
import numpy as np
import pytest
@@ -6,9 +5,7 @@
from pandas.core.dtypes.generic import ABCDateOffset
import pandas as pd
-from pandas import (
- Series, Timedelta, TimedeltaIndex, Timestamp, timedelta_range,
- to_timedelta)
+from pandas import Series, TimedeltaIndex, timedelta_range
from pandas.tests.test_base import Ops
import pandas.util.testing as tm
@@ -27,54 +24,6 @@ def test_ops_properties(self):
self.check_ops_properties(TimedeltaIndex._field_ops, f)
self.check_ops_properties(TimedeltaIndex._object_ops, f)
- def test_minmax(self):
-
- # monotonic
- idx1 = TimedeltaIndex(['1 days', '2 days', '3 days'])
- assert idx1.is_monotonic
-
- # non-monotonic
- idx2 = TimedeltaIndex(['1 days', np.nan, '3 days', 'NaT'])
- assert not idx2.is_monotonic
-
- for idx in [idx1, idx2]:
- assert idx.min() == Timedelta('1 days')
- assert idx.max() == Timedelta('3 days')
- assert idx.argmin() == 0
- assert idx.argmax() == 2
-
- for op in ['min', 'max']:
- # Return NaT
- obj = TimedeltaIndex([])
- assert pd.isna(getattr(obj, op)())
-
- obj = TimedeltaIndex([pd.NaT])
- assert pd.isna(getattr(obj, op)())
-
- obj = TimedeltaIndex([pd.NaT, pd.NaT, pd.NaT])
- assert pd.isna(getattr(obj, op)())
-
- def test_numpy_minmax(self):
- td = timedelta_range('16815 days', '16820 days', freq='D')
-
- assert np.min(td) == Timedelta('16815 days')
- assert np.max(td) == Timedelta('16820 days')
-
- errmsg = "the 'out' parameter is not supported"
- with pytest.raises(ValueError, match=errmsg):
- np.min(td, out=0)
- with pytest.raises(ValueError, match=errmsg):
- np.max(td, out=0)
-
- assert np.argmin(td) == 0
- assert np.argmax(td) == 5
-
- errmsg = "the 'out' parameter is not supported"
- with pytest.raises(ValueError, match=errmsg):
- np.argmin(td, out=0)
- with pytest.raises(ValueError, match=errmsg):
- np.argmax(td, out=0)
-
def test_value_counts_unique(self):
# GH 7735
@@ -330,61 +279,3 @@ def test_freq_setter_errors(self):
# setting with non-freq string
with pytest.raises(ValueError, match='Invalid frequency'):
idx.freq = 'foo'
-
-
-class TestTimedeltas(object):
-
- def test_timedelta_ops(self):
- # GH4984
- # make sure ops return Timedelta
- s = Series([Timestamp('20130101') + timedelta(seconds=i * i)
- for i in range(10)])
- td = s.diff()
-
- result = td.mean()
- expected = to_timedelta(timedelta(seconds=9))
- assert result == expected
-
- result = td.to_frame().mean()
- assert result[0] == expected
-
- result = td.quantile(.1)
- expected = Timedelta(np.timedelta64(2600, 'ms'))
- assert result == expected
-
- result = td.median()
- expected = to_timedelta('00:00:09')
- assert result == expected
-
- result = td.to_frame().median()
- assert result[0] == expected
-
- # GH 6462
- # consistency in returned values for sum
- result = td.sum()
- expected = to_timedelta('00:01:21')
- assert result == expected
-
- result = td.to_frame().sum()
- assert result[0] == expected
-
- # std
- result = td.std()
- expected = to_timedelta(Series(td.dropna().values).std())
- assert result == expected
-
- result = td.to_frame().std()
- assert result[0] == expected
-
- # invalid ops
- for op in ['skew', 'kurt', 'sem', 'prod']:
- pytest.raises(TypeError, getattr(td, op))
-
- # GH 10040
- # make sure NaT is properly handled by median()
- s = Series([Timestamp('2015-02-03'), Timestamp('2015-02-07')])
- assert s.diff().median() == timedelta(days=4)
-
- s = Series([Timestamp('2015-02-03'), Timestamp('2015-02-07'),
- Timestamp('2015-02-15')])
- assert s.diff().median() == timedelta(days=6)
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index d27308029fa19..c7bb667f71fac 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -1,11 +1,14 @@
# -*- coding: utf-8 -*-
-from datetime import datetime
+from datetime import datetime, timedelta
import numpy as np
import pytest
import pandas as pd
-from pandas import Categorical, DataFrame, Index, PeriodIndex, Series, compat
+from pandas import (
+ Categorical, DataFrame, DatetimeIndex, Index, NaT, Period, PeriodIndex,
+ RangeIndex, Series, Timedelta, TimedeltaIndex, Timestamp, compat, isna,
+ timedelta_range, to_timedelta)
from pandas.core import nanops
import pandas.util.testing as tm
@@ -136,6 +139,266 @@ def test_nanops(self):
assert obj.argmax(skipna=False) == -1
+class TestIndexReductions(object):
+ # Note: the name TestIndexReductions indicates these tests
+ # were moved from a Index-specific test file, _not_ that these tests are
+ # intended long-term to be Index-specific
+
+ @pytest.mark.parametrize('start,stop,step',
+ [(0, 400, 3), (500, 0, -6), (-10**6, 10**6, 4),
+ (10**6, -10**6, -4), (0, 10, 20)])
+ def test_max_min_range(self, start, stop, step):
+ # GH#17607
+ idx = RangeIndex(start, stop, step)
+ expected = idx._int64index.max()
+ result = idx.max()
+ assert result == expected
+
+ # skipna should be irrelevant since RangeIndex should never have NAs
+ result2 = idx.max(skipna=False)
+ assert result2 == expected
+
+ expected = idx._int64index.min()
+ result = idx.min()
+ assert result == expected
+
+ # skipna should be irrelevant since RangeIndex should never have NAs
+ result2 = idx.min(skipna=False)
+ assert result2 == expected
+
+ # empty
+ idx = RangeIndex(start, stop, -step)
+ assert isna(idx.max())
+ assert isna(idx.min())
+
+ def test_minmax_timedelta64(self):
+
+ # monotonic
+ idx1 = TimedeltaIndex(['1 days', '2 days', '3 days'])
+ assert idx1.is_monotonic
+
+ # non-monotonic
+ idx2 = TimedeltaIndex(['1 days', np.nan, '3 days', 'NaT'])
+ assert not idx2.is_monotonic
+
+ for idx in [idx1, idx2]:
+ assert idx.min() == Timedelta('1 days')
+ assert idx.max() == Timedelta('3 days')
+ assert idx.argmin() == 0
+ assert idx.argmax() == 2
+
+ for op in ['min', 'max']:
+ # Return NaT
+ obj = TimedeltaIndex([])
+ assert pd.isna(getattr(obj, op)())
+
+ obj = TimedeltaIndex([pd.NaT])
+ assert pd.isna(getattr(obj, op)())
+
+ obj = TimedeltaIndex([pd.NaT, pd.NaT, pd.NaT])
+ assert pd.isna(getattr(obj, op)())
+
+ def test_numpy_minmax_timedelta64(self):
+ td = timedelta_range('16815 days', '16820 days', freq='D')
+
+ assert np.min(td) == Timedelta('16815 days')
+ assert np.max(td) == Timedelta('16820 days')
+
+ errmsg = "the 'out' parameter is not supported"
+ with pytest.raises(ValueError, match=errmsg):
+ np.min(td, out=0)
+ with pytest.raises(ValueError, match=errmsg):
+ np.max(td, out=0)
+
+ assert np.argmin(td) == 0
+ assert np.argmax(td) == 5
+
+ errmsg = "the 'out' parameter is not supported"
+ with pytest.raises(ValueError, match=errmsg):
+ np.argmin(td, out=0)
+ with pytest.raises(ValueError, match=errmsg):
+ np.argmax(td, out=0)
+
+ def test_timedelta_ops(self):
+ # GH#4984
+ # make sure ops return Timedelta
+ s = Series([Timestamp('20130101') + timedelta(seconds=i * i)
+ for i in range(10)])
+ td = s.diff()
+
+ result = td.mean()
+ expected = to_timedelta(timedelta(seconds=9))
+ assert result == expected
+
+ result = td.to_frame().mean()
+ assert result[0] == expected
+
+ result = td.quantile(.1)
+ expected = Timedelta(np.timedelta64(2600, 'ms'))
+ assert result == expected
+
+ result = td.median()
+ expected = to_timedelta('00:00:09')
+ assert result == expected
+
+ result = td.to_frame().median()
+ assert result[0] == expected
+
+ # GH#6462
+ # consistency in returned values for sum
+ result = td.sum()
+ expected = to_timedelta('00:01:21')
+ assert result == expected
+
+ result = td.to_frame().sum()
+ assert result[0] == expected
+
+ # std
+ result = td.std()
+ expected = to_timedelta(Series(td.dropna().values).std())
+ assert result == expected
+
+ result = td.to_frame().std()
+ assert result[0] == expected
+
+ # invalid ops
+ for op in ['skew', 'kurt', 'sem', 'prod']:
+ pytest.raises(TypeError, getattr(td, op))
+
+ # GH#10040
+ # make sure NaT is properly handled by median()
+ s = Series([Timestamp('2015-02-03'), Timestamp('2015-02-07')])
+ assert s.diff().median() == timedelta(days=4)
+
+ s = Series([Timestamp('2015-02-03'), Timestamp('2015-02-07'),
+ Timestamp('2015-02-15')])
+ assert s.diff().median() == timedelta(days=6)
+
+ def test_minmax_tz(self, tz_naive_fixture):
+ tz = tz_naive_fixture
+ # monotonic
+ idx1 = pd.DatetimeIndex(['2011-01-01', '2011-01-02',
+ '2011-01-03'], tz=tz)
+ assert idx1.is_monotonic
+
+ # non-monotonic
+ idx2 = pd.DatetimeIndex(['2011-01-01', pd.NaT, '2011-01-03',
+ '2011-01-02', pd.NaT], tz=tz)
+ assert not idx2.is_monotonic
+
+ for idx in [idx1, idx2]:
+ assert idx.min() == Timestamp('2011-01-01', tz=tz)
+ assert idx.max() == Timestamp('2011-01-03', tz=tz)
+ assert idx.argmin() == 0
+ assert idx.argmax() == 2
+
+ @pytest.mark.parametrize('op', ['min', 'max'])
+ def test_minmax_nat_datetime64(self, op):
+ # Return NaT
+ obj = DatetimeIndex([])
+ assert pd.isna(getattr(obj, op)())
+
+ obj = DatetimeIndex([pd.NaT])
+ assert pd.isna(getattr(obj, op)())
+
+ obj = DatetimeIndex([pd.NaT, pd.NaT, pd.NaT])
+ assert pd.isna(getattr(obj, op)())
+
+ def test_numpy_minmax_datetime64(self):
+ dr = pd.date_range(start='2016-01-15', end='2016-01-20')
+
+ assert np.min(dr) == Timestamp('2016-01-15 00:00:00', freq='D')
+ assert np.max(dr) == Timestamp('2016-01-20 00:00:00', freq='D')
+
+ errmsg = "the 'out' parameter is not supported"
+ with pytest.raises(ValueError, match=errmsg):
+ np.min(dr, out=0)
+
+ with pytest.raises(ValueError, match=errmsg):
+ np.max(dr, out=0)
+
+ assert np.argmin(dr) == 0
+ assert np.argmax(dr) == 5
+
+ errmsg = "the 'out' parameter is not supported"
+ with pytest.raises(ValueError, match=errmsg):
+ np.argmin(dr, out=0)
+
+ with pytest.raises(ValueError, match=errmsg):
+ np.argmax(dr, out=0)
+
+ def test_minmax_period(self):
+
+ # monotonic
+ idx1 = pd.PeriodIndex([NaT, '2011-01-01', '2011-01-02',
+ '2011-01-03'], freq='D')
+ assert idx1.is_monotonic
+
+ # non-monotonic
+ idx2 = pd.PeriodIndex(['2011-01-01', NaT, '2011-01-03',
+ '2011-01-02', NaT], freq='D')
+ assert not idx2.is_monotonic
+
+ for idx in [idx1, idx2]:
+ assert idx.min() == pd.Period('2011-01-01', freq='D')
+ assert idx.max() == pd.Period('2011-01-03', freq='D')
+ assert idx1.argmin() == 1
+ assert idx2.argmin() == 0
+ assert idx1.argmax() == 3
+ assert idx2.argmax() == 2
+
+ for op in ['min', 'max']:
+ # Return NaT
+ obj = PeriodIndex([], freq='M')
+ result = getattr(obj, op)()
+ assert result is NaT
+
+ obj = PeriodIndex([NaT], freq='M')
+ result = getattr(obj, op)()
+ assert result is NaT
+
+ obj = PeriodIndex([NaT, NaT, NaT], freq='M')
+ result = getattr(obj, op)()
+ assert result is NaT
+
+ def test_numpy_minmax_period(self):
+ pr = pd.period_range(start='2016-01-15', end='2016-01-20')
+
+ assert np.min(pr) == Period('2016-01-15', freq='D')
+ assert np.max(pr) == Period('2016-01-20', freq='D')
+
+ errmsg = "the 'out' parameter is not supported"
+ with pytest.raises(ValueError, match=errmsg):
+ np.min(pr, out=0)
+ with pytest.raises(ValueError, match=errmsg):
+ np.max(pr, out=0)
+
+ assert np.argmin(pr) == 0
+ assert np.argmax(pr) == 5
+
+ errmsg = "the 'out' parameter is not supported"
+ with pytest.raises(ValueError, match=errmsg):
+ np.argmin(pr, out=0)
+ with pytest.raises(ValueError, match=errmsg):
+ np.argmax(pr, out=0)
+
+ def test_min_max_categorical(self):
+
+ ci = pd.CategoricalIndex(list('aabbca'),
+ categories=list('cab'),
+ ordered=False)
+ with pytest.raises(TypeError):
+ ci.min()
+ with pytest.raises(TypeError):
+ ci.max()
+
+ ci = pd.CategoricalIndex(list('aabbca'),
+ categories=list('cab'),
+ ordered=True)
+ assert ci.min() == 'c'
+ assert ci.max() == 'b'
+
+
class TestSeriesReductions(object):
# Note: the name TestSeriesReductions indicates these tests
# were moved from a series-specific test file, _not_ that these tests are
diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py
index 1e65118194be7..4bcd16a86e865 100644
--- a/pandas/tests/test_nanops.py
+++ b/pandas/tests/test_nanops.py
@@ -27,21 +27,21 @@ def setup_method(self, method):
np.random.seed(11235)
nanops._USE_BOTTLENECK = False
- self.arr_shape = (11, 7, 5)
+ arr_shape = (11, 7, 5)
- self.arr_float = np.random.randn(*self.arr_shape)
- self.arr_float1 = np.random.randn(*self.arr_shape)
+ self.arr_float = np.random.randn(*arr_shape)
+ self.arr_float1 = np.random.randn(*arr_shape)
self.arr_complex = self.arr_float + self.arr_float1 * 1j
- self.arr_int = np.random.randint(-10, 10, self.arr_shape)
- self.arr_bool = np.random.randint(0, 2, self.arr_shape) == 0
+ self.arr_int = np.random.randint(-10, 10, arr_shape)
+ self.arr_bool = np.random.randint(0, 2, arr_shape) == 0
self.arr_str = np.abs(self.arr_float).astype('S')
self.arr_utf = np.abs(self.arr_float).astype('U')
self.arr_date = np.random.randint(0, 20000,
- self.arr_shape).astype('M8[ns]')
+ arr_shape).astype('M8[ns]')
self.arr_tdelta = np.random.randint(0, 20000,
- self.arr_shape).astype('m8[ns]')
+ arr_shape).astype('m8[ns]')
- self.arr_nan = np.tile(np.nan, self.arr_shape)
+ self.arr_nan = np.tile(np.nan, arr_shape)
self.arr_float_nan = np.vstack([self.arr_float, self.arr_nan])
self.arr_float1_nan = np.vstack([self.arr_float1, self.arr_nan])
self.arr_nan_float1 = np.vstack([self.arr_nan, self.arr_float1])
@@ -49,22 +49,22 @@ def setup_method(self, method):
self.arr_inf = self.arr_float * np.inf
self.arr_float_inf = np.vstack([self.arr_float, self.arr_inf])
- self.arr_float1_inf = np.vstack([self.arr_float1, self.arr_inf])
- self.arr_inf_float1 = np.vstack([self.arr_inf, self.arr_float1])
- self.arr_inf_inf = np.vstack([self.arr_inf, self.arr_inf])
self.arr_nan_inf = np.vstack([self.arr_nan, self.arr_inf])
self.arr_float_nan_inf = np.vstack([self.arr_float, self.arr_nan,
self.arr_inf])
- self.arr_nan_float1_inf = np.vstack([self.arr_float, self.arr_inf,
- self.arr_nan])
self.arr_nan_nan_inf = np.vstack([self.arr_nan, self.arr_nan,
self.arr_inf])
- self.arr_obj = np.vstack([self.arr_float.astype(
- 'O'), self.arr_int.astype('O'), self.arr_bool.astype(
- 'O'), self.arr_complex.astype('O'), self.arr_str.astype(
- 'O'), self.arr_utf.astype('O'), self.arr_date.astype('O'),
- self.arr_tdelta.astype('O')])
+ self.arr_obj = np.vstack([
+ self.arr_float.astype('O'),
+ self.arr_int.astype('O'),
+ self.arr_bool.astype('O'),
+ self.arr_complex.astype('O'),
+ self.arr_str.astype('O'),
+ self.arr_utf.astype('O'),
+ self.arr_date.astype('O'),
+ self.arr_tdelta.astype('O')
+ ])
with np.errstate(invalid='ignore'):
self.arr_nan_nanj = self.arr_nan + self.arr_nan * 1j
@@ -77,51 +77,19 @@ def setup_method(self, method):
self.arr_float_2d = self.arr_float[:, :, 0]
self.arr_float1_2d = self.arr_float1[:, :, 0]
- self.arr_complex_2d = self.arr_complex[:, :, 0]
- self.arr_int_2d = self.arr_int[:, :, 0]
- self.arr_bool_2d = self.arr_bool[:, :, 0]
- self.arr_str_2d = self.arr_str[:, :, 0]
- self.arr_utf_2d = self.arr_utf[:, :, 0]
- self.arr_date_2d = self.arr_date[:, :, 0]
- self.arr_tdelta_2d = self.arr_tdelta[:, :, 0]
self.arr_nan_2d = self.arr_nan[:, :, 0]
self.arr_float_nan_2d = self.arr_float_nan[:, :, 0]
self.arr_float1_nan_2d = self.arr_float1_nan[:, :, 0]
self.arr_nan_float1_2d = self.arr_nan_float1[:, :, 0]
- self.arr_nan_nan_2d = self.arr_nan_nan[:, :, 0]
- self.arr_nan_nanj_2d = self.arr_nan_nanj[:, :, 0]
- self.arr_complex_nan_2d = self.arr_complex_nan[:, :, 0]
-
- self.arr_inf_2d = self.arr_inf[:, :, 0]
- self.arr_float_inf_2d = self.arr_float_inf[:, :, 0]
- self.arr_nan_inf_2d = self.arr_nan_inf[:, :, 0]
- self.arr_float_nan_inf_2d = self.arr_float_nan_inf[:, :, 0]
- self.arr_nan_nan_inf_2d = self.arr_nan_nan_inf[:, :, 0]
self.arr_float_1d = self.arr_float[:, 0, 0]
self.arr_float1_1d = self.arr_float1[:, 0, 0]
- self.arr_complex_1d = self.arr_complex[:, 0, 0]
- self.arr_int_1d = self.arr_int[:, 0, 0]
- self.arr_bool_1d = self.arr_bool[:, 0, 0]
- self.arr_str_1d = self.arr_str[:, 0, 0]
- self.arr_utf_1d = self.arr_utf[:, 0, 0]
- self.arr_date_1d = self.arr_date[:, 0, 0]
- self.arr_tdelta_1d = self.arr_tdelta[:, 0, 0]
self.arr_nan_1d = self.arr_nan[:, 0, 0]
self.arr_float_nan_1d = self.arr_float_nan[:, 0, 0]
self.arr_float1_nan_1d = self.arr_float1_nan[:, 0, 0]
self.arr_nan_float1_1d = self.arr_nan_float1[:, 0, 0]
- self.arr_nan_nan_1d = self.arr_nan_nan[:, 0, 0]
- self.arr_nan_nanj_1d = self.arr_nan_nanj[:, 0, 0]
- self.arr_complex_nan_1d = self.arr_complex_nan[:, 0, 0]
-
- self.arr_inf_1d = self.arr_inf.ravel()
- self.arr_float_inf_1d = self.arr_float_inf[:, 0, 0]
- self.arr_nan_inf_1d = self.arr_nan_inf[:, 0, 0]
- self.arr_float_nan_inf_1d = self.arr_float_nan_inf[:, 0, 0]
- self.arr_nan_nan_inf_1d = self.arr_nan_nan_inf[:, 0, 0]
def teardown_method(self, method):
nanops._USE_BOTTLENECK = use_bn
| Remove unused attributes in test_nanops | https://api.github.com/repos/pandas-dev/pandas/pulls/24776 | 2019-01-14T23:37:18Z | 2019-01-16T01:43:21Z | 2019-01-16T01:43:21Z | 2019-01-16T02:57:03Z |
Update DataFrame.eq docstring | diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index e11f0ee01e57c..10cebc6f94b92 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -732,8 +732,7 @@ def _get_op_name(op, special):
B 150 250
C 100 300
-Compare to a scalar and operator version which return the same
-results.
+Comparison with a scalar, using either the operator or method:
>>> df == 100
cost revenue
@@ -747,33 +746,40 @@ def _get_op_name(op, special):
B False False
C True False
-Compare to a list and Series by axis and operator version. As shown,
-for list axis is by default 'index', but for Series axis is by
-default 'columns'.
+When `other` is a :class:`Series`, the columns of a DataFrame are aligned
+with the index of `other` and broadcast:
->>> df != [100, 250, 300]
- cost revenue
-A True False
-B True False
-C True False
+>>> df != pd.Series([100, 250], index=["cost", "revenue"])
+ cost revenue
+A True True
+B True False
+C False True
+
+Use the method to control the broadcast axis:
->>> df.ne([100, 250, 300], axis='index')
+>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index')
cost revenue
A True False
-B True False
-C True False
+B True True
+C True True
+D True True
->>> df != pd.Series([100, 250, 300])
- cost revenue 0 1 2
-A True True True True True
-B True True True True True
-C True True True True True
+When comparing to an arbitrary sequence, the number of columns must
+match the number elements in `other`:
->>> df.ne(pd.Series([100, 250, 300]), axis='columns')
- cost revenue 0 1 2
-A True True True True True
-B True True True True True
-C True True True True True
+>>> df == [250, 100]
+ cost revenue
+A True True
+B False False
+C False False
+
+Use the method to control the axis:
+
+>>> df.eq([250, 250, 100], axis='index')
+ cost revenue
+A True False
+B False True
+C True False
Compare to a DataFrame of different shape.
@@ -798,7 +804,7 @@ def _get_op_name(op, special):
>>> df_multindex = pd.DataFrame({{'cost': [250, 150, 100, 150, 300, 220],
... 'revenue': [100, 250, 300, 200, 175, 225]}},
... index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'],
-... ['A', 'B', 'C', 'A', 'B' ,'C']])
+... ['A', 'B', 'C', 'A', 'B', 'C']])
>>> df_multindex
cost revenue
Q1 A 250 100
| This was failing due to http://pandas.pydata.org/pandas-docs/version/0.24.0rc1/whatsnew/v0.24.0.html#dataframe-comparison-operations-broadcasting-changes
I'm surprised the doctests didn't catch this. @datapythonista, `pandas.DataFrame.eq` is included in the API docs at http://pandas-docs.github.io/pandas-docs-travis/api/generated/pandas.DataFrame.eq.html. I believe it's because EX02 isn't passed in the code checks. @datapythonista do you know if that's deliberate? | https://api.github.com/repos/pandas-dev/pandas/pulls/24774 | 2019-01-14T22:33:39Z | 2019-01-15T14:04:20Z | 2019-01-15T14:04:20Z | 2019-02-13T13:08:28Z |
Fix flake8 issues in doc/source/enhancingperf.rst | diff --git a/doc/source/enhancingperf.rst b/doc/source/enhancingperf.rst
index a4a96eea4d8e2..0e3d389aa4f6e 100644
--- a/doc/source/enhancingperf.rst
+++ b/doc/source/enhancingperf.rst
@@ -73,7 +73,7 @@ four calls) using the `prun ipython magic function <http://ipython.org/ipython-d
.. ipython:: python
- %prun -l 4 df.apply(lambda x: integrate_f(x['a'], x['b'], x['N']), axis=1)
+ %prun -l 4 df.apply(lambda x: integrate_f(x['a'], x['b'], x['N']), axis=1) # noqa E999
By far the majority of time is spend inside either ``integrate_f`` or ``f``,
hence we'll concentrate our efforts cythonizing these two functions.
@@ -189,8 +189,10 @@ in Python, so maybe we could minimize these by cythonizing the apply part.
...: for i in range(N):
...: s += f_typed(a + i * dx)
...: return s * dx
- ...: cpdef np.ndarray[double] apply_integrate_f(np.ndarray col_a, np.ndarray col_b, np.ndarray col_N):
- ...: assert (col_a.dtype == np.float and col_b.dtype == np.float and col_N.dtype == np.int)
+ ...: cpdef np.ndarray[double] apply_integrate_f(np.ndarray col_a, np.ndarray col_b,
+ ...: np.ndarray col_N):
+ ...: assert (col_a.dtype == np.float
+ ...: and col_b.dtype == np.float and col_N.dtype == np.int)
...: cdef Py_ssize_t i, n = len(col_N)
...: assert (len(col_a) == len(col_b) == n)
...: cdef np.ndarray[double] res = np.empty(n)
@@ -271,7 +273,9 @@ advanced Cython techniques:
...: return s * dx
...: @cython.boundscheck(False)
...: @cython.wraparound(False)
- ...: cpdef np.ndarray[double] apply_integrate_f_wrap(np.ndarray[double] col_a, np.ndarray[double] col_b, np.ndarray[int] col_N):
+ ...: cpdef np.ndarray[double] apply_integrate_f_wrap(np.ndarray[double] col_a,
+ ...: np.ndarray[double] col_b,
+ ...: np.ndarray[int] col_N):
...: cdef int i, n = len(col_N)
...: assert len(col_a) == len(col_b) == n
...: cdef np.ndarray[double] res = np.empty(n)
@@ -317,45 +321,45 @@ take the plain Python code from above and annotate with the ``@jit`` decorator.
.. code-block:: python
- import numba
+ import numba
- @numba.jit
- def f_plain(x):
- return x * (x - 1)
+ @numba.jit
+ def f_plain(x):
+ return x * (x - 1)
- @numba.jit
- def integrate_f_numba(a, b, N):
- s = 0
- dx = (b - a) / N
- for i in range(N):
- s += f_plain(a + i * dx)
- return s * dx
+ @numba.jit
+ def integrate_f_numba(a, b, N):
+ s = 0
+ dx = (b - a) / N
+ for i in range(N):
+ s += f_plain(a + i * dx)
+ return s * dx
- @numba.jit
- def apply_integrate_f_numba(col_a, col_b, col_N):
- n = len(col_N)
- result = np.empty(n, dtype='float64')
- assert len(col_a) == len(col_b) == n
- for i in range(n):
- result[i] = integrate_f_numba(col_a[i], col_b[i], col_N[i])
- return result
+ @numba.jit
+ def apply_integrate_f_numba(col_a, col_b, col_N):
+ n = len(col_N)
+ result = np.empty(n, dtype='float64')
+ assert len(col_a) == len(col_b) == n
+ for i in range(n):
+ result[i] = integrate_f_numba(col_a[i], col_b[i], col_N[i])
+ return result
- def compute_numba(df):
- result = apply_integrate_f_numba(df['a'].values, df['b'].values,
- df['N'].values)
- return pd.Series(result, index=df.index, name='result')
+ def compute_numba(df):
+ result = apply_integrate_f_numba(df['a'].values, df['b'].values,
+ df['N'].values)
+ return pd.Series(result, index=df.index, name='result')
Note that we directly pass NumPy arrays to the Numba function. ``compute_numba`` is just a wrapper that provides a
nicer interface by passing/returning pandas objects.
.. code-block:: ipython
- In [4]: %timeit compute_numba(df)
- 1000 loops, best of 3: 798 us per loop
+ In [4]: %timeit compute_numba(df)
+ 1000 loops, best of 3: 798 us per loop
In this example, using Numba was faster than Cython.
@@ -368,30 +372,30 @@ Consider the following toy example of doubling each observation:
.. code-block:: python
- import numba
+ import numba
- def double_every_value_nonumba(x):
- return x * 2
+ def double_every_value_nonumba(x):
+ return x * 2
- @numba.vectorize
- def double_every_value_withnumba(x):
- return x * 2
+ @numba.vectorize
+ def double_every_value_withnumba(x): # noqa E501
+ return x * 2
.. code-block:: ipython
- # Custom function without numba
- In [5]: %timeit df['col1_doubled'] = df.a.apply(double_every_value_nonumba)
- 1000 loops, best of 3: 797 us per loop
+ # Custom function without numba
+ In [5]: %timeit df['col1_doubled'] = df.a.apply(double_every_value_nonumba) # noqa E501
+ 1000 loops, best of 3: 797 us per loop
- # Standard implementation (faster than a custom function)
- In [6]: %timeit df['col1_doubled'] = df.a*2
- 1000 loops, best of 3: 233 us per loop
+ # Standard implementation (faster than a custom function)
+ In [6]: %timeit df['col1_doubled'] = df.a * 2
+ 1000 loops, best of 3: 233 us per loop
- # Custom function with numba
- In [7]: %timeit df['col1_doubled'] = double_every_value_withnumba(df.a.values)
- 1000 loops, best of 3: 145 us per loop
+ # Custom function with numba
+ In [7]: %timeit (df['col1_doubled'] = double_every_value_withnumba(df.a.values)
+ 1000 loops, best of 3: 145 us per loop
Caveats
~~~~~~~
diff --git a/setup.cfg b/setup.cfg
index 44d92c0b8777f..95c71826a80d4 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -48,7 +48,6 @@ ignore = E402, # module level import not at top of file
exclude =
doc/source/basics.rst
doc/source/contributing_docstring.rst
- doc/source/enhancingperf.rst
[yapf]
| - [ ] closes #24176
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
| https://api.github.com/repos/pandas-dev/pandas/pulls/24772 | 2019-01-14T20:14:27Z | 2019-01-15T14:12:07Z | 2019-01-15T14:12:07Z | 2019-01-15T14:12:07Z |
API: Added is_extension_array_dtype | diff --git a/doc/source/api/general_utility_functions.rst b/doc/source/api/general_utility_functions.rst
index bed76d5b04b5e..e151f8f57ed5e 100644
--- a/doc/source/api/general_utility_functions.rst
+++ b/doc/source/api/general_utility_functions.rst
@@ -63,6 +63,7 @@ Dtype introspection
api.types.is_datetime64_ns_dtype
api.types.is_datetime64tz_dtype
api.types.is_extension_type
+ api.types.is_extension_array_dtype
api.types.is_float_dtype
api.types.is_int64_dtype
api.types.is_integer_dtype
diff --git a/pandas/core/dtypes/api.py b/pandas/core/dtypes/api.py
index 76021705563bf..e9d7b9c4281bd 100644
--- a/pandas/core/dtypes/api.py
+++ b/pandas/core/dtypes/api.py
@@ -5,10 +5,10 @@
is_categorical_dtype, is_complex, is_complex_dtype,
is_datetime64_any_dtype, is_datetime64_dtype, is_datetime64_ns_dtype,
is_datetime64tz_dtype, is_datetimetz, is_dict_like, is_dtype_equal,
- is_extension_type, is_file_like, is_float, is_float_dtype, is_hashable,
- is_int64_dtype, is_integer, is_integer_dtype, is_interval,
- is_interval_dtype, is_iterator, is_list_like, is_named_tuple, is_number,
- is_numeric_dtype, is_object_dtype, is_period, is_period_dtype, is_re,
- is_re_compilable, is_scalar, is_signed_integer_dtype, is_sparse,
+ is_extension_array_dtype, is_extension_type, is_file_like, is_float,
+ is_float_dtype, is_hashable, is_int64_dtype, is_integer, is_integer_dtype,
+ is_interval, is_interval_dtype, is_iterator, is_list_like, is_named_tuple,
+ is_number, is_numeric_dtype, is_object_dtype, is_period, is_period_dtype,
+ is_re, is_re_compilable, is_scalar, is_signed_integer_dtype, is_sparse,
is_string_dtype, is_timedelta64_dtype, is_timedelta64_ns_dtype,
is_unsigned_integer_dtype, pandas_dtype)
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index 507dacb5322a6..e9bf0f87088db 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -1700,15 +1700,21 @@ def is_extension_type(arr):
def is_extension_array_dtype(arr_or_dtype):
- """Check if an object is a pandas extension array type.
+ """
+ Check if an object is a pandas extension array type.
+
+ See the :ref:`Use Guide <extending.extension-types>` for more.
Parameters
----------
arr_or_dtype : object
+ For array-like input, the ``.dtype`` attribute will
+ be extracted.
Returns
-------
bool
+ Whether the `arr_or_dtype` is an extension array type.
Notes
-----
@@ -1718,9 +1724,25 @@ def is_extension_array_dtype(arr_or_dtype):
* Categorical
* Sparse
* Interval
+ * Period
+ * DatetimeArray
+ * TimedeltaArray
Third-party libraries may implement arrays or types satisfying
this interface as well.
+
+ Examples
+ --------
+ >>> from pandas.api.types import is_extension_array_dtype
+ >>> arr = pd.Categorical(['a', 'b'])
+ >>> is_extension_array_dtype(arr)
+ True
+ >>> is_extension_array_dtype(arr.dtype)
+ True
+
+ >>> arr = np.array(['a', 'b'])
+ >>> is_extension_array_dtype(arr.dtype)
+ False
"""
dtype = getattr(arr_or_dtype, 'dtype', arr_or_dtype)
return (isinstance(dtype, ExtensionDtype) or
diff --git a/pandas/tests/api/test_types.py b/pandas/tests/api/test_types.py
index 0a81557005477..235d7ecc64f60 100644
--- a/pandas/tests/api/test_types.py
+++ b/pandas/tests/api/test_types.py
@@ -24,7 +24,8 @@ class TestTypes(Base):
'is_dict_like', 'is_iterator', 'is_file_like',
'is_list_like', 'is_hashable', 'is_array_like',
'is_named_tuple',
- 'pandas_dtype', 'union_categoricals', 'infer_dtype']
+ 'pandas_dtype', 'union_categoricals', 'infer_dtype',
+ 'is_extension_array_dtype']
deprecated = ['is_period', 'is_datetimetz']
dtypes = ['CategoricalDtype', 'DatetimeTZDtype',
'PeriodDtype', 'IntervalDtype']
| https://api.github.com/repos/pandas-dev/pandas/pulls/24771 | 2019-01-14T19:57:16Z | 2019-01-14T21:05:34Z | 2019-01-14T21:05:34Z | 2019-11-21T16:17:21Z | |
DOC: Correct minor spelling error | diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index 7097a702227d7..856aa52f82cf5 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -412,12 +412,12 @@ class _BaseOffset(object):
**self.kwds)
def __neg__(self):
- # Note: we are defering directly to __mul__ instead of __rmul__, as
+ # Note: we are deferring directly to __mul__ instead of __rmul__, as
# that allows us to use methods that can go in a `cdef class`
return self * -1
def copy(self):
- # Note: we are defering directly to __mul__ instead of __rmul__, as
+ # Note: we are deferring directly to __mul__ instead of __rmul__, as
# that allows us to use methods that can go in a `cdef class`
return self * 1
| - [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24770 | 2019-01-14T19:16:05Z | 2019-01-14T20:07:00Z | 2019-01-14T20:07:00Z | 2019-01-14T20:07:05Z |
DOC: update DF.set_index | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 3685a24d60e74..de9583ed208a5 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1147,8 +1147,8 @@ Other API Changes
- :class:`pandas.io.formats.style.Styler` supports a ``number-format`` property when using :meth:`~pandas.io.formats.style.Styler.to_excel` (:issue:`22015`)
- :meth:`DataFrame.corr` and :meth:`Series.corr` now raise a ``ValueError`` along with a helpful error message instead of a ``KeyError`` when supplied with an invalid method (:issue:`22298`)
- :meth:`shift` will now always return a copy, instead of the previous behaviour of returning self when shifting by 0 (:issue:`22397`)
-- :meth:`DataFrame.set_index` now allows all one-dimensional list-likes, raises a ``TypeError`` for incorrect types,
- has an improved ``KeyError`` message, and will not fail on duplicate column names with ``drop=True``. (:issue:`22484`)
+- :meth:`DataFrame.set_index` now gives a better (and less frequent) KeyError, raises a ``ValueError`` for incorrect types,
+ and will not fail on duplicate column names with ``drop=True``. (:issue:`22484`)
- Slicing a single row of a DataFrame with multiple ExtensionArrays of the same type now preserves the dtype, rather than coercing to object (:issue:`22784`)
- :class:`DateOffset` attribute `_cacheable` and method `_should_cache` have been removed (:issue:`23118`)
- :meth:`Series.searchsorted`, when supplied a scalar value to search for, now returns a scalar instead of an array (:issue:`23801`).
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 309fb3b841461..b4f79bda25517 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -4042,12 +4042,16 @@ def set_index(self, keys, drop=True, append=False, inplace=False,
Set the DataFrame index using existing columns.
Set the DataFrame index (row labels) using one or more existing
- columns. The index can replace the existing index or expand on it.
+ columns or arrays (of the correct length). The index can replace the
+ existing index or expand on it.
Parameters
----------
- keys : label or list of label
- Name or names of the columns that will be used as the index.
+ keys : label or array-like or list of labels/arrays
+ This parameter can be either a single column key, a single array of
+ the same length as the calling DataFrame, or a list containing an
+ arbitrary combination of column keys and arrays. Here, "array"
+ encompasses :class:`Series`, :class:`Index` and ``np.ndarray``.
drop : bool, default True
Delete columns to be used as the new index.
append : bool, default False
@@ -4092,7 +4096,7 @@ def set_index(self, keys, drop=True, append=False, inplace=False,
7 2013 84
10 2014 31
- Create a multi-index using columns 'year' and 'month':
+ Create a MultiIndex using columns 'year' and 'month':
>>> df.set_index(['year', 'month'])
sale
@@ -4102,35 +4106,51 @@ def set_index(self, keys, drop=True, append=False, inplace=False,
2013 7 84
2014 10 31
- Create a multi-index using a set of values and a column:
+ Create a MultiIndex using an Index and a column:
- >>> df.set_index([[1, 2, 3, 4], 'year'])
+ >>> df.set_index([pd.Index([1, 2, 3, 4]), 'year'])
month sale
year
1 2012 1 55
2 2014 4 40
3 2013 7 84
4 2014 10 31
+
+ Create a MultiIndex using two Series:
+
+ >>> s = pd.Series([1, 2, 3, 4])
+ >>> df.set_index([s, s**2])
+ month year sale
+ 1 1 1 2012 55
+ 2 4 4 2014 40
+ 3 9 7 2013 84
+ 4 16 10 2014 31
"""
inplace = validate_bool_kwarg(inplace, 'inplace')
- if not isinstance(keys, list):
+
+ err_msg = ('The parameter "keys" may be a column key, one-dimensional '
+ 'array, or a list containing only valid column keys and '
+ 'one-dimensional arrays.')
+
+ if (is_scalar(keys) or isinstance(keys, tuple)
+ or isinstance(keys, (ABCIndexClass, ABCSeries, np.ndarray))):
+ # make sure we have a container of keys/arrays we can iterate over
+ # tuples can appear as valid column keys!
keys = [keys]
+ elif not isinstance(keys, list):
+ raise ValueError(err_msg)
missing = []
for col in keys:
- if (is_scalar(col) or isinstance(col, tuple)) and col in self:
- # tuples can be both column keys or list-likes
- # if they are valid column keys, everything is fine
- continue
- elif is_scalar(col) and col not in self:
- # tuples that are not column keys are considered list-like,
- # not considered missing
- missing.append(col)
- elif (not is_list_like(col, allow_sets=False)
+ if (is_scalar(col) or isinstance(col, tuple)):
+ # if col is a valid column key, everything is fine
+ # tuples are always considered keys, never as list-likes
+ if col not in self:
+ missing.append(col)
+ elif (not isinstance(col, (ABCIndexClass, ABCSeries,
+ np.ndarray, list))
or getattr(col, 'ndim', 1) > 1):
- raise TypeError('The parameter "keys" may only contain a '
- 'combination of valid column keys and '
- 'one-dimensional list-likes')
+ raise ValueError(err_msg)
if missing:
raise KeyError('{}'.format(missing))
@@ -4163,12 +4183,6 @@ def set_index(self, keys, drop=True, append=False, inplace=False,
elif isinstance(col, (list, np.ndarray)):
arrays.append(col)
names.append(None)
- elif (is_list_like(col)
- and not (isinstance(col, tuple) and col in self)):
- # all other list-likes (but avoid valid column keys)
- col = list(col) # ensure iterator do not get read twice etc.
- arrays.append(col)
- names.append(None)
# from here, col can only be a column label
else:
arrays.append(frame[col]._values)
diff --git a/pandas/tests/frame/test_alter_axes.py b/pandas/tests/frame/test_alter_axes.py
index b63151dfb459e..c2355742199dc 100644
--- a/pandas/tests/frame/test_alter_axes.py
+++ b/pandas/tests/frame/test_alter_axes.py
@@ -118,7 +118,7 @@ def test_set_index_after_mutation(self):
# Add list-of-list constructor because list is ambiguous -> lambda
# also test index name if append=True (name is duplicate here for B)
@pytest.mark.parametrize('box', [Series, Index, np.array,
- list, tuple, iter, lambda x: [list(x)],
+ list, lambda x: [list(x)],
lambda x: MultiIndex.from_arrays([x])])
@pytest.mark.parametrize('append, index_name', [(True, None),
(True, 'B'), (True, 'test'), (False, None)])
@@ -135,7 +135,7 @@ def test_set_index_pass_single_array(self, frame_of_index_cols,
with pytest.raises(KeyError, match=msg):
df.set_index(key, drop=drop, append=append)
else:
- # np.array/tuple/iter/list-of-list "forget" the name of B
+ # np.array/list-of-list "forget" the name of B
name_mi = getattr(key, 'names', None)
name = [getattr(key, 'name', None)] if name_mi is None else name_mi
@@ -150,8 +150,7 @@ def test_set_index_pass_single_array(self, frame_of_index_cols,
# MultiIndex constructor does not work directly on Series -> lambda
# also test index name if append=True (name is duplicate here for A & B)
- @pytest.mark.parametrize('box', [Series, Index, np.array,
- list, tuple, iter,
+ @pytest.mark.parametrize('box', [Series, Index, np.array, list,
lambda x: MultiIndex.from_arrays([x])])
@pytest.mark.parametrize('append, index_name',
[(True, None), (True, 'A'), (True, 'B'),
@@ -163,7 +162,7 @@ def test_set_index_pass_arrays(self, frame_of_index_cols,
df.index.name = index_name
keys = ['A', box(df['B'])]
- # np.array/list/tuple/iter "forget" the name of B
+ # np.array/list "forget" the name of B
names = ['A', None if box in [np.array, list, tuple, iter] else 'B']
result = df.set_index(keys, drop=drop, append=append)
@@ -179,12 +178,10 @@ def test_set_index_pass_arrays(self, frame_of_index_cols,
# MultiIndex constructor does not work directly on Series -> lambda
# We also emulate a "constructor" for the label -> lambda
# also test index name if append=True (name is duplicate here for A)
- @pytest.mark.parametrize('box2', [Series, Index, np.array,
- list, tuple, iter,
+ @pytest.mark.parametrize('box2', [Series, Index, np.array, list,
lambda x: MultiIndex.from_arrays([x]),
lambda x: x.name])
- @pytest.mark.parametrize('box1', [Series, Index, np.array,
- list, tuple, iter,
+ @pytest.mark.parametrize('box1', [Series, Index, np.array, list,
lambda x: MultiIndex.from_arrays([x]),
lambda x: x.name])
@pytest.mark.parametrize('append, index_name', [(True, None),
@@ -198,9 +195,6 @@ def test_set_index_pass_arrays_duplicate(self, frame_of_index_cols, drop,
keys = [box1(df['A']), box2(df['A'])]
result = df.set_index(keys, drop=drop, append=append)
- # if either box was iter, the content has been consumed; re-read it
- keys = [box1(df['A']), box2(df['A'])]
-
# need to adapt first drop for case that both keys are 'A' --
# cannot drop the same column twice;
# use "is" because == would give ambiguous Boolean error for containers
@@ -208,7 +202,7 @@ def test_set_index_pass_arrays_duplicate(self, frame_of_index_cols, drop,
# to test against already-tested behaviour, we add sequentially,
# hence second append always True; must wrap keys in list, otherwise
- # box = list would be illegal
+ # box = list would be interpreted as keys
expected = df.set_index([keys[0]], drop=first_drop, append=append)
expected = expected.set_index([keys[1]], drop=drop, append=True)
tm.assert_frame_equal(result, expected)
@@ -238,7 +232,7 @@ def test_set_index_verify_integrity(self, frame_of_index_cols):
@pytest.mark.parametrize('append', [True, False])
@pytest.mark.parametrize('drop', [True, False])
- def test_set_index_raise(self, frame_of_index_cols, drop, append):
+ def test_set_index_raise_keys(self, frame_of_index_cols, drop, append):
df = frame_of_index_cols
with pytest.raises(KeyError, match="['foo', 'bar', 'baz']"):
@@ -249,14 +243,31 @@ def test_set_index_raise(self, frame_of_index_cols, drop, append):
with pytest.raises(KeyError, match='X'):
df.set_index([df['A'], df['B'], 'X'], drop=drop, append=append)
- msg = 'The parameter "keys" may only contain a combination of.*'
- # forbidden type, e.g. set
- with pytest.raises(TypeError, match=msg):
- df.set_index(set(df['A']), drop=drop, append=append)
+ msg = "[('foo', 'foo', 'foo', 'bar', 'bar')]"
+ # tuples always raise KeyError
+ with pytest.raises(KeyError, match=msg):
+ df.set_index(tuple(df['A']), drop=drop, append=append)
+
+ # also within a list
+ with pytest.raises(KeyError, match=msg):
+ df.set_index(['A', df['A'], tuple(df['A'])],
+ drop=drop, append=append)
+
+ @pytest.mark.parametrize('append', [True, False])
+ @pytest.mark.parametrize('drop', [True, False])
+ @pytest.mark.parametrize('box', [set, iter])
+ def test_set_index_raise_on_type(self, frame_of_index_cols, box,
+ drop, append):
+ df = frame_of_index_cols
+
+ msg = 'The parameter "keys" may be a column key, .*'
+ # forbidden type, e.g. set/tuple/iter
+ with pytest.raises(ValueError, match=msg):
+ df.set_index(box(df['A']), drop=drop, append=append)
- # forbidden type in list, e.g. set
- with pytest.raises(TypeError, match=msg):
- df.set_index(['A', df['A'], set(df['A'])],
+ # forbidden type in list, e.g. set/tuple/iter
+ with pytest.raises(ValueError, match=msg):
+ df.set_index(['A', df['A'], box(df['A'])],
drop=drop, append=append)
def test_construction_with_categorical_index(self):
| Split off from #24697 by request of @jorisvandenbossche & @jreback
I kept the change for the whatsnew of #22486, to at least not *emphasize* that there are now ambiguous list-likes available for `DataFrame.set_index` (which haven't seen a release yet and would be removed again by #24697), which would/will make moving forward on this a bit easier. @toobaz
| https://api.github.com/repos/pandas-dev/pandas/pulls/24762 | 2019-01-14T07:01:51Z | 2019-01-19T21:18:53Z | 2019-01-19T21:18:53Z | 2019-01-20T02:39:47Z |
BUG: DataFrame.min/max with axis=1 and uniform datetime64[ns, tz] types does not return NaNs | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 5213120b33f06..61902ede045ef 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1647,6 +1647,7 @@ Timezones
- Bug in :meth:`DataFrame.any` returns wrong value when ``axis=1`` and the data is of datetimelike type (:issue:`23070`)
- Bug in :meth:`DatetimeIndex.to_period` where a timezone aware index was converted to UTC first before creating :class:`PeriodIndex` (:issue:`22905`)
- Bug in :meth:`DataFrame.tz_localize`, :meth:`DataFrame.tz_convert`, :meth:`Series.tz_localize`, and :meth:`Series.tz_convert` where ``copy=False`` would mutate the original argument inplace (:issue:`6326`)
+- Bug in :meth:`DataFrame.max` and :meth:`DataFrame.min` with ``axis=1`` where a :class:`Series` with ``NaN`` would be returned when all columns contained the same timezone (:issue:`10390`)
Offsets
^^^^^^^
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 7bbbdd70e062e..309fb3b841461 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -49,6 +49,7 @@
find_common_type)
from pandas.core.dtypes.common import (
is_dict_like,
+ is_datetime64tz_dtype,
is_object_dtype,
is_extension_type,
is_extension_array_dtype,
@@ -7390,7 +7391,9 @@ def f(x):
return op(x, axis=axis, skipna=skipna, **kwds)
# exclude timedelta/datetime unless we are uniform types
- if axis == 1 and self._is_mixed_type and self._is_datelike_mixed_type:
+ if (axis == 1 and self._is_datelike_mixed_type
+ and (not self._is_homogeneous_type
+ and not is_datetime64tz_dtype(self.dtypes[0]))):
numeric_only = True
if numeric_only is None:
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index d27308029fa19..b269fca6f9ea6 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -135,6 +135,19 @@ def test_nanops(self):
assert obj.argmin(skipna=False) == -1
assert obj.argmax(skipna=False) == -1
+ @pytest.mark.parametrize('op, expected_col', [
+ ['max', 'a'], ['min', 'b']
+ ])
+ def test_same_tz_min_max_axis_1(self, op, expected_col):
+ # GH 10390
+ df = DataFrame(pd.date_range('2016-01-01 00:00:00', periods=3,
+ tz='UTC'),
+ columns=['a'])
+ df['b'] = df.a.subtract(pd.Timedelta(seconds=3600))
+ result = getattr(df, op)(axis=1)
+ expected = df[expected_col]
+ tm.assert_series_equal(result, expected)
+
class TestSeriesReductions(object):
# Note: the name TestSeriesReductions indicates these tests
| - [x] closes #10390
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Essentially, check that all blocks are are datetimetz type and the same timezone before performing `max`/`min` since datetimetz blocks are only 1D | https://api.github.com/repos/pandas-dev/pandas/pulls/24759 | 2019-01-14T00:28:56Z | 2019-01-16T01:36:21Z | 2019-01-16T01:36:21Z | 2019-01-16T05:11:24Z |
COMPAT: Properly encode filenames in read_csv | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index a18739f4b26bf..5213120b33f06 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1790,6 +1790,7 @@ I/O
- Bug in :meth:`DataFrame.to_dict` when the resulting dict contains non-Python scalars in the case of numeric data (:issue:`23753`)
- :func:`DataFrame.to_string()`, :func:`DataFrame.to_html()`, :func:`DataFrame.to_latex()` will correctly format output when a string is passed as the ``float_format`` argument (:issue:`21625`, :issue:`22270`)
- Bug in :func:`read_csv` that caused it to raise ``OverflowError`` when trying to use 'inf' as ``na_value`` with integer index column (:issue:`17128`)
+- Bug in :func:`read_csv` that caused the C engine on Python 3.6+ on Windows to improperly read CSV filenames with accented or special characters (:issue:`15086`)
- Bug in :func:`read_fwf` in which the compression type of a file was not being properly inferred (:issue:`22199`)
- Bug in :func:`pandas.io.json.json_normalize` that caused it to raise ``TypeError`` when two consecutive elements of ``record_path`` are dicts (:issue:`22706`)
- Bug in :meth:`DataFrame.to_stata`, :class:`pandas.io.stata.StataWriter` and :class:`pandas.io.stata.StataWriter117` where a exception would leave a partially written and invalid dta file (:issue:`23573`)
diff --git a/pandas/_libs/parsers.pyx b/pandas/_libs/parsers.pyx
index e0fcf102701f4..6cb6ed749f87b 100644
--- a/pandas/_libs/parsers.pyx
+++ b/pandas/_libs/parsers.pyx
@@ -677,7 +677,13 @@ cdef class TextReader:
if isinstance(source, basestring):
if not isinstance(source, bytes):
- source = source.encode(sys.getfilesystemencoding() or 'utf-8')
+ if compat.PY36 and compat.is_platform_windows():
+ # see gh-15086.
+ encoding = "mbcs"
+ else:
+ encoding = sys.getfilesystemencoding() or "utf-8"
+
+ source = source.encode(encoding)
if self.memory_map:
ptr = new_mmap(source)
diff --git a/pandas/tests/io/parser/test_common.py b/pandas/tests/io/parser/test_common.py
index 6860452f5ccc4..d87ef7cd15a64 100644
--- a/pandas/tests/io/parser/test_common.py
+++ b/pandas/tests/io/parser/test_common.py
@@ -1904,6 +1904,18 @@ def test_suppress_error_output(all_parsers, capsys):
assert captured.err == ""
+def test_filename_with_special_chars(all_parsers):
+ # see gh-15086.
+ parser = all_parsers
+ df = DataFrame({"a": [1, 2, 3]})
+
+ with tm.ensure_clean("sé-es-vé.csv") as path:
+ df.to_csv(path, index=False)
+
+ result = parser.read_csv(path)
+ tm.assert_frame_equal(result, df)
+
+
def test_read_table_deprecated(all_parsers):
# see gh-21948
parser = all_parsers
| Python 3.6+ changes the default encoding to `utf8` ([PEP 529](https://www.python.org/dev/peps/pep-0529/)), which conflicts with the encoding of Windows (`mbcs`). This conflicts rears its head when using only the C engine of `read_csv` because of the low level functionality that we implement ourselves.
This fix checks if we're using Python 3.6+ and on Windows, after which we force the encoding to `mbcs`
Closes #15086. | https://api.github.com/repos/pandas-dev/pandas/pulls/24758 | 2019-01-13T23:42:56Z | 2019-01-14T13:36:13Z | 2019-01-14T13:36:12Z | 2019-01-14T17:59:14Z |
implement+test mean for datetimelike EA/Index/Series | diff --git a/doc/source/reference/indexing.rst b/doc/source/reference/indexing.rst
index 42ebf648f299f..6d27e225b681e 100644
--- a/doc/source/reference/indexing.rst
+++ b/doc/source/reference/indexing.rst
@@ -403,6 +403,13 @@ Conversion
DatetimeIndex.to_series
DatetimeIndex.to_frame
+Methods
+~~~~~~~
+.. autosummary::
+ :toctree: api/
+
+ DatetimeIndex.mean
+
TimedeltaIndex
--------------
.. autosummary::
@@ -435,6 +442,13 @@ Conversion
TimedeltaIndex.ceil
TimedeltaIndex.to_frame
+Methods
+~~~~~~~
+.. autosummary::
+ :toctree: api/
+
+ TimedeltaIndex.mean
+
.. currentmodule:: pandas
PeriodIndex
diff --git a/doc/source/whatsnew/v0.25.0.rst b/doc/source/whatsnew/v0.25.0.rst
index 0e8cd95084a8d..6794c0c01e653 100644
--- a/doc/source/whatsnew/v0.25.0.rst
+++ b/doc/source/whatsnew/v0.25.0.rst
@@ -82,6 +82,7 @@ Other Enhancements
- :meth:`DataFrame.query` and :meth:`DataFrame.eval` now supports quoting column names with backticks to refer to names with spaces (:issue:`6508`)
- :func:`merge_asof` now gives a more clear error message when merge keys are categoricals that are not equal (:issue:`26136`)
- :meth:`pandas.core.window.Rolling` supports exponential (or Poisson) window type (:issue:`21303`)
+- :class:`DatetimeIndex` and :class:`TimedeltaIndex` now have a `mean` method (:issue:`24757`)
-
.. _whatsnew_0250.api_breaking:
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index c32f8642dc2ed..61594be8ec385 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -1382,7 +1382,7 @@ def _ensure_localized(self, arg, ambiguous='raise', nonexistent='raise',
def _reduce(self, name, axis=0, skipna=True, **kwargs):
op = getattr(self, name, None)
if op:
- return op(axis=axis, skipna=skipna, **kwargs)
+ return op(skipna=skipna, **kwargs)
else:
return super()._reduce(name, skipna, **kwargs)
@@ -1438,6 +1438,54 @@ def max(self, axis=None, skipna=True, *args, **kwargs):
# Don't have to worry about NA `result`, since no NA went in.
return self._box_func(result)
+ def mean(self, skipna=True):
+ """
+ Return the mean value of the Array.
+
+ .. versionadded:: 0.25.0
+
+ Parameters
+ ----------
+ skipna : bool, default True
+ Whether to ignore any NaT elements
+
+ Returns
+ -------
+ scalar (Timestamp or Timedelta)
+
+ See Also
+ --------
+ numpy.ndarray.mean
+ Series.mean : Return the mean value in a Series.
+
+ Notes
+ -----
+ mean is only defined for Datetime and Timedelta dtypes, not for Period.
+ """
+ if is_period_dtype(self):
+ # See discussion in GH#24757
+ raise TypeError(
+ "mean is not implemented for {cls} since the meaning is "
+ "ambiguous. An alternative is "
+ "obj.to_timestamp(how='start').mean()"
+ .format(cls=type(self).__name__))
+
+ mask = self.isna()
+ if skipna:
+ values = self[~mask]
+ elif mask.any():
+ return NaT
+ else:
+ values = self
+
+ if not len(values):
+ # short-circut for empty max / min
+ return NaT
+
+ result = nanops.nanmean(values.view('i8'), skipna=skipna)
+ # Don't have to worry about NA `result`, since no NA went in.
+ return self._box_func(result)
+
# -------------------------------------------------------------------
# Shared Constructor Helpers
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 092cec00228cd..6491a98812b8f 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -73,6 +73,7 @@ class DatetimeIndexOpsMixin(ExtensionOpsMixin):
_maybe_mask_results = ea_passthrough(
DatetimeLikeArrayMixin._maybe_mask_results)
__iter__ = ea_passthrough(DatetimeLikeArrayMixin.__iter__)
+ mean = ea_passthrough(DatetimeLikeArrayMixin.mean)
@property
def freq(self):
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 1bf3cb86811cb..f122a6525237c 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -203,6 +203,7 @@ class DatetimeIndex(DatetimeIndexOpsMixin, Int64Index, DatetimeDelegateMixin):
to_frame
month_name
day_name
+ mean
See Also
--------
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 0574a4b41c920..f5362c0b6bb5d 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -129,6 +129,7 @@ class TimedeltaIndex(DatetimeIndexOpsMixin, dtl.TimelikeOps, Int64Index,
floor
ceil
to_frame
+ mean
See Also
--------
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 8fb6ad3e3ccc5..37f74b35ba2a8 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -3729,6 +3729,10 @@ def _reduce(self, op, name, axis=0, skipna=True, numeric_only=None,
elif is_datetime64_dtype(delegate):
# use DatetimeIndex implementation to handle skipna correctly
delegate = DatetimeIndex(delegate)
+ elif is_timedelta64_dtype(delegate) and hasattr(TimedeltaIndex, name):
+ # use TimedeltaIndex to handle skipna correctly
+ # TODO: remove hasattr check after TimedeltaIndex has `std` method
+ delegate = TimedeltaIndex(delegate)
# dispatch to numpy arrays
elif isinstance(delegate, np.ndarray):
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index 487ff7932ec5f..568b229435434 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -1205,6 +1205,47 @@ def test_mean_corner(self, float_frame, float_string_frame):
means = float_frame.mean(0)
assert means['bool'] == float_frame['bool'].values.mean()
+ def test_mean_datetimelike(self):
+ # GH#24757 check that datetimelike are excluded by default, handled
+ # correctly with numeric_only=True
+
+ df = pd.DataFrame({
+ 'A': np.arange(3),
+ 'B': pd.date_range('2016-01-01', periods=3),
+ 'C': pd.timedelta_range('1D', periods=3),
+ 'D': pd.period_range('2016', periods=3, freq='A')
+ })
+ result = df.mean(numeric_only=True)
+ expected = pd.Series({'A': 1.})
+ tm.assert_series_equal(result, expected)
+
+ result = df.mean()
+ expected = pd.Series({
+ 'A': 1.,
+ 'C': df.loc[1, 'C']
+ })
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.xfail(reason="casts to object-dtype and then tries to "
+ "add timestamps",
+ raises=TypeError, strict=True)
+ def test_mean_datetimelike_numeric_only_false(self):
+ df = pd.DataFrame({
+ 'A': np.arange(3),
+ 'B': pd.date_range('2016-01-01', periods=3),
+ 'C': pd.timedelta_range('1D', periods=3),
+ 'D': pd.period_range('2016', periods=3, freq='A')
+ })
+
+ result = df.mean(numeric_only=False)
+ expected = pd.Series({
+ 'A': 1,
+ 'B': df.loc[1, 'B'],
+ 'C': df.loc[1, 'C'],
+ 'D': df.loc[1, 'D']
+ })
+ tm.assert_series_equal(result, expected)
+
def test_stats_mixed_type(self, float_string_frame):
# don't blow up
float_string_frame.std(1)
diff --git a/pandas/tests/reductions/test_stat_reductions.py b/pandas/tests/reductions/test_stat_reductions.py
index 223904048dd99..b0fd2f290031e 100644
--- a/pandas/tests/reductions/test_stat_reductions.py
+++ b/pandas/tests/reductions/test_stat_reductions.py
@@ -10,9 +10,78 @@
import pandas as pd
from pandas import DataFrame, Series
+from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
import pandas.util.testing as tm
+class TestDatetimeLikeStatReductions:
+
+ @pytest.mark.parametrize('box', [Series, pd.Index, DatetimeArray])
+ def test_dt64_mean(self, tz_naive_fixture, box):
+ tz = tz_naive_fixture
+
+ dti = pd.date_range('2001-01-01', periods=11, tz=tz)
+ # shuffle so that we are not just working with monotone-increasing
+ dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])
+ dtarr = dti._data
+
+ obj = box(dtarr)
+ assert obj.mean() == pd.Timestamp('2001-01-06', tz=tz)
+ assert obj.mean(skipna=False) == pd.Timestamp('2001-01-06', tz=tz)
+
+ # dtarr[-2] will be the first date 2001-01-1
+ dtarr[-2] = pd.NaT
+
+ obj = box(dtarr)
+ assert obj.mean() == pd.Timestamp('2001-01-06 07:12:00', tz=tz)
+ assert obj.mean(skipna=False) is pd.NaT
+
+ @pytest.mark.parametrize('box', [Series, pd.Index, PeriodArray])
+ def test_period_mean(self, box):
+ # GH#24757
+ dti = pd.date_range('2001-01-01', periods=11)
+ # shuffle so that we are not just working with monotone-increasing
+ dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])
+
+ # use hourly frequency to avoid rounding errors in expected results
+ # TODO: flesh this out with different frequencies
+ parr = dti._data.to_period('H')
+ obj = box(parr)
+ with pytest.raises(TypeError, match="ambiguous"):
+ obj.mean()
+ with pytest.raises(TypeError, match="ambiguous"):
+ obj.mean(skipna=True)
+
+ # parr[-2] will be the first date 2001-01-1
+ parr[-2] = pd.NaT
+
+ with pytest.raises(TypeError, match="ambiguous"):
+ obj.mean()
+ with pytest.raises(TypeError, match="ambiguous"):
+ obj.mean(skipna=True)
+
+ @pytest.mark.parametrize('box', [Series, pd.Index, TimedeltaArray])
+ def test_td64_mean(self, box):
+ tdi = pd.TimedeltaIndex([0, 3, -2, -7, 1, 2, -1, 3, 5, -2, 4],
+ unit='D')
+
+ tdarr = tdi._data
+ obj = box(tdarr)
+
+ result = obj.mean()
+ expected = np.array(tdarr).mean()
+ assert result == expected
+
+ tdarr[0] = pd.NaT
+ assert obj.mean(skipna=False) is pd.NaT
+
+ result2 = obj.mean(skipna=True)
+ assert result2 == tdi[1:].mean()
+
+ # exact equality fails by 1 nanosecond
+ assert result2.round('us') == (result * 11. / 10).round('us')
+
+
class TestSeriesStatReductions:
# Note: the name TestSeriesStatReductions indicates these tests
# were moved from a series-specific test file, _not_ that these tests are
| This takes over from #23890, implementing+testing reductions one at a time.
- [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24757 | 2019-01-13T23:41:52Z | 2019-06-10T17:31:06Z | 2019-06-10T17:31:06Z | 2019-06-27T20:10:27Z |
CI: Pinning flake8-rst, last version raises incorrect errors | diff --git a/environment.yml b/environment.yml
index a980499029478..7a177cfee3d39 100644
--- a/environment.yml
+++ b/environment.yml
@@ -14,7 +14,7 @@ dependencies:
- cython>=0.28.2
- flake8
- flake8-comprehensions
- - flake8-rst>=0.6.0
+ - flake8-rst>=0.6.0,<=0.7.0
- gitpython
- hypothesis>=3.82
- isort
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 48bd95470d391..ba78430a4b19e 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -5,7 +5,7 @@ asv
cython>=0.28.2
flake8
flake8-comprehensions
-flake8-rst>=0.6.0
+flake8-rst>=0.6.0,<=0.7.0
gitpython
hypothesis>=3.82
isort
| - [X] closes #24755
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
CC: @jreback @FHaase
| https://api.github.com/repos/pandas-dev/pandas/pulls/24756 | 2019-01-13T22:14:47Z | 2019-01-13T23:45:56Z | 2019-01-13T23:45:56Z | 2019-01-13T23:45:57Z |
CategoricalAccessor.categorical removed in 0.24.0rc1 #24751 | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 5213120b33f06..da581348d7592 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1309,6 +1309,7 @@ Deprecations
- :meth:`Series.clip_lower`, :meth:`Series.clip_upper`, :meth:`DataFrame.clip_lower` and :meth:`DataFrame.clip_upper` are deprecated and will be removed in a future version. Use ``Series.clip(lower=threshold)``, ``Series.clip(upper=threshold)`` and the equivalent ``DataFrame`` methods (:issue:`24203`)
- :meth:`Series.nonzero` is deprecated and will be removed in a future version (:issue:`18262`)
- Passing an integer to :meth:`Series.fillna` and :meth:`DataFrame.fillna` with ``timedelta64[ns]`` dtypes is deprecated, will raise ``TypeError`` in a future version. Use ``obj.fillna(pd.Timedelta(...))`` instead (:issue:`24694`)
+- ``Series.cat.categorical``, ``Series.cat.name`` and ``Sersies.cat.index`` have been deprecated. Use the attributes on ``Series.cat`` or ``Series`` directly. (:issue:`24751`).
.. _whatsnew_0240.deprecations.datetimelike_int_ops:
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 1368232470402..35b662eaae9a5 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -2498,8 +2498,8 @@ class CategoricalAccessor(PandasDelegate, PandasObject, NoNewAttributesMixin):
def __init__(self, data):
self._validate(data)
self._parent = data.values
- self.index = data.index
- self.name = data.name
+ self._index = data.index
+ self._name = data.name
self._freeze()
@staticmethod
@@ -2520,15 +2520,47 @@ def codes(self):
Return Series of codes as well as the index.
"""
from pandas import Series
- return Series(self._parent.codes, index=self.index)
+ return Series(self._parent.codes, index=self._index)
def _delegate_method(self, name, *args, **kwargs):
from pandas import Series
method = getattr(self._parent, name)
res = method(*args, **kwargs)
if res is not None:
- return Series(res, index=self.index, name=self.name)
+ return Series(res, index=self._index, name=self._name)
+ @property
+ def categorical(self):
+ # Note: Upon deprecation, `test_tab_completion_with_categorical` will
+ # need to be updated. `categorical` will need to be removed from
+ # `ok_for_cat`.
+ warn("`Series.cat.categorical` has been deprecated. Use the "
+ "attributes on 'Series.cat' directly instead.",
+ FutureWarning,
+ stacklevel=2)
+ return self._parent
+
+ @property
+ def name(self):
+ # Note: Upon deprecation, `test_tab_completion_with_categorical` will
+ # need to be updated. `name` will need to be removed from
+ # `ok_for_cat`.
+ warn("`Series.cat.name` has been deprecated. Use `Series.name` "
+ "instead.",
+ FutureWarning,
+ stacklevel=2)
+ return self._name
+
+ @property
+ def index(self):
+ # Note: Upon deprecation, `test_tab_completion_with_categorical` will
+ # need to be updated. `index` will need to be removed from
+ # ok_for_cat`.
+ warn("`Series.cat.index` has been deprecated. Use `Series.index` "
+ "instead.",
+ FutureWarning,
+ stacklevel=2)
+ return self._index
# utility routines
diff --git a/pandas/tests/arrays/categorical/test_warnings.py b/pandas/tests/arrays/categorical/test_warnings.py
index 91278580254aa..23d00585f950e 100644
--- a/pandas/tests/arrays/categorical/test_warnings.py
+++ b/pandas/tests/arrays/categorical/test_warnings.py
@@ -2,6 +2,7 @@
import pytest
+import pandas as pd
import pandas.util.testing as tm
@@ -16,3 +17,15 @@ def test_tab_complete_warning(self, ip):
with tm.assert_produces_warning(None):
with provisionalcompleter('ignore'):
list(ip.Completer.completions('c.', 1))
+
+ def test_CategoricalAccessor_categorical_deprecation(object):
+ with tm.assert_produces_warning(FutureWarning):
+ pd.Series(['a', 'b'], dtype='category').cat.categorical
+
+ def test_CategoricalAccessor_name_deprecation(object):
+ with tm.assert_produces_warning(FutureWarning):
+ pd.Series(['a', 'b'], dtype='category').cat.name
+
+ def test_CategoricalAccessor_index_deprecation(object):
+ with tm.assert_produces_warning(FutureWarning):
+ pd.Series(['a', 'b'], dtype='category').cat.index
diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py
index 09e556af883c1..c95cf125e22f7 100644
--- a/pandas/tests/series/test_api.py
+++ b/pandas/tests/series/test_api.py
@@ -245,10 +245,11 @@ def test_tab_completion(self):
def test_tab_completion_with_categorical(self):
# test the tab completion display
- ok_for_cat = ['categories', 'codes', 'ordered', 'set_categories',
- 'add_categories', 'remove_categories',
- 'rename_categories', 'reorder_categories',
- 'remove_unused_categories', 'as_ordered', 'as_unordered']
+ ok_for_cat = ['name', 'index', 'categorical', 'categories', 'codes',
+ 'ordered', 'set_categories', 'add_categories',
+ 'remove_categories', 'rename_categories',
+ 'reorder_categories', 'remove_unused_categories',
+ 'as_ordered', 'as_unordered']
def get_dir(s):
results = [r for r in s.cat.__dir__() if not r.startswith('_')]
diff --git a/pandas/tests/test_config.py b/pandas/tests/test_config.py
index 2cdcb948eb917..6e47f5543012f 100644
--- a/pandas/tests/test_config.py
+++ b/pandas/tests/test_config.py
@@ -251,7 +251,6 @@ def test_deprecate_option(self):
KeyError,
message="Nonexistent option didn't raise KeyError"):
self.cf.get_option('foo')
-
assert len(w) == 1 # should have raised one warning
assert 'deprecated' in str(w[-1]) # we get the default message
| - [ ] closes #24751
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24754 | 2019-01-13T20:43:46Z | 2019-01-15T22:53:17Z | 2019-01-15T22:53:16Z | 2019-01-15T22:53:21Z |
STY: use pytest.raises context syntax (series/indexing/*) | diff --git a/pandas/tests/series/indexing/test_alter_index.py b/pandas/tests/series/indexing/test_alter_index.py
index e2cffe653d935..a826a0644fa78 100644
--- a/pandas/tests/series/indexing/test_alter_index.py
+++ b/pandas/tests/series/indexing/test_alter_index.py
@@ -243,7 +243,10 @@ def test_reindex_corner(test_data):
# bad fill method
ts = test_data.ts[::2]
- pytest.raises(Exception, ts.reindex, test_data.ts.index, method='foo')
+ msg = (r"Invalid fill method\. Expecting pad \(ffill\), backfill"
+ r" \(bfill\) or nearest\. Got foo")
+ with pytest.raises(ValueError, match=msg):
+ ts.reindex(test_data.ts.index, method='foo')
def test_reindex_pad():
diff --git a/pandas/tests/series/indexing/test_boolean.py b/pandas/tests/series/indexing/test_boolean.py
index 9d024bffa3240..89b481b92b73f 100644
--- a/pandas/tests/series/indexing/test_boolean.py
+++ b/pandas/tests/series/indexing/test_boolean.py
@@ -49,10 +49,12 @@ def test_getitem_boolean_empty():
# invalid because of the boolean indexer
# that's empty or not-aligned
- with pytest.raises(IndexingError):
+ msg = (r"Unalignable boolean Series provided as indexer \(index of"
+ r" the boolean Series and of the indexed object do not match")
+ with pytest.raises(IndexingError, match=msg):
s[Series([], dtype=bool)]
- with pytest.raises(IndexingError):
+ with pytest.raises(IndexingError, match=msg):
s[Series([True], dtype=bool)]
@@ -77,8 +79,11 @@ def test_getitem_boolean_object(test_data):
# nans raise exception
omask[5:10] = np.nan
- pytest.raises(Exception, s.__getitem__, omask)
- pytest.raises(Exception, s.__setitem__, omask, 5)
+ msg = "cannot index with vector containing NA / NaN values"
+ with pytest.raises(ValueError, match=msg):
+ s[omask]
+ with pytest.raises(ValueError, match=msg):
+ s[omask] = 5
def test_getitem_setitem_boolean_corner(test_data):
@@ -87,15 +92,17 @@ def test_getitem_setitem_boolean_corner(test_data):
# these used to raise...??
- pytest.raises(Exception, ts.__getitem__, mask_shifted)
- pytest.raises(Exception, ts.__setitem__, mask_shifted, 1)
- # ts[mask_shifted]
- # ts[mask_shifted] = 1
+ msg = (r"Unalignable boolean Series provided as indexer \(index of"
+ r" the boolean Series and of the indexed object do not match")
+ with pytest.raises(IndexingError, match=msg):
+ ts[mask_shifted]
+ with pytest.raises(IndexingError, match=msg):
+ ts[mask_shifted] = 1
- pytest.raises(Exception, ts.loc.__getitem__, mask_shifted)
- pytest.raises(Exception, ts.loc.__setitem__, mask_shifted, 1)
- # ts.loc[mask_shifted]
- # ts.loc[mask_shifted] = 2
+ with pytest.raises(IndexingError, match=msg):
+ ts.loc[mask_shifted]
+ with pytest.raises(IndexingError, match=msg):
+ ts.loc[mask_shifted] = 1
def test_setitem_boolean(test_data):
@@ -168,14 +175,13 @@ def test_where_unsafe_upcast(dtype):
@pytest.mark.parametrize("dtype", [
np.int8, np.int16, np.int32, np.float32
])
-def test_where_unsafe_itemsize_fail(dtype):
- # Can't do these, as we are forced to change the
- # item size of the input to something we cannot.
+def test_where_upcast(dtype):
+ # see gh-9743
s = Series(np.arange(10), dtype=dtype)
mask = s < 5
values = [2.5, 3.5, 4.5, 5.5, 6.5]
- pytest.raises(Exception, s.__setitem__, tuple(mask), values)
+ s[mask] = values
def test_where_unsafe():
@@ -206,10 +212,11 @@ def test_where_unsafe():
s = Series(np.arange(10))
mask = s > 5
- with pytest.raises(ValueError):
+ msg = "cannot assign mismatch length to masked array"
+ with pytest.raises(ValueError, match=msg):
s[mask] = [5, 4, 3, 2, 1]
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
s[mask] = [0] * 5
# dtype changes
@@ -276,8 +283,11 @@ def test_where_error():
s = Series(np.random.randn(5))
cond = s > 0
- pytest.raises(ValueError, s.where, 1)
- pytest.raises(ValueError, s.where, cond[:3].values, -s)
+ msg = "Array conditional must be same shape as self"
+ with pytest.raises(ValueError, match=msg):
+ s.where(1)
+ with pytest.raises(ValueError, match=msg):
+ s.where(cond[:3].values, -s)
# GH 2745
s = Series([1, 2])
@@ -286,10 +296,13 @@ def test_where_error():
assert_series_equal(s, expected)
# failures
- pytest.raises(ValueError, s.__setitem__, tuple([[[True, False]]]),
- [0, 2, 3])
- pytest.raises(ValueError, s.__setitem__, tuple([[[True, False]]]),
- [])
+ msg = "cannot assign mismatch length to masked array"
+ with pytest.raises(ValueError, match=msg):
+ s[[True, False]] = [0, 2, 3]
+ msg = ("NumPy boolean array indexing assignment cannot assign 0 input"
+ " values to the 1 output values where the mask is true")
+ with pytest.raises(ValueError, match=msg):
+ s[[True, False]] = []
@pytest.mark.parametrize('klass', [list, tuple, np.array, Series])
@@ -349,10 +362,13 @@ def test_where_setitem_invalid():
# GH 2702
# make sure correct exceptions are raised on invalid list assignment
+ msg = ("cannot set using a {} indexer with a different length than"
+ " the value")
+
# slice
s = Series(list('abc'))
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg.format('slice')):
s[0:3] = list(range(27))
s[0:3] = list(range(3))
@@ -362,7 +378,7 @@ def test_where_setitem_invalid():
# slice with step
s = Series(list('abcdef'))
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg.format('slice')):
s[0:4:2] = list(range(27))
s = Series(list('abcdef'))
@@ -373,7 +389,7 @@ def test_where_setitem_invalid():
# neg slices
s = Series(list('abcdef'))
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg.format('slice')):
s[:-1] = list(range(27))
s[-3:-1] = list(range(2))
@@ -383,12 +399,12 @@ def test_where_setitem_invalid():
# list
s = Series(list('abc'))
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg.format('list-like')):
s[[0, 1, 2]] = list(range(27))
s = Series(list('abc'))
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg.format('list-like')):
s[[0, 1, 2]] = list(range(2))
# scalar
@@ -590,8 +606,11 @@ def test_mask():
rs2 = s2.mask(cond[:3], -s2)
assert_series_equal(rs, rs2)
- pytest.raises(ValueError, s.mask, 1)
- pytest.raises(ValueError, s.mask, cond[:3].values, -s)
+ msg = "Array conditional must be same shape as self"
+ with pytest.raises(ValueError, match=msg):
+ s.mask(1)
+ with pytest.raises(ValueError, match=msg):
+ s.mask(cond[:3].values, -s)
# dtype changes
s = Series([1, 2, 3, 4])
diff --git a/pandas/tests/series/indexing/test_datetime.py b/pandas/tests/series/indexing/test_datetime.py
index 21395f6004760..0efc9feb0dbd4 100644
--- a/pandas/tests/series/indexing/test_datetime.py
+++ b/pandas/tests/series/indexing/test_datetime.py
@@ -33,8 +33,8 @@ def test_fancy_getitem():
assert s['2009-1-2'] == 48
assert s[datetime(2009, 1, 2)] == 48
assert s[Timestamp(datetime(2009, 1, 2))] == 48
- pytest.raises(KeyError, s.__getitem__, '2009-1-3')
-
+ with pytest.raises(KeyError, match=r"^'2009-1-3'$"):
+ s['2009-1-3']
assert_series_equal(s['3/6/2009':'2009-06-05'],
s[datetime(2009, 3, 6):datetime(2009, 6, 5)])
@@ -298,7 +298,8 @@ def test_getitem_setitem_datetimeindex():
lb = datetime(1990, 1, 1, 4)
rb = datetime(1990, 1, 1, 7)
- with pytest.raises(TypeError):
+ msg = "Cannot compare tz-naive and tz-aware datetime-like objects"
+ with pytest.raises(TypeError, match=msg):
# tznaive vs tzaware comparison is invalid
# see GH#18376, GH#18162
ts[(ts.index >= lb) & (ts.index <= rb)]
@@ -400,7 +401,8 @@ def test_datetime_indexing():
s = Series(len(index), index=index)
stamp = Timestamp('1/8/2000')
- pytest.raises(KeyError, s.__getitem__, stamp)
+ with pytest.raises(KeyError, match=r"^947289600000000000L?$"):
+ s[stamp]
s[stamp] = 0
assert s[stamp] == 0
@@ -408,7 +410,8 @@ def test_datetime_indexing():
s = Series(len(index), index=index)
s = s[::-1]
- pytest.raises(KeyError, s.__getitem__, stamp)
+ with pytest.raises(KeyError, match=r"^947289600000000000L?$"):
+ s[stamp]
s[stamp] = 0
assert s[stamp] == 0
@@ -499,7 +502,8 @@ def test_duplicate_dates_indexing(dups):
expected = Series(np.where(mask, 0, ts), index=ts.index)
assert_series_equal(cp, expected)
- pytest.raises(KeyError, ts.__getitem__, datetime(2000, 1, 6))
+ with pytest.raises(KeyError, match=r"^947116800000000000L?$"):
+ ts[datetime(2000, 1, 6)]
# new index
ts[datetime(2000, 1, 6)] = 0
@@ -664,8 +668,11 @@ def test_indexing():
expected = df.loc[[df.index[2]]]
# this is a single date, so will raise
- pytest.raises(KeyError, df.__getitem__, '2012-01-02 18:01:02', )
- pytest.raises(KeyError, df.__getitem__, df.index[2], )
+ with pytest.raises(KeyError, match=r"^'2012-01-02 18:01:02'$"):
+ df['2012-01-02 18:01:02']
+ msg = r"Timestamp\('2012-01-02 18:01:02-0600', tz='US/Central', freq='S'\)"
+ with pytest.raises(KeyError, match=msg):
+ df[df.index[2]]
"""
diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py
index 92c41f65eb831..a5855f68127f4 100644
--- a/pandas/tests/series/indexing/test_indexing.py
+++ b/pandas/tests/series/indexing/test_indexing.py
@@ -24,15 +24,24 @@
def test_basic_indexing():
s = Series(np.random.randn(5), index=['a', 'b', 'a', 'a', 'b'])
- pytest.raises(IndexError, s.__getitem__, 5)
- pytest.raises(IndexError, s.__setitem__, 5, 0)
+ msg = "index out of bounds"
+ with pytest.raises(IndexError, match=msg):
+ s[5]
+ msg = "index 5 is out of bounds for axis 0 with size 5"
+ with pytest.raises(IndexError, match=msg):
+ s[5] = 0
- pytest.raises(KeyError, s.__getitem__, 'c')
+ with pytest.raises(KeyError, match=r"^'c'$"):
+ s['c']
s = s.sort_index()
- pytest.raises(IndexError, s.__getitem__, 5)
- pytest.raises(IndexError, s.__setitem__, 5, 0)
+ msg = r"index out of bounds|^5$"
+ with pytest.raises(IndexError, match=msg):
+ s[5]
+ msg = r"index 5 is out of bounds for axis (0|1) with size 5|^5$"
+ with pytest.raises(IndexError, match=msg):
+ s[5] = 0
def test_basic_getitem_with_labels(test_data):
@@ -105,7 +114,8 @@ def test_getitem_get(test_data):
# missing
d = test_data.ts.index[0] - BDay()
- pytest.raises(KeyError, test_data.ts.__getitem__, d)
+ with pytest.raises(KeyError, match=r"Timestamp\('1999-12-31 00:00:00'\)"):
+ test_data.ts[d]
# None
# GH 5652
@@ -166,11 +176,14 @@ def test_getitem_with_duplicates_indices(
def test_getitem_out_of_bounds(test_data):
# don't segfault, GH #495
- pytest.raises(IndexError, test_data.ts.__getitem__, len(test_data.ts))
+ msg = "index out of bounds"
+ with pytest.raises(IndexError, match=msg):
+ test_data.ts[len(test_data.ts)]
# GH #917
s = Series([])
- pytest.raises(IndexError, s.__getitem__, -1)
+ with pytest.raises(IndexError, match=msg):
+ s[-1]
def test_getitem_setitem_integers():
@@ -245,8 +258,10 @@ def test_series_box_timestamp():
def test_getitem_ambiguous_keyerror():
s = Series(lrange(10), index=lrange(0, 20, 2))
- pytest.raises(KeyError, s.__getitem__, 1)
- pytest.raises(KeyError, s.loc.__getitem__, 1)
+ with pytest.raises(KeyError, match=r"^1L?$"):
+ s[1]
+ with pytest.raises(KeyError, match=r"^1L?$"):
+ s.loc[1]
def test_getitem_unordered_dup():
@@ -295,7 +310,10 @@ def test_getitem_dataframe():
rng = list(range(10))
s = pd.Series(10, index=rng)
df = pd.DataFrame(rng, index=rng)
- pytest.raises(TypeError, s.__getitem__, df > 5)
+ msg = ("Indexing a Series with DataFrame is not supported,"
+ " use the appropriate DataFrame column")
+ with pytest.raises(TypeError, match=msg):
+ s[df > 5]
def test_setitem(test_data):
@@ -394,9 +412,10 @@ def test_setslice(test_data):
@pytest.mark.filterwarnings("ignore:Using a non-tuple:FutureWarning")
def test_basic_getitem_setitem_corner(test_data):
# invalid tuples, e.g. td.ts[:, None] vs. td.ts[:, 2]
- with pytest.raises(ValueError, match='tuple-index'):
+ msg = "Can only tuple-index with a MultiIndex"
+ with pytest.raises(ValueError, match=msg):
test_data.ts[:, 2]
- with pytest.raises(ValueError, match='tuple-index'):
+ with pytest.raises(ValueError, match=msg):
test_data.ts[:, 2] = 2
# weird lists. [slice(0, 5)] will work but not two slices
@@ -405,10 +424,11 @@ def test_basic_getitem_setitem_corner(test_data):
assert_series_equal(result, expected)
# OK
- pytest.raises(Exception, test_data.ts.__getitem__,
- [5, slice(None, None)])
- pytest.raises(Exception, test_data.ts.__setitem__,
- [5, slice(None, None)], 2)
+ msg = r"unhashable type(: 'slice')?"
+ with pytest.raises(TypeError, match=msg):
+ test_data.ts[[5, slice(None, None)]]
+ with pytest.raises(TypeError, match=msg):
+ test_data.ts[[5, slice(None, None)]] = 2
@pytest.mark.parametrize('tz', ['US/Eastern', 'UTC', 'Asia/Tokyo'])
@@ -730,7 +750,8 @@ def test_setitem_scalar_into_readonly_backing_data():
series = Series(array)
for n in range(len(series)):
- with pytest.raises(ValueError):
+ msg = "assignment destination is read-only"
+ with pytest.raises(ValueError, match=msg):
series[n] = 1
assert array[n] == 0
@@ -743,7 +764,8 @@ def test_setitem_slice_into_readonly_backing_data():
array.flags.writeable = False # make the array immutable
series = Series(array)
- with pytest.raises(ValueError):
+ msg = "assignment destination is read-only"
+ with pytest.raises(ValueError, match=msg):
series[1:3] = 1
assert not array.any()
@@ -791,8 +813,11 @@ def test_take():
expected = Series([4, 2, 4], index=[4, 3, 4])
tm.assert_series_equal(actual, expected)
- pytest.raises(IndexError, s.take, [1, 10])
- pytest.raises(IndexError, s.take, [2, 5])
+ msg = "index {} is out of bounds for size 5"
+ with pytest.raises(IndexError, match=msg.format(10)):
+ s.take([1, 10])
+ with pytest.raises(IndexError, match=msg.format(5)):
+ s.take([2, 5])
with tm.assert_produces_warning(FutureWarning):
s.take([-1, 3, 4], convert=False)
diff --git a/pandas/tests/series/indexing/test_loc.py b/pandas/tests/series/indexing/test_loc.py
index 27d0eee673c11..8c1709ff016b3 100644
--- a/pandas/tests/series/indexing/test_loc.py
+++ b/pandas/tests/series/indexing/test_loc.py
@@ -48,8 +48,11 @@ def test_loc_getitem_not_monotonic(test_data):
ts2 = test_data.ts[::2][[1, 2, 0]]
- pytest.raises(KeyError, ts2.loc.__getitem__, slice(d1, d2))
- pytest.raises(KeyError, ts2.loc.__setitem__, slice(d1, d2), 0)
+ msg = r"Timestamp\('2000-01-10 00:00:00'\)"
+ with pytest.raises(KeyError, match=msg):
+ ts2.loc[d1:d2]
+ with pytest.raises(KeyError, match=msg):
+ ts2.loc[d1:d2] = 0
def test_loc_getitem_setitem_integer_slice_keyerrors():
@@ -74,8 +77,10 @@ def test_loc_getitem_setitem_integer_slice_keyerrors():
# non-monotonic, raise KeyError
s2 = s.iloc[lrange(5) + lrange(5, 10)[::-1]]
- pytest.raises(KeyError, s2.loc.__getitem__, slice(3, 11))
- pytest.raises(KeyError, s2.loc.__setitem__, slice(3, 11), 0)
+ with pytest.raises(KeyError, match=r"^3L?$"):
+ s2.loc[3:11]
+ with pytest.raises(KeyError, match=r"^3L?$"):
+ s2.loc[3:11] = 0
def test_loc_getitem_iterator(test_data):
@@ -97,8 +102,9 @@ def test_loc_setitem_boolean(test_data):
def test_loc_setitem_corner(test_data):
inds = list(test_data.series.index[[5, 8, 12]])
test_data.series.loc[inds] = 5
- pytest.raises(Exception, test_data.series.loc.__setitem__,
- inds + ['foo'], 5)
+ msg = r"\['foo'\] not in index"
+ with pytest.raises(KeyError, match=msg):
+ test_data.series.loc[inds + ['foo']] = 5
def test_basic_setitem_with_labels(test_data):
@@ -135,8 +141,11 @@ def test_basic_setitem_with_labels(test_data):
inds_notfound = [0, 4, 5, 6]
arr_inds_notfound = np.array([0, 4, 5, 6])
- pytest.raises(Exception, s.__setitem__, inds_notfound, 0)
- pytest.raises(Exception, s.__setitem__, arr_inds_notfound, 0)
+ msg = r"\[5\] not contained in the index"
+ with pytest.raises(ValueError, match=msg):
+ s[inds_notfound] = 0
+ with pytest.raises(Exception, match=msg):
+ s[arr_inds_notfound] = 0
# GH12089
# with tz for values
diff --git a/pandas/tests/series/indexing/test_numeric.py b/pandas/tests/series/indexing/test_numeric.py
index 8a4fdc7e12e4d..e4afb0e456706 100644
--- a/pandas/tests/series/indexing/test_numeric.py
+++ b/pandas/tests/series/indexing/test_numeric.py
@@ -96,7 +96,7 @@ def test_delitem():
# empty
s = Series()
- with pytest.raises(KeyError):
+ with pytest.raises(KeyError, match=r"^0$"):
del s[0]
# only 1 left, del, add, del
@@ -150,8 +150,12 @@ def test_slice_float64():
def test_getitem_negative_out_of_bounds():
s = Series(tm.rands_array(5, 10), index=tm.rands_array(10, 10))
- pytest.raises(IndexError, s.__getitem__, -11)
- pytest.raises(IndexError, s.__setitem__, -11, 'foo')
+ msg = "index out of bounds"
+ with pytest.raises(IndexError, match=msg):
+ s[-11]
+ msg = "index -11 is out of bounds for axis 0 with size 10"
+ with pytest.raises(IndexError, match=msg):
+ s[-11] = 'foo'
def test_getitem_regression():
@@ -203,13 +207,19 @@ def test_setitem_float_labels():
def test_slice_float_get_set(test_data):
- pytest.raises(TypeError, lambda: test_data.ts[4.0:10.0])
+ msg = (r"cannot do slice indexing on <class 'pandas\.core\.indexes"
+ r"\.datetimes\.DatetimeIndex'> with these indexers \[{key}\]"
+ r" of <(class|type) 'float'>")
+ with pytest.raises(TypeError, match=msg.format(key=r"4\.0")):
+ test_data.ts[4.0:10.0]
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg.format(key=r"4\.0")):
test_data.ts[4.0:10.0] = 0
- pytest.raises(TypeError, test_data.ts.__getitem__, slice(4.5, 10.0))
- pytest.raises(TypeError, test_data.ts.__setitem__, slice(4.5, 10.0), 0)
+ with pytest.raises(TypeError, match=msg.format(key=r"4\.5")):
+ test_data.ts[4.5:10.0]
+ with pytest.raises(TypeError, match=msg.format(key=r"4\.5")):
+ test_data.ts[4.5:10.0] = 0
def test_slice_floats2():
@@ -228,16 +238,20 @@ def test_slice_floats2():
def test_int_indexing():
s = Series(np.random.randn(6), index=[0, 0, 1, 1, 2, 2])
- pytest.raises(KeyError, s.__getitem__, 5)
+ with pytest.raises(KeyError, match=r"^5$"):
+ s[5]
- pytest.raises(KeyError, s.__getitem__, 'c')
+ with pytest.raises(KeyError, match=r"^'c'$"):
+ s['c']
# not monotonic
s = Series(np.random.randn(6), index=[2, 2, 0, 0, 1, 1])
- pytest.raises(KeyError, s.__getitem__, 5)
+ with pytest.raises(KeyError, match=r"^5$"):
+ s[5]
- pytest.raises(KeyError, s.__getitem__, 'c')
+ with pytest.raises(KeyError, match=r"^'c'$"):
+ s['c']
def test_getitem_int64(test_data):
| xref #24332
`@pytest.mark.xfail` applied to `test_where_unsafe_itemsize_fail` : does not raise using python index operator instead of `__setitem__` with `tuple` | https://api.github.com/repos/pandas-dev/pandas/pulls/24750 | 2019-01-13T13:01:25Z | 2019-01-13T23:57:19Z | 2019-01-13T23:57:19Z | 2019-01-15T19:54:40Z |
ENH: Only apply first group once in fast GroupBy.apply | diff --git a/doc/source/user_guide/groupby.rst b/doc/source/user_guide/groupby.rst
index e4dd82afcdf65..4f116a42253e5 100644
--- a/doc/source/user_guide/groupby.rst
+++ b/doc/source/user_guide/groupby.rst
@@ -946,23 +946,6 @@ that is itself a series, and possibly upcast the result to a DataFrame:
So depending on the path taken, and exactly what you are grouping. Thus the grouped columns(s) may be included in
the output as well as set the indices.
-.. warning::
-
- In the current implementation apply calls func twice on the
- first group to decide whether it can take a fast or slow code
- path. This can lead to unexpected behavior if func has
- side-effects, as they will take effect twice for the first
- group.
-
- .. ipython:: python
-
- d = pd.DataFrame({"a": ["x", "y"], "b": [1, 2]})
- def identity(df):
- print(df)
- return df
-
- d.groupby("a").apply(identity)
-
Other useful features
---------------------
diff --git a/doc/source/whatsnew/v0.25.0.rst b/doc/source/whatsnew/v0.25.0.rst
index 0c3ef237126c2..561562f367db2 100644
--- a/doc/source/whatsnew/v0.25.0.rst
+++ b/doc/source/whatsnew/v0.25.0.rst
@@ -73,6 +73,50 @@ is respected in indexing. (:issue:`24076`, :issue:`16785`)
df = pd.DataFrame([0], index=pd.DatetimeIndex(['2019-01-01'], tz='US/Pacific'))
df['2019-01-01 12:00:00+04:00':'2019-01-01 13:00:00+04:00']
+.. _whatsnew_0250.api_breaking.groupby_apply_first_group_once:
+
+GroupBy.apply on ``DataFrame`` evaluates first group only once
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The implementation of :meth:`DataFrameGroupBy.apply() <pandas.core.groupby.DataFrameGroupBy.apply>`
+previously evaluated the supplied function consistently twice on the first group
+to infer if it is safe to use a fast code path. Particularly for functions with
+side effects, this was an undesired behavior and may have led to surprises.
+
+(:issue:`2936`, :issue:`2656`, :issue:`7739`, :issue:`10519`, :issue:`12155`,
+:issue:`20084`, :issue:`21417`)
+
+Now every group is evaluated only a single time.
+
+.. ipython:: python
+
+ df = pd.DataFrame({"a": ["x", "y"], "b": [1, 2]})
+ df
+
+ def func(group):
+ print(group.name)
+ return group
+
+*Previous Behaviour*:
+
+.. code-block:: python
+
+ In [3]: df.groupby('a').apply(func)
+ x
+ x
+ y
+ Out[3]:
+ a b
+ 0 x 1
+ 1 y 2
+
+*New Behaviour*:
+
+.. ipython:: python
+
+ df.groupby("a").apply(func)
+
+
Concatenating Sparse Values
^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -83,14 +127,14 @@ Series or DataFrame with sparse values, rather than a ``SparseDataFrame`` (:issu
df = pd.DataFrame({"A": pd.SparseArray([0, 1])})
-*Previous Behavior:*
+*Previous Behavior*:
.. code-block:: ipython
In [2]: type(pd.concat([df, df]))
pandas.core.sparse.frame.SparseDataFrame
-*New Behavior:*
+*New Behavior*:
.. ipython:: python
diff --git a/pandas/_libs/reduction.pyx b/pandas/_libs/reduction.pyx
index 517d59c399179..5df6e02d6a040 100644
--- a/pandas/_libs/reduction.pyx
+++ b/pandas/_libs/reduction.pyx
@@ -509,17 +509,6 @@ def apply_frame_axis0(object frame, object f, object names,
results = []
- # Need to infer if our low-level mucking is going to cause a segfault
- if n > 0:
- chunk = frame.iloc[starts[0]:ends[0]]
- object.__setattr__(chunk, 'name', names[0])
- try:
- result = f(chunk)
- if result is chunk:
- raise InvalidApply('Function unsafe for fast apply')
- except:
- raise InvalidApply('Let this error raise above us')
-
slider = BlockSlider(frame)
mutated = False
@@ -529,13 +518,18 @@ def apply_frame_axis0(object frame, object f, object names,
slider.move(starts[i], ends[i])
item_cache.clear() # ugh
+ chunk = slider.dummy
+ object.__setattr__(chunk, 'name', names[i])
- object.__setattr__(slider.dummy, 'name', names[i])
- piece = f(slider.dummy)
+ try:
+ piece = f(chunk)
+ except:
+ raise InvalidApply('Let this error raise above us')
- # I'm paying the price for index-sharing, ugh
+ # Need to infer if low level index slider will cause segfaults
+ require_slow_apply = i == 0 and piece is chunk
try:
- if piece.index is slider.dummy.index:
+ if piece.index is chunk.index:
piece = piece.copy(deep='all')
else:
mutated = True
@@ -543,6 +537,12 @@ def apply_frame_axis0(object frame, object f, object names,
pass
results.append(piece)
+
+ # If the data was modified inplace we need to
+ # take the slow path to not risk segfaults
+ # we have already computed the first piece
+ if require_slow_apply:
+ break
finally:
slider.reset()
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 525af28c27ff5..ec22548de6da3 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -165,26 +165,45 @@ def apply(self, f, data, axis=0):
mutated = self.mutated
splitter = self._get_splitter(data, axis=axis)
group_keys = self._get_group_keys()
+ result_values = None
# oh boy
f_name = com.get_callable_name(f)
if (f_name not in base.plotting_methods and
hasattr(splitter, 'fast_apply') and axis == 0):
try:
- values, mutated = splitter.fast_apply(f, group_keys)
- return group_keys, values, mutated
+ result_values, mutated = splitter.fast_apply(f, group_keys)
+
+ # If the fast apply path could be used we can return here.
+ # Otherwise we need to fall back to the slow implementation.
+ if len(result_values) == len(group_keys):
+ return group_keys, result_values, mutated
+
except reduction.InvalidApply:
- # we detect a mutation of some kind
- # so take slow path
+ # Cannot fast apply on MultiIndex (_has_complex_internals).
+ # This Exception is also raised if `f` triggers an exception
+ # but it is preferable to raise the exception in Python.
pass
except Exception:
# raise this error to the caller
pass
- result_values = []
for key, (i, group) in zip(group_keys, splitter):
object.__setattr__(group, 'name', key)
+ # result_values is None if fast apply path wasn't taken
+ # or fast apply aborted with an unexpected exception.
+ # In either case, initialize the result list and perform
+ # the slow iteration.
+ if result_values is None:
+ result_values = []
+
+ # If result_values is not None we're in the case that the
+ # fast apply loop was broken prematurely but we have
+ # already the result for the first group which we can reuse.
+ elif i == 0:
+ continue
+
# group might be modified
group_axes = _get_axes(group)
res = f(group)
@@ -854,10 +873,7 @@ def fast_apply(self, f, names):
return [], True
sdata = self._get_sorted_data()
- results, mutated = reduction.apply_frame_axis0(sdata, f, names,
- starts, ends)
-
- return results, mutated
+ return reduction.apply_frame_axis0(sdata, f, names, starts, ends)
def _chop(self, sdata, slice_obj):
if self.axis == 0:
diff --git a/pandas/tests/groupby/test_apply.py b/pandas/tests/groupby/test_apply.py
index dea7e518ac605..d753556f9978d 100644
--- a/pandas/tests/groupby/test_apply.py
+++ b/pandas/tests/groupby/test_apply.py
@@ -102,9 +102,80 @@ def f(g):
group_keys = grouper._get_group_keys()
values, mutated = splitter.fast_apply(f, group_keys)
+
assert not mutated
+@pytest.mark.parametrize(
+ "df, group_names",
+ [
+ (DataFrame({"a": [1, 1, 1, 2, 3],
+ "b": ["a", "a", "a", "b", "c"]}),
+ [1, 2, 3]),
+ (DataFrame({"a": [0, 0, 1, 1],
+ "b": [0, 1, 0, 1]}),
+ [0, 1]),
+ (DataFrame({"a": [1]}),
+ [1]),
+ (DataFrame({"a": [1, 1, 1, 2, 2, 1, 1, 2],
+ "b": range(8)}),
+ [1, 2]),
+ (DataFrame({"a": [1, 2, 3, 1, 2, 3],
+ "two": [4, 5, 6, 7, 8, 9]}),
+ [1, 2, 3]),
+ (DataFrame({"a": list("aaabbbcccc"),
+ "B": [3, 4, 3, 6, 5, 2, 1, 9, 5, 4],
+ "C": [4, 0, 2, 2, 2, 7, 8, 6, 2, 8]}),
+ ["a", "b", "c"]),
+ (DataFrame([[1, 2, 3], [2, 2, 3]], columns=["a", "b", "c"]),
+ [1, 2]),
+ ], ids=['GH2936', 'GH7739 & GH10519', 'GH10519',
+ 'GH2656', 'GH12155', 'GH20084', 'GH21417'])
+def test_group_apply_once_per_group(df, group_names):
+ # GH2936, GH7739, GH10519, GH2656, GH12155, GH20084, GH21417
+
+ # This test should ensure that a function is only evaluted
+ # once per group. Previously the function has been evaluated twice
+ # on the first group to check if the Cython index slider is safe to use
+ # This test ensures that the side effect (append to list) is only triggered
+ # once per group
+
+ names = []
+ # cannot parameterize over the functions since they need external
+ # `names` to detect side effects
+
+ def f_copy(group):
+ # this takes the fast apply path
+ names.append(group.name)
+ return group.copy()
+
+ def f_nocopy(group):
+ # this takes the slow apply path
+ names.append(group.name)
+ return group
+
+ def f_scalar(group):
+ # GH7739, GH2656
+ names.append(group.name)
+ return 0
+
+ def f_none(group):
+ # GH10519, GH12155, GH21417
+ names.append(group.name)
+ return None
+
+ def f_constant_df(group):
+ # GH2936, GH20084
+ names.append(group.name)
+ return DataFrame({"a": [1], "b": [1]})
+
+ for func in [f_copy, f_nocopy, f_scalar, f_none, f_constant_df]:
+ del names[:]
+
+ df.groupby("a").apply(func)
+ assert names == group_names
+
+
def test_apply_with_mixed_dtype():
# GH3480, apply with mixed dtype on axis=1 breaks in 0.11
df = DataFrame({'foo1': np.random.randn(6),
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 8267f38f939b1..56d428f29a38c 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -1381,11 +1381,9 @@ def test_group_name_available_in_inference_pass():
def f(group):
names.append(group.name)
return group.copy()
-
df.groupby('a', sort=False, group_keys=False).apply(f)
- # we expect 2 zeros because we call ``f`` once to see if a faster route
- # can be used.
- expected_names = [0, 0, 1, 2]
+
+ expected_names = [0, 1, 2]
assert names == expected_names
| The issue of applying a function to the first row twice has been reported quite a few times (issues are usually referenced to #2936) and is also a documented shortcoming/implementation detail (see Notes in [docs](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.apply.html))
The argumentation is usually that this needs to be done to determine whether or not we can take a fast path for the calculation. Even if we're using the fast path for the calculation, however, the first row is still evaluated twice. I believe with this refactoring it would be possible to only eval the first row once iff the fast path is taken.
For functions with side effects or very expensive calculations in general this may be a big deal as discussed in various other issues.
I'm wondering if this small change may already help out folks. Truth be told, I'm not 100% certain about what's actually happening in this loop regarding the slider and item cache. For the use case where I encountered this, it seems to do the trick, though.
closes #2936
closes #2656
closes #7739
closes #10519
closes #12155
closes #20084
closes #21417
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24748 | 2019-01-13T08:53:12Z | 2019-03-26T04:38:34Z | 2019-03-26T04:38:34Z | 2020-05-02T09:38:12Z |
PERF: speed up .ix by moving deprecation string out of __init__ | diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 95bf776b1f19d..bbcde8f3b3305 100755
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -1405,17 +1405,16 @@ class _IXIndexer(_NDFrameIndexer):
See more at :ref:`Advanced Indexing <advanced>`.
"""
- def __init__(self, name, obj):
-
- _ix_deprecation_warning = textwrap.dedent("""
- .ix is deprecated. Please use
- .loc for label based indexing or
- .iloc for positional indexing
+ _ix_deprecation_warning = textwrap.dedent("""
+ .ix is deprecated. Please use
+ .loc for label based indexing or
+ .iloc for positional indexing
- See the documentation here:
- http://pandas.pydata.org/pandas-docs/stable/indexing.html#ix-indexer-is-deprecated""") # noqa
+ See the documentation here:
+ http://pandas.pydata.org/pandas-docs/stable/indexing.html#ix-indexer-is-deprecated""") # noqa
- warnings.warn(_ix_deprecation_warning,
+ def __init__(self, name, obj):
+ warnings.warn(self._ix_deprecation_warning,
DeprecationWarning, stacklevel=2)
super(_IXIndexer, self).__init__(name, obj)
| While `.ix` is deprecated, the `DeprecationWarning` itself adds a decent fraction of overhead to calling it. Simply storing the warning string on the class (or global scope) yields a sizable speedup:
```
$ asv compare v0.24.0rc1 HEAD -s --only-changed --sort ratio
before after ratio
[fdc4db25] [d0821a4c]
<v0.24.0rc1^0> <ix_speedup>
- 2.57±0.1ms 2.29±0.01ms 0.89 indexing.NumericSeriesIndexing.time_ix_list_like(<class 'pandas.core.indexes.numeric.UInt64Index'>, 'nonunique_monotonic_inc')
- 2.69±0.2ms 2.39±0.02ms 0.89 indexing.NumericSeriesIndexing.time_ix_list_like(<class 'pandas.core.indexes.numeric.Float64Index'>, 'nonunique_monotonic_inc')
- 124±2μs 103±5μs 0.83 indexing.NumericSeriesIndexing.time_ix_scalar(<class 'pandas.core.indexes.numeric.UInt64Index'>, 'unique_monotonic_inc')
- 149±4μs 121±4μs 0.81 indexing.NumericSeriesIndexing.time_ix_slice(<class 'pandas.core.indexes.numeric.Float64Index'>, 'unique_monotonic_inc')
- 2.43±0.08ms 1.96±0.05ms 0.81 indexing.NumericSeriesIndexing.time_ix_list_like(<class 'pandas.core.indexes.numeric.Int64Index'>, 'unique_monotonic_inc')
- 179±20μs 138±7μs 0.77 indexing.NumericSeriesIndexing.time_ix_slice(<class 'pandas.core.indexes.numeric.Int64Index'>, 'unique_monotonic_inc')
- 506±6μs 384±6μs 0.76 indexing.NumericSeriesIndexing.time_ix_scalar(<class 'pandas.core.indexes.numeric.Float64Index'>, 'nonunique_monotonic_inc')
- 84.6±1μs 63.5±2μs 0.75 indexing.NumericSeriesIndexing.time_ix_scalar(<class 'pandas.core.indexes.numeric.Float64Index'>, 'unique_monotonic_inc')
- 69.1±4μs 50.4±2μs 0.73 indexing.NumericSeriesIndexing.time_ix_scalar(<class 'pandas.core.indexes.numeric.Int64Index'>, 'unique_monotonic_inc')
- 1.22±0.02ms 728±2μs 0.60 indexing.NumericSeriesIndexing.time_ix_slice(<class 'pandas.core.indexes.numeric.Float64Index'>, 'nonunique_monotonic_inc')
- 31.3±4μs 8.67±0.9μs 0.28 indexing.DataFrameStringIndexing.time_ix
- 16.5±1μs 2.67±0.3μs 0.16 indexing.MethodLookup.time_lookup_ix
```
- [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24747 | 2019-01-13T03:18:08Z | 2019-01-13T23:52:45Z | 2019-01-13T23:52:45Z | 2019-01-13T23:52:50Z |
CI: isort ci | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index b5774d0571dfa..3e62a08975dad 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -101,7 +101,7 @@ if [[ -z "$CHECK" || "$CHECK" == "lint" ]]; then
# Imports - Check formatting using isort see setup.cfg for settings
MSG='Check import format using isort ' ; echo $MSG
- isort --recursive --check-only pandas
+ isort --recursive --check-only pandas asv_bench
RET=$(($RET + $?)) ; echo $MSG "DONE"
fi
diff --git a/setup.cfg b/setup.cfg
index 48c56caa0c8f7..44d92c0b8777f 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -115,7 +115,6 @@ force_sort_within_sections=True
skip=
pandas/core/api.py,
pandas/core/frame.py,
- doc/source/conf.py,
asv_bench/benchmarks/algorithms.py,
asv_bench/benchmarks/attrs_caching.py,
asv_bench/benchmarks/binary_ops.py,
@@ -150,3 +149,8 @@ skip=
asv_bench/benchmarks/sparse.py,
asv_bench/benchmarks/stat_ops.py,
asv_bench/benchmarks/timeseries.py
+ asv_bench/benchmarks/pandas_vb_common.py
+ asv_bench/benchmarks/offset.py
+ asv_bench/benchmarks/dtypes.py
+ asv_bench/benchmarks/strings.py
+ asv_bench/benchmarks/period.py
| - [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
asv_bench and doc dir where [added](https://github.com/pandas-dev/pandas/pull/24092/files) to the isort skip section. We should actually check this directory in CI.
Checking doc dir is more effort that its worth ( barely any .py files ) so let's just leave this. | https://api.github.com/repos/pandas-dev/pandas/pulls/24746 | 2019-01-12T21:06:36Z | 2019-01-14T00:03:49Z | 2019-01-14T00:03:49Z | 2019-02-17T18:41:39Z |
CLN: More isort | diff --git a/pandas/tests/computation/test_compat.py b/pandas/tests/computation/test_compat.py
index c25ef4bf38cab..7cc373d06cfe1 100644
--- a/pandas/tests/computation/test_compat.py
+++ b/pandas/tests/computation/test_compat.py
@@ -1,11 +1,11 @@
-import pytest
from distutils.version import LooseVersion
-import pandas as pd
+import pytest
+import pandas as pd
+from pandas.core.computation.check import _MIN_NUMEXPR_VERSION
from pandas.core.computation.engines import _engines
import pandas.core.computation.expr as expr
-from pandas.core.computation.check import _MIN_NUMEXPR_VERSION
def test_compat():
diff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py
index 1649c99384ef2..c1ba15f428eb7 100644
--- a/pandas/tests/computation/test_eval.py
+++ b/pandas/tests/computation/test_eval.py
@@ -1,39 +1,34 @@
-import warnings
-import operator
from distutils.version import LooseVersion
from itertools import product
+import operator
+import warnings
+import numpy as np
+from numpy.random import rand, randint, randn
import pytest
-from numpy.random import randn, rand, randint
-import numpy as np
+from pandas.compat import PY3, reduce
+from pandas.errors import PerformanceWarning
+import pandas.util._test_decorators as td
from pandas.core.dtypes.common import is_bool, is_list_like, is_scalar
-import pandas as pd
-from pandas.errors import PerformanceWarning
-from pandas import DataFrame, Series, Panel, date_range
-from pandas.util.testing import makeCustomDataframe as mkdf
+import pandas as pd
+from pandas import DataFrame, Panel, Series, date_range
from pandas.core.computation import pytables
from pandas.core.computation.check import _NUMEXPR_VERSION
-from pandas.core.computation.engines import _engines, NumExprClobberingError
-from pandas.core.computation.expr import PythonExprVisitor, PandasExprVisitor
+from pandas.core.computation.engines import NumExprClobberingError, _engines
+import pandas.core.computation.expr as expr
+from pandas.core.computation.expr import PandasExprVisitor, PythonExprVisitor
from pandas.core.computation.expressions import (
- _USE_NUMEXPR, _NUMEXPR_INSTALLED)
+ _NUMEXPR_INSTALLED, _USE_NUMEXPR)
from pandas.core.computation.ops import (
- _binary_ops_dict,
- _special_case_arith_ops_syms,
- _arith_ops_syms, _bool_ops_syms,
- _unary_math_ops, _binary_math_ops)
-
-import pandas.core.computation.expr as expr
+ _arith_ops_syms, _binary_math_ops, _binary_ops_dict, _bool_ops_syms,
+ _special_case_arith_ops_syms, _unary_math_ops)
import pandas.util.testing as tm
-import pandas.util._test_decorators as td
-from pandas.util.testing import (assert_frame_equal, randbool,
- assert_numpy_array_equal, assert_series_equal,
- assert_produces_warning)
-from pandas.compat import PY3, reduce
-
+from pandas.util.testing import (
+ assert_frame_equal, assert_numpy_array_equal, assert_produces_warning,
+ assert_series_equal, makeCustomDataframe as mkdf, randbool)
_series_frame_incompatible = _bool_ops_syms
_scalar_skip = 'in', 'not in'
diff --git a/pandas/tests/extension/arrow/test_bool.py b/pandas/tests/extension/arrow/test_bool.py
index 2ace0fadc73e9..15ceb6adff59c 100644
--- a/pandas/tests/extension/arrow/test_bool.py
+++ b/pandas/tests/extension/arrow/test_bool.py
@@ -2,12 +2,12 @@
import pytest
import pandas as pd
-import pandas.util.testing as tm
from pandas.tests.extension import base
+import pandas.util.testing as tm
pytest.importorskip('pyarrow', minversion="0.10.0")
-from .bool import ArrowBoolArray, ArrowBoolDtype
+from .bool import ArrowBoolArray, ArrowBoolDtype # isort:skip
@pytest.fixture
diff --git a/pandas/tests/extension/test_sparse.py b/pandas/tests/extension/test_sparse.py
index 39a138ed534bd..21dbf9524961c 100644
--- a/pandas/tests/extension/test_sparse.py
+++ b/pandas/tests/extension/test_sparse.py
@@ -1,11 +1,12 @@
import numpy as np
import pytest
+from pandas.errors import PerformanceWarning
+
import pandas as pd
-import pandas.util.testing as tm
from pandas import SparseArray, SparseDtype
-from pandas.errors import PerformanceWarning
from pandas.tests.extension import base
+import pandas.util.testing as tm
def make_data(fill_value):
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 7147761d23caa..fe0706efdc4f8 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -1,32 +1,29 @@
# -*- coding: utf-8 -*-
# pylint: disable=W0102
-from datetime import datetime, date
+from datetime import date, datetime
+from distutils.version import LooseVersion
+import itertools
import operator
+import re
import sys
-import pytest
+
import numpy as np
+import pytest
-import re
-from distutils.version import LooseVersion
-import itertools
-from pandas import (Index, MultiIndex, DataFrame, DatetimeIndex,
- Series, Categorical, SparseArray)
-
-from pandas.compat import OrderedDict, lrange
-from pandas.core.arrays import (
- DatetimeArray,
- TimedeltaArray,
-)
-from pandas.core.internals import (SingleBlockManager,
- make_block, BlockManager)
+from pandas._libs.internals import BlockPlacement
+from pandas.compat import OrderedDict, lrange, u, zip
+
+import pandas as pd
+from pandas import (
+ Categorical, DataFrame, DatetimeIndex, Index, MultiIndex, Series,
+ SparseArray)
import pandas.core.algorithms as algos
+from pandas.core.arrays import DatetimeArray, TimedeltaArray
+from pandas.core.internals import BlockManager, SingleBlockManager, make_block
import pandas.util.testing as tm
-import pandas as pd
-from pandas._libs.internals import BlockPlacement
-from pandas.util.testing import (assert_almost_equal, assert_frame_equal,
- randn, assert_series_equal)
-from pandas.compat import zip, u
+from pandas.util.testing import (
+ assert_almost_equal, assert_frame_equal, assert_series_equal, randn)
# in 3.6.1 a c-api slicing function changed, see src/compat_helper.h
PY361 = LooseVersion(sys.version) >= LooseVersion('3.6.1')
diff --git a/pandas/tests/tools/test_numeric.py b/pandas/tests/tools/test_numeric.py
index a0a1364f4617e..537881f3a5e85 100644
--- a/pandas/tests/tools/test_numeric.py
+++ b/pandas/tests/tools/test_numeric.py
@@ -1,12 +1,12 @@
-import pytest
import decimal
import numpy as np
+from numpy import iinfo
+import pytest
+
import pandas as pd
from pandas import to_numeric
-
from pandas.util import testing as tm
-from numpy import iinfo
class TestToNumeric(object):
diff --git a/setup.cfg b/setup.cfg
index 3b7d1da9a2b02..48c56caa0c8f7 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -115,16 +115,6 @@ force_sort_within_sections=True
skip=
pandas/core/api.py,
pandas/core/frame.py,
- pandas/tests/api/test_types.py,
- pandas/tests/api/test_api.py,
- pandas/tests/tools/test_numeric.py,
- pandas/tests/internals/test_internals.py,
- pandas/tests/extension/test_sparse.py,
- pandas/tests/extension/base/reduce.py,
- pandas/tests/computation/test_compat.py,
- pandas/tests/computation/test_eval.py,
- pandas/types/common.py,
- pandas/tests/extension/arrow/test_bool.py,
doc/source/conf.py,
asv_bench/benchmarks/algorithms.py,
asv_bench/benchmarks/attrs_caching.py,
| - [x] xref #23334
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
Hopefully nearing the end of these now..
| https://api.github.com/repos/pandas-dev/pandas/pulls/24745 | 2019-01-12T20:51:50Z | 2019-01-13T18:59:00Z | 2019-01-13T18:59:00Z | 2019-01-13T18:59:04Z |
DOC: Use backticks instead of quotes | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index d3d34e6b9ec3e..2a60429629638 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -149,7 +149,7 @@ These dtypes can be merged & reshaped & casted.
pd.concat([df[['A']], df[['B', 'C']]], axis=1).dtypes
df['A'].astype(float)
-Reduction and groupby operations such as 'sum' work.
+Reduction and groupby operations such as ``sum`` work.
.. ipython:: python
| Small formatting edit to whatsnew. I think there should be backticks and not single quotes here? | https://api.github.com/repos/pandas-dev/pandas/pulls/24744 | 2019-01-12T20:05:30Z | 2019-01-13T18:58:03Z | 2019-01-13T18:58:03Z | 2019-01-14T21:55:49Z |
PERF: 3x speedup in Series of dicts with datetime keys by not having error message scale with input | diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index 79756d4c0cfab..f84471c3b04e8 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -686,16 +686,19 @@ def construct_from_string(cls, string):
>>> DatetimeTZDtype.construct_from_string('datetime64[ns, UTC]')
datetime64[ns, UTC]
"""
- msg = "Could not construct DatetimeTZDtype from '{}'"
- try:
- match = cls._match.match(string)
- if match:
- d = match.groupdict()
- return cls(unit=d['unit'], tz=d['tz'])
- except Exception:
- # TODO(py3): Change this pass to `raise TypeError(msg) from e`
- pass
- raise TypeError(msg.format(string))
+ if isinstance(string, compat.string_types):
+ msg = "Could not construct DatetimeTZDtype from '{}'"
+ try:
+ match = cls._match.match(string)
+ if match:
+ d = match.groupdict()
+ return cls(unit=d['unit'], tz=d['tz'])
+ except Exception:
+ # TODO(py3): Change this pass to `raise TypeError(msg) from e`
+ pass
+ raise TypeError(msg.format(string))
+
+ raise TypeError("Could not construct DatetimeTZDtype")
def __unicode__(self):
return "datetime64[{unit}, {tz}]".format(unit=self.unit, tz=self.tz)
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index 40b8f7afa3598..0fe0a845f5129 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -232,6 +232,10 @@ def test_construct_from_string_raises(self):
with pytest.raises(TypeError, match="notatz"):
DatetimeTZDtype.construct_from_string('datetime64[ns, notatz]')
+ with pytest.raises(TypeError,
+ match="^Could not construct DatetimeTZDtype$"):
+ DatetimeTZDtype.construct_from_string(['datetime64[ns, notatz]'])
+
def test_is_dtype(self):
assert not DatetimeTZDtype.is_dtype(None)
assert DatetimeTZDtype.is_dtype(self.dtype)
| Surprisingly, the majority of the time spent in constructing a `Series` from a dict with `datetime`-like keys is spent formatting the keys into strings for an error message that gets suppressed.
As there's a test ensuring the string case makes it into the error message, we preserve the behavior there. In non-string cases, we mirror how the other `Dtypes` handle this case and do not include the input.
```
$ asv compare v0.24.0rc1 HEAD -s
before after ratio
[fdc4db25] [5c82eab5]
<v0.24.0rc1^0> <series_dict_speedup>
- 1.14±0.02s 303±4ms 0.27 series_methods.SeriesConstructor.time_constructor('dict')
```
- [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/24743 | 2019-01-12T18:19:43Z | 2019-01-13T18:54:17Z | 2019-01-13T18:54:17Z | 2019-01-13T18:54:22Z |
CLN/TST: indexing/multiindex/test_getitem.py | diff --git a/pandas/tests/indexing/multiindex/test_getitem.py b/pandas/tests/indexing/multiindex/test_getitem.py
index 88e96329105dd..b7fdbee0b7185 100644
--- a/pandas/tests/indexing/multiindex/test_getitem.py
+++ b/pandas/tests/indexing/multiindex/test_getitem.py
@@ -1,35 +1,15 @@
import numpy as np
import pytest
-from pandas.compat import range, u, zip
+from pandas.compat import u, zip
-import pandas as pd
from pandas import DataFrame, Index, MultiIndex, Series
-import pandas.core.common as com
from pandas.core.indexing import IndexingError
from pandas.util import testing as tm
-
-@pytest.fixture
-def frame_random_data_integer_multi_index():
- levels = [[0, 1], [0, 1, 2]]
- codes = [[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]]
- index = MultiIndex(levels=levels, codes=codes)
- return DataFrame(np.random.randn(6, 2), index=index)
-
-
-@pytest.fixture
-def dataframe_with_duplicate_index():
- """Fixture for DataFrame used in tests for gh-4145 and gh-4146"""
- data = [['a', 'd', 'e', 'c', 'f', 'b'],
- [1, 4, 5, 3, 6, 2],
- [1, 4, 5, 3, 6, 2]]
- index = ['h1', 'h3', 'h5']
- columns = MultiIndex(
- levels=[['A', 'B'], ['A1', 'A2', 'B1', 'B2']],
- codes=[[0, 0, 0, 1, 1, 1], [0, 3, 3, 0, 1, 2]],
- names=['main', 'sub'])
- return DataFrame(data, index=index, columns=columns)
+# ----------------------------------------------------------------------------
+# test indexing of Series with multi-level Index
+# ----------------------------------------------------------------------------
@pytest.mark.parametrize('access_method', [lambda s, x: s[:, x],
@@ -51,7 +31,7 @@ def test_series_getitem_multiindex(access_method, level1_value, expected):
@pytest.mark.parametrize('level0_value', ['D', 'A'])
-def test_getitem_duplicates_multiindex(level0_value):
+def test_series_getitem_duplicates_multiindex(level0_value):
# GH 5725 the 'A' happens to be a valid Timestamp so the doesn't raise
# the appropriate error, only in PY3 of course!
@@ -65,12 +45,10 @@ def test_getitem_duplicates_multiindex(level0_value):
# confirm indexing on missing value raises KeyError
if level0_value != 'A':
- msg = "'A'"
- with pytest.raises(KeyError, match=msg):
+ with pytest.raises(KeyError, match=r"^'A'$"):
df.val['A']
- msg = "'X'"
- with pytest.raises(KeyError, match=msg):
+ with pytest.raises(KeyError, match=r"^'X'$"):
df.val['X']
result = df.val[level0_value]
@@ -79,89 +57,6 @@ def test_getitem_duplicates_multiindex(level0_value):
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize('indexer, is_level1, expected_error', [
- ([], False, None), # empty ok
- (['A'], False, None),
- (['A', 'D'], False, None),
- (['D'], False, r"\['D'\] not in index"), # not any values found
- (pd.IndexSlice[:, ['foo']], True, None),
- (pd.IndexSlice[:, ['foo', 'bah']], True, None)
-])
-def test_getitem_duplicates_multiindex_missing_indexers(indexer, is_level1,
- expected_error):
- # GH 7866
- # multi-index slicing with missing indexers
- idx = MultiIndex.from_product([['A', 'B', 'C'],
- ['foo', 'bar', 'baz']],
- names=['one', 'two'])
- s = Series(np.arange(9, dtype='int64'), index=idx).sort_index()
-
- if indexer == []:
- expected = s.iloc[[]]
- elif is_level1:
- expected = Series([0, 3, 6], index=MultiIndex.from_product(
- [['A', 'B', 'C'], ['foo']], names=['one', 'two'])).sort_index()
- else:
- exp_idx = MultiIndex.from_product([['A'], ['foo', 'bar', 'baz']],
- names=['one', 'two'])
- expected = Series(np.arange(3, dtype='int64'),
- index=exp_idx).sort_index()
-
- if expected_error is not None:
- with pytest.raises(KeyError, match=expected_error):
- s.loc[indexer]
- else:
- result = s.loc[indexer]
- tm.assert_series_equal(result, expected)
-
-
-@pytest.mark.parametrize('columns_indexer', [
- ([], slice(None)),
- (['foo'], [])
-])
-def test_getitem_duplicates_multiindex_empty_indexer(columns_indexer):
- # GH 8737
- # empty indexer
- multi_index = MultiIndex.from_product((['foo', 'bar', 'baz'],
- ['alpha', 'beta']))
- df = DataFrame(np.random.randn(5, 6), index=range(5), columns=multi_index)
- df = df.sort_index(level=0, axis=1)
-
- expected = DataFrame(index=range(5), columns=multi_index.reindex([])[0])
- result = df.loc[:, columns_indexer]
- tm.assert_frame_equal(result, expected)
-
-
-def test_getitem_duplicates_multiindex_non_scalar_type_object():
- # regression from < 0.14.0
- # GH 7914
- df = DataFrame([[np.mean, np.median], ['mean', 'median']],
- columns=MultiIndex.from_tuples([('functs', 'mean'),
- ('functs', 'median')]),
- index=['function', 'name'])
- result = df.loc['function', ('functs', 'mean')]
- expected = np.mean
- assert result == expected
-
-
-def test_getitem_simple(multiindex_dataframe_random_data):
- df = multiindex_dataframe_random_data.T
- expected = df.values[:, 0]
- result = df['foo', 'one'].values
- tm.assert_almost_equal(result, expected)
-
-
-@pytest.mark.parametrize('indexer,msg', [
- (lambda df: df[('foo', 'four')], r"\('foo', 'four'\)"),
- (lambda df: df['foobar'], "'foobar'")
-])
-def test_getitem_simple_key_error(
- multiindex_dataframe_random_data, indexer, msg):
- df = multiindex_dataframe_random_data.T
- with pytest.raises(KeyError, match=msg):
- indexer(df)
-
-
@pytest.mark.parametrize('indexer', [
lambda s: s[2000, 3],
lambda s: s.loc[2000, 3]
@@ -189,23 +84,9 @@ def test_series_getitem_returns_scalar(
assert result == expected
-@pytest.mark.filterwarnings("ignore:\\n.ix:DeprecationWarning")
-@pytest.mark.parametrize('indexer', [
- lambda s: s.loc[[(2000, 3, 10), (2000, 3, 13)]],
- lambda s: s.ix[[(2000, 3, 10), (2000, 3, 13)]]
-])
-def test_series_getitem_fancy(
- multiindex_year_month_day_dataframe_random_data, indexer):
- s = multiindex_year_month_day_dataframe_random_data['A']
- expected = s.reindex(s.index[49:51])
-
- result = indexer(s)
- tm.assert_series_equal(result, expected)
-
-
-@pytest.mark.parametrize('indexer,error,msg', [
- (lambda s: s.__getitem__((2000, 3, 4)), KeyError, '356'),
- (lambda s: s[(2000, 3, 4)], KeyError, '356'),
+@pytest.mark.parametrize('indexer,expected_error,expected_error_msg', [
+ (lambda s: s.__getitem__((2000, 3, 4)), KeyError, r"^356L?$"),
+ (lambda s: s[(2000, 3, 4)], KeyError, r"^356L?$"),
(lambda s: s.loc[(2000, 3, 4)], IndexingError, 'Too many indexers'),
(lambda s: s.__getitem__(len(s)), IndexError, 'index out of bounds'),
(lambda s: s[len(s)], IndexError, 'index out of bounds'),
@@ -213,9 +94,10 @@ def test_series_getitem_fancy(
'single positional indexer is out-of-bounds')
])
def test_series_getitem_indexing_errors(
- multiindex_year_month_day_dataframe_random_data, indexer, error, msg):
+ multiindex_year_month_day_dataframe_random_data, indexer,
+ expected_error, expected_error_msg):
s = multiindex_year_month_day_dataframe_random_data['A']
- with pytest.raises(error, match=msg):
+ with pytest.raises(expected_error, match=expected_error_msg):
indexer(s)
@@ -227,6 +109,28 @@ def test_series_getitem_corner_generator(
tm.assert_series_equal(result, expected)
+# ----------------------------------------------------------------------------
+# test indexing of DataFrame with multi-level Index
+# ----------------------------------------------------------------------------
+
+def test_getitem_simple(multiindex_dataframe_random_data):
+ df = multiindex_dataframe_random_data.T
+ expected = df.values[:, 0]
+ result = df['foo', 'one'].values
+ tm.assert_almost_equal(result, expected)
+
+
+@pytest.mark.parametrize('indexer,expected_error_msg', [
+ (lambda df: df[('foo', 'four')], r"^\('foo', 'four'\)$"),
+ (lambda df: df['foobar'], r"^'foobar'$")
+])
+def test_frame_getitem_simple_key_error(
+ multiindex_dataframe_random_data, indexer, expected_error_msg):
+ df = multiindex_dataframe_random_data.T
+ with pytest.raises(KeyError, match=expected_error_msg):
+ indexer(df)
+
+
def test_frame_getitem_multicolumn_empty_level():
df = DataFrame({'a': ['1', '2', '3'], 'b': ['2', '3', '4']})
df.columns = [['level1 item1', 'level1 item2'], ['', 'level2 item2'],
@@ -238,24 +142,12 @@ def test_frame_getitem_multicolumn_empty_level():
tm.assert_frame_equal(result, expected)
-def test_getitem_tuple_plus_slice():
- # GH 671
- df = DataFrame({'a': np.arange(10),
- 'b': np.arange(10),
- 'c': np.random.randn(10),
- 'd': np.random.randn(10)}
- ).set_index(['a', 'b'])
- expected = df.loc[0, 0]
- result = df.loc[(0, 0), :]
- tm.assert_series_equal(result, expected)
-
-
@pytest.mark.parametrize('indexer,expected_slice', [
(lambda df: df['foo'], slice(3)),
(lambda df: df['bar'], slice(3, 5)),
(lambda df: df.loc[:, 'bar'], slice(3, 5))
])
-def test_getitem_toplevel(
+def test_frame_getitem_toplevel(
multiindex_dataframe_random_data, indexer, expected_slice):
df = multiindex_dataframe_random_data.T
expected = df.reindex(columns=df.columns[expected_slice])
@@ -264,72 +156,8 @@ def test_getitem_toplevel(
tm.assert_frame_equal(result, expected)
-def test_getitem_int(frame_random_data_integer_multi_index):
- df = frame_random_data_integer_multi_index
- result = df.loc[1]
- expected = df[-3:]
- expected.index = expected.index.droplevel(0)
- tm.assert_frame_equal(result, expected)
-
-
-def test_getitem_int_raises_exception(frame_random_data_integer_multi_index):
- df = frame_random_data_integer_multi_index
- msg = "3"
- with pytest.raises(KeyError, match=msg):
- df.loc.__getitem__(3)
-
-
-def test_getitem_iloc(multiindex_dataframe_random_data):
- df = multiindex_dataframe_random_data
- result = df.iloc[2]
- expected = df.xs(df.index[2])
- tm.assert_series_equal(result, expected)
-
-
-def test_frame_setitem_view_direct(multiindex_dataframe_random_data):
- # this works because we are modifying the underlying array
- # really a no-no
- df = multiindex_dataframe_random_data.T
- df['foo'].values[:] = 0
- assert (df['foo'].values == 0).all()
-
-
-def test_frame_setitem_copy_raises(multiindex_dataframe_random_data):
- # will raise/warn as its chained assignment
- df = multiindex_dataframe_random_data.T
- msg = "A value is trying to be set on a copy of a slice from a DataFrame"
- with pytest.raises(com.SettingWithCopyError, match=msg):
- df['foo']['one'] = 2
-
-
-def test_frame_setitem_copy_no_write(multiindex_dataframe_random_data):
- frame = multiindex_dataframe_random_data.T
- expected = frame
- df = frame.copy()
- msg = "A value is trying to be set on a copy of a slice from a DataFrame"
- with pytest.raises(com.SettingWithCopyError, match=msg):
- df['foo']['one'] = 2
-
- result = df
- tm.assert_frame_equal(result, expected)
-
-
-def test_getitem_lowerdim_corner(multiindex_dataframe_random_data):
- df = multiindex_dataframe_random_data
-
- # test setup - check key not in dataframe
- with pytest.raises(KeyError, match="11"):
- df.loc[('bar', 'three'), 'B']
-
- # in theory should be inserting in a sorted space????
- df.loc[('bar', 'three'), 'B'] = 0
- expected = 0
- result = df.sort_index().loc[('bar', 'three'), 'B']
- assert result == expected
-
-
@pytest.mark.parametrize('unicode_strings', [True, False])
-def test_mixed_depth_get(unicode_strings):
+def test_frame_mixed_depth_get(unicode_strings):
# If unicode_strings is True, the column labels in dataframe
# construction will use unicode strings in Python 2 (pull request
# #17099).
@@ -355,11 +183,29 @@ def test_mixed_depth_get(unicode_strings):
tm.assert_series_equal(result, expected)
+# ----------------------------------------------------------------------------
+# test indexing of DataFrame with multi-level Index with duplicates
+# ----------------------------------------------------------------------------
+
+@pytest.fixture
+def dataframe_with_duplicate_index():
+ """Fixture for DataFrame used in tests for gh-4145 and gh-4146"""
+ data = [['a', 'd', 'e', 'c', 'f', 'b'],
+ [1, 4, 5, 3, 6, 2],
+ [1, 4, 5, 3, 6, 2]]
+ index = ['h1', 'h3', 'h5']
+ columns = MultiIndex(
+ levels=[['A', 'B'], ['A1', 'A2', 'B1', 'B2']],
+ codes=[[0, 0, 0, 1, 1, 1], [0, 3, 3, 0, 1, 2]],
+ names=['main', 'sub'])
+ return DataFrame(data, index=index, columns=columns)
+
+
@pytest.mark.parametrize('indexer', [
- lambda df: df.loc[:, ('A', 'A1')],
- lambda df: df[('A', 'A1')]
+ lambda df: df[('A', 'A1')],
+ lambda df: df.loc[:, ('A', 'A1')]
])
-def test_mi_access(dataframe_with_duplicate_index, indexer):
+def test_frame_mi_access(dataframe_with_duplicate_index, indexer):
# GH 4145
df = dataframe_with_duplicate_index
index = Index(['h1', 'h3', 'h5'])
@@ -370,7 +216,7 @@ def test_mi_access(dataframe_with_duplicate_index, indexer):
tm.assert_frame_equal(result, expected)
-def test_mi_access_returns_series(dataframe_with_duplicate_index):
+def test_frame_mi_access_returns_series(dataframe_with_duplicate_index):
# GH 4146, not returning a block manager when selecting a unique index
# from a duplicate index
# as of 4879, this returns a Series (which is similar to what happens
@@ -381,7 +227,7 @@ def test_mi_access_returns_series(dataframe_with_duplicate_index):
tm.assert_series_equal(result, expected)
-def test_mi_access_returns_frame(dataframe_with_duplicate_index):
+def test_frame_mi_access_returns_frame(dataframe_with_duplicate_index):
# selecting a non_unique from the 2nd level
df = dataframe_with_duplicate_index
expected = DataFrame([['d', 4, 4], ['e', 5, 5]],
diff --git a/pandas/tests/indexing/multiindex/test_iloc.py b/pandas/tests/indexing/multiindex/test_iloc.py
index a1681c1239aa3..bdd505804c82b 100644
--- a/pandas/tests/indexing/multiindex/test_iloc.py
+++ b/pandas/tests/indexing/multiindex/test_iloc.py
@@ -142,3 +142,10 @@ def test_iloc_setitem_int_multiindex_series(data, indexes, values, expected_k):
df['k'] = expected_k
expected = df.k
tm.assert_series_equal(series, expected)
+
+
+def test_getitem_iloc(multiindex_dataframe_random_data):
+ df = multiindex_dataframe_random_data
+ result = df.iloc[2]
+ expected = df.xs(df.index[2])
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexing/multiindex/test_loc.py b/pandas/tests/indexing/multiindex/test_loc.py
index 75995a24a2ad1..ea451d40eb5d3 100644
--- a/pandas/tests/indexing/multiindex/test_loc.py
+++ b/pandas/tests/indexing/multiindex/test_loc.py
@@ -4,6 +4,7 @@
import numpy as np
import pytest
+import pandas as pd
from pandas import DataFrame, Index, MultiIndex, Series
from pandas.util import testing as tm
@@ -15,6 +16,14 @@ def single_level_multiindex():
codes=[[0, 1, 2, 3]], names=['first'])
+@pytest.fixture
+def frame_random_data_integer_multi_index():
+ levels = [[0, 1], [0, 1, 2]]
+ codes = [[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]]
+ index = MultiIndex(levels=levels, codes=codes)
+ return DataFrame(np.random.randn(6, 2), index=index)
+
+
@pytest.mark.filterwarnings("ignore:\\n.ix:DeprecationWarning")
class TestMultiIndexLoc(object):
@@ -247,3 +256,123 @@ def convert_nested_indexer(indexer_type, keys):
index=MultiIndex.from_product(keys))
tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize('indexer, is_level1, expected_error', [
+ ([], False, None), # empty ok
+ (['A'], False, None),
+ (['A', 'D'], False, None),
+ (['D'], False, r"\['D'\] not in index"), # not any values found
+ (pd.IndexSlice[:, ['foo']], True, None),
+ (pd.IndexSlice[:, ['foo', 'bah']], True, None)
+])
+def test_loc_getitem_duplicates_multiindex_missing_indexers(indexer, is_level1,
+ expected_error):
+ # GH 7866
+ # multi-index slicing with missing indexers
+ idx = MultiIndex.from_product([['A', 'B', 'C'],
+ ['foo', 'bar', 'baz']],
+ names=['one', 'two'])
+ s = Series(np.arange(9, dtype='int64'), index=idx).sort_index()
+
+ if indexer == []:
+ expected = s.iloc[[]]
+ elif is_level1:
+ expected = Series([0, 3, 6], index=MultiIndex.from_product(
+ [['A', 'B', 'C'], ['foo']], names=['one', 'two'])).sort_index()
+ else:
+ exp_idx = MultiIndex.from_product([['A'], ['foo', 'bar', 'baz']],
+ names=['one', 'two'])
+ expected = Series(np.arange(3, dtype='int64'),
+ index=exp_idx).sort_index()
+
+ if expected_error is not None:
+ with pytest.raises(KeyError, match=expected_error):
+ s.loc[indexer]
+ else:
+ result = s.loc[indexer]
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.filterwarnings("ignore:\\n.ix:DeprecationWarning")
+@pytest.mark.parametrize('indexer', [
+ lambda s: s.loc[[(2000, 3, 10), (2000, 3, 13)]],
+ lambda s: s.ix[[(2000, 3, 10), (2000, 3, 13)]]
+])
+def test_series_loc_getitem_fancy(
+ multiindex_year_month_day_dataframe_random_data, indexer):
+ s = multiindex_year_month_day_dataframe_random_data['A']
+ expected = s.reindex(s.index[49:51])
+
+ result = indexer(s)
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize('columns_indexer', [
+ ([], slice(None)),
+ (['foo'], [])
+])
+def test_loc_getitem_duplicates_multiindex_empty_indexer(columns_indexer):
+ # GH 8737
+ # empty indexer
+ multi_index = MultiIndex.from_product((['foo', 'bar', 'baz'],
+ ['alpha', 'beta']))
+ df = DataFrame(np.random.randn(5, 6), index=range(5), columns=multi_index)
+ df = df.sort_index(level=0, axis=1)
+
+ expected = DataFrame(index=range(5), columns=multi_index.reindex([])[0])
+ result = df.loc[:, columns_indexer]
+ tm.assert_frame_equal(result, expected)
+
+
+def test_loc_getitem_duplicates_multiindex_non_scalar_type_object():
+ # regression from < 0.14.0
+ # GH 7914
+ df = DataFrame([[np.mean, np.median], ['mean', 'median']],
+ columns=MultiIndex.from_tuples([('functs', 'mean'),
+ ('functs', 'median')]),
+ index=['function', 'name'])
+ result = df.loc['function', ('functs', 'mean')]
+ expected = np.mean
+ assert result == expected
+
+
+def test_loc_getitem_tuple_plus_slice():
+ # GH 671
+ df = DataFrame({'a': np.arange(10),
+ 'b': np.arange(10),
+ 'c': np.random.randn(10),
+ 'd': np.random.randn(10)}
+ ).set_index(['a', 'b'])
+ expected = df.loc[0, 0]
+ result = df.loc[(0, 0), :]
+ tm.assert_series_equal(result, expected)
+
+
+def test_loc_getitem_int(frame_random_data_integer_multi_index):
+ df = frame_random_data_integer_multi_index
+ result = df.loc[1]
+ expected = df[-3:]
+ expected.index = expected.index.droplevel(0)
+ tm.assert_frame_equal(result, expected)
+
+
+def test_loc_getitem_int_raises_exception(
+ frame_random_data_integer_multi_index):
+ df = frame_random_data_integer_multi_index
+ with pytest.raises(KeyError, match=r"^3L?$"):
+ df.loc[3]
+
+
+def test_loc_getitem_lowerdim_corner(multiindex_dataframe_random_data):
+ df = multiindex_dataframe_random_data
+
+ # test setup - check key not in dataframe
+ with pytest.raises(KeyError, match=r"^11L?$"):
+ df.loc[('bar', 'three'), 'B']
+
+ # in theory should be inserting in a sorted space????
+ df.loc[('bar', 'three'), 'B'] = 0
+ expected = 0
+ result = df.sort_index().loc[('bar', 'three'), 'B']
+ assert result == expected
diff --git a/pandas/tests/indexing/multiindex/test_setitem.py b/pandas/tests/indexing/multiindex/test_setitem.py
index d49ca34edd0fd..f8f037dbda46b 100644
--- a/pandas/tests/indexing/multiindex/test_setitem.py
+++ b/pandas/tests/indexing/multiindex/test_setitem.py
@@ -7,6 +7,7 @@
import pandas as pd
from pandas import (
DataFrame, MultiIndex, Series, Timestamp, date_range, isna, notna)
+import pandas.core.common as com
from pandas.util import testing as tm
@@ -408,3 +409,31 @@ def test_astype_assignment_with_dups(self):
df['A'] = df['A'].astype(np.float64)
tm.assert_index_equal(df.index, index)
+
+
+def test_frame_setitem_view_direct(multiindex_dataframe_random_data):
+ # this works because we are modifying the underlying array
+ # really a no-no
+ df = multiindex_dataframe_random_data.T
+ df['foo'].values[:] = 0
+ assert (df['foo'].values == 0).all()
+
+
+def test_frame_setitem_copy_raises(multiindex_dataframe_random_data):
+ # will raise/warn as its chained assignment
+ df = multiindex_dataframe_random_data.T
+ msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+ with pytest.raises(com.SettingWithCopyError, match=msg):
+ df['foo']['one'] = 2
+
+
+def test_frame_setitem_copy_no_write(multiindex_dataframe_random_data):
+ frame = multiindex_dataframe_random_data.T
+ expected = frame
+ df = frame.copy()
+ msg = "A value is trying to be set on a copy of a slice from a DataFrame"
+ with pytest.raises(com.SettingWithCopyError, match=msg):
+ df['foo']['one'] = 2
+
+ result = df
+ tm.assert_frame_equal(result, expected)
| follow-on from #24452 to add section breaks and move tests. also `KeyError` checks made more explicit. | https://api.github.com/repos/pandas-dev/pandas/pulls/24741 | 2019-01-12T17:27:27Z | 2019-01-13T20:34:41Z | 2019-01-13T20:34:41Z | 2019-01-15T19:53:48Z |
DOC: Small whatsnew fixes | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 3950ff3c8863d..d3d34e6b9ec3e 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1128,7 +1128,7 @@ update the ``ExtensionDtype._metadata`` tuple to match the signature of your
- :meth:`~Series.shift` now dispatches to :meth:`ExtensionArray.shift` (:issue:`22386`)
- :meth:`Series.combine()` works correctly with :class:`~pandas.api.extensions.ExtensionArray` inside of :class:`Series` (:issue:`20825`)
- :meth:`Series.combine()` with scalar argument now works for any function type (:issue:`21248`)
-- :meth:`Series.astype` and :meth:`DataFrame.astype` now dispatch to :meth:`ExtensionArray.astype` (:issue:`21185:`).
+- :meth:`Series.astype` and :meth:`DataFrame.astype` now dispatch to :meth:`ExtensionArray.astype` (:issue:`21185`).
- Slicing a single row of a ``DataFrame`` with multiple ExtensionArrays of the same type now preserves the dtype, rather than coercing to object (:issue:`22784`)
- Bug when concatenating multiple ``Series`` with different extension dtypes not casting to object dtype (:issue:`22994`)
- Series backed by an ``ExtensionArray`` now work with :func:`util.hash_pandas_object` (:issue:`23066`)
@@ -1261,7 +1261,7 @@ Other API Changes
- The order of the arguments of :func:`DataFrame.to_html` and :func:`DataFrame.to_string` is rearranged to be consistent with each other. (:issue:`23614`)
- :meth:`CategoricalIndex.reindex` now raises a ``ValueError`` if the target index is non-unique and not equal to the current index. It previously only raised if the target index was not of a categorical dtype (:issue:`23963`).
- :func:`Series.to_list` and :func:`Index.to_list` are now aliases of ``Series.tolist`` respectively ``Index.tolist`` (:issue:`8826`)
-- The result of ``SparseSeries.unstack`` is now a :class:`DataFrame` with sparse values, rather than a :class:`SparseDataFrame` (issue:`24372`).
+- The result of ``SparseSeries.unstack`` is now a :class:`DataFrame` with sparse values, rather than a :class:`SparseDataFrame` (:issue:`24372`).
.. _whatsnew_0240.deprecations:
@@ -1300,15 +1300,15 @@ Deprecations
- The ``keep_tz=False`` option (the default) of the ``keep_tz`` keyword of
:meth:`DatetimeIndex.to_series` is deprecated (:issue:`17832`).
- Timezone converting a tz-aware ``datetime.datetime`` or :class:`Timestamp` with :class:`Timestamp` and the ``tz`` argument is now deprecated. Instead, use :meth:`Timestamp.tz_convert` (:issue:`23579`)
-- :func:`pandas.api.types.is_period` is deprecated in favor of `pandas.api.types.is_period_dtype` (:issue:`23917`)
-- :func:`pandas.api.types.is_datetimetz` is deprecated in favor of `pandas.api.types.is_datetime64tz` (:issue:`23917`)
+- :func:`pandas.api.types.is_period` is deprecated in favor of ``pandas.api.types.is_period_dtype`` (:issue:`23917`)
+- :func:`pandas.api.types.is_datetimetz` is deprecated in favor of ``pandas.api.types.is_datetime64tz`` (:issue:`23917`)
- Creating a :class:`TimedeltaIndex`, :class:`DatetimeIndex`, or :class:`PeriodIndex` by passing range arguments `start`, `end`, and `periods` is deprecated in favor of :func:`timedelta_range`, :func:`date_range`, or :func:`period_range` (:issue:`23919`)
- Passing a string alias like ``'datetime64[ns, UTC]'`` as the ``unit`` parameter to :class:`DatetimeTZDtype` is deprecated. Use :class:`DatetimeTZDtype.construct_from_string` instead (:issue:`23990`).
- The ``skipna`` parameter of :meth:`~pandas.api.types.infer_dtype` will switch to ``True`` by default in a future version of pandas (:issue:`17066`, :issue:`24050`)
- In :meth:`Series.where` with Categorical data, providing an ``other`` that is not present in the categories is deprecated. Convert the categorical to a different dtype or add the ``other`` to the categories first (:issue:`24077`).
- :meth:`Series.clip_lower`, :meth:`Series.clip_upper`, :meth:`DataFrame.clip_lower` and :meth:`DataFrame.clip_upper` are deprecated and will be removed in a future version. Use ``Series.clip(lower=threshold)``, ``Series.clip(upper=threshold)`` and the equivalent ``DataFrame`` methods (:issue:`24203`)
- :meth:`Series.nonzero` is deprecated and will be removed in a future version (:issue:`18262`)
-- Passing an integer to :meth:`Series.fillna` and :meth:`DataFrame.fillna` with ``timedelta64[ns]`` dtypes is deprecated, will raise ``TypeError`` in a future version. Use ``obj.fillna(pd.Timedelta(...))` instead (:issue:`24694`)
+- Passing an integer to :meth:`Series.fillna` and :meth:`DataFrame.fillna` with ``timedelta64[ns]`` dtypes is deprecated, will raise ``TypeError`` in a future version. Use ``obj.fillna(pd.Timedelta(...))`` instead (:issue:`24694`)
.. _whatsnew_0240.deprecations.datetimelike_int_ops:
@@ -1525,7 +1525,7 @@ Performance Improvements
- Improved performance of :meth:`~DataFrame.where` for Categorical data (:issue:`24077`)
- Improved performance of iterating over a :class:`Series`. Using :meth:`DataFrame.itertuples` now creates iterators
without internally allocating lists of all elements (:issue:`20783`)
-- Improved performance of :class:`Period` constructor, additionally benefitting ``PeriodArray`` and ``PeriodIndex`` creation (:issue:`24084` and :issue:`24118`)
+- Improved performance of :class:`Period` constructor, additionally benefitting ``PeriodArray`` and ``PeriodIndex`` creation (:issue:`24084`, :issue:`24118`)
- Improved performance of tz-aware :class:`DatetimeArray` binary operations (:issue:`24491`)
.. _whatsnew_0240.bug_fixes:
@@ -1671,7 +1671,7 @@ Numeric
- Bug in :class:`DataFrame` with ``timedelta64[ns]`` dtype arithmetic operations with ``ndarray`` with integer dtype incorrectly treating the narray as ``timedelta64[ns]`` dtype (:issue:`23114`)
- Bug in :meth:`Series.rpow` with object dtype ``NaN`` for ``1 ** NA`` instead of ``1`` (:issue:`22922`).
- :meth:`Series.agg` can now handle numpy NaN-aware methods like :func:`numpy.nansum` (:issue:`19629`)
-- Bug in :meth:`Series.rank` and :meth:`DataFrame.rank` when ``pct=True`` and more than 2:sup:`24` rows are present resulted in percentages greater than 1.0 (:issue:`18271`)
+- Bug in :meth:`Series.rank` and :meth:`DataFrame.rank` when ``pct=True`` and more than 2\ :sup:`24` rows are present resulted in percentages greater than 1.0 (:issue:`18271`)
- Calls such as :meth:`DataFrame.round` with a non-unique :meth:`CategoricalIndex` now return expected data. Previously, data would be improperly duplicated (:issue:`21809`).
- Added ``log10``, `floor` and `ceil` to the list of supported functions in :meth:`DataFrame.eval` (:issue:`24139`, :issue:`24353`)
- Logical operations ``&, |, ^`` between :class:`Series` and :class:`Index` will no longer raise ``ValueError`` (:issue:`22092`)
@@ -1758,7 +1758,7 @@ I/O
- Bug in :meth:`read_excel()` when ``parse_cols`` is specified with an empty dataset (:issue:`9208`)
- :func:`read_html()` no longer ignores all-whitespace ``<tr>`` within ``<thead>`` when considering the ``skiprows`` and ``header`` arguments. Previously, users had to decrease their ``header`` and ``skiprows`` values on such tables to work around the issue. (:issue:`21641`)
- :func:`read_excel()` will correctly show the deprecation warning for previously deprecated ``sheetname`` (:issue:`17994`)
-- :func:`read_csv()` and func:`read_table()` will throw ``UnicodeError`` and not coredump on badly encoded strings (:issue:`22748`)
+- :func:`read_csv()` and :func:`read_table()` will throw ``UnicodeError`` and not coredump on badly encoded strings (:issue:`22748`)
- :func:`read_csv()` will correctly parse timezone-aware datetimes (:issue:`22256`)
- Bug in :func:`read_csv()` in which memory management was prematurely optimized for the C engine when the data was being read in chunks (:issue:`23509`)
- Bug in :func:`read_csv()` in unnamed columns were being improperly identified when extracting a multi-index (:issue:`23687`)
| A few small things that I saw when scanning over the What's New page. | https://api.github.com/repos/pandas-dev/pandas/pulls/24738 | 2019-01-12T01:18:00Z | 2019-01-12T10:32:15Z | 2019-01-12T10:32:15Z | 2019-01-12T17:25:35Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.