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 |
|---|---|---|---|---|---|---|---|
Backport PR #56636 on branch 2.2.x (DOC: Fixup CoW userguide) | diff --git a/doc/source/user_guide/copy_on_write.rst b/doc/source/user_guide/copy_on_write.rst
index 050c3901c3420..a083297925007 100644
--- a/doc/source/user_guide/copy_on_write.rst
+++ b/doc/source/user_guide/copy_on_write.rst
@@ -317,7 +317,7 @@ you are modifying one object inplace.
.. ipython:: python
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
- df2 = df.reset_index()
+ df2 = df.reset_index(drop=True)
df2.iloc[0, 0] = 100
This creates two objects that share data and thus the setitem operation will trigger a
@@ -328,7 +328,7 @@ held by the object.
.. ipython:: python
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
- df = df.reset_index()
+ df = df.reset_index(drop=True)
df.iloc[0, 0] = 100
No copy is necessary in this example.
| Backport PR #56636: DOC: Fixup CoW userguide | https://api.github.com/repos/pandas-dev/pandas/pulls/56639 | 2023-12-27T19:03:55Z | 2023-12-27T19:43:09Z | 2023-12-27T19:43:09Z | 2023-12-27T19:43:09Z |
PERF: resolution, is_normalized | diff --git a/pandas/_libs/tslibs/vectorized.pyx b/pandas/_libs/tslibs/vectorized.pyx
index 0a19092f57706..1e09874639d4f 100644
--- a/pandas/_libs/tslibs/vectorized.pyx
+++ b/pandas/_libs/tslibs/vectorized.pyx
@@ -234,7 +234,7 @@ def get_resolution(
for i in range(n):
# Analogous to: utc_val = stamps[i]
- utc_val = cnp.PyArray_GETITEM(stamps, cnp.PyArray_ITER_DATA(it))
+ utc_val = (<int64_t*>cnp.PyArray_ITER_DATA(it))[0]
if utc_val == NPY_NAT:
pass
@@ -331,7 +331,7 @@ def is_date_array_normalized(ndarray stamps, tzinfo tz, NPY_DATETIMEUNIT reso) -
for i in range(n):
# Analogous to: utc_val = stamps[i]
- utc_val = cnp.PyArray_GETITEM(stamps, cnp.PyArray_ITER_DATA(it))
+ utc_val = (<int64_t*>cnp.PyArray_ITER_DATA(it))[0]
local_val = info.utc_val_to_local_val(utc_val, &pos)
| ```
dti = pd.date_range("2016-01-01", periods=10_000)
dta = dti._data
In [4]: %timeit dta.is_normalized
354 µs ± 3.62 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each) # <- main
122 µs ± 2.71 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each) # <- PR
In [5]: %timeit dta.resolution
493 µs ± 4.86 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each) # <- main
258 µs ± 10.3 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each) # <- PR
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/56637 | 2023-12-27T17:31:47Z | 2023-12-27T18:52:01Z | 2023-12-27T18:52:01Z | 2023-12-27T23:43:38Z |
DOC: Fixup CoW userguide | diff --git a/doc/source/user_guide/copy_on_write.rst b/doc/source/user_guide/copy_on_write.rst
index 050c3901c3420..a083297925007 100644
--- a/doc/source/user_guide/copy_on_write.rst
+++ b/doc/source/user_guide/copy_on_write.rst
@@ -317,7 +317,7 @@ you are modifying one object inplace.
.. ipython:: python
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
- df2 = df.reset_index()
+ df2 = df.reset_index(drop=True)
df2.iloc[0, 0] = 100
This creates two objects that share data and thus the setitem operation will trigger a
@@ -328,7 +328,7 @@ held by the object.
.. ipython:: python
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
- df = df.reset_index()
+ df = df.reset_index(drop=True)
df.iloc[0, 0] = 100
No copy is necessary in this example.
| - [ ] closes #56622 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/56636 | 2023-12-27T16:31:28Z | 2023-12-27T19:02:55Z | 2023-12-27T19:02:55Z | 2023-12-27T19:18:30Z |
CoW: Boolean indexer in MultiIndex raising read-only error | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 5ee94b74c527e..38e82d43b3e92 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -773,6 +773,7 @@ Interval
Indexing
^^^^^^^^
+- Bug in :meth:`DataFrame.loc` mutating a boolean indexer when :class:`DataFrame` has a :class:`MultiIndex` (:issue:`56635`)
- Bug in :meth:`DataFrame.loc` when setting :class:`Series` with extension dtype into NumPy dtype (:issue:`55604`)
- Bug in :meth:`Index.difference` not returning a unique set of values when ``other`` is empty or ``other`` is considered non-comparable (:issue:`55113`)
- Bug in setting :class:`Categorical` values into a :class:`DataFrame` with numpy dtypes raising ``RecursionError`` (:issue:`52927`)
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 2a4e027e2b806..02a841a2075fd 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -3488,6 +3488,8 @@ def _to_bool_indexer(indexer) -> npt.NDArray[np.bool_]:
"is not the same length as the index"
)
lvl_indexer = np.asarray(k)
+ if indexer is None:
+ lvl_indexer = lvl_indexer.copy()
elif is_list_like(k):
# a collection of labels to include from this level (these are or'd)
diff --git a/pandas/tests/copy_view/test_indexing.py b/pandas/tests/copy_view/test_indexing.py
index 9afc98e558c11..91cd77741f79b 100644
--- a/pandas/tests/copy_view/test_indexing.py
+++ b/pandas/tests/copy_view/test_indexing.py
@@ -1180,6 +1180,27 @@ def test_series_midx_tuples_slice(using_copy_on_write, warn_copy_on_write):
tm.assert_series_equal(ser, expected)
+def test_midx_read_only_bool_indexer():
+ # GH#56635
+ def mklbl(prefix, n):
+ return [f"{prefix}{i}" for i in range(n)]
+
+ idx = pd.MultiIndex.from_product(
+ [mklbl("A", 4), mklbl("B", 2), mklbl("C", 4), mklbl("D", 2)]
+ )
+ cols = pd.MultiIndex.from_tuples(
+ [("a", "foo"), ("a", "bar"), ("b", "foo"), ("b", "bah")], names=["lvl0", "lvl1"]
+ )
+ df = DataFrame(1, index=idx, columns=cols).sort_index().sort_index(axis=1)
+
+ mask = df[("a", "foo")] == 1
+ expected_mask = mask.copy()
+ result = df.loc[pd.IndexSlice[mask, :, ["C1", "C3"]], :]
+ expected = df.loc[pd.IndexSlice[:, :, ["C1", "C3"]], :]
+ tm.assert_frame_equal(result, expected)
+ tm.assert_series_equal(mask, expected_mask)
+
+
def test_loc_enlarging_with_dataframe(using_copy_on_write):
df = DataFrame({"a": [1, 2, 3]})
rhs = DataFrame({"b": [1, 2, 3], "c": [4, 5, 6]})
| Found this while going through the docs | https://api.github.com/repos/pandas-dev/pandas/pulls/56635 | 2023-12-27T16:14:39Z | 2023-12-28T18:48:25Z | 2023-12-28T18:48:25Z | 2023-12-28T18:48:49Z |
DOC: Add whatsnew for 2.3.0 | diff --git a/doc/source/whatsnew/index.rst b/doc/source/whatsnew/index.rst
index ec024f36d78b1..09d1ae08df57a 100644
--- a/doc/source/whatsnew/index.rst
+++ b/doc/source/whatsnew/index.rst
@@ -10,6 +10,15 @@ This is the list of changes to pandas between each release. For full details,
see the `commit logs <https://github.com/pandas-dev/pandas/commits/>`_. For install and
upgrade instructions, see :ref:`install`.
+Version 2.3
+-----------
+
+.. toctree::
+ :maxdepth: 2
+
+ v2.3.0
+
+
Version 2.2
-----------
diff --git a/doc/source/whatsnew/v2.3.0.rst b/doc/source/whatsnew/v2.3.0.rst
new file mode 100644
index 0000000000000..1f1b0c7d7195a
--- /dev/null
+++ b/doc/source/whatsnew/v2.3.0.rst
@@ -0,0 +1,219 @@
+.. _whatsnew_230:
+
+What's new in 2.3.0 (Month XX, 2024)
+------------------------------------
+
+These are the changes in pandas 2.2.0. See :ref:`release` for a full changelog
+including other versions of pandas.
+
+{{ header }}
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_230.enhancements:
+
+Enhancements
+~~~~~~~~~~~~
+
+.. _whatsnew_230.enhancements.enhancement1:
+
+enhancement1
+^^^^^^^^^^^^
+
+.. _whatsnew_230.enhancements.enhancement2:
+
+enhancement2
+^^^^^^^^^^^^
+
+.. _whatsnew_230.enhancements.other:
+
+Other enhancements
+^^^^^^^^^^^^^^^^^^
+-
+-
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_230.notable_bug_fixes:
+
+Notable bug fixes
+~~~~~~~~~~~~~~~~~
+
+These are bug fixes that might have notable behavior changes.
+
+.. _whatsnew_230.notable_bug_fixes.notable_bug_fix1:
+
+notable_bug_fix1
+^^^^^^^^^^^^^^^^
+
+.. _whatsnew_230.notable_bug_fixes.notable_bug_fix2:
+
+notable_bug_fix2
+^^^^^^^^^^^^^^^^
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_230.api_breaking:
+
+Backwards incompatible API changes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. _whatsnew_230.api_breaking.deps:
+
+Increased minimum versions for dependencies
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Some minimum supported versions of dependencies were updated.
+If installed, we now require:
+
++-----------------+-----------------+----------+---------+
+| Package | Minimum Version | Required | Changed |
++=================+=================+==========+=========+
+| | | X | X |
++-----------------+-----------------+----------+---------+
+
+For `optional libraries <https://pandas.pydata.org/docs/getting_started/install.html>`_ the general recommendation is to use the latest version.
+The following table lists the lowest version per library that is currently being tested throughout the development of pandas.
+Optional libraries below the lowest tested version may still work, but are not considered supported.
+
++-----------------+---------------------+
+| Package | New Minimum Version |
++=================+=====================+
+| | |
++-----------------+---------------------+
+
+See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for more.
+
+.. _whatsnew_230.api_breaking.other:
+
+Other API changes
+^^^^^^^^^^^^^^^^^
+-
+-
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_230.deprecations:
+
+Deprecations
+~~~~~~~~~~~~
+-
+-
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_230.performance:
+
+Performance improvements
+~~~~~~~~~~~~~~~~~~~~~~~~
+-
+-
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_230.bug_fixes:
+
+Bug fixes
+~~~~~~~~~
+
+Categorical
+^^^^^^^^^^^
+-
+-
+
+Datetimelike
+^^^^^^^^^^^^
+-
+-
+
+Timedelta
+^^^^^^^^^
+-
+-
+
+Timezones
+^^^^^^^^^
+-
+-
+
+Numeric
+^^^^^^^
+-
+-
+
+Conversion
+^^^^^^^^^^
+-
+-
+
+Strings
+^^^^^^^
+-
+-
+
+Interval
+^^^^^^^^
+-
+-
+
+Indexing
+^^^^^^^^
+-
+-
+
+Missing
+^^^^^^^
+-
+-
+
+MultiIndex
+^^^^^^^^^^
+-
+-
+
+I/O
+^^^
+-
+-
+
+Period
+^^^^^^
+-
+-
+
+Plotting
+^^^^^^^^
+-
+-
+
+Groupby/resample/rolling
+^^^^^^^^^^^^^^^^^^^^^^^^
+-
+-
+
+Reshaping
+^^^^^^^^^
+-
+-
+
+Sparse
+^^^^^^
+-
+-
+
+ExtensionArray
+^^^^^^^^^^^^^^
+-
+-
+
+Styler
+^^^^^^
+-
+-
+
+Other
+^^^^^
+
+.. ***DO NOT USE THIS SECTION***
+
+-
+-
+
+.. ---------------------------------------------------------------------------
+.. _whatsnew_230.contributors:
+
+Contributors
+~~~~~~~~~~~~
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/56634 | 2023-12-27T16:06:11Z | 2023-12-28T16:25:57Z | 2023-12-28T16:25:57Z | 2024-01-11T00:05:18Z |
CoW: Enable CoW by default and remove warning build | diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index a3cffb4b03b93..2b09aa9343b79 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -73,18 +73,6 @@ jobs:
env_file: actions-312.yaml
pattern: "not slow and not network and not single_cpu"
pandas_copy_on_write: "1"
- - name: "Copy-on-Write 3.11 (warnings)"
- env_file: actions-311.yaml
- pattern: "not slow and not network and not single_cpu"
- pandas_copy_on_write: "warn"
- - name: "Copy-on-Write 3.10 (warnings)"
- env_file: actions-310.yaml
- pattern: "not slow and not network and not single_cpu"
- pandas_copy_on_write: "warn"
- - name: "Copy-on-Write 3.9 (warnings)"
- env_file: actions-39.yaml
- pattern: "not slow and not network and not single_cpu"
- pandas_copy_on_write: "warn"
- name: "Pypy"
env_file: actions-pypy-39.yaml
pattern: "not slow and not network and not single_cpu"
diff --git a/asv_bench/benchmarks/algos/isin.py b/asv_bench/benchmarks/algos/isin.py
index f9ea3d5684751..a17732c70c2c7 100644
--- a/asv_bench/benchmarks/algos/isin.py
+++ b/asv_bench/benchmarks/algos/isin.py
@@ -59,7 +59,8 @@ def setup(self, dtype):
elif dtype in ["str", "string[python]", "string[pyarrow]"]:
try:
self.series = Series(
- Index([f"i-{i}" for i in range(N)], dtype=object), dtype=dtype
+ Index([f"i-{i}" for i in range(N)], dtype=object)._values,
+ dtype=dtype,
)
except ImportError as err:
raise NotImplementedError from err
diff --git a/asv_bench/benchmarks/strings.py b/asv_bench/benchmarks/strings.py
index e6842fbc13f46..467fab857d306 100644
--- a/asv_bench/benchmarks/strings.py
+++ b/asv_bench/benchmarks/strings.py
@@ -19,7 +19,8 @@ class Dtypes:
def setup(self, dtype):
try:
self.s = Series(
- Index([f"i-{i}" for i in range(10000)], dtype=object), dtype=dtype
+ Index([f"i-{i}" for i in range(10000)], dtype=object)._values,
+ dtype=dtype,
)
except ImportError as err:
raise NotImplementedError from err
diff --git a/pandas/_config/__init__.py b/pandas/_config/__init__.py
index 5b2bac2e8d747..0594d1c190a72 100644
--- a/pandas/_config/__init__.py
+++ b/pandas/_config/__init__.py
@@ -32,13 +32,11 @@
def using_copy_on_write() -> bool:
- _mode_options = _global_config["mode"]
- return _mode_options["copy_on_write"] is True
+ return True
def warn_copy_on_write() -> bool:
- _mode_options = _global_config["mode"]
- return _mode_options["copy_on_write"] == "warn"
+ return False
def using_nullable_dtypes() -> bool:
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 26e03ca30d4fb..db251a07aeb5d 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -1963,7 +1963,7 @@ def using_copy_on_write() -> bool:
"""
Fixture to check if Copy-on-Write is enabled.
"""
- return pd.options.mode.copy_on_write is True
+ return True
@pytest.fixture
@@ -1971,7 +1971,7 @@ def warn_copy_on_write() -> bool:
"""
Fixture to check if Copy-on-Write is in warning mode.
"""
- return pd.options.mode.copy_on_write == "warn"
+ return False
@pytest.fixture
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 037f809eaabca..73f9481e53dea 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -6704,8 +6704,7 @@ def copy(self, deep: bool_t | None = True) -> Self:
:ref:`gotchas <gotchas.thread-safety>` when copying in a threading
environment.
- When ``copy_on_write`` in pandas config is set to ``True``, the
- ``copy_on_write`` config takes effect even when ``deep=False``.
+ Copy-on-Write protects shallow copies against accidental modifications.
This means that any changes to the copied data would make a new copy
of the data upon write (and vice versa). Changes made to either the
original or copied variable would not be reflected in the counterpart.
@@ -6731,12 +6730,15 @@ def copy(self, deep: bool_t | None = True) -> Self:
>>> deep = s.copy()
>>> shallow = s.copy(deep=False)
- Shallow copy shares data and index with original.
+ Shallow copy shares index with original, the data is a
+ view of the original.
>>> s is shallow
False
- >>> s.values is shallow.values and s.index is shallow.index
- True
+ >>> s.values is shallow.values
+ False
+ >>> s.index is shallow.index
+ False
Deep copy has own copy of data and index.
@@ -6745,18 +6747,17 @@ def copy(self, deep: bool_t | None = True) -> Self:
>>> s.values is deep.values or s.index is deep.index
False
- Updates to the data shared by shallow copy and original is reflected
- in both (NOTE: this will no longer be true for pandas >= 3.0);
- deep copy remains unchanged.
+ The shallow copy is protected against updating the original object
+ as well. Thus, updates will only reflect in one of both objects.
>>> s.iloc[0] = 3
>>> shallow.iloc[1] = 4
>>> s
a 3
- b 4
+ b 2
dtype: int64
>>> shallow
- a 3
+ a 1
b 4
dtype: int64
>>> deep
@@ -6779,22 +6780,6 @@ def copy(self, deep: bool_t | None = True) -> Self:
0 [10, 2]
1 [3, 4]
dtype: object
-
- **Copy-on-Write is set to true**, the shallow copy is not modified
- when the original data is changed:
-
- >>> with pd.option_context("mode.copy_on_write", True):
- ... s = pd.Series([1, 2], index=["a", "b"])
- ... copy = s.copy(deep=False)
- ... s.iloc[0] = 100
- ... s
- a 100
- b 2
- dtype: int64
- >>> copy
- a 1
- b 2
- dtype: int64
"""
data = self._mgr.copy(deep=deep)
self._clear_item_cache()
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index a80ee421a1b8a..0495f23508c09 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -3492,6 +3492,8 @@ def _to_bool_indexer(indexer) -> npt.NDArray[np.bool_]:
"cannot index with a boolean indexer that "
"is not the same length as the index"
)
+ if isinstance(k, (ABCSeries, Index)):
+ k = k._values
lvl_indexer = np.asarray(k)
if indexer is None:
lvl_indexer = lvl_indexer.copy()
diff --git a/pandas/tests/copy_view/test_internals.py b/pandas/tests/copy_view/test_internals.py
index 400fb8e03c18c..f1a4decce623f 100644
--- a/pandas/tests/copy_view/test_internals.py
+++ b/pandas/tests/copy_view/test_internals.py
@@ -1,7 +1,6 @@
import numpy as np
import pytest
-import pandas as pd
from pandas import DataFrame
import pandas._testing as tm
from pandas.tests.copy_view.util import get_array
@@ -42,35 +41,6 @@ def test_consolidate(using_copy_on_write):
assert df.loc[0, "b"] == 0.1
-@pytest.mark.single_cpu
-def test_switch_options():
- # ensure we can switch the value of the option within one session
- # (assuming data is constructed after switching)
-
- # using the option_context to ensure we set back to global option value
- # after running the test
- with pd.option_context("mode.copy_on_write", False):
- df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
- subset = df[:]
- subset.iloc[0, 0] = 0
- # df updated with CoW disabled
- assert df.iloc[0, 0] == 0
-
- pd.options.mode.copy_on_write = True
- df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
- subset = df[:]
- subset.iloc[0, 0] = 0
- # df not updated with CoW enabled
- assert df.iloc[0, 0] == 1
-
- pd.options.mode.copy_on_write = False
- df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
- subset = df[:]
- subset.iloc[0, 0] = 0
- # df updated with CoW disabled
- assert df.iloc[0, 0] == 0
-
-
@pytest.mark.parametrize("dtype", [np.intp, np.int8])
@pytest.mark.parametrize(
"locs, arr",
diff --git a/pandas/tests/extension/conftest.py b/pandas/tests/extension/conftest.py
index 77f1dd2a8e49c..3a3844d5a8b7a 100644
--- a/pandas/tests/extension/conftest.py
+++ b/pandas/tests/extension/conftest.py
@@ -2,10 +2,7 @@
import pytest
-from pandas import (
- Series,
- options,
-)
+from pandas import Series
@pytest.fixture
@@ -222,4 +219,4 @@ def using_copy_on_write() -> bool:
"""
Fixture to check if Copy-on-Write is enabled.
"""
- return options.mode.copy_on_write is True
+ return True
diff --git a/pandas/tests/frame/methods/test_copy.py b/pandas/tests/frame/methods/test_copy.py
index 6208d0256a655..5b72a84320c52 100644
--- a/pandas/tests/frame/methods/test_copy.py
+++ b/pandas/tests/frame/methods/test_copy.py
@@ -1,10 +1,7 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
from pandas import DataFrame
-import pandas._testing as tm
class TestCopy:
@@ -18,25 +15,6 @@ def test_copy_index_name_checking(self, float_frame, attr):
getattr(cp, attr).name = "foo"
assert getattr(float_frame, attr).name is None
- @td.skip_copy_on_write_invalid_test
- def test_copy_cache(self):
- # GH#31784 _item_cache not cleared on copy causes incorrect reads after updates
- df = DataFrame({"a": [1]})
-
- df["x"] = [0]
- df["a"]
-
- df.copy()
-
- df["a"].values[0] = -1
-
- tm.assert_frame_equal(df, DataFrame({"a": [-1], "x": [0]}))
-
- df["y"] = [0]
-
- assert df["a"].values[0] == -1
- tm.assert_frame_equal(df, DataFrame({"a": [-1], "x": [0], "y": [0]}))
-
def test_copy(self, float_frame, float_string_frame):
cop = float_frame.copy()
cop["E"] = cop["A"]
diff --git a/pandas/tests/series/test_ufunc.py b/pandas/tests/series/test_ufunc.py
index 3ef319174313d..94a6910509e2d 100644
--- a/pandas/tests/series/test_ufunc.py
+++ b/pandas/tests/series/test_ufunc.py
@@ -5,8 +5,6 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
import pandas as pd
import pandas._testing as tm
from pandas.arrays import SparseArray
@@ -456,8 +454,7 @@ def add3(x, y, z):
ufunc(ser, ser, df)
-# TODO(CoW) see https://github.com/pandas-dev/pandas/pull/51082
-@td.skip_copy_on_write_not_yet_implemented
+@pytest.mark.xfail(reason="see https://github.com/pandas-dev/pandas/pull/51082")
def test_np_fix():
# np.fix is not a ufunc but is composed of several ufunc calls under the hood
# with `out` and `where` keywords
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index 10776fe5d050f..feba0e86c6b32 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -58,8 +58,8 @@ def test_dask_ufunc():
s = Series([1.5, 2.3, 3.7, 4.0])
ds = dd.from_pandas(s, npartitions=2)
- result = da.fix(ds).compute()
- expected = np.fix(s)
+ result = da.log(ds).compute()
+ expected = np.log(s)
tm.assert_series_equal(result, expected)
finally:
pd.set_option("compute.use_numexpr", olduse)
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index 37908c9ac255b..78626781289c4 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -33,12 +33,9 @@ def test_foo():
import pytest
-from pandas._config import get_option
-
if TYPE_CHECKING:
from pandas._typing import F
-
from pandas.compat import (
IS64,
is_platform_windows,
@@ -144,14 +141,3 @@ def documented_fixture(fixture):
return fixture
return documented_fixture
-
-
-skip_copy_on_write_not_yet_implemented = pytest.mark.xfail(
- get_option("mode.copy_on_write") is True,
- reason="Not yet implemented/adapted for Copy-on-Write mode",
-)
-
-skip_copy_on_write_invalid_test = pytest.mark.skipif(
- get_option("mode.copy_on_write") is True,
- reason="Test not valid for Copy-on-Write mode",
-)
| I'd prefer to go this way in enabling CoW. Having it on makes it easier to enforce the change step by step rather than doing it all at once. | https://api.github.com/repos/pandas-dev/pandas/pulls/56633 | 2023-12-27T15:50:11Z | 2024-02-01T09:04:05Z | 2024-02-01T09:04:05Z | 2024-02-01T09:04:09Z |
DOC: Minor fixups for 2.2.0 whatsnew | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 5ee94b74c527e..5b955aa45219a 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -123,7 +123,7 @@ nullability handling.
with pg_dbapi.connect(uri) as conn:
df.to_sql("pandas_table", conn, index=False)
- # for roundtripping
+ # for round-tripping
with pg_dbapi.connect(uri) as conn:
df2 = pd.read_sql("pandas_table", conn)
@@ -176,7 +176,7 @@ leverage the ``dtype_backend="pyarrow"`` argument of :func:`~pandas.read_sql`
.. code-block:: ipython
- # for roundtripping
+ # for round-tripping
with pg_dbapi.connect(uri) as conn:
df2 = pd.read_sql("pandas_table", conn, dtype_backend="pyarrow")
@@ -306,22 +306,21 @@ Other enhancements
- :meth:`~DataFrame.to_sql` with method parameter set to ``multi`` works with Oracle on the backend
- :attr:`Series.attrs` / :attr:`DataFrame.attrs` now uses a deepcopy for propagating ``attrs`` (:issue:`54134`).
- :func:`get_dummies` now returning extension dtypes ``boolean`` or ``bool[pyarrow]`` that are compatible with the input dtype (:issue:`56273`)
-- :func:`read_csv` now supports ``on_bad_lines`` parameter with ``engine="pyarrow"``. (:issue:`54480`)
+- :func:`read_csv` now supports ``on_bad_lines`` parameter with ``engine="pyarrow"`` (:issue:`54480`)
- :func:`read_sas` returns ``datetime64`` dtypes with resolutions better matching those stored natively in SAS, and avoids returning object-dtype in cases that cannot be stored with ``datetime64[ns]`` dtype (:issue:`56127`)
-- :func:`read_spss` now returns a :class:`DataFrame` that stores the metadata in :attr:`DataFrame.attrs`. (:issue:`54264`)
+- :func:`read_spss` now returns a :class:`DataFrame` that stores the metadata in :attr:`DataFrame.attrs` (:issue:`54264`)
- :func:`tseries.api.guess_datetime_format` is now part of the public API (:issue:`54727`)
+- :meth:`DataFrame.apply` now allows the usage of numba (via ``engine="numba"``) to JIT compile the passed function, allowing for potential speedups (:issue:`54666`)
- :meth:`ExtensionArray._explode` interface method added to allow extension type implementations of the ``explode`` method (:issue:`54833`)
- :meth:`ExtensionArray.duplicated` added to allow extension type implementations of the ``duplicated`` method (:issue:`55255`)
- :meth:`Series.ffill`, :meth:`Series.bfill`, :meth:`DataFrame.ffill`, and :meth:`DataFrame.bfill` have gained the argument ``limit_area`` (:issue:`56492`)
- Allow passing ``read_only``, ``data_only`` and ``keep_links`` arguments to openpyxl using ``engine_kwargs`` of :func:`read_excel` (:issue:`55027`)
-- DataFrame.apply now allows the usage of numba (via ``engine="numba"``) to JIT compile the passed function, allowing for potential speedups (:issue:`54666`)
- Implement masked algorithms for :meth:`Series.value_counts` (:issue:`54984`)
- Implemented :meth:`Series.str.extract` for :class:`ArrowDtype` (:issue:`56268`)
-- Improved error message that appears in :meth:`DatetimeIndex.to_period` with frequencies which are not supported as period frequencies, such as "BMS" (:issue:`56243`)
-- Improved error message when constructing :class:`Period` with invalid offsets such as "QS" (:issue:`55785`)
+- Improved error message that appears in :meth:`DatetimeIndex.to_period` with frequencies which are not supported as period frequencies, such as ``"BMS"`` (:issue:`56243`)
+- Improved error message when constructing :class:`Period` with invalid offsets such as ``"QS"`` (:issue:`55785`)
- The dtypes ``string[pyarrow]`` and ``string[pyarrow_numpy]`` now both utilize the ``large_string`` type from PyArrow to avoid overflow for long columns (:issue:`56259`)
-
.. ---------------------------------------------------------------------------
.. _whatsnew_220.notable_bug_fixes:
@@ -386,6 +385,8 @@ index levels when joining on two indexes with different levels (:issue:`34133`).
left = pd.DataFrame({"left": 1}, index=pd.MultiIndex.from_tuples([("x", 1), ("x", 2)], names=["A", "B"]))
right = pd.DataFrame({"right": 2}, index=pd.MultiIndex.from_tuples([(1, 1), (2, 2)], names=["B", "C"]))
+ left
+ right
result = left.join(right)
*Old Behavior*
@@ -415,15 +416,6 @@ Backwards incompatible API changes
Increased minimum versions for dependencies
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Some minimum supported versions of dependencies were updated.
-If installed, we now require:
-
-+-----------------+-----------------+----------+---------+
-| Package | Minimum Version | Required | Changed |
-+=================+=================+==========+=========+
-| | | X | X |
-+-----------------+-----------------+----------+---------+
-
For `optional libraries <https://pandas.pydata.org/docs/getting_started/install.html>`_ the general recommendation is to use the latest version.
The following table lists the lowest version per library that is currently being tested throughout the development of pandas.
Optional libraries below the lowest tested version may still work, but are not considered supported.
@@ -433,8 +425,6 @@ Optional libraries below the lowest tested version may still work, but are not c
+=================+=================+=========+
| mypy (dev) | 1.8.0 | X |
+-----------------+-----------------+---------+
-| | | X |
-+-----------------+-----------------+---------+
See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for more.
@@ -606,20 +596,20 @@ Other Deprecations
- Deprecated ``year``, ``month``, ``quarter``, ``day``, ``hour``, ``minute``, and ``second`` keywords in the :class:`PeriodIndex` constructor, use :meth:`PeriodIndex.from_fields` instead (:issue:`55960`)
- Deprecated accepting a type as an argument in :meth:`Index.view`, call without any arguments instead (:issue:`55709`)
- Deprecated allowing non-integer ``periods`` argument in :func:`date_range`, :func:`timedelta_range`, :func:`period_range`, and :func:`interval_range` (:issue:`56036`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_clipboard`. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_csv` except ``path_or_buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_dict`. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_excel` except ``excel_writer``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_gbq` except ``destination_table``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_hdf` except ``path_or_buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_html` except ``buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_json` except ``path_or_buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_latex` except ``buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_markdown` except ``buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_parquet` except ``path``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_pickle` except ``path``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_string` except ``buf``. (:issue:`54229`)
-- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_xml` except ``path_or_buffer``. (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_clipboard` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_csv` except ``path_or_buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_dict` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_excel` except ``excel_writer`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_gbq` except ``destination_table`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_hdf` except ``path_or_buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_html` except ``buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_json` except ``path_or_buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_latex` except ``buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_markdown` except ``buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_parquet` except ``path`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_pickle` except ``path`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_string` except ``buf`` (:issue:`54229`)
+- Deprecated allowing non-keyword arguments in :meth:`DataFrame.to_xml` except ``path_or_buffer`` (:issue:`54229`)
- Deprecated allowing passing :class:`BlockManager` objects to :class:`DataFrame` or :class:`SingleBlockManager` objects to :class:`Series` (:issue:`52419`)
- Deprecated behavior of :meth:`Index.insert` with an object-dtype index silently performing type inference on the result, explicitly call ``result.infer_objects(copy=False)`` for the old behavior instead (:issue:`51363`)
- Deprecated casting non-datetimelike values (mainly strings) in :meth:`Series.isin` and :meth:`Index.isin` with ``datetime64``, ``timedelta64``, and :class:`PeriodDtype` dtypes (:issue:`53111`)
@@ -692,31 +682,30 @@ Bug fixes
Categorical
^^^^^^^^^^^
- :meth:`Categorical.isin` raising ``InvalidIndexError`` for categorical containing overlapping :class:`Interval` values (:issue:`34974`)
-- Bug in :meth:`CategoricalDtype.__eq__` returning false for unordered categorical data with mixed types (:issue:`55468`)
--
+- Bug in :meth:`CategoricalDtype.__eq__` returning ``False`` for unordered categorical data with mixed types (:issue:`55468`)
Datetimelike
^^^^^^^^^^^^
- Bug in :class:`DatetimeIndex` construction when passing both a ``tz`` and either ``dayfirst`` or ``yearfirst`` ignoring dayfirst/yearfirst (:issue:`55813`)
- Bug in :class:`DatetimeIndex` when passing an object-dtype ndarray of float objects and a ``tz`` incorrectly localizing the result (:issue:`55780`)
- Bug in :func:`Series.isin` with :class:`DatetimeTZDtype` dtype and comparison values that are all ``NaT`` incorrectly returning all-``False`` even if the series contains ``NaT`` entries (:issue:`56427`)
-- Bug in :func:`concat` raising ``AttributeError`` when concatenating all-NA DataFrame with :class:`DatetimeTZDtype` dtype DataFrame. (:issue:`52093`)
+- Bug in :func:`concat` raising ``AttributeError`` when concatenating all-NA DataFrame with :class:`DatetimeTZDtype` dtype DataFrame (:issue:`52093`)
- Bug in :func:`testing.assert_extension_array_equal` that could use the wrong unit when comparing resolutions (:issue:`55730`)
- Bug in :func:`to_datetime` and :class:`DatetimeIndex` when passing a list of mixed-string-and-numeric types incorrectly raising (:issue:`55780`)
- Bug in :func:`to_datetime` and :class:`DatetimeIndex` when passing mixed-type objects with a mix of timezones or mix of timezone-awareness failing to raise ``ValueError`` (:issue:`55693`)
+- Bug in :meth:`.Tick.delta` with very large ticks raising ``OverflowError`` instead of ``OutOfBoundsTimedelta`` (:issue:`55503`)
- Bug in :meth:`DatetimeIndex.shift` with non-nanosecond resolution incorrectly returning with nanosecond resolution (:issue:`56117`)
- Bug in :meth:`DatetimeIndex.union` returning object dtype for tz-aware indexes with the same timezone but different units (:issue:`55238`)
- Bug in :meth:`Index.is_monotonic_increasing` and :meth:`Index.is_monotonic_decreasing` always caching :meth:`Index.is_unique` as ``True`` when first value in index is ``NaT`` (:issue:`55755`)
- Bug in :meth:`Index.view` to a datetime64 dtype with non-supported resolution incorrectly raising (:issue:`55710`)
- Bug in :meth:`Series.dt.round` with non-nanosecond resolution and ``NaT`` entries incorrectly raising ``OverflowError`` (:issue:`56158`)
- Bug in :meth:`Series.fillna` with non-nanosecond resolution dtypes and higher-resolution vector values returning incorrect (internally-corrupted) results (:issue:`56410`)
-- Bug in :meth:`Tick.delta` with very large ticks raising ``OverflowError`` instead of ``OutOfBoundsTimedelta`` (:issue:`55503`)
- Bug in :meth:`Timestamp.unit` being inferred incorrectly from an ISO8601 format string with minute or hour resolution and a timezone offset (:issue:`56208`)
-- Bug in ``.astype`` converting from a higher-resolution ``datetime64`` dtype to a lower-resolution ``datetime64`` dtype (e.g. ``datetime64[us]->datetim64[ms]``) silently overflowing with values near the lower implementation bound (:issue:`55979`)
+- Bug in ``.astype`` converting from a higher-resolution ``datetime64`` dtype to a lower-resolution ``datetime64`` dtype (e.g. ``datetime64[us]->datetime64[ms]``) silently overflowing with values near the lower implementation bound (:issue:`55979`)
- Bug in adding or subtracting a :class:`Week` offset to a ``datetime64`` :class:`Series`, :class:`Index`, or :class:`DataFrame` column with non-nanosecond resolution returning incorrect results (:issue:`55583`)
- Bug in addition or subtraction of :class:`BusinessDay` offset with ``offset`` attribute to non-nanosecond :class:`Index`, :class:`Series`, or :class:`DataFrame` column giving incorrect results (:issue:`55608`)
- Bug in addition or subtraction of :class:`DateOffset` objects with microsecond components to ``datetime64`` :class:`Index`, :class:`Series`, or :class:`DataFrame` columns with non-nanosecond resolution (:issue:`55595`)
-- Bug in addition or subtraction of very large :class:`Tick` objects with :class:`Timestamp` or :class:`Timedelta` objects raising ``OverflowError`` instead of ``OutOfBoundsTimedelta`` (:issue:`55503`)
+- Bug in addition or subtraction of very large :class:`.Tick` objects with :class:`Timestamp` or :class:`Timedelta` objects raising ``OverflowError`` instead of ``OutOfBoundsTimedelta`` (:issue:`55503`)
- Bug in creating a :class:`Index`, :class:`Series`, or :class:`DataFrame` with a non-nanosecond :class:`DatetimeTZDtype` and inputs that would be out of bounds with nanosecond resolution incorrectly raising ``OutOfBoundsDatetime`` (:issue:`54620`)
- Bug in creating a :class:`Index`, :class:`Series`, or :class:`DataFrame` with a non-nanosecond ``datetime64`` (or :class:`DatetimeTZDtype`) from mixed-numeric inputs treating those as nanoseconds instead of as multiples of the dtype's unit (which would happen with non-mixed numeric inputs) (:issue:`56004`)
- Bug in creating a :class:`Index`, :class:`Series`, or :class:`DataFrame` with a non-nanosecond ``datetime64`` dtype and inputs that would be out of bounds for a ``datetime64[ns]`` incorrectly raising ``OutOfBoundsDatetime`` (:issue:`55756`)
@@ -739,14 +728,12 @@ Numeric
^^^^^^^
- Bug in :func:`read_csv` with ``engine="pyarrow"`` causing rounding errors for large integers (:issue:`52505`)
- Bug in :meth:`Series.pow` not filling missing values correctly (:issue:`55512`)
--
Conversion
^^^^^^^^^^
- Bug in :meth:`DataFrame.astype` when called with ``str`` on unpickled array - the array might change in-place (:issue:`54654`)
- Bug in :meth:`DataFrame.astype` where ``errors="ignore"`` had no effect for extension types (:issue:`54654`)
- Bug in :meth:`Series.convert_dtypes` not converting all NA column to ``null[pyarrow]`` (:issue:`55346`)
--
Strings
^^^^^^^
@@ -763,13 +750,12 @@ Strings
Interval
^^^^^^^^
-- Bug in :class:`Interval` ``__repr__`` not displaying UTC offsets for :class:`Timestamp` bounds. Additionally the hour, minute and second components will now be shown. (:issue:`55015`)
+- Bug in :class:`Interval` ``__repr__`` not displaying UTC offsets for :class:`Timestamp` bounds. Additionally the hour, minute and second components will now be shown (:issue:`55015`)
- Bug in :meth:`IntervalIndex.factorize` and :meth:`Series.factorize` with :class:`IntervalDtype` with datetime64 or timedelta64 intervals not preserving non-nanosecond units (:issue:`56099`)
- Bug in :meth:`IntervalIndex.from_arrays` when passed ``datetime64`` or ``timedelta64`` arrays with mismatched resolutions constructing an invalid ``IntervalArray`` object (:issue:`55714`)
- Bug in :meth:`IntervalIndex.get_indexer` with datetime or timedelta intervals incorrectly matching on integer targets (:issue:`47772`)
- Bug in :meth:`IntervalIndex.get_indexer` with timezone-aware datetime intervals incorrectly matching on a sequence of timezone-naive targets (:issue:`47772`)
- Bug in setting values on a :class:`Series` with an :class:`IntervalIndex` using a slice incorrectly raising (:issue:`54722`)
--
Indexing
^^^^^^^^
@@ -781,25 +767,23 @@ Indexing
Missing
^^^^^^^
- Bug in :meth:`DataFrame.update` wasn't updating in-place for tz-aware datetime64 dtypes (:issue:`56227`)
--
MultiIndex
^^^^^^^^^^
- Bug in :meth:`MultiIndex.get_indexer` not raising ``ValueError`` when ``method`` provided and index is non-monotonic (:issue:`53452`)
--
I/O
^^^
-- Bug in :func:`read_csv` where ``engine="python"`` did not respect ``chunksize`` arg when ``skiprows`` was specified. (:issue:`56323`)
-- Bug in :func:`read_csv` where ``engine="python"`` was causing a ``TypeError`` when a callable ``skiprows`` and a chunk size was specified. (:issue:`55677`)
-- Bug in :func:`read_csv` where ``on_bad_lines="warn"`` would write to ``stderr`` instead of raise a Python warning. This now yields a :class:`.errors.ParserWarning` (:issue:`54296`)
+- Bug in :func:`read_csv` where ``engine="python"`` did not respect ``chunksize`` arg when ``skiprows`` was specified (:issue:`56323`)
+- Bug in :func:`read_csv` where ``engine="python"`` was causing a ``TypeError`` when a callable ``skiprows`` and a chunk size was specified (:issue:`55677`)
+- Bug in :func:`read_csv` where ``on_bad_lines="warn"`` would write to ``stderr`` instead of raising a Python warning; this now yields a :class:`.errors.ParserWarning` (:issue:`54296`)
- Bug in :func:`read_csv` with ``engine="pyarrow"`` where ``quotechar`` was ignored (:issue:`52266`)
-- Bug in :func:`read_csv` with ``engine="pyarrow"`` where ``usecols`` wasn't working with a csv with no headers (:issue:`54459`)
-- Bug in :func:`read_excel`, with ``engine="xlrd"`` (``xls`` files) erroring when file contains NaNs/Infs (:issue:`54564`)
+- Bug in :func:`read_csv` with ``engine="pyarrow"`` where ``usecols`` wasn't working with a CSV with no headers (:issue:`54459`)
+- Bug in :func:`read_excel`, with ``engine="xlrd"`` (``xls`` files) erroring when the file contains ``NaN`` or ``Inf`` (:issue:`54564`)
- Bug in :func:`read_json` not handling dtype conversion properly if ``infer_string`` is set (:issue:`56195`)
-- Bug in :meth:`DataFrame.to_excel`, with ``OdsWriter`` (``ods`` files) writing boolean/string value (:issue:`54994`)
+- Bug in :meth:`DataFrame.to_excel`, with ``OdsWriter`` (``ods`` files) writing Boolean/string value (:issue:`54994`)
- Bug in :meth:`DataFrame.to_hdf` and :func:`read_hdf` with ``datetime64`` dtypes with non-nanosecond resolution failing to round-trip correctly (:issue:`55622`)
-- Bug in :meth:`~pandas.read_excel` with ``engine="odf"`` (``ods`` files) when string contains annotation (:issue:`55200`)
+- Bug in :meth:`~pandas.read_excel` with ``engine="odf"`` (``ods`` files) when a string cell contains an annotation (:issue:`55200`)
- Bug in :meth:`~pandas.read_excel` with an ODS file without cached formatted cell for float values (:issue:`55219`)
- Bug where :meth:`DataFrame.to_json` would raise an ``OverflowError`` instead of a ``TypeError`` with unsupported NumPy types (:issue:`55403`)
@@ -808,12 +792,11 @@ Period
- Bug in :class:`PeriodIndex` construction when more than one of ``data``, ``ordinal`` and ``**fields`` are passed failing to raise ``ValueError`` (:issue:`55961`)
- Bug in :class:`Period` addition silently wrapping around instead of raising ``OverflowError`` (:issue:`55503`)
- Bug in casting from :class:`PeriodDtype` with ``astype`` to ``datetime64`` or :class:`DatetimeTZDtype` with non-nanosecond unit incorrectly returning with nanosecond unit (:issue:`55958`)
--
Plotting
^^^^^^^^
-- Bug in :meth:`DataFrame.plot.box` with ``vert=False`` and a matplotlib ``Axes`` created with ``sharey=True`` (:issue:`54941`)
-- Bug in :meth:`DataFrame.plot.scatter` discaring string columns (:issue:`56142`)
+- Bug in :meth:`DataFrame.plot.box` with ``vert=False`` and a Matplotlib ``Axes`` created with ``sharey=True`` (:issue:`54941`)
+- Bug in :meth:`DataFrame.plot.scatter` discarding string columns (:issue:`56142`)
- Bug in :meth:`Series.plot` when reusing an ``ax`` object failing to raise when a ``how`` keyword is passed (:issue:`55953`)
Groupby/resample/rolling
@@ -821,9 +804,9 @@ Groupby/resample/rolling
- Bug in :class:`.Rolling` where duplicate datetimelike indexes are treated as consecutive rather than equal with ``closed='left'`` and ``closed='neither'`` (:issue:`20712`)
- Bug in :meth:`.DataFrameGroupBy.idxmin`, :meth:`.DataFrameGroupBy.idxmax`, :meth:`.SeriesGroupBy.idxmin`, and :meth:`.SeriesGroupBy.idxmax` would not retain :class:`.Categorical` dtype when the index was a :class:`.CategoricalIndex` that contained NA values (:issue:`54234`)
- Bug in :meth:`.DataFrameGroupBy.transform` and :meth:`.SeriesGroupBy.transform` when ``observed=False`` and ``f="idxmin"`` or ``f="idxmax"`` would incorrectly raise on unobserved categories (:issue:`54234`)
-- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_count` could result in incorrect sorting if the columns of the DataFrame or name of the Series are integers (:issue:`55951`)
-- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_count` would not respect ``sort=False`` in :meth:`DataFrame.groupby` and :meth:`Series.groupby` (:issue:`55951`)
-- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_count` would sort by proportions rather than frequencies when ``sort=True`` and ``normalize=True`` (:issue:`55951`)
+- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_counts` could result in incorrect sorting if the columns of the DataFrame or name of the Series are integers (:issue:`55951`)
+- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_counts` would not respect ``sort=False`` in :meth:`DataFrame.groupby` and :meth:`Series.groupby` (:issue:`55951`)
+- Bug in :meth:`.DataFrameGroupBy.value_counts` and :meth:`.SeriesGroupBy.value_counts` would sort by proportions rather than frequencies when ``sort=True`` and ``normalize=True`` (:issue:`55951`)
- Bug in :meth:`DataFrame.asfreq` and :meth:`Series.asfreq` with a :class:`DatetimeIndex` with non-nanosecond resolution incorrectly converting to nanosecond resolution (:issue:`55958`)
- Bug in :meth:`DataFrame.ewm` when passed ``times`` with non-nanosecond ``datetime64`` or :class:`DatetimeTZDtype` dtype (:issue:`56262`)
- Bug in :meth:`DataFrame.groupby` and :meth:`Series.groupby` where grouping by a combination of ``Decimal`` and NA values would fail when ``sort=True`` (:issue:`54847`)
@@ -845,22 +828,11 @@ Reshaping
- Bug in :meth:`DataFrame.melt` where it would not preserve the datetime (:issue:`55254`)
- Bug in :meth:`DataFrame.pivot_table` where the row margin is incorrect when the columns have numeric names (:issue:`26568`)
- Bug in :meth:`DataFrame.pivot` with numeric columns and extension dtype for data (:issue:`56528`)
-- Bug in :meth:`DataFrame.stack` and :meth:`Series.stack` with ``future_stack=True`` would not preserve NA values in the index (:issue:`56573`)
+- Bug in :meth:`DataFrame.stack` with ``future_stack=True`` would not preserve NA values in the index (:issue:`56573`)
Sparse
^^^^^^
- Bug in :meth:`SparseArray.take` when using a different fill value than the array's fill value (:issue:`55181`)
--
-
-ExtensionArray
-^^^^^^^^^^^^^^
--
--
-
-Styler
-^^^^^^
--
--
Other
^^^^^
@@ -871,15 +843,11 @@ Other
- Bug in :meth:`DataFrame.apply` where passing ``raw=True`` ignored ``args`` passed to the applied function (:issue:`55009`)
- Bug in :meth:`DataFrame.from_dict` which would always sort the rows of the created :class:`DataFrame`. (:issue:`55683`)
- Bug in :meth:`DataFrame.sort_index` when passing ``axis="columns"`` and ``ignore_index=True`` raising a ``ValueError`` (:issue:`56478`)
-- Bug in rendering ``inf`` values inside a a :class:`DataFrame` with the ``use_inf_as_na`` option enabled (:issue:`55483`)
+- Bug in rendering ``inf`` values inside a :class:`DataFrame` with the ``use_inf_as_na`` option enabled (:issue:`55483`)
- Bug in rendering a :class:`Series` with a :class:`MultiIndex` when one of the index level's names is 0 not having that name displayed (:issue:`55415`)
- Bug in the error message when assigning an empty :class:`DataFrame` to a column (:issue:`55956`)
- Bug when time-like strings were being cast to :class:`ArrowDtype` with ``pyarrow.time64`` type (:issue:`56463`)
-.. ***DO NOT USE THIS SECTION***
-
--
--
.. ---------------------------------------------------------------------------
.. _whatsnew_220.contributors:
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/56632 | 2023-12-27T14:50:41Z | 2023-12-27T19:19:25Z | 2023-12-27T19:19:25Z | 2023-12-27T19:36:08Z |
TYP: more simple return types from ruff | diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index 25a71ce5b5f4f..784e11415ade6 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -827,7 +827,7 @@ def generate_numba_apply_func(
def apply_with_numba(self):
pass
- def validate_values_for_numba(self):
+ def validate_values_for_numba(self) -> None:
# Validate column dtyps all OK
for colname, dtype in self.obj.dtypes.items():
if not is_numeric_dtype(dtype):
diff --git a/pandas/core/array_algos/replace.py b/pandas/core/array_algos/replace.py
index 5f377276be480..60fc172139f13 100644
--- a/pandas/core/array_algos/replace.py
+++ b/pandas/core/array_algos/replace.py
@@ -67,7 +67,7 @@ def compare_or_regex_search(
def _check_comparison_types(
result: ArrayLike | bool, a: ArrayLike, b: Scalar | Pattern
- ):
+ ) -> None:
"""
Raises an error if the two arrays (a,b) cannot be compared.
Otherwise, returns the comparison result as expected.
diff --git a/pandas/core/arrays/arrow/accessors.py b/pandas/core/arrays/arrow/accessors.py
index 7f88267943526..23825faa70095 100644
--- a/pandas/core/arrays/arrow/accessors.py
+++ b/pandas/core/arrays/arrow/accessors.py
@@ -39,7 +39,7 @@ def __init__(self, data, validation_msg: str) -> None:
def _is_valid_pyarrow_dtype(self, pyarrow_dtype) -> bool:
pass
- def _validate(self, data):
+ def _validate(self, data) -> None:
dtype = data.dtype
if not isinstance(dtype, ArrowDtype):
# Raise AttributeError so that inspect can handle non-struct Series.
diff --git a/pandas/core/arrays/arrow/extension_types.py b/pandas/core/arrays/arrow/extension_types.py
index 72bfd6f2212f8..d52b60df47adc 100644
--- a/pandas/core/arrays/arrow/extension_types.py
+++ b/pandas/core/arrays/arrow/extension_types.py
@@ -135,7 +135,7 @@ def to_pandas_dtype(self) -> IntervalDtype:
"""
-def patch_pyarrow():
+def patch_pyarrow() -> None:
# starting from pyarrow 14.0.1, it has its own mechanism
if not pa_version_under14p1:
return
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 065a942cae768..8a88227ad54a3 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -2164,7 +2164,9 @@ def __contains__(self, key) -> bool:
# ------------------------------------------------------------------
# Rendering Methods
- def _formatter(self, boxed: bool = False):
+ # error: Return type "None" of "_formatter" incompatible with return
+ # type "Callable[[Any], str | None]" in supertype "ExtensionArray"
+ def _formatter(self, boxed: bool = False) -> None: # type: ignore[override]
# Returning None here will cause format_array to do inference.
return None
@@ -2890,7 +2892,7 @@ def __init__(self, data) -> None:
self._freeze()
@staticmethod
- def _validate(data):
+ def _validate(data) -> None:
if not isinstance(data.dtype, CategoricalDtype):
raise AttributeError("Can only use .cat accessor with a 'category' dtype")
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 11a0c7bf18fcb..e04fcb84d51a0 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -2058,7 +2058,7 @@ def freq(self, value) -> None:
self._freq = value
@final
- def _maybe_pin_freq(self, freq, validate_kwds: dict):
+ def _maybe_pin_freq(self, freq, validate_kwds: dict) -> None:
"""
Constructor helper to pin the appropriate `freq` attribute. Assumes
that self._freq is currently set to any freq inferred in
@@ -2092,7 +2092,7 @@ def _maybe_pin_freq(self, freq, validate_kwds: dict):
@final
@classmethod
- def _validate_frequency(cls, index, freq: BaseOffset, **kwargs):
+ def _validate_frequency(cls, index, freq: BaseOffset, **kwargs) -> None:
"""
Validate that a frequency is compatible with the values of a given
Datetime Array/Index or Timedelta Array/Index
diff --git a/pandas/core/arrays/sparse/accessor.py b/pandas/core/arrays/sparse/accessor.py
index fc7debb1f31e4..3dd7ebf564ca1 100644
--- a/pandas/core/arrays/sparse/accessor.py
+++ b/pandas/core/arrays/sparse/accessor.py
@@ -30,7 +30,7 @@ def __init__(self, data=None) -> None:
self._parent = data
self._validate(data)
- def _validate(self, data):
+ def _validate(self, data) -> None:
raise NotImplementedError
@@ -50,7 +50,7 @@ class SparseAccessor(BaseAccessor, PandasDelegate):
array([2, 2, 2])
"""
- def _validate(self, data):
+ def _validate(self, data) -> None:
if not isinstance(data.dtype, SparseDtype):
raise AttributeError(self._validation_msg)
@@ -243,7 +243,7 @@ class SparseFrameAccessor(BaseAccessor, PandasDelegate):
0.5
"""
- def _validate(self, data):
+ def _validate(self, data) -> None:
dtypes = data.dtypes
if not all(isinstance(t, SparseDtype) for t in dtypes):
raise AttributeError(self._validation_msg)
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 5db77db2a9c66..7a3ea85dde2b4 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -1830,7 +1830,9 @@ def __repr__(self) -> str:
pp_index = printing.pprint_thing(self.sp_index)
return f"{pp_str}\nFill: {pp_fill}\n{pp_index}"
- def _formatter(self, boxed: bool = False):
+ # error: Return type "None" of "_formatter" incompatible with return
+ # type "Callable[[Any], str | None]" in supertype "ExtensionArray"
+ def _formatter(self, boxed: bool = False) -> None: # type: ignore[override]
# Defer to the formatter from the GenericArrayFormatter calling us.
# This will infer the correct formatter from the dtype of the values.
return None
diff --git a/pandas/core/arrays/sparse/scipy_sparse.py b/pandas/core/arrays/sparse/scipy_sparse.py
index 71b71a9779da5..31e09c923d933 100644
--- a/pandas/core/arrays/sparse/scipy_sparse.py
+++ b/pandas/core/arrays/sparse/scipy_sparse.py
@@ -27,7 +27,7 @@
)
-def _check_is_partition(parts: Iterable, whole: Iterable):
+def _check_is_partition(parts: Iterable, whole: Iterable) -> None:
whole = set(whole)
parts = [set(x) for x in parts]
if set.intersection(*parts) != set():
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 00197a150fb97..f451ebc352733 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -364,7 +364,7 @@ def __init__(self, values, copy: bool = False) -> None:
self._validate()
NDArrayBacked.__init__(self, self._ndarray, StringDtype(storage="python"))
- def _validate(self):
+ def _validate(self) -> None:
"""Validate that we only store NA or strings."""
if len(self._ndarray) and not lib.is_string_array(self._ndarray, skipna=True):
raise ValueError("StringArray requires a sequence of strings or pandas.NA")
diff --git a/pandas/core/computation/eval.py b/pandas/core/computation/eval.py
index f1fe528de06f8..6313c2e2c98de 100644
--- a/pandas/core/computation/eval.py
+++ b/pandas/core/computation/eval.py
@@ -72,7 +72,7 @@ def _check_engine(engine: str | None) -> str:
return engine
-def _check_parser(parser: str):
+def _check_parser(parser: str) -> None:
"""
Make sure a valid parser is passed.
@@ -91,7 +91,7 @@ def _check_parser(parser: str):
)
-def _check_resolvers(resolvers):
+def _check_resolvers(resolvers) -> None:
if resolvers is not None:
for resolver in resolvers:
if not hasattr(resolver, "__getitem__"):
@@ -102,7 +102,7 @@ def _check_resolvers(resolvers):
)
-def _check_expression(expr):
+def _check_expression(expr) -> None:
"""
Make sure an expression is not an empty string
@@ -149,7 +149,7 @@ def _convert_expression(expr) -> str:
return s
-def _check_for_locals(expr: str, stack_level: int, parser: str):
+def _check_for_locals(expr: str, stack_level: int, parser: str) -> None:
at_top_of_stack = stack_level == 0
not_pandas_parser = parser != "pandas"
diff --git a/pandas/core/computation/ops.py b/pandas/core/computation/ops.py
index 95ac20ba39edc..9422434b5cde3 100644
--- a/pandas/core/computation/ops.py
+++ b/pandas/core/computation/ops.py
@@ -491,7 +491,7 @@ def stringify(value):
v = v.tz_convert("UTC")
self.lhs.update(v)
- def _disallow_scalar_only_bool_ops(self):
+ def _disallow_scalar_only_bool_ops(self) -> None:
rhs = self.rhs
lhs = self.lhs
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 7a088bf84c48e..72c33e95f68a0 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -231,7 +231,7 @@ def _maybe_unbox_datetimelike(value: Scalar, dtype: DtypeObj) -> Scalar:
return value
-def _disallow_mismatched_datetimelike(value, dtype: DtypeObj):
+def _disallow_mismatched_datetimelike(value, dtype: DtypeObj) -> None:
"""
numpy allows np.array(dt64values, dtype="timedelta64[ns]") and
vice-versa, but we do not want to allow this, so we need to
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 3e2e589440bd9..a46e42b9241ff 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -4316,7 +4316,7 @@ def _setitem_array(self, key, value):
else:
self._iset_not_inplace(key, value)
- def _iset_not_inplace(self, key, value):
+ def _iset_not_inplace(self, key, value) -> None:
# GH#39510 when setting with df[key] = obj with a list-like key and
# list-like value, we iterate over those listlikes and set columns
# one at a time. This is different from dispatching to
@@ -4360,7 +4360,7 @@ def igetitem(obj, i: int):
finally:
self.columns = orig_columns
- def _setitem_frame(self, key, value):
+ def _setitem_frame(self, key, value) -> None:
# support boolean setting with DataFrame input, e.g.
# df[df > df2] = 0
if isinstance(key, np.ndarray):
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index de25a02c6b37c..91a150c63c5b6 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -4394,7 +4394,7 @@ def _check_is_chained_assignment_possible(self) -> bool_t:
return False
@final
- def _check_setitem_copy(self, t: str = "setting", force: bool_t = False):
+ def _check_setitem_copy(self, t: str = "setting", force: bool_t = False) -> None:
"""
Parameters
@@ -4510,7 +4510,7 @@ def __delitem__(self, key) -> None:
# Unsorted
@final
- def _check_inplace_and_allows_duplicate_labels(self, inplace: bool_t):
+ def _check_inplace_and_allows_duplicate_labels(self, inplace: bool_t) -> None:
if inplace and not self.flags.allows_duplicate_labels:
raise ValueError(
"Cannot specify 'inplace=True' when "
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 88a08dd55f739..d262dcd144d79 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -3209,7 +3209,7 @@ def _get_reconciled_name_object(self, other):
return self
@final
- def _validate_sort_keyword(self, sort):
+ def _validate_sort_keyword(self, sort) -> None:
if sort not in [None, False, True]:
raise ValueError(
"The 'sort' keyword only takes the values of "
@@ -6051,7 +6051,7 @@ def argsort(self, *args, **kwargs) -> npt.NDArray[np.intp]:
# by RangeIndex, MultIIndex
return self._data.argsort(*args, **kwargs)
- def _check_indexing_error(self, key):
+ def _check_indexing_error(self, key) -> None:
if not is_scalar(key):
# if key is not a scalar, directly raise an error (the code below
# would convert to numpy arrays and raise later any way) - GH29926
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 2a4e027e2b806..56e3899eae6f6 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -1571,7 +1571,7 @@ def _format_multi(
def _get_names(self) -> FrozenList:
return FrozenList(self._names)
- def _set_names(self, names, *, level=None, validate: bool = True):
+ def _set_names(self, names, *, level=None, validate: bool = True) -> None:
"""
Set new names on index. Each name has to be a hashable type.
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 4be7e17035128..a7dd3b486ab11 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -911,7 +911,7 @@ def __setitem__(self, key, value) -> None:
iloc = self if self.name == "iloc" else self.obj.iloc
iloc._setitem_with_indexer(indexer, value, self.name)
- def _validate_key(self, key, axis: AxisInt):
+ def _validate_key(self, key, axis: AxisInt) -> None:
"""
Ensure that key is valid for current indexer.
@@ -1225,7 +1225,7 @@ class _LocIndexer(_LocationIndexer):
# Key Checks
@doc(_LocationIndexer._validate_key)
- def _validate_key(self, key, axis: Axis):
+ def _validate_key(self, key, axis: Axis) -> None:
# valid for a collection of labels (we check their presence later)
# slice of labels (where start-end in labels)
# slice of integers (only if in the labels)
@@ -1572,7 +1572,7 @@ class _iLocIndexer(_LocationIndexer):
# -------------------------------------------------------------------
# Key Checks
- def _validate_key(self, key, axis: AxisInt):
+ def _validate_key(self, key, axis: AxisInt) -> None:
if com.is_bool_indexer(key):
if hasattr(key, "index") and isinstance(key.index, Index):
if key.index.inferred_type == "integer":
@@ -1783,7 +1783,7 @@ def _get_setitem_indexer(self, key):
# -------------------------------------------------------------------
- def _setitem_with_indexer(self, indexer, value, name: str = "iloc"):
+ def _setitem_with_indexer(self, indexer, value, name: str = "iloc") -> None:
"""
_setitem_with_indexer is for setting values on a Series/DataFrame
using positional indexers.
@@ -2038,7 +2038,7 @@ def _setitem_with_indexer_split_path(self, indexer, value, name: str):
for loc in ilocs:
self._setitem_single_column(loc, value, pi)
- def _setitem_with_indexer_2d_value(self, indexer, value):
+ def _setitem_with_indexer_2d_value(self, indexer, value) -> None:
# We get here with np.ndim(value) == 2, excluding DataFrame,
# which goes through _setitem_with_indexer_frame_value
pi = indexer[0]
@@ -2060,7 +2060,9 @@ def _setitem_with_indexer_2d_value(self, indexer, value):
value_col = value_col.tolist()
self._setitem_single_column(loc, value_col, pi)
- def _setitem_with_indexer_frame_value(self, indexer, value: DataFrame, name: str):
+ def _setitem_with_indexer_frame_value(
+ self, indexer, value: DataFrame, name: str
+ ) -> None:
ilocs = self._ensure_iterable_column_indexer(indexer[1])
sub_indexer = list(indexer)
diff --git a/pandas/core/internals/base.py b/pandas/core/internals/base.py
index ae91f167205a0..8f16a6623c8cb 100644
--- a/pandas/core/internals/base.py
+++ b/pandas/core/internals/base.py
@@ -53,7 +53,7 @@
class _AlreadyWarned:
- def __init__(self):
+ def __init__(self) -> None:
# This class is used on the manager level to the block level to
# ensure that we warn only once. The block method can update the
# warned_already option without returning a value to keep the
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index 3719bf1f77f85..5f38720135efa 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -1940,13 +1940,15 @@ def _post_setstate(self) -> None:
def _block(self) -> Block:
return self.blocks[0]
+ # error: Cannot override writeable attribute with read-only property
@property
- def _blknos(self):
+ def _blknos(self) -> None: # type: ignore[override]
"""compat with BlockManager"""
return None
+ # error: Cannot override writeable attribute with read-only property
@property
- def _blklocs(self):
+ def _blklocs(self) -> None: # type: ignore[override]
"""compat with BlockManager"""
return None
diff --git a/pandas/core/ops/array_ops.py b/pandas/core/ops/array_ops.py
index 4b762a359d321..8ccd7c84cb05c 100644
--- a/pandas/core/ops/array_ops.py
+++ b/pandas/core/ops/array_ops.py
@@ -591,7 +591,7 @@ def maybe_prepare_scalar_for_op(obj, shape: Shape):
}
-def _bool_arith_check(op, a: np.ndarray, b):
+def _bool_arith_check(op, a: np.ndarray, b) -> None:
"""
In contrast to numpy, pandas raises an error for certain operations
with booleans.
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index aacea92611697..31859c7d04e04 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -765,7 +765,7 @@ def _get_concat_axis(self) -> Index:
return concat_axis
- def _maybe_check_integrity(self, concat_index: Index):
+ def _maybe_check_integrity(self, concat_index: Index) -> None:
if self.verify_integrity:
if not concat_index.is_unique:
overlap = concat_index[concat_index.duplicated()].unique()
diff --git a/pandas/core/reshape/encoding.py b/pandas/core/reshape/encoding.py
index 3ed67bb7b7c02..44158227d903b 100644
--- a/pandas/core/reshape/encoding.py
+++ b/pandas/core/reshape/encoding.py
@@ -169,7 +169,7 @@ def get_dummies(
data_to_encode = data[columns]
# validate prefixes and separator to avoid silently dropping cols
- def check_len(item, name: str):
+ def check_len(item, name: str) -> None:
if is_list_like(item):
if not len(item) == data_to_encode.shape[1]:
len_msg = (
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 690e3c2700c6c..f4903023e8059 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -2091,7 +2091,7 @@ def _maybe_require_matching_dtypes(
) -> None:
# TODO: why do we do this for AsOfMerge but not the others?
- def _check_dtype_match(left: ArrayLike, right: ArrayLike, i: int):
+ def _check_dtype_match(left: ArrayLike, right: ArrayLike, i: int) -> None:
if left.dtype != right.dtype:
if isinstance(left.dtype, CategoricalDtype) and isinstance(
right.dtype, CategoricalDtype
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index 7a49682d7c57c..3493f1c78da91 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -188,7 +188,7 @@ def _make_sorted_values(self, values: np.ndarray) -> np.ndarray:
return sorted_values
return values
- def _make_selectors(self):
+ def _make_selectors(self) -> None:
new_levels = self.new_index_levels
# make the mask
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index e78bd258c11ff..fa5b84fefb883 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -1143,7 +1143,7 @@ class Window(BaseWindow):
"method",
]
- def _validate(self):
+ def _validate(self) -> None:
super()._validate()
if not isinstance(self.win_type, str):
@@ -1861,7 +1861,7 @@ class Rolling(RollingAndExpandingMixin):
"method",
]
- def _validate(self):
+ def _validate(self) -> None:
super()._validate()
# we allow rolling on a datetimelike index
@@ -2906,7 +2906,7 @@ def _get_window_indexer(self) -> GroupbyIndexer:
)
return window_indexer
- def _validate_datetimelike_monotonic(self):
+ def _validate_datetimelike_monotonic(self) -> None:
"""
Validate that each group in self._on is monotonic
"""
diff --git a/pandas/io/formats/style_render.py b/pandas/io/formats/style_render.py
index 416b263ba8497..55541e5262719 100644
--- a/pandas/io/formats/style_render.py
+++ b/pandas/io/formats/style_render.py
@@ -2288,12 +2288,12 @@ def _parse_latex_css_conversion(styles: CSSList) -> CSSList:
Ignore conversion if tagged with `--latex` option, skipped if no conversion found.
"""
- def font_weight(value, arg):
+ def font_weight(value, arg) -> tuple[str, str] | None:
if value in ("bold", "bolder"):
return "bfseries", f"{arg}"
return None
- def font_style(value, arg):
+ def font_style(value, arg) -> tuple[str, str] | None:
if value == "italic":
return "itshape", f"{arg}"
if value == "oblique":
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 1139519d2bcd3..c30238e412450 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -3207,7 +3207,7 @@ class SeriesFixed(GenericFixed):
name: Hashable
@property
- def shape(self):
+ def shape(self) -> tuple[int] | None:
try:
return (len(self.group.values),)
except (TypeError, AttributeError):
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/56628 | 2023-12-26T21:39:19Z | 2023-12-27T18:54:54Z | 2023-12-27T18:54:54Z | 2024-01-17T02:50:00Z |
TST: Remove arraymanager markers | diff --git a/pandas/tests/copy_view/test_astype.py b/pandas/tests/copy_view/test_astype.py
index d462ce3d3187d..3c1a157dd2c6a 100644
--- a/pandas/tests/copy_view/test_astype.py
+++ b/pandas/tests/copy_view/test_astype.py
@@ -4,7 +4,6 @@
import pytest
from pandas.compat.pyarrow import pa_version_under12p0
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -88,7 +87,6 @@ def test_astype_different_target_dtype(using_copy_on_write, dtype):
tm.assert_frame_equal(df2, df_orig.astype(dtype))
-@td.skip_array_manager_invalid_test
def test_astype_numpy_to_ea():
ser = Series([1, 2, 3])
with pd.option_context("mode.copy_on_write", True):
diff --git a/pandas/tests/copy_view/test_internals.py b/pandas/tests/copy_view/test_internals.py
index a727331307d7e..615b024bd06bf 100644
--- a/pandas/tests/copy_view/test_internals.py
+++ b/pandas/tests/copy_view/test_internals.py
@@ -1,15 +1,12 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
import pandas as pd
from pandas import DataFrame
import pandas._testing as tm
from pandas.tests.copy_view.util import get_array
-@td.skip_array_manager_invalid_test
def test_consolidate(using_copy_on_write):
# create unconsolidated DataFrame
df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
@@ -46,7 +43,6 @@ def test_consolidate(using_copy_on_write):
@pytest.mark.single_cpu
-@td.skip_array_manager_invalid_test
def test_switch_options():
# ensure we can switch the value of the option within one session
# (assuming data is constructed after switching)
@@ -75,7 +71,6 @@ def test_switch_options():
assert df.iloc[0, 0] == 0
-@td.skip_array_manager_invalid_test
@pytest.mark.parametrize("dtype", [np.intp, np.int8])
@pytest.mark.parametrize(
"locs, arr",
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index 7837adec0c9e0..e3a467e8bf65b 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -15,7 +15,6 @@
PerformanceWarning,
SettingWithCopyError,
)
-import pandas.util._test_decorators as td
from pandas.core.dtypes.common import is_integer
@@ -574,7 +573,6 @@ def test_getitem_setitem_integer_slice_keyerrors(self):
with pytest.raises(KeyError, match=r"^3$"):
df2.loc[3:11] = 0
- @td.skip_array_manager_invalid_test # already covered in test_iloc_col_slice_view
def test_fancy_getitem_slice_mixed(
self, float_frame, float_string_frame, using_copy_on_write, warn_copy_on_write
):
@@ -640,7 +638,6 @@ def test_getitem_fancy_scalar(self, float_frame):
for idx in f.index[::5]:
assert ix[idx, col] == ts[idx]
- @td.skip_array_manager_invalid_test # TODO(ArrayManager) rewrite not using .values
def test_setitem_fancy_scalar(self, float_frame):
f = float_frame
expected = float_frame.copy()
@@ -680,7 +677,6 @@ def test_getitem_fancy_boolean(self, float_frame):
expected = f.reindex(index=f.index[boolvec], columns=["C", "D"])
tm.assert_frame_equal(result, expected)
- @td.skip_array_manager_invalid_test # TODO(ArrayManager) rewrite not using .values
def test_setitem_fancy_boolean(self, float_frame):
# from 2d, set with booleans
frame = float_frame.copy()
@@ -1404,7 +1400,6 @@ def test_loc_setitem_rhs_frame(self, idxr, val, warn):
expected = DataFrame({"a": [np.nan, val]})
tm.assert_frame_equal(df, expected)
- @td.skip_array_manager_invalid_test
def test_iloc_setitem_enlarge_no_warning(self, warn_copy_on_write):
# GH#47381
df = DataFrame(columns=["a", "b"])
diff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py
index f031cb2218e31..0e0f8cf61d3d7 100644
--- a/pandas/tests/frame/indexing/test_setitem.py
+++ b/pandas/tests/frame/indexing/test_setitem.py
@@ -3,8 +3,6 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
from pandas.core.dtypes.base import _registry as ea_registry
from pandas.core.dtypes.common import is_object_dtype
from pandas.core.dtypes.dtypes import (
@@ -704,8 +702,6 @@ def test_setitem_ea_dtype_rhs_series(self):
expected = DataFrame({"a": [1, 2]}, dtype="Int64")
tm.assert_frame_equal(df, expected)
- # TODO(ArrayManager) set column with 2d column array, see #44788
- @td.skip_array_manager_not_yet_implemented
def test_setitem_npmatrix_2d(self):
# GH#42376
# for use-case df["x"] = sparse.random((10, 10)).mean(axis=1)
@@ -1063,7 +1059,6 @@ def inc(x):
class TestDataFrameSetItemBooleanMask:
- @td.skip_array_manager_invalid_test # TODO(ArrayManager) rewrite not using .values
@pytest.mark.parametrize(
"mask_type",
[lambda df: df > np.abs(df) / 2, lambda df: (df > np.abs(df) / 2).values],
@@ -1307,7 +1302,6 @@ def test_setitem_not_operating_inplace(self, value, set_value, indexer):
df[indexer] = set_value
tm.assert_frame_equal(view, expected)
- @td.skip_array_manager_invalid_test
def test_setitem_column_update_inplace(
self, using_copy_on_write, warn_copy_on_write
):
diff --git a/pandas/tests/frame/methods/test_copy.py b/pandas/tests/frame/methods/test_copy.py
index e7901ed363106..6208d0256a655 100644
--- a/pandas/tests/frame/methods/test_copy.py
+++ b/pandas/tests/frame/methods/test_copy.py
@@ -46,7 +46,6 @@ def test_copy(self, float_frame, float_string_frame):
copy = float_string_frame.copy()
assert copy._mgr is not float_string_frame._mgr
- @td.skip_array_manager_invalid_test
def test_copy_consolidates(self):
# GH#42477
df = DataFrame(
diff --git a/pandas/tests/frame/methods/test_fillna.py b/pandas/tests/frame/methods/test_fillna.py
index 6757669351c5c..4131138a7c588 100644
--- a/pandas/tests/frame/methods/test_fillna.py
+++ b/pandas/tests/frame/methods/test_fillna.py
@@ -3,8 +3,6 @@
from pandas._config import using_pyarrow_string_dtype
-import pandas.util._test_decorators as td
-
from pandas import (
Categorical,
DataFrame,
@@ -49,7 +47,6 @@ def test_fillna_dict_inplace_nonunique_columns(
if not using_copy_on_write:
assert tm.shares_memory(df.iloc[:, 2], orig.iloc[:, 2])
- @td.skip_array_manager_not_yet_implemented
def test_fillna_on_column_view(self, using_copy_on_write):
# GH#46149 avoid unnecessary copies
arr = np.full((40, 50), np.nan)
@@ -752,7 +749,6 @@ def test_fillna_inplace_with_columns_limit_and_value(self):
df.fillna(axis=1, value=100, limit=1, inplace=True)
tm.assert_frame_equal(df, expected)
- @td.skip_array_manager_invalid_test
@pytest.mark.parametrize("val", [-1, {"x": -1, "y": -1}])
def test_inplace_dict_update_view(
self, val, using_copy_on_write, warn_copy_on_write
diff --git a/pandas/tests/frame/methods/test_interpolate.py b/pandas/tests/frame/methods/test_interpolate.py
index a93931a970687..e377fdd635bfe 100644
--- a/pandas/tests/frame/methods/test_interpolate.py
+++ b/pandas/tests/frame/methods/test_interpolate.py
@@ -470,7 +470,7 @@ def test_interp_string_axis(self, axis_name, axis_number):
@pytest.mark.parametrize("multiblock", [True, False])
@pytest.mark.parametrize("method", ["ffill", "bfill", "pad"])
- def test_interp_fillna_methods(self, request, axis, multiblock, method):
+ def test_interp_fillna_methods(self, axis, multiblock, method):
# GH 12918
df = DataFrame(
{
diff --git a/pandas/tests/frame/methods/test_is_homogeneous_dtype.py b/pandas/tests/frame/methods/test_is_homogeneous_dtype.py
index 1fe28cb8eb856..086986702d24f 100644
--- a/pandas/tests/frame/methods/test_is_homogeneous_dtype.py
+++ b/pandas/tests/frame/methods/test_is_homogeneous_dtype.py
@@ -1,16 +1,11 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
from pandas import (
Categorical,
DataFrame,
)
-# _is_homogeneous_type always returns True for ArrayManager
-pytestmark = td.skip_array_manager_invalid_test
-
@pytest.mark.parametrize(
"data, expected",
diff --git a/pandas/tests/frame/methods/test_reindex.py b/pandas/tests/frame/methods/test_reindex.py
index d862e14ce86cb..d2ec84bc9371f 100644
--- a/pandas/tests/frame/methods/test_reindex.py
+++ b/pandas/tests/frame/methods/test_reindex.py
@@ -13,7 +13,6 @@
is_platform_windows,
)
from pandas.compat.numpy import np_version_gt2
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -136,7 +135,6 @@ class TestDataFrameSelectReindex:
reason="Passes int32 values to DatetimeArray in make_na_array on "
"windows, 32bit linux builds",
)
- @td.skip_array_manager_not_yet_implemented
def test_reindex_tzaware_fill_value(self):
# GH#52586
df = DataFrame([[1]])
@@ -198,7 +196,6 @@ def test_reindex_copies_ea(self, using_copy_on_write):
else:
assert not np.shares_memory(result2[0].array._data, df[0].array._data)
- @td.skip_array_manager_not_yet_implemented
def test_reindex_date_fill_value(self):
# passing date to dt64 is deprecated; enforced in 2.0 to cast to object
arr = date_range("2016-01-01", periods=6).values.reshape(3, 2)
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
index 907ff67eac7a1..c477c9c1852b7 100644
--- a/pandas/tests/frame/methods/test_shift.py
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -1,8 +1,6 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
import pandas as pd
from pandas import (
CategoricalIndex,
@@ -464,7 +462,6 @@ def test_shift_axis1_multiple_blocks(self):
tm.assert_frame_equal(result, expected)
- @td.skip_array_manager_not_yet_implemented # TODO(ArrayManager) axis=1 support
def test_shift_axis1_multiple_blocks_with_int_fill(self):
# GH#42719
rng = np.random.default_rng(2)
diff --git a/pandas/tests/frame/methods/test_to_dict_of_blocks.py b/pandas/tests/frame/methods/test_to_dict_of_blocks.py
index f64cfd5fe6a2d..217010ab2e7ee 100644
--- a/pandas/tests/frame/methods/test_to_dict_of_blocks.py
+++ b/pandas/tests/frame/methods/test_to_dict_of_blocks.py
@@ -1,8 +1,6 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
from pandas import (
DataFrame,
MultiIndex,
@@ -10,8 +8,6 @@
import pandas._testing as tm
from pandas.core.arrays import NumpyExtensionArray
-pytestmark = td.skip_array_manager_invalid_test
-
class TestToDictOfBlocks:
@pytest.mark.filterwarnings("ignore:Setting a value on a view:FutureWarning")
diff --git a/pandas/tests/frame/methods/test_to_numpy.py b/pandas/tests/frame/methods/test_to_numpy.py
index bdb9b2c055061..d92af2775922b 100644
--- a/pandas/tests/frame/methods/test_to_numpy.py
+++ b/pandas/tests/frame/methods/test_to_numpy.py
@@ -1,7 +1,5 @@
import numpy as np
-import pandas.util._test_decorators as td
-
from pandas import (
DataFrame,
Timestamp,
@@ -22,7 +20,6 @@ def test_to_numpy_dtype(self):
result = df.to_numpy(dtype="int64")
tm.assert_numpy_array_equal(result, expected)
- @td.skip_array_manager_invalid_test
def test_to_numpy_copy(self, using_copy_on_write):
arr = np.random.default_rng(2).standard_normal((4, 3))
df = DataFrame(arr)
diff --git a/pandas/tests/frame/methods/test_transpose.py b/pandas/tests/frame/methods/test_transpose.py
index d0caa071fae1c..45bd8ff0268a8 100644
--- a/pandas/tests/frame/methods/test_transpose.py
+++ b/pandas/tests/frame/methods/test_transpose.py
@@ -1,8 +1,6 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
from pandas import (
DataFrame,
DatetimeIndex,
@@ -126,7 +124,6 @@ def test_transpose_mixed(self):
for col, s in mixed_T.items():
assert s.dtype == np.object_
- @td.skip_array_manager_invalid_test
def test_transpose_get_view(self, float_frame, using_copy_on_write):
dft = float_frame.T
dft.iloc[:, 5:10] = 5
@@ -136,7 +133,6 @@ def test_transpose_get_view(self, float_frame, using_copy_on_write):
else:
assert (float_frame.values[5:10] == 5).all()
- @td.skip_array_manager_invalid_test
def test_transpose_get_view_dt64tzget_view(self, using_copy_on_write):
dti = date_range("2016-01-01", periods=6, tz="US/Pacific")
arr = dti._data.reshape(3, 2)
diff --git a/pandas/tests/frame/methods/test_update.py b/pandas/tests/frame/methods/test_update.py
index 7c7a0d23ff75f..fd4c9d64d656e 100644
--- a/pandas/tests/frame/methods/test_update.py
+++ b/pandas/tests/frame/methods/test_update.py
@@ -1,8 +1,6 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
import pandas as pd
from pandas import (
DataFrame,
@@ -175,7 +173,6 @@ def test_update_with_different_dtype(self, using_copy_on_write):
)
tm.assert_frame_equal(df, expected)
- @td.skip_array_manager_invalid_test
def test_update_modify_view(
self, using_copy_on_write, warn_copy_on_write, using_infer_string
):
diff --git a/pandas/tests/frame/methods/test_values.py b/pandas/tests/frame/methods/test_values.py
index bbca4ee1b88b1..f1230e55f9054 100644
--- a/pandas/tests/frame/methods/test_values.py
+++ b/pandas/tests/frame/methods/test_values.py
@@ -1,8 +1,6 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
from pandas import (
DataFrame,
NaT,
@@ -15,7 +13,6 @@
class TestDataFrameValues:
- @td.skip_array_manager_invalid_test
def test_values(self, float_frame, using_copy_on_write):
if using_copy_on_write:
with pytest.raises(ValueError, match="read-only"):
@@ -231,7 +228,6 @@ def test_values_lcd(self, mixed_float_frame, mixed_int_frame):
class TestPrivateValues:
- @td.skip_array_manager_invalid_test
def test_private_values_dt64tz(self, using_copy_on_write):
dta = date_range("2000", periods=4, tz="US/Central")._data.reshape(-1, 1)
@@ -249,7 +245,6 @@ def test_private_values_dt64tz(self, using_copy_on_write):
df2 = df - df
tm.assert_equal(df2._values, tda)
- @td.skip_array_manager_invalid_test
def test_private_values_dt64tz_multicol(self, using_copy_on_write):
dta = date_range("2000", periods=8, tz="US/Central")._data.reshape(-1, 2)
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index ecaf826c46d9b..be6ed91973e80 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -896,7 +896,6 @@ def test_df_arith_2d_array_rowlike_broadcasts(
):
# GH#23000
opname = all_arithmetic_operators
-
arr = np.arange(6).reshape(3, 2)
df = DataFrame(arr, columns=[True, False], index=["A", "B", "C"])
@@ -919,7 +918,6 @@ def test_df_arith_2d_array_collike_broadcasts(
):
# GH#23000
opname = all_arithmetic_operators
-
arr = np.arange(6).reshape(3, 2)
df = DataFrame(arr, columns=[True, False], index=["A", "B", "C"])
diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py
index 712494ef15f97..22fff2116510a 100644
--- a/pandas/tests/frame/test_block_internals.py
+++ b/pandas/tests/frame/test_block_internals.py
@@ -8,7 +8,6 @@
import pytest
from pandas.errors import PerformanceWarning
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -26,11 +25,6 @@
# structure
-# TODO(ArrayManager) check which of those tests need to be rewritten to test the
-# equivalent for ArrayManager
-pytestmark = td.skip_array_manager_invalid_test
-
-
class TestDataFrameBlockInternals:
def test_setitem_invalidates_datetime_index_freq(self):
# GH#24096 altering a datetime64tz column inplace invalidates the
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 8ff69472ea113..aefb0377d1bf4 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -25,7 +25,6 @@
from pandas._libs import lib
from pandas.errors import IntCastingNaNError
-import pandas.util._test_decorators as td
from pandas.core.dtypes.common import is_integer_dtype
from pandas.core.dtypes.dtypes import (
@@ -324,7 +323,6 @@ def test_constructor_dtype_nocast_view_2d_array(
df2 = DataFrame(df.values, dtype=df[0].dtype)
assert df2._mgr.arrays[0].flags.c_contiguous
- @td.skip_array_manager_invalid_test
@pytest.mark.xfail(using_pyarrow_string_dtype(), reason="conversion copies")
def test_1d_object_array_does_not_copy(self):
# https://github.com/pandas-dev/pandas/issues/39272
@@ -332,7 +330,6 @@ def test_1d_object_array_does_not_copy(self):
df = DataFrame(arr, copy=False)
assert np.shares_memory(df.values, arr)
- @td.skip_array_manager_invalid_test
@pytest.mark.xfail(using_pyarrow_string_dtype(), reason="conversion copies")
def test_2d_object_array_does_not_copy(self):
# https://github.com/pandas-dev/pandas/issues/39272
@@ -2489,7 +2486,6 @@ def test_constructor_list_str_na(self, string_dtype):
@pytest.mark.parametrize("copy", [False, True])
def test_dict_nocopy(
self,
- request,
copy,
any_numeric_ea_dtype,
any_numpy_dtype,
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index 512b5d6ace469..dd88e7401a03f 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -1701,7 +1701,6 @@ def test_reductions_skipna_none_raises(
with pytest.raises(ValueError, match=msg):
getattr(obj, all_reductions)(skipna=None)
- @td.skip_array_manager_invalid_test
def test_reduction_timestamp_smallest_unit(self):
# GH#52524
df = DataFrame(
@@ -1720,7 +1719,6 @@ def test_reduction_timestamp_smallest_unit(self):
)
tm.assert_series_equal(result, expected)
- @td.skip_array_manager_not_yet_implemented
def test_reduction_timedelta_smallest_unit(self):
# GH#52524
df = DataFrame(
diff --git a/pandas/tests/groupby/test_bin_groupby.py b/pandas/tests/groupby/test_bin_groupby.py
index 49b2e621b7adc..ac5374597585a 100644
--- a/pandas/tests/groupby/test_bin_groupby.py
+++ b/pandas/tests/groupby/test_bin_groupby.py
@@ -2,7 +2,6 @@
import pytest
from pandas._libs import lib
-import pandas.util._test_decorators as td
import pandas as pd
import pandas._testing as tm
@@ -22,7 +21,7 @@ def cumsum_max(x):
"func",
[
cumsum_max,
- pytest.param(assert_block_lengths, marks=td.skip_array_manager_invalid_test),
+ assert_block_lengths,
],
)
def test_mgr_locs_updated(func):
diff --git a/pandas/tests/indexing/multiindex/test_chaining_and_caching.py b/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
index 0dd1a56890fee..014ba6fc12b72 100644
--- a/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
@@ -3,7 +3,6 @@
from pandas._libs import index as libindex
from pandas.errors import SettingWithCopyError
-import pandas.util._test_decorators as td
from pandas import (
DataFrame,
@@ -43,7 +42,6 @@ def test_detect_chained_assignment(using_copy_on_write, warn_copy_on_write):
zed["eyes"]["right"].fillna(value=555, inplace=True)
-@td.skip_array_manager_invalid_test # with ArrayManager df.loc[0] is not a view
def test_cache_updating(using_copy_on_write, warn_copy_on_write):
# 5216
# make sure that we don't try to set a dead cache
diff --git a/pandas/tests/indexing/multiindex/test_partial.py b/pandas/tests/indexing/multiindex/test_partial.py
index fdf88b2a97e46..5aff1f1309004 100644
--- a/pandas/tests/indexing/multiindex/test_partial.py
+++ b/pandas/tests/indexing/multiindex/test_partial.py
@@ -1,8 +1,6 @@
import numpy as np
import pytest
-import pandas.util._test_decorators as td
-
from pandas import (
DataFrame,
DatetimeIndex,
@@ -118,9 +116,6 @@ def test_getitem_partial_column_select(self):
with pytest.raises(KeyError, match=r"\('a', 'foo'\)"):
df.loc[("a", "foo"), :]
- # TODO(ArrayManager) rewrite test to not use .values
- # exp.loc[2000, 4].values[:] select multiple columns -> .values is not a view
- @td.skip_array_manager_invalid_test
def test_partial_set(
self,
multiindex_year_month_day_dataframe_random_data,
diff --git a/pandas/tests/indexing/multiindex/test_setitem.py b/pandas/tests/indexing/multiindex/test_setitem.py
index 53ad4d6b41687..22a0a49762097 100644
--- a/pandas/tests/indexing/multiindex/test_setitem.py
+++ b/pandas/tests/indexing/multiindex/test_setitem.py
@@ -2,7 +2,6 @@
import pytest
from pandas.errors import SettingWithCopyError
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -126,9 +125,6 @@ def test_setitem_multiindex3(self):
expected=copy,
)
- # TODO(ArrayManager) df.loc["bar"] *= 2 doesn't raise an error but results in
- # all NaNs -> doesn't work in the "split" path (also for BlockManager actually)
- @td.skip_array_manager_not_yet_implemented
def test_multiindex_setitem(self):
# GH 3738
# setting with a multi-index right hand side
@@ -520,8 +516,6 @@ def test_setitem_enlargement_keep_index_names(self):
tm.assert_frame_equal(df, expected)
-@td.skip_array_manager_invalid_test # df["foo"] select multiple columns -> .values
-# is not a view
def test_frame_setitem_view_direct(
multiindex_dataframe_random_data, using_copy_on_write
):
diff --git a/pandas/tests/indexing/test_chaining_and_caching.py b/pandas/tests/indexing/test_chaining_and_caching.py
index ca796463f4a1e..5eeaa50e2c3b6 100644
--- a/pandas/tests/indexing/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/test_chaining_and_caching.py
@@ -7,7 +7,6 @@
SettingWithCopyError,
SettingWithCopyWarning,
)
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -539,8 +538,6 @@ def test_detect_chained_assignment_warning_stacklevel(
chained[2] = rhs
tm.assert_frame_equal(df, df_original)
- # TODO(ArrayManager) fast_xs with array-like scalars is not yet working
- @td.skip_array_manager_not_yet_implemented
def test_chained_getitem_with_lists(self):
# GH6394
# Regression in chained getitem indexing with embedded list-like from
diff --git a/pandas/tests/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index a1d8577d534f5..13d786f98c42b 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -7,7 +7,6 @@
import pytest
from pandas.errors import IndexingError
-import pandas.util._test_decorators as td
from pandas import (
NA,
@@ -1193,7 +1192,6 @@ def test_iloc_setitem_2d_ndarray_into_ea_block(self):
expected = DataFrame({"status": ["a", "a", "c"]}, dtype=df["status"].dtype)
tm.assert_frame_equal(df, expected)
- @td.skip_array_manager_not_yet_implemented
def test_iloc_getitem_int_single_ea_block_view(self):
# GH#45241
# TODO: make an extension interface test for this?
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index da10555e60301..1aa988cca0400 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -17,7 +17,6 @@
from pandas._libs import index as libindex
from pandas.compat.numpy import np_version_gt2
from pandas.errors import IndexingError
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -2640,7 +2639,6 @@ def test_loc_setitem_mask_td64_series_value(self):
assert expected == result
tm.assert_frame_equal(df, df_copy)
- @td.skip_array_manager_invalid_test # TODO(ArrayManager) rewrite not using .values
def test_loc_setitem_boolean_and_column(self, float_frame):
expected = float_frame.copy()
mask = float_frame["A"] > 0
@@ -3315,7 +3313,6 @@ def test_loc_assign_dict_to_row(self, dtype):
tm.assert_frame_equal(df, expected)
- @td.skip_array_manager_invalid_test
def test_loc_setitem_dict_timedelta_multiple_set(self):
# GH 16309
result = DataFrame(columns=["time", "value"])
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 2265522bc7ecb..66dd893df51de 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -10,7 +10,6 @@
from pandas._libs.internals import BlockPlacement
from pandas.compat import IS64
-import pandas.util._test_decorators as td
from pandas.core.dtypes.common import is_scalar
@@ -44,10 +43,6 @@
new_block,
)
-# this file contains BlockManager specific tests
-# TODO(ArrayManager) factor out interleave_dtype tests
-pytestmark = td.skip_array_manager_invalid_test
-
@pytest.fixture(params=[new_block, make_block])
def block_maker(request):
diff --git a/pandas/tests/io/pytables/test_append.py b/pandas/tests/io/pytables/test_append.py
index 00a81a4f1f385..706610316ef43 100644
--- a/pandas/tests/io/pytables/test_append.py
+++ b/pandas/tests/io/pytables/test_append.py
@@ -6,7 +6,6 @@
import pytest
from pandas._libs.tslibs import Timestamp
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -733,10 +732,6 @@ def test_append_misc_empty_frame(setup_path):
tm.assert_frame_equal(store.select("df2"), df)
-# TODO(ArrayManager) currently we rely on falling back to BlockManager, but
-# the conversion from AM->BM converts the invalid object dtype column into
-# a datetime64 column no longer raising an error
-@td.skip_array_manager_not_yet_implemented
def test_append_raise(setup_path):
with ensure_clean_store(setup_path) as store:
# test append with invalid input to get good error messages
diff --git a/pandas/tests/io/test_fsspec.py b/pandas/tests/io/test_fsspec.py
index a1dec8a2d05b4..f6fb032b9d51a 100644
--- a/pandas/tests/io/test_fsspec.py
+++ b/pandas/tests/io/test_fsspec.py
@@ -194,7 +194,6 @@ def test_arrowparquet_options(fsspectest):
assert fsspectest.test[0] == "parquet_read"
-@td.skip_array_manager_not_yet_implemented # TODO(ArrayManager) fastparquet
def test_fastparquet_options(fsspectest):
"""Regression test for writing to a not-yet-existent GCS Parquet file."""
pytest.importorskip("fastparquet")
@@ -253,7 +252,6 @@ def test_s3_protocols(s3_public_bucket_with_data, tips_file, protocol, s3so):
@pytest.mark.single_cpu
-@td.skip_array_manager_not_yet_implemented # TODO(ArrayManager) fastparquet
def test_s3_parquet(s3_public_bucket, s3so, df1):
pytest.importorskip("fastparquet")
pytest.importorskip("s3fs")
diff --git a/pandas/tests/io/test_http_headers.py b/pandas/tests/io/test_http_headers.py
index 2ca11ad1f74e6..550637a50c1c4 100644
--- a/pandas/tests/io/test_http_headers.py
+++ b/pandas/tests/io/test_http_headers.py
@@ -100,11 +100,9 @@ def stata_responder(df):
pytest.param(
parquetfastparquet_responder,
partial(pd.read_parquet, engine="fastparquet"),
- # TODO(ArrayManager) fastparquet
marks=[
td.skip_if_no("fastparquet"),
td.skip_if_no("fsspec"),
- td.skip_array_manager_not_yet_implemented,
],
),
(pickle_respnder, pd.read_pickle),
diff --git a/pandas/tests/io/test_pickle.py b/pandas/tests/io/test_pickle.py
index 4f3993a038197..4e1f09b929224 100644
--- a/pandas/tests/io/test_pickle.py
+++ b/pandas/tests/io/test_pickle.py
@@ -37,7 +37,6 @@
)
from pandas.compat._optional import import_optional_dependency
from pandas.compat.compressors import flatten_buffer
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -600,7 +599,6 @@ def test_pickle_strings(string_series):
tm.assert_series_equal(unp_series, string_series)
-@td.skip_array_manager_invalid_test
def test_pickle_preserves_block_ndim():
# GH#37631
ser = Series(list("abc")).astype("category").iloc[[0]]
diff --git a/pandas/tests/reshape/concat/test_concat.py b/pandas/tests/reshape/concat/test_concat.py
index 2cc91992f1fd7..5ec95cbf24b39 100644
--- a/pandas/tests/reshape/concat/test_concat.py
+++ b/pandas/tests/reshape/concat/test_concat.py
@@ -10,7 +10,6 @@
import pytest
from pandas.errors import InvalidIndexError
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -773,7 +772,6 @@ def test_concat_retain_attrs(data):
assert df.attrs[1] == 1
-@td.skip_array_manager_invalid_test
@pytest.mark.parametrize("df_dtype", ["float64", "int64", "datetime64[ns]"])
@pytest.mark.parametrize("empty_dtype", [None, "float64", "object"])
def test_concat_ignore_empty_object_float(empty_dtype, df_dtype):
@@ -799,7 +797,6 @@ def test_concat_ignore_empty_object_float(empty_dtype, df_dtype):
tm.assert_frame_equal(result, expected)
-@td.skip_array_manager_invalid_test
@pytest.mark.parametrize("df_dtype", ["float64", "int64", "datetime64[ns]"])
@pytest.mark.parametrize("empty_dtype", [None, "float64", "object"])
def test_concat_ignore_all_na_object_float(empty_dtype, df_dtype):
@@ -827,7 +824,6 @@ def test_concat_ignore_all_na_object_float(empty_dtype, df_dtype):
tm.assert_frame_equal(result, expected)
-@td.skip_array_manager_invalid_test
def test_concat_ignore_empty_from_reindex():
# https://github.com/pandas-dev/pandas/pull/43507#issuecomment-920375856
df1 = DataFrame({"a": [1], "b": [pd.Timestamp("2012-01-01")]})
diff --git a/pandas/tests/series/methods/test_reindex.py b/pandas/tests/series/methods/test_reindex.py
index 1a4a390da1323..1959e71f60775 100644
--- a/pandas/tests/series/methods/test_reindex.py
+++ b/pandas/tests/series/methods/test_reindex.py
@@ -3,8 +3,6 @@
from pandas._config import using_pyarrow_string_dtype
-import pandas.util._test_decorators as td
-
from pandas import (
NA,
Categorical,
@@ -315,7 +313,6 @@ def test_reindex_fill_value():
tm.assert_series_equal(result, expected)
-@td.skip_array_manager_not_yet_implemented
@pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
@pytest.mark.parametrize("fill_value", ["string", 0, Timedelta(0)])
def test_reindex_fill_value_datetimelike_upcast(dtype, fill_value):
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 866bfb995a6d5..b802e92e4fcca 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -16,7 +16,6 @@
)
from pandas.compat.numpy import np_version_gt2
from pandas.errors import IntCastingNaNError
-import pandas.util._test_decorators as td
from pandas.core.dtypes.dtypes import CategoricalDtype
@@ -702,7 +701,6 @@ def test_constructor_copy(self):
assert x[0] == 2.0
assert y[0] == 1.0
- @td.skip_array_manager_invalid_test # TODO(ArrayManager) rewrite test
@pytest.mark.parametrize(
"index",
[
@@ -2194,7 +2192,6 @@ def test_constructor_no_pandas_array(self):
assert isinstance(result._mgr.blocks[0], NumpyBlock)
assert result._mgr.blocks[0].is_numeric
- @td.skip_array_manager_invalid_test
def test_from_array(self):
result = Series(pd.array(["1h", "2h"], dtype="timedelta64[ns]"))
assert result._mgr.blocks[0].is_extension is False
@@ -2202,7 +2199,6 @@ def test_from_array(self):
result = Series(pd.array(["2015"], dtype="datetime64[ns]"))
assert result._mgr.blocks[0].is_extension is False
- @td.skip_array_manager_invalid_test
def test_from_list_dtype(self):
result = Series(["1h", "2h"], dtype="timedelta64[ns]")
assert result._mgr.blocks[0].is_extension is False
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index 2c1912bce856d..37908c9ac255b 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -38,7 +38,6 @@ def test_foo():
if TYPE_CHECKING:
from pandas._typing import F
-from pandas._config.config import _get_option
from pandas.compat import (
IS64,
@@ -147,21 +146,6 @@ def documented_fixture(fixture):
return documented_fixture
-def mark_array_manager_not_yet_implemented(request) -> None:
- mark = pytest.mark.xfail(reason="Not yet implemented for ArrayManager")
- request.applymarker(mark)
-
-
-skip_array_manager_not_yet_implemented = pytest.mark.xfail(
- _get_option("mode.data_manager", silent=True) == "array",
- reason="Not yet implemented for ArrayManager",
-)
-
-skip_array_manager_invalid_test = pytest.mark.skipif(
- _get_option("mode.data_manager", silent=True) == "array",
- reason="Test that relies on BlockManager internals or specific behaviour",
-)
-
skip_copy_on_write_not_yet_implemented = pytest.mark.xfail(
get_option("mode.copy_on_write") is True,
reason="Not yet implemented/adapted for Copy-on-Write mode",
| No longer really necessary since we don't test this in the CI anymore | https://api.github.com/repos/pandas-dev/pandas/pulls/56626 | 2023-12-26T19:46:45Z | 2023-12-27T15:30:31Z | 2023-12-27T15:30:31Z | 2023-12-27T18:08:27Z |
TST/CLN: Remove more seldom used fixtures | diff --git a/pandas/conftest.py b/pandas/conftest.py
index c325a268fe418..4a3fb5c2916c6 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -1838,16 +1838,6 @@ def ip():
return InteractiveShell(config=c)
-@pytest.fixture(params=["bsr", "coo", "csc", "csr", "dia", "dok", "lil"])
-def spmatrix(request):
- """
- Yields scipy sparse matrix classes.
- """
- sparse = pytest.importorskip("scipy.sparse")
-
- return getattr(sparse, request.param + "_matrix")
-
-
@pytest.fixture(
params=[
getattr(pd.offsets, o)
diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index ebcd7cbd963d7..121bfb78fe5c8 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -37,14 +37,6 @@ def switch_numexpr_min_elements(request, monkeypatch):
yield request.param
-@pytest.fixture(params=[Index, Series, tm.to_array])
-def box_pandas_1d_array(request):
- """
- Fixture to test behavior for Index, Series and tm.to_array classes
- """
- return request.param
-
-
@pytest.fixture(
params=[
# TODO: add more dtypes here
@@ -62,17 +54,6 @@ def numeric_idx(request):
return request.param
-@pytest.fixture(
- params=[Index, Series, tm.to_array, np.array, list], ids=lambda x: x.__name__
-)
-def box_1d_array(request):
- """
- Fixture to test behavior for Index, Series, tm.to_array, numpy Array and list
- classes
- """
- return request.param
-
-
def adjust_negative_zero(zero, expected):
"""
Helper to adjust the expected result if we are dividing by -0.0
@@ -1499,6 +1480,8 @@ def test_dataframe_div_silenced():
"data, expected_data",
[([0, 1, 2], [0, 2, 4])],
)
+@pytest.mark.parametrize("box_pandas_1d_array", [Index, Series, tm.to_array])
+@pytest.mark.parametrize("box_1d_array", [Index, Series, tm.to_array, np.array, list])
def test_integer_array_add_list_like(
box_pandas_1d_array, box_1d_array, data, expected_data
):
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 3ec6d70494902..e2ef83c243957 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -1977,9 +1977,12 @@ def test_nan_to_nat_conversions():
@pytest.mark.filterwarnings("ignore::PendingDeprecationWarning")
+@pytest.mark.parametrize("spmatrix", ["bsr", "coo", "csc", "csr", "dia", "dok", "lil"])
def test_is_scipy_sparse(spmatrix):
- pytest.importorskip("scipy")
- assert is_scipy_sparse(spmatrix([[0, 1]]))
+ sparse = pytest.importorskip("scipy.sparse")
+
+ klass = getattr(sparse, spmatrix + "_matrix")
+ assert is_scipy_sparse(klass([[0, 1]]))
assert not is_scipy_sparse(np.array([1]))
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index e3a467e8bf65b..1b83c048411a8 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -1662,25 +1662,6 @@ def orig(self):
orig = DataFrame({"cats": cats, "values": values}, index=idx)
return orig
- @pytest.fixture
- def exp_single_row(self):
- # The expected values if we change a single row
- cats1 = Categorical(["a", "a", "b", "a", "a", "a", "a"], categories=["a", "b"])
- idx1 = Index(["h", "i", "j", "k", "l", "m", "n"])
- values1 = [1, 1, 2, 1, 1, 1, 1]
- exp_single_row = DataFrame({"cats": cats1, "values": values1}, index=idx1)
- return exp_single_row
-
- @pytest.fixture
- def exp_multi_row(self):
- # assign multiple rows (mixed values) (-> array) -> exp_multi_row
- # changed multiple rows
- cats2 = Categorical(["a", "a", "b", "b", "a", "a", "a"], categories=["a", "b"])
- idx2 = Index(["h", "i", "j", "k", "l", "m", "n"])
- values2 = [1, 1, 2, 2, 1, 1, 1]
- exp_multi_row = DataFrame({"cats": cats2, "values": values2}, index=idx2)
- return exp_multi_row
-
@pytest.fixture
def exp_parts_cats_col(self):
# changed part of the cats column
@@ -1702,7 +1683,7 @@ def exp_single_cats_value(self):
return exp_single_cats_value
@pytest.mark.parametrize("indexer", [tm.loc, tm.iloc])
- def test_loc_iloc_setitem_list_of_lists(self, orig, exp_multi_row, indexer):
+ def test_loc_iloc_setitem_list_of_lists(self, orig, indexer):
# - assign multiple rows (mixed values) -> exp_multi_row
df = orig.copy()
@@ -1711,6 +1692,11 @@ def test_loc_iloc_setitem_list_of_lists(self, orig, exp_multi_row, indexer):
key = slice("j", "k")
indexer(df)[key, :] = [["b", 2], ["b", 2]]
+
+ cats2 = Categorical(["a", "a", "b", "b", "a", "a", "a"], categories=["a", "b"])
+ idx2 = Index(["h", "i", "j", "k", "l", "m", "n"])
+ values2 = [1, 1, 2, 2, 1, 1, 1]
+ exp_multi_row = DataFrame({"cats": cats2, "values": values2}, index=idx2)
tm.assert_frame_equal(df, exp_multi_row)
df = orig.copy()
@@ -1752,9 +1738,7 @@ def test_loc_iloc_setitem_mask_single_value_in_categories(
tm.assert_frame_equal(df, exp_single_cats_value)
@pytest.mark.parametrize("indexer", [tm.loc, tm.iloc])
- def test_loc_iloc_setitem_full_row_non_categorical_rhs(
- self, orig, exp_single_row, indexer
- ):
+ def test_loc_iloc_setitem_full_row_non_categorical_rhs(self, orig, indexer):
# - assign a complete row (mixed values) -> exp_single_row
df = orig.copy()
@@ -1764,6 +1748,10 @@ def test_loc_iloc_setitem_full_row_non_categorical_rhs(
# not categorical dtype, but "b" _is_ among the categories for df["cat"]
indexer(df)[key, :] = ["b", 2]
+ cats1 = Categorical(["a", "a", "b", "a", "a", "a", "a"], categories=["a", "b"])
+ idx1 = Index(["h", "i", "j", "k", "l", "m", "n"])
+ values1 = [1, 1, 2, 1, 1, 1, 1]
+ exp_single_row = DataFrame({"cats": cats1, "values": values1}, index=idx1)
tm.assert_frame_equal(df, exp_single_row)
# "c" is not among the categories for df["cat"]
diff --git a/pandas/tests/frame/methods/test_join.py b/pandas/tests/frame/methods/test_join.py
index 02f0b9e20871d..82802dd6e99eb 100644
--- a/pandas/tests/frame/methods/test_join.py
+++ b/pandas/tests/frame/methods/test_join.py
@@ -17,25 +17,6 @@
from pandas.core.reshape.concat import concat
-@pytest.fixture
-def frame_with_period_index():
- return DataFrame(
- data=np.arange(20).reshape(4, 5),
- columns=list("abcde"),
- index=period_range(start="2000", freq="Y", periods=4),
- )
-
-
-@pytest.fixture
-def left():
- return DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
-
-
-@pytest.fixture
-def right():
- return DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
-
-
@pytest.fixture
def left_no_dup():
return DataFrame(
@@ -112,7 +93,9 @@ def right_w_dups(right_no_dup):
),
],
)
-def test_join(left, right, how, sort, expected):
+def test_join(how, sort, expected):
+ left = DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
+ right = DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
result = left.join(right, how=how, sort=sort, validate="1:1")
tm.assert_frame_equal(result, expected)
@@ -347,7 +330,12 @@ def test_join_overlap(float_frame):
tm.assert_frame_equal(joined, expected.loc[:, joined.columns])
-def test_join_period_index(frame_with_period_index):
+def test_join_period_index():
+ frame_with_period_index = DataFrame(
+ data=np.arange(20).reshape(4, 5),
+ columns=list("abcde"),
+ index=period_range(start="2000", freq="Y", periods=4),
+ )
other = frame_with_period_index.rename(columns=lambda key: f"{key}{key}")
joined_values = np.concatenate([frame_with_period_index.values] * 2, axis=1)
diff --git a/pandas/tests/frame/methods/test_nlargest.py b/pandas/tests/frame/methods/test_nlargest.py
index 3ba893501914a..8a7b985c98069 100644
--- a/pandas/tests/frame/methods/test_nlargest.py
+++ b/pandas/tests/frame/methods/test_nlargest.py
@@ -12,25 +12,6 @@
from pandas.util.version import Version
-@pytest.fixture
-def df_duplicates():
- return pd.DataFrame(
- {"a": [1, 2, 3, 4, 4], "b": [1, 1, 1, 1, 1], "c": [0, 1, 2, 5, 4]},
- index=[0, 0, 1, 1, 1],
- )
-
-
-@pytest.fixture
-def df_strings():
- return pd.DataFrame(
- {
- "a": np.random.default_rng(2).permutation(10),
- "b": list(ascii_lowercase[:10]),
- "c": np.random.default_rng(2).permutation(10).astype("float64"),
- }
- )
-
-
@pytest.fixture
def df_main_dtypes():
return pd.DataFrame(
@@ -81,9 +62,15 @@ class TestNLargestNSmallest:
],
)
@pytest.mark.parametrize("n", range(1, 11))
- def test_nlargest_n(self, df_strings, nselect_method, n, order):
+ def test_nlargest_n(self, nselect_method, n, order):
# GH#10393
- df = df_strings
+ df = pd.DataFrame(
+ {
+ "a": np.random.default_rng(2).permutation(10),
+ "b": list(ascii_lowercase[:10]),
+ "c": np.random.default_rng(2).permutation(10).astype("float64"),
+ }
+ )
if "b" in order:
error_msg = (
f"Column 'b' has dtype (object|string), "
@@ -156,10 +143,13 @@ def test_nlargest_n_identical_values(self):
[["a", "b", "c"], ["c", "b", "a"], ["a"], ["b"], ["a", "b"], ["c", "b"]],
)
@pytest.mark.parametrize("n", range(1, 6))
- def test_nlargest_n_duplicate_index(self, df_duplicates, n, order, request):
+ def test_nlargest_n_duplicate_index(self, n, order, request):
# GH#13412
- df = df_duplicates
+ df = pd.DataFrame(
+ {"a": [1, 2, 3, 4, 4], "b": [1, 1, 1, 1, 1], "c": [0, 1, 2, 5, 4]},
+ index=[0, 0, 1, 1, 1],
+ )
result = df.nsmallest(n, order)
expected = df.sort_values(order).head(n)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_subclass.py b/pandas/tests/frame/test_subclass.py
index ef78ae62cb4d6..91f5de8e7d7f3 100644
--- a/pandas/tests/frame/test_subclass.py
+++ b/pandas/tests/frame/test_subclass.py
@@ -15,16 +15,6 @@
)
-@pytest.fixture()
-def gpd_style_subclass_df():
- class SubclassedDataFrame(DataFrame):
- @property
- def _constructor(self):
- return SubclassedDataFrame
-
- return SubclassedDataFrame({"a": [1, 2, 3]})
-
-
class TestDataFrameSubclassing:
def test_frame_subclassing_and_slicing(self):
# Subclass frame and ensure it returns the right class on slicing it
@@ -710,14 +700,21 @@ def test_idxmax_preserves_subclass(self):
result = df.idxmax()
assert isinstance(result, tm.SubclassedSeries)
- def test_convert_dtypes_preserves_subclass(self, gpd_style_subclass_df):
+ def test_convert_dtypes_preserves_subclass(self):
# GH 43668
df = tm.SubclassedDataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
result = df.convert_dtypes()
assert isinstance(result, tm.SubclassedDataFrame)
- result = gpd_style_subclass_df.convert_dtypes()
- assert isinstance(result, type(gpd_style_subclass_df))
+ def test_convert_dtypes_preserves_subclass_with_constructor(self):
+ class SubclassedDataFrame(DataFrame):
+ @property
+ def _constructor(self):
+ return SubclassedDataFrame
+
+ df = SubclassedDataFrame({"a": [1, 2, 3]})
+ result = df.convert_dtypes()
+ assert isinstance(result, SubclassedDataFrame)
def test_astype_preserves_subclass(self):
# GH#40810
diff --git a/pandas/tests/frame/test_validate.py b/pandas/tests/frame/test_validate.py
index e99e0a6863848..fdeecba29a617 100644
--- a/pandas/tests/frame/test_validate.py
+++ b/pandas/tests/frame/test_validate.py
@@ -3,11 +3,6 @@
from pandas.core.frame import DataFrame
-@pytest.fixture
-def dataframe():
- return DataFrame({"a": [1, 2], "b": [3, 4]})
-
-
class TestDataFrameValidate:
"""Tests for error handling related to data types of method arguments."""
@@ -24,7 +19,8 @@ class TestDataFrameValidate:
],
)
@pytest.mark.parametrize("inplace", [1, "True", [1, 2, 3], 5.0])
- def test_validate_bool_args(self, dataframe, func, inplace):
+ def test_validate_bool_args(self, func, inplace):
+ dataframe = DataFrame({"a": [1, 2], "b": [3, 4]})
msg = 'For argument "inplace" expected type bool'
kwargs = {"inplace": inplace}
diff --git a/pandas/tests/generic/test_finalize.py b/pandas/tests/generic/test_finalize.py
index 866e9e203ffe3..f25e7d4ab8c79 100644
--- a/pandas/tests/generic/test_finalize.py
+++ b/pandas/tests/generic/test_finalize.py
@@ -386,18 +386,11 @@ def idfn(x):
return str(x)
-@pytest.fixture(params=_all_methods, ids=lambda x: idfn(x[-1]))
-def ndframe_method(request):
- """
- An NDFrame method returning an NDFrame.
- """
- return request.param
-
-
@pytest.mark.filterwarnings(
"ignore:DataFrame.fillna with 'method' is deprecated:FutureWarning",
"ignore:last is deprecated:FutureWarning",
)
+@pytest.mark.parametrize("ndframe_method", _all_methods, ids=lambda x: idfn(x[-1]))
def test_finalize_called(ndframe_method):
cls, init_args, method = ndframe_method
ndframe = cls(*init_args)
diff --git a/pandas/tests/generic/test_label_or_level_utils.py b/pandas/tests/generic/test_label_or_level_utils.py
index 97be46f716d7d..80c24c647bc11 100644
--- a/pandas/tests/generic/test_label_or_level_utils.py
+++ b/pandas/tests/generic/test_label_or_level_utils.py
@@ -34,15 +34,6 @@ def df_ambig(df):
return df
-@pytest.fixture
-def df_duplabels(df):
- """DataFrame with level 'L1' and labels 'L2', 'L3', and 'L2'"""
- df = df.set_index(["L1"])
- df = pd.concat([df, df["L2"]], axis=1)
-
- return df
-
-
# Test is label/level reference
# =============================
def get_labels_levels(df_levels):
@@ -229,7 +220,9 @@ def test_get_label_or_level_values_df_ambig(df_ambig, axis):
assert_label_values(df_ambig, ["L3"], axis=axis)
-def test_get_label_or_level_values_df_duplabels(df_duplabels, axis):
+def test_get_label_or_level_values_df_duplabels(df, axis):
+ df = df.set_index(["L1"])
+ df_duplabels = pd.concat([df, df["L2"]], axis=1)
axis = df_duplabels._get_axis_number(axis)
# Transpose frame if axis == 1
if axis == 1:
diff --git a/pandas/tests/groupby/methods/test_describe.py b/pandas/tests/groupby/methods/test_describe.py
index f27e99809176c..e73fb15a54181 100644
--- a/pandas/tests/groupby/methods/test_describe.py
+++ b/pandas/tests/groupby/methods/test_describe.py
@@ -226,49 +226,34 @@ def test_describe_duplicate_columns():
tm.assert_frame_equal(result, expected)
-class TestGroupByNonCythonPaths:
+def test_describe_non_cython_paths():
# GH#5610 non-cython calls should not include the grouper
# Tests for code not expected to go through cython paths.
+ df = DataFrame(
+ [[1, 2, "foo"], [1, np.nan, "bar"], [3, np.nan, "baz"]],
+ columns=["A", "B", "C"],
+ )
+ gb = df.groupby("A")
+ expected_index = Index([1, 3], name="A")
+ expected_col = MultiIndex(
+ levels=[["B"], ["count", "mean", "std", "min", "25%", "50%", "75%", "max"]],
+ codes=[[0] * 8, list(range(8))],
+ )
+ expected = DataFrame(
+ [
+ [1.0, 2.0, np.nan, 2.0, 2.0, 2.0, 2.0, 2.0],
+ [0.0, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+ ],
+ index=expected_index,
+ columns=expected_col,
+ )
+ result = gb.describe()
+ tm.assert_frame_equal(result, expected)
- @pytest.fixture
- def df(self):
- df = DataFrame(
- [[1, 2, "foo"], [1, np.nan, "bar"], [3, np.nan, "baz"]],
- columns=["A", "B", "C"],
- )
- return df
-
- @pytest.fixture
- def gb(self, df):
- gb = df.groupby("A")
- return gb
-
- @pytest.fixture
- def gni(self, df):
- gni = df.groupby("A", as_index=False)
- return gni
-
- def test_describe(self, df, gb, gni):
- # describe
- expected_index = Index([1, 3], name="A")
- expected_col = MultiIndex(
- levels=[["B"], ["count", "mean", "std", "min", "25%", "50%", "75%", "max"]],
- codes=[[0] * 8, list(range(8))],
- )
- expected = DataFrame(
- [
- [1.0, 2.0, np.nan, 2.0, 2.0, 2.0, 2.0, 2.0],
- [0.0, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
- ],
- index=expected_index,
- columns=expected_col,
- )
- result = gb.describe()
- tm.assert_frame_equal(result, expected)
-
- expected = expected.reset_index()
- result = gni.describe()
- tm.assert_frame_equal(result, expected)
+ gni = df.groupby("A", as_index=False)
+ expected = expected.reset_index()
+ result = gni.describe()
+ tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("dtype", [int, float, object])
diff --git a/pandas/tests/groupby/methods/test_value_counts.py b/pandas/tests/groupby/methods/test_value_counts.py
index 5c9f7febe32b3..35f2f47f5ff97 100644
--- a/pandas/tests/groupby/methods/test_value_counts.py
+++ b/pandas/tests/groupby/methods/test_value_counts.py
@@ -419,14 +419,6 @@ def test_compound(
tm.assert_frame_equal(result, expected)
-@pytest.fixture
-def animals_df():
- return DataFrame(
- {"key": [1, 1, 1, 1], "num_legs": [2, 4, 4, 6], "num_wings": [2, 0, 0, 0]},
- index=["falcon", "dog", "cat", "ant"],
- )
-
-
@pytest.mark.parametrize(
"sort, ascending, normalize, name, expected_data, expected_index",
[
@@ -444,10 +436,14 @@ def animals_df():
],
)
def test_data_frame_value_counts(
- animals_df, sort, ascending, normalize, name, expected_data, expected_index
+ sort, ascending, normalize, name, expected_data, expected_index
):
# 3-way compare with :meth:`~DataFrame.value_counts`
# Tests from frame/methods/test_value_counts.py
+ animals_df = DataFrame(
+ {"key": [1, 1, 1, 1], "num_legs": [2, 4, 4, 6], "num_wings": [2, 0, 0, 0]},
+ index=["falcon", "dog", "cat", "ant"],
+ )
result_frame = animals_df.value_counts(
sort=sort, ascending=ascending, normalize=normalize
)
@@ -467,19 +463,6 @@ def test_data_frame_value_counts(
tm.assert_series_equal(result_frame_groupby, expected)
-@pytest.fixture
-def nulls_df():
- n = np.nan
- return DataFrame(
- {
- "A": [1, 1, n, 4, n, 6, 6, 6, 6],
- "B": [1, 1, 3, n, n, 6, 6, 6, 6],
- "C": [1, 2, 3, 4, 5, 6, n, 8, n],
- "D": [1, 2, 3, 4, 5, 6, 7, n, n],
- }
- )
-
-
@pytest.mark.parametrize(
"group_dropna, count_dropna, expected_rows, expected_values",
[
@@ -495,7 +478,7 @@ def nulls_df():
],
)
def test_dropna_combinations(
- nulls_df, group_dropna, count_dropna, expected_rows, expected_values, request
+ group_dropna, count_dropna, expected_rows, expected_values, request
):
if Version(np.__version__) >= Version("1.25") and not group_dropna:
request.applymarker(
@@ -507,6 +490,14 @@ def test_dropna_combinations(
strict=False,
)
)
+ nulls_df = DataFrame(
+ {
+ "A": [1, 1, np.nan, 4, np.nan, 6, 6, 6, 6],
+ "B": [1, 1, 3, np.nan, np.nan, 6, 6, 6, 6],
+ "C": [1, 2, 3, 4, 5, 6, np.nan, 8, np.nan],
+ "D": [1, 2, 3, 4, 5, 6, 7, np.nan, np.nan],
+ }
+ )
gp = nulls_df.groupby(["A", "B"], dropna=group_dropna)
result = gp.value_counts(normalize=True, sort=True, dropna=count_dropna)
columns = DataFrame()
@@ -517,17 +508,6 @@ def test_dropna_combinations(
tm.assert_series_equal(result, expected)
-@pytest.fixture
-def names_with_nulls_df(nulls_fixture):
- return DataFrame(
- {
- "key": [1, 1, 1, 1],
- "first_name": ["John", "Anne", "John", "Beth"],
- "middle_name": ["Smith", nulls_fixture, nulls_fixture, "Louise"],
- },
- )
-
-
@pytest.mark.parametrize(
"dropna, expected_data, expected_index",
[
@@ -556,11 +536,18 @@ def names_with_nulls_df(nulls_fixture):
)
@pytest.mark.parametrize("normalize, name", [(False, "count"), (True, "proportion")])
def test_data_frame_value_counts_dropna(
- names_with_nulls_df, dropna, normalize, name, expected_data, expected_index
+ nulls_fixture, dropna, normalize, name, expected_data, expected_index
):
# GH 41334
# 3-way compare with :meth:`~DataFrame.value_counts`
# Tests with nulls from frame/methods/test_value_counts.py
+ names_with_nulls_df = DataFrame(
+ {
+ "key": [1, 1, 1, 1],
+ "first_name": ["John", "Anne", "John", "Beth"],
+ "middle_name": ["Smith", nulls_fixture, nulls_fixture, "Louise"],
+ },
+ )
result_frame = names_with_nulls_df.value_counts(dropna=dropna, normalize=normalize)
expected = Series(
data=expected_data,
diff --git a/pandas/tests/groupby/test_index_as_string.py b/pandas/tests/groupby/test_index_as_string.py
index 4aaf3de9a23b2..743db7e70b14b 100644
--- a/pandas/tests/groupby/test_index_as_string.py
+++ b/pandas/tests/groupby/test_index_as_string.py
@@ -5,38 +5,6 @@
import pandas._testing as tm
-@pytest.fixture(params=[["inner"], ["inner", "outer"]])
-def frame(request):
- levels = request.param
- df = pd.DataFrame(
- {
- "outer": ["a", "a", "a", "b", "b", "b"],
- "inner": [1, 2, 3, 1, 2, 3],
- "A": np.arange(6),
- "B": ["one", "one", "two", "two", "one", "one"],
- }
- )
- if levels:
- df = df.set_index(levels)
-
- return df
-
-
-@pytest.fixture()
-def series():
- df = pd.DataFrame(
- {
- "outer": ["a", "a", "a", "b", "b", "b"],
- "inner": [1, 2, 3, 1, 2, 3],
- "A": np.arange(6),
- "B": ["one", "one", "two", "two", "one", "one"],
- }
- )
- s = df.set_index(["outer", "inner", "B"])["A"]
-
- return s
-
-
@pytest.mark.parametrize(
"key_strs,groupers",
[
@@ -46,7 +14,17 @@ def series():
(["inner", "B"], [pd.Grouper(level="inner"), "B"]), # Index and column
],
)
-def test_grouper_index_level_as_string(frame, key_strs, groupers):
+@pytest.mark.parametrize("levels", [["inner"], ["inner", "outer"]])
+def test_grouper_index_level_as_string(levels, key_strs, groupers):
+ frame = pd.DataFrame(
+ {
+ "outer": ["a", "a", "a", "b", "b", "b"],
+ "inner": [1, 2, 3, 1, 2, 3],
+ "A": np.arange(6),
+ "B": ["one", "one", "two", "two", "one", "one"],
+ }
+ )
+ frame = frame.set_index(levels)
if "B" not in key_strs or "outer" in frame.columns:
result = frame.groupby(key_strs).mean(numeric_only=True)
expected = frame.groupby(groupers).mean(numeric_only=True)
@@ -71,8 +49,17 @@ def test_grouper_index_level_as_string(frame, key_strs, groupers):
["B", "outer", "inner"],
],
)
-def test_grouper_index_level_as_string_series(series, levels):
+def test_grouper_index_level_as_string_series(levels):
# Compute expected result
+ df = pd.DataFrame(
+ {
+ "outer": ["a", "a", "a", "b", "b", "b"],
+ "inner": [1, 2, 3, 1, 2, 3],
+ "A": np.arange(6),
+ "B": ["one", "one", "two", "two", "one", "one"],
+ }
+ )
+ series = df.set_index(["outer", "inner", "B"])["A"]
if isinstance(levels, list):
groupers = [pd.Grouper(level=lv) for lv in levels]
else:
diff --git a/pandas/tests/groupby/test_indexing.py b/pandas/tests/groupby/test_indexing.py
index 664c52babac13..f839bf156ca00 100644
--- a/pandas/tests/groupby/test_indexing.py
+++ b/pandas/tests/groupby/test_indexing.py
@@ -118,15 +118,26 @@ def test_doc_examples():
tm.assert_frame_equal(result, expected)
-@pytest.fixture()
-def multiindex_data():
+def test_multiindex():
+ # Test the multiindex mentioned as the use-case in the documentation
+
+ def _make_df_from_data(data):
+ rows = {}
+ for date in data:
+ for level in data[date]:
+ rows[(date, level[0])] = {"A": level[1], "B": level[2]}
+
+ df = pd.DataFrame.from_dict(rows, orient="index")
+ df.index.names = ("Date", "Item")
+ return df
+
rng = np.random.default_rng(2)
ndates = 100
nitems = 20
dates = pd.date_range("20130101", periods=ndates, freq="D")
items = [f"item {i}" for i in range(nitems)]
- data = {}
+ multiindex_data = {}
for date in dates:
nitems_for_date = nitems - rng.integers(0, 12)
levels = [
@@ -134,28 +145,12 @@ def multiindex_data():
for item in items[:nitems_for_date]
]
levels.sort(key=lambda x: x[1])
- data[date] = levels
-
- return data
-
+ multiindex_data[date] = levels
-def _make_df_from_data(data):
- rows = {}
- for date in data:
- for level in data[date]:
- rows[(date, level[0])] = {"A": level[1], "B": level[2]}
-
- df = pd.DataFrame.from_dict(rows, orient="index")
- df.index.names = ("Date", "Item")
- return df
-
-
-def test_multiindex(multiindex_data):
- # Test the multiindex mentioned as the use-case in the documentation
df = _make_df_from_data(multiindex_data)
result = df.groupby("Date", as_index=False).nth(slice(3, -3))
- sliced = {date: multiindex_data[date][3:-3] for date in multiindex_data}
+ sliced = {date: values[3:-3] for date, values in multiindex_data.items()}
expected = _make_df_from_data(sliced)
tm.assert_frame_equal(result, expected)
@@ -271,15 +266,11 @@ def test_step(step):
tm.assert_frame_equal(result, expected)
-@pytest.fixture()
-def column_group_df():
- return pd.DataFrame(
+def test_column_axis():
+ column_group_df = pd.DataFrame(
[[0, 1, 2, 3, 4, 5, 6], [0, 0, 1, 0, 1, 0, 2]],
columns=["A", "B", "C", "D", "E", "F", "G"],
)
-
-
-def test_column_axis(column_group_df):
msg = "DataFrame.groupby with axis=1"
with tm.assert_produces_warning(FutureWarning, match=msg):
g = column_group_df.groupby(column_group_df.iloc[1], axis=1)
diff --git a/pandas/tests/groupby/test_raises.py b/pandas/tests/groupby/test_raises.py
index 0b451ce73db89..738711019b5fd 100644
--- a/pandas/tests/groupby/test_raises.py
+++ b/pandas/tests/groupby/test_raises.py
@@ -67,19 +67,6 @@ def df_with_datetime_col():
return df
-@pytest.fixture
-def df_with_timedelta_col():
- df = DataFrame(
- {
- "a": [1, 1, 1, 1, 1, 2, 2, 2, 2],
- "b": [3, 3, 4, 4, 4, 4, 4, 3, 3],
- "c": range(9),
- "d": datetime.timedelta(days=1),
- }
- )
- return df
-
-
@pytest.fixture
def df_with_cat_col():
df = DataFrame(
@@ -353,8 +340,15 @@ def test_groupby_raises_datetime_np(
@pytest.mark.parametrize("func", ["prod", "cumprod", "skew", "var"])
-def test_groupby_raises_timedelta(func, df_with_timedelta_col):
- df = df_with_timedelta_col
+def test_groupby_raises_timedelta(func):
+ df = DataFrame(
+ {
+ "a": [1, 1, 1, 1, 1, 2, 2, 2, 2],
+ "b": [3, 3, 4, 4, 4, 4, 4, 3, 3],
+ "c": range(9),
+ "d": datetime.timedelta(days=1),
+ }
+ )
gb = df.groupby(by="a")
_call_and_check(
diff --git a/pandas/tests/indexes/datetimelike_/test_nat.py b/pandas/tests/indexes/datetimelike_/test_nat.py
index 50cf29d016355..3dd0ce1cbd637 100644
--- a/pandas/tests/indexes/datetimelike_/test_nat.py
+++ b/pandas/tests/indexes/datetimelike_/test_nat.py
@@ -10,44 +10,33 @@
import pandas._testing as tm
-class NATests:
- def test_nat(self, index_without_na):
- empty_index = index_without_na[:0]
-
- index_with_na = index_without_na.copy(deep=True)
- index_with_na._data[1] = NaT
-
- assert empty_index._na_value is NaT
- assert index_with_na._na_value is NaT
- assert index_without_na._na_value is NaT
-
- idx = index_without_na
- assert idx._can_hold_na
-
- tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
- assert idx.hasnans is False
-
- idx = index_with_na
- assert idx._can_hold_na
-
- tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
- assert idx.hasnans is True
+@pytest.mark.parametrize(
+ "index_without_na",
+ [
+ TimedeltaIndex(["1 days", "2 days"]),
+ PeriodIndex(["2011-01-01", "2011-01-02"], freq="D"),
+ DatetimeIndex(["2011-01-01", "2011-01-02"]),
+ DatetimeIndex(["2011-01-01", "2011-01-02"], tz="UTC"),
+ ],
+)
+def test_nat(index_without_na):
+ empty_index = index_without_na[:0]
+ index_with_na = index_without_na.copy(deep=True)
+ index_with_na._data[1] = NaT
-class TestDatetimeIndexNA(NATests):
- @pytest.fixture
- def index_without_na(self, tz_naive_fixture):
- tz = tz_naive_fixture
- return DatetimeIndex(["2011-01-01", "2011-01-02"], tz=tz)
+ assert empty_index._na_value is NaT
+ assert index_with_na._na_value is NaT
+ assert index_without_na._na_value is NaT
+ idx = index_without_na
+ assert idx._can_hold_na
-class TestTimedeltaIndexNA(NATests):
- @pytest.fixture
- def index_without_na(self):
- return TimedeltaIndex(["1 days", "2 days"])
+ tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
+ assert idx.hasnans is False
+ idx = index_with_na
+ assert idx._can_hold_na
-class TestPeriodIndexNA(NATests):
- @pytest.fixture
- def index_without_na(self):
- return PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
+ tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
+ assert idx.hasnans is True
diff --git a/pandas/tests/indexes/interval/test_constructors.py b/pandas/tests/indexes/interval/test_constructors.py
index 778c07b46e57c..e9864723f026e 100644
--- a/pandas/tests/indexes/interval/test_constructors.py
+++ b/pandas/tests/indexes/interval/test_constructors.py
@@ -23,11 +23,6 @@
import pandas.core.common as com
-@pytest.fixture(params=[None, "foo"])
-def name(request):
- return request.param
-
-
class ConstructorTests:
"""
Common tests for all variations of IntervalIndex construction. Input data
@@ -35,8 +30,9 @@ class ConstructorTests:
get_kwargs_from_breaks to the expected format.
"""
- @pytest.fixture(
- params=[
+ @pytest.mark.parametrize(
+ "breaks_and_expected_subtype",
+ [
([3, 14, 15, 92, 653], np.int64),
(np.arange(10, dtype="int64"), np.int64),
(Index(np.arange(-10, 11, dtype=np.int64)), np.int64),
@@ -48,11 +44,9 @@ class ConstructorTests:
"datetime64[ns, US/Eastern]",
),
(timedelta_range("1 day", periods=10), "<m8[ns]"),
- ]
+ ],
)
- def breaks_and_expected_subtype(self, request):
- return request.param
-
+ @pytest.mark.parametrize("name", [None, "foo"])
def test_constructor(self, constructor, breaks_and_expected_subtype, closed, name):
breaks, expected_subtype = breaks_and_expected_subtype
@@ -372,14 +366,6 @@ def test_na_tuples(self):
class TestClassConstructors(ConstructorTests):
"""Tests specific to the IntervalIndex/Index constructors"""
- @pytest.fixture(
- params=[IntervalIndex, partial(Index, dtype="interval")],
- ids=["IntervalIndex", "Index"],
- )
- def klass(self, request):
- # We use a separate fixture here to include Index.__new__ with dtype kwarg
- return request.param
-
@pytest.fixture
def constructor(self):
return IntervalIndex
@@ -418,6 +404,11 @@ def test_constructor_string(self):
# the interval of strings is already forbidden.
pass
+ @pytest.mark.parametrize(
+ "klass",
+ [IntervalIndex, partial(Index, dtype="interval")],
+ ids=["IntervalIndex", "Index"],
+ )
def test_constructor_errors(self, klass):
# mismatched closed within intervals with no constructor override
ivs = [Interval(0, 1, closed="right"), Interval(2, 3, closed="left")]
diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index 89b991318be0d..7391d39bdde7b 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -21,11 +21,6 @@
import pandas.core.common as com
-@pytest.fixture(params=[None, "foo"])
-def name(request):
- return request.param
-
-
class TestIntervalIndex:
index = IntervalIndex.from_arrays([0, 1], [1, 2])
@@ -865,6 +860,7 @@ def test_nbytes(self):
expected = 64 # 4 * 8 * 2
assert result == expected
+ @pytest.mark.parametrize("name", [None, "foo"])
def test_set_closed(self, name, closed, other_closed):
# GH 21670
index = interval_range(0, 5, closed=closed, name=name)
diff --git a/pandas/tests/indexes/interval/test_interval_tree.py b/pandas/tests/indexes/interval/test_interval_tree.py
index 45b25f2533afd..49b17f8b3d40e 100644
--- a/pandas/tests/indexes/interval/test_interval_tree.py
+++ b/pandas/tests/indexes/interval/test_interval_tree.py
@@ -18,11 +18,6 @@ def skipif_32bit(param):
return pytest.param(param, marks=marks)
-@pytest.fixture(params=["int64", "float64", "uint64"])
-def dtype(request):
- return request.param
-
-
@pytest.fixture(params=[skipif_32bit(1), skipif_32bit(2), 10])
def leaf_size(request):
"""
@@ -103,6 +98,7 @@ def test_get_indexer_non_unique_overflow(self, dtype, target_value, target_dtype
expected_missing = np.array([0], dtype="intp")
tm.assert_numpy_array_equal(result_missing, expected_missing)
+ @pytest.mark.parametrize("dtype", ["int64", "float64", "uint64"])
def test_duplicates(self, dtype):
left = np.array([0, 0, 0], dtype=dtype)
tree = IntervalTree(left, left + 1)
diff --git a/pandas/tests/indexes/numeric/test_indexing.py b/pandas/tests/indexes/numeric/test_indexing.py
index cd28d519313ed..f2458a6c6114d 100644
--- a/pandas/tests/indexes/numeric/test_indexing.py
+++ b/pandas/tests/indexes/numeric/test_indexing.py
@@ -17,13 +17,6 @@
)
-@pytest.fixture
-def index_large():
- # large values used in Index[uint64] tests where no compat needed with Int64/Float64
- large = [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25]
- return Index(large, dtype=np.uint64)
-
-
class TestGetLoc:
def test_get_loc(self):
index = Index([0, 1, 2])
@@ -303,7 +296,11 @@ def test_get_indexer_int64(self):
expected = np.array([0, 1, 1, 2, 2, 3, 3, 4, 4, 5], dtype=np.intp)
tm.assert_numpy_array_equal(indexer, expected)
- def test_get_indexer_uint64(self, index_large):
+ def test_get_indexer_uint64(self):
+ index_large = Index(
+ [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25],
+ dtype=np.uint64,
+ )
target = Index(np.arange(10).astype("uint64") * 5 + 2**63)
indexer = index_large.get_indexer(target)
expected = np.array([0, -1, 1, 2, 3, 4, -1, -1, -1, -1], dtype=np.intp)
diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index dc5a6719284a6..4416034795463 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -15,12 +15,16 @@ def dtype(self, request):
return request.param
@pytest.fixture
- def simple_index(self, dtype):
- values = np.arange(5, dtype=dtype)
- return Index(values)
+ def mixed_index(self, dtype):
+ return Index([1.5, 2, 3, 4, 5], dtype=dtype)
+
+ @pytest.fixture
+ def float_index(self, dtype):
+ return Index([0.0, 2.5, 5.0, 7.5, 10.0], dtype=dtype)
- @pytest.fixture(
- params=[
+ @pytest.mark.parametrize(
+ "index_data",
+ [
[1.5, 2, 3, 4, 5],
[0.0, 2.5, 5.0, 7.5, 10.0],
[5, 4, 3, 2, 1.5],
@@ -28,18 +32,8 @@ def simple_index(self, dtype):
],
ids=["mixed", "float", "mixed_dec", "float_dec"],
)
- def index(self, request, dtype):
- return Index(request.param, dtype=dtype)
-
- @pytest.fixture
- def mixed_index(self, dtype):
- return Index([1.5, 2, 3, 4, 5], dtype=dtype)
-
- @pytest.fixture
- def float_index(self, dtype):
- return Index([0.0, 2.5, 5.0, 7.5, 10.0], dtype=dtype)
-
- def test_repr_roundtrip(self, index):
+ def test_repr_roundtrip(self, index_data, dtype):
+ index = Index(index_data, dtype=dtype)
tm.assert_index_equal(eval(repr(index)), index, exact=True)
def check_coerce(self, a, b, is_float_index=True):
@@ -227,8 +221,8 @@ def test_fillna_float64(self):
exp = Index([1.0, "obj", 3.0], name="x")
tm.assert_index_equal(idx.fillna("obj"), exp, exact=True)
- def test_logical_compat(self, simple_index):
- idx = simple_index
+ def test_logical_compat(self, dtype):
+ idx = Index(np.arange(5, dtype=dtype))
assert idx.all() == idx.values.all()
assert idx.any() == idx.values.any()
diff --git a/pandas/tests/indexes/numeric/test_setops.py b/pandas/tests/indexes/numeric/test_setops.py
index 376b51dd98bb1..102560852e8e4 100644
--- a/pandas/tests/indexes/numeric/test_setops.py
+++ b/pandas/tests/indexes/numeric/test_setops.py
@@ -96,7 +96,11 @@ def test_float64_index_difference(self):
result = string_index.difference(float_index)
tm.assert_index_equal(result, string_index)
- def test_intersection_uint64_outside_int64_range(self, index_large):
+ def test_intersection_uint64_outside_int64_range(self):
+ index_large = Index(
+ [2**63, 2**63 + 10, 2**63 + 15, 2**63 + 20, 2**63 + 25],
+ dtype=np.uint64,
+ )
other = Index([2**63, 2**63 + 5, 2**63 + 10, 2**63 + 15, 2**63 + 20])
result = index_large.intersection(other)
expected = Index(np.sort(np.intersect1d(index_large.values, other.values)))
diff --git a/pandas/tests/indexing/conftest.py b/pandas/tests/indexing/conftest.py
deleted file mode 100644
index 4184c6a0047cc..0000000000000
--- a/pandas/tests/indexing/conftest.py
+++ /dev/null
@@ -1,127 +0,0 @@
-import numpy as np
-import pytest
-
-from pandas import (
- DataFrame,
- Index,
- MultiIndex,
- Series,
- date_range,
-)
-
-
-@pytest.fixture
-def series_ints():
- return Series(np.random.default_rng(2).random(4), index=np.arange(0, 8, 2))
-
-
-@pytest.fixture
-def frame_ints():
- return DataFrame(
- np.random.default_rng(2).standard_normal((4, 4)),
- index=np.arange(0, 8, 2),
- columns=np.arange(0, 12, 3),
- )
-
-
-@pytest.fixture
-def series_uints():
- return Series(
- np.random.default_rng(2).random(4),
- index=Index(np.arange(0, 8, 2, dtype=np.uint64)),
- )
-
-
-@pytest.fixture
-def frame_uints():
- return DataFrame(
- np.random.default_rng(2).standard_normal((4, 4)),
- index=Index(range(0, 8, 2), dtype=np.uint64),
- columns=Index(range(0, 12, 3), dtype=np.uint64),
- )
-
-
-@pytest.fixture
-def series_labels():
- return Series(np.random.default_rng(2).standard_normal(4), index=list("abcd"))
-
-
-@pytest.fixture
-def frame_labels():
- return DataFrame(
- np.random.default_rng(2).standard_normal((4, 4)),
- index=list("abcd"),
- columns=list("ABCD"),
- )
-
-
-@pytest.fixture
-def series_ts():
- return Series(
- np.random.default_rng(2).standard_normal(4),
- index=date_range("20130101", periods=4),
- )
-
-
-@pytest.fixture
-def frame_ts():
- return DataFrame(
- np.random.default_rng(2).standard_normal((4, 4)),
- index=date_range("20130101", periods=4),
- )
-
-
-@pytest.fixture
-def series_floats():
- return Series(
- np.random.default_rng(2).random(4),
- index=Index(range(0, 8, 2), dtype=np.float64),
- )
-
-
-@pytest.fixture
-def frame_floats():
- return DataFrame(
- np.random.default_rng(2).standard_normal((4, 4)),
- index=Index(range(0, 8, 2), dtype=np.float64),
- columns=Index(range(0, 12, 3), dtype=np.float64),
- )
-
-
-@pytest.fixture
-def series_mixed():
- return Series(np.random.default_rng(2).standard_normal(4), index=[2, 4, "null", 8])
-
-
-@pytest.fixture
-def frame_mixed():
- return DataFrame(
- np.random.default_rng(2).standard_normal((4, 4)), index=[2, 4, "null", 8]
- )
-
-
-@pytest.fixture
-def frame_empty():
- return DataFrame()
-
-
-@pytest.fixture
-def series_empty():
- return Series(dtype=object)
-
-
-@pytest.fixture
-def frame_multi():
- return DataFrame(
- np.random.default_rng(2).standard_normal((4, 4)),
- index=MultiIndex.from_product([[1, 2], [3, 4]]),
- columns=MultiIndex.from_product([[5, 6], [7, 8]]),
- )
-
-
-@pytest.fixture
-def series_multi():
- return Series(
- np.random.default_rng(2).random(4),
- index=MultiIndex.from_product([[1, 2], [3, 4]]),
- )
diff --git a/pandas/tests/indexing/multiindex/test_loc.py b/pandas/tests/indexing/multiindex/test_loc.py
index 5508153322adb..de7d644698f2c 100644
--- a/pandas/tests/indexing/multiindex/test_loc.py
+++ b/pandas/tests/indexing/multiindex/test_loc.py
@@ -16,14 +16,6 @@
import pandas._testing as tm
-@pytest.fixture
-def single_level_multiindex():
- """single level MultiIndex"""
- return MultiIndex(
- levels=[["foo", "bar", "baz", "qux"]], codes=[[0, 1, 2, 3]], names=["first"]
- )
-
-
@pytest.fixture
def frame_random_data_integer_multi_index():
levels = [[0, 1], [0, 1, 2]]
@@ -277,8 +269,10 @@ def test_loc_multiindex_incomplete(self):
result = s.loc[2:4:2, "a":"c"]
tm.assert_series_equal(result, expected)
- def test_get_loc_single_level(self, single_level_multiindex):
- single_level = single_level_multiindex
+ def test_get_loc_single_level(self):
+ single_level = MultiIndex(
+ levels=[["foo", "bar", "baz", "qux"]], codes=[[0, 1, 2, 3]], names=["first"]
+ )
s = Series(
np.random.default_rng(2).standard_normal(len(single_level)),
index=single_level,
diff --git a/pandas/tests/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index 13d786f98c42b..e0898a636474c 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -38,13 +38,18 @@
class TestiLoc:
@pytest.mark.parametrize("key", [2, -1, [0, 1, 2]])
- @pytest.mark.parametrize("kind", ["series", "frame"])
@pytest.mark.parametrize(
- "col",
- ["labels", "mixed", "ts", "floats", "empty"],
+ "index",
+ [
+ Index(list("abcd"), dtype=object),
+ Index([2, 4, "null", 8], dtype=object),
+ date_range("20130101", periods=4),
+ Index(range(0, 8, 2), dtype=np.float64),
+ Index([]),
+ ],
)
- def test_iloc_getitem_int_and_list_int(self, key, kind, col, request):
- obj = request.getfixturevalue(f"{kind}_{col}")
+ def test_iloc_getitem_int_and_list_int(self, key, frame_or_series, index, request):
+ obj = frame_or_series(range(len(index)), index=index)
check_indexing_smoketest_or_raises(
obj,
"iloc",
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index ada6f88679673..c455b0bc8599b 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -68,116 +68,111 @@ def test_none_values_on_string_columns(self):
assert df.loc[2, "a"] is None
- @pytest.mark.parametrize("kind", ["series", "frame"])
- def test_loc_getitem_int(self, kind, request):
+ def test_loc_getitem_int(self, frame_or_series):
# int label
- obj = request.getfixturevalue(f"{kind}_labels")
+ obj = frame_or_series(range(3), index=Index(list("abc"), dtype=object))
check_indexing_smoketest_or_raises(obj, "loc", 2, fails=KeyError)
- @pytest.mark.parametrize("kind", ["series", "frame"])
- def test_loc_getitem_label(self, kind, request):
+ def test_loc_getitem_label(self, frame_or_series):
# label
- obj = request.getfixturevalue(f"{kind}_empty")
+ obj = frame_or_series()
check_indexing_smoketest_or_raises(obj, "loc", "c", fails=KeyError)
+ @pytest.mark.parametrize("key", ["f", 20])
@pytest.mark.parametrize(
- "key, typs, axes",
+ "index",
[
- ["f", ["ints", "uints", "labels", "mixed", "ts"], None],
- ["f", ["floats"], None],
- [20, ["ints", "uints", "mixed"], None],
- [20, ["labels"], None],
- [20, ["ts"], 0],
- [20, ["floats"], 0],
+ Index(list("abcd"), dtype=object),
+ Index([2, 4, "null", 8], dtype=object),
+ date_range("20130101", periods=4),
+ Index(range(0, 8, 2), dtype=np.float64),
+ Index([]),
],
)
- @pytest.mark.parametrize("kind", ["series", "frame"])
- def test_loc_getitem_label_out_of_range(self, key, typs, axes, kind, request):
- for typ in typs:
- obj = request.getfixturevalue(f"{kind}_{typ}")
- # out of range label
- check_indexing_smoketest_or_raises(
- obj, "loc", key, axes=axes, fails=KeyError
- )
+ def test_loc_getitem_label_out_of_range(self, key, index, frame_or_series):
+ obj = frame_or_series(range(len(index)), index=index)
+ # out of range label
+ check_indexing_smoketest_or_raises(obj, "loc", key, fails=KeyError)
+
+ @pytest.mark.parametrize("key", [[0, 1, 2], [1, 3.0, "A"]])
+ @pytest.mark.parametrize("dtype", [np.int64, np.uint64, np.float64])
+ def test_loc_getitem_label_list(self, key, dtype, frame_or_series):
+ obj = frame_or_series(range(3), index=Index([0, 1, 2], dtype=dtype))
+ # list of labels
+ check_indexing_smoketest_or_raises(obj, "loc", key, fails=KeyError)
@pytest.mark.parametrize(
- "key, typs",
+ "index",
[
- [[0, 1, 2], ["ints", "uints", "floats"]],
- [[1, 3.0, "A"], ["ints", "uints", "floats"]],
+ None,
+ Index([0, 1, 2], dtype=np.int64),
+ Index([0, 1, 2], dtype=np.uint64),
+ Index([0, 1, 2], dtype=np.float64),
+ MultiIndex.from_arrays([range(3), range(3)]),
],
)
- @pytest.mark.parametrize("kind", ["series", "frame"])
- def test_loc_getitem_label_list(self, key, typs, kind, request):
- for typ in typs:
- obj = request.getfixturevalue(f"{kind}_{typ}")
- # list of labels
- check_indexing_smoketest_or_raises(obj, "loc", key, fails=KeyError)
-
@pytest.mark.parametrize(
- "key, typs, axes",
- [
- [[0, 1, 2], ["empty"], None],
- [[0, 2, 10], ["ints", "uints", "floats"], 0],
- [[3, 6, 7], ["ints", "uints", "floats"], 1],
- # GH 17758 - MultiIndex and missing keys
- [[(1, 3), (1, 4), (2, 5)], ["multi"], 0],
- ],
+ "key", [[0, 1, 2], [0, 2, 10], [3, 6, 7], [(1, 3), (1, 4), (2, 5)]]
)
- @pytest.mark.parametrize("kind", ["series", "frame"])
- def test_loc_getitem_label_list_with_missing(self, key, typs, axes, kind, request):
- for typ in typs:
- obj = request.getfixturevalue(f"{kind}_{typ}")
- check_indexing_smoketest_or_raises(
- obj, "loc", key, axes=axes, fails=KeyError
- )
+ def test_loc_getitem_label_list_with_missing(self, key, index, frame_or_series):
+ if index is None:
+ obj = frame_or_series()
+ else:
+ obj = frame_or_series(range(len(index)), index=index)
+ check_indexing_smoketest_or_raises(obj, "loc", key, fails=KeyError)
- @pytest.mark.parametrize("typs", ["ints", "uints"])
- @pytest.mark.parametrize("kind", ["series", "frame"])
- def test_loc_getitem_label_list_fails(self, typs, kind, request):
+ @pytest.mark.parametrize("dtype", [np.int64, np.uint64])
+ def test_loc_getitem_label_list_fails(self, dtype, frame_or_series):
# fails
- obj = request.getfixturevalue(f"{kind}_{typs}")
+ obj = frame_or_series(range(3), Index([0, 1, 2], dtype=dtype))
check_indexing_smoketest_or_raises(
obj, "loc", [20, 30, 40], axes=1, fails=KeyError
)
- def test_loc_getitem_label_array_like(self):
- # TODO: test something?
- # array like
- pass
-
- @pytest.mark.parametrize("kind", ["series", "frame"])
- def test_loc_getitem_bool(self, kind, request):
- obj = request.getfixturevalue(f"{kind}_empty")
+ def test_loc_getitem_bool(self, frame_or_series):
+ obj = frame_or_series()
# boolean indexers
b = [True, False, True, False]
check_indexing_smoketest_or_raises(obj, "loc", b, fails=IndexError)
@pytest.mark.parametrize(
- "slc, typs, axes, fails",
+ "slc, indexes, axes, fails",
[
[
slice(1, 3),
- ["labels", "mixed", "empty", "ts", "floats"],
+ [
+ Index(list("abcd"), dtype=object),
+ Index([2, 4, "null", 8], dtype=object),
+ None,
+ date_range("20130101", periods=4),
+ Index(range(0, 12, 3), dtype=np.float64),
+ ],
None,
TypeError,
],
- [slice("20130102", "20130104"), ["ts"], 1, TypeError],
- [slice(2, 8), ["mixed"], 0, TypeError],
- [slice(2, 8), ["mixed"], 1, KeyError],
- [slice(2, 4, 2), ["mixed"], 0, TypeError],
+ [
+ slice("20130102", "20130104"),
+ [date_range("20130101", periods=4)],
+ 1,
+ TypeError,
+ ],
+ [slice(2, 8), [Index([2, 4, "null", 8], dtype=object)], 0, TypeError],
+ [slice(2, 8), [Index([2, 4, "null", 8], dtype=object)], 1, KeyError],
+ [slice(2, 4, 2), [Index([2, 4, "null", 8], dtype=object)], 0, TypeError],
],
)
- @pytest.mark.parametrize("kind", ["series", "frame"])
- def test_loc_getitem_label_slice(self, slc, typs, axes, fails, kind, request):
+ def test_loc_getitem_label_slice(self, slc, indexes, axes, fails, frame_or_series):
# label slices (with ints)
# real label slices
# GH 14316
- for typ in typs:
- obj = request.getfixturevalue(f"{kind}_{typ}")
+ for index in indexes:
+ if index is None:
+ obj = frame_or_series()
+ else:
+ obj = frame_or_series(range(len(index)), index=index)
check_indexing_smoketest_or_raises(
obj,
"loc",
diff --git a/pandas/tests/indexing/test_scalar.py b/pandas/tests/indexing/test_scalar.py
index 29e3dc0aebe95..ef4cd402aaf24 100644
--- a/pandas/tests/indexing/test_scalar.py
+++ b/pandas/tests/indexing/test_scalar.py
@@ -10,6 +10,7 @@
from pandas import (
DataFrame,
+ Index,
Series,
Timedelta,
Timestamp,
@@ -32,29 +33,42 @@ def generate_indices(f, values=False):
class TestScalar:
- @pytest.mark.parametrize("kind", ["series", "frame"])
- @pytest.mark.parametrize("col", ["ints", "uints"])
- def test_iat_set_ints(self, kind, col, request):
- f = request.getfixturevalue(f"{kind}_{col}")
+ @pytest.mark.parametrize("dtype", [np.int64, np.uint64])
+ def test_iat_set_ints(self, dtype, frame_or_series):
+ f = frame_or_series(range(3), index=Index([0, 1, 2], dtype=dtype))
indices = generate_indices(f, True)
for i in indices:
f.iat[i] = 1
expected = f.values[i]
tm.assert_almost_equal(expected, 1)
- @pytest.mark.parametrize("kind", ["series", "frame"])
- @pytest.mark.parametrize("col", ["labels", "ts", "floats"])
- def test_iat_set_other(self, kind, col, request):
- f = request.getfixturevalue(f"{kind}_{col}")
+ @pytest.mark.parametrize(
+ "index",
+ [
+ Index(list("abcd"), dtype=object),
+ date_range("20130101", periods=4),
+ Index(range(0, 8, 2), dtype=np.float64),
+ ],
+ )
+ def test_iat_set_other(self, index, frame_or_series):
+ f = frame_or_series(range(len(index)), index=index)
msg = "iAt based indexing can only have integer indexers"
with pytest.raises(ValueError, match=msg):
idx = next(generate_indices(f, False))
f.iat[idx] = 1
- @pytest.mark.parametrize("kind", ["series", "frame"])
- @pytest.mark.parametrize("col", ["ints", "uints", "labels", "ts", "floats"])
- def test_at_set_ints_other(self, kind, col, request):
- f = request.getfixturevalue(f"{kind}_{col}")
+ @pytest.mark.parametrize(
+ "index",
+ [
+ Index(list("abcd"), dtype=object),
+ date_range("20130101", periods=4),
+ Index(range(0, 8, 2), dtype=np.float64),
+ Index(range(0, 8, 2), dtype=np.uint64),
+ Index(range(0, 8, 2), dtype=np.int64),
+ ],
+ )
+ def test_at_set_ints_other(self, index, frame_or_series):
+ f = frame_or_series(range(len(index)), index=index)
indices = generate_indices(f, False)
for i in indices:
f.at[i] = 1
diff --git a/pandas/tests/interchange/test_impl.py b/pandas/tests/interchange/test_impl.py
index 8bc6b48922a4f..6d8cc501ade6c 100644
--- a/pandas/tests/interchange/test_impl.py
+++ b/pandas/tests/interchange/test_impl.py
@@ -21,29 +21,12 @@
from pandas.core.interchange.utils import ArrowCTypes
-@pytest.fixture
-def data_categorical():
- return {
+@pytest.mark.parametrize("data", [("ordered", True), ("unordered", False)])
+def test_categorical_dtype(data):
+ data_categorical = {
"ordered": pd.Categorical(list("testdata") * 30, ordered=True),
"unordered": pd.Categorical(list("testdata") * 30, ordered=False),
}
-
-
-@pytest.fixture
-def string_data():
- return {
- "separator data": [
- "abC|DeF,Hik",
- "234,3245.67",
- "gSaf,qWer|Gre",
- "asd3,4sad|",
- np.nan,
- ]
- }
-
-
-@pytest.mark.parametrize("data", [("ordered", True), ("unordered", False)])
-def test_categorical_dtype(data, data_categorical):
df = pd.DataFrame({"A": (data_categorical[data[0]])})
col = df.__dataframe__().get_column_by_name("A")
@@ -231,7 +214,16 @@ def test_mixed_missing():
assert df2.get_column_by_name(col_name).null_count == 2
-def test_string(string_data):
+def test_string():
+ string_data = {
+ "separator data": [
+ "abC|DeF,Hik",
+ "234,3245.67",
+ "gSaf,qWer|Gre",
+ "asd3,4sad|",
+ np.nan,
+ ]
+ }
test_str_data = string_data["separator data"] + [""]
df = pd.DataFrame({"A": test_str_data})
col = df.__dataframe__().get_column_by_name("A")
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 0ca29c219b55b..43e94b8c55589 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -4,7 +4,6 @@
"""
from datetime import datetime
from io import StringIO
-from pathlib import Path
import re
from shutil import get_terminal_size
@@ -32,55 +31,6 @@
import pandas.io.formats.format as fmt
-@pytest.fixture(params=["string", "pathlike", "buffer"])
-def filepath_or_buffer_id(request):
- """
- A fixture yielding test ids for filepath_or_buffer testing.
- """
- return request.param
-
-
-@pytest.fixture
-def filepath_or_buffer(filepath_or_buffer_id, tmp_path):
- """
- A fixture yielding a string representing a filepath, a path-like object
- and a StringIO buffer. Also checks that buffer is not closed.
- """
- if filepath_or_buffer_id == "buffer":
- buf = StringIO()
- yield buf
- assert not buf.closed
- else:
- assert isinstance(tmp_path, Path)
- if filepath_or_buffer_id == "pathlike":
- yield tmp_path / "foo"
- else:
- yield str(tmp_path / "foo")
-
-
-@pytest.fixture
-def assert_filepath_or_buffer_equals(
- filepath_or_buffer, filepath_or_buffer_id, encoding
-):
- """
- Assertion helper for checking filepath_or_buffer.
- """
- if encoding is None:
- encoding = "utf-8"
-
- def _assert_filepath_or_buffer_equals(expected):
- if filepath_or_buffer_id == "string":
- with open(filepath_or_buffer, encoding=encoding) as f:
- result = f.read()
- elif filepath_or_buffer_id == "pathlike":
- result = filepath_or_buffer.read_text(encoding=encoding)
- elif filepath_or_buffer_id == "buffer":
- result = filepath_or_buffer.getvalue()
- assert result == expected
-
- return _assert_filepath_or_buffer_equals
-
-
def has_info_repr(df):
r = repr(df)
c1 = r.split("\n")[0].startswith("<class")
@@ -2258,14 +2208,21 @@ def test_format_percentiles_integer_idx(self):
"encoding, data",
[(None, "abc"), ("utf-8", "abc"), ("gbk", "造成输出中文显示乱码"), ("foo", "abc")],
)
+@pytest.mark.parametrize("filepath_or_buffer_id", ["string", "pathlike", "buffer"])
def test_filepath_or_buffer_arg(
method,
- filepath_or_buffer,
- assert_filepath_or_buffer_equals,
+ tmp_path,
encoding,
data,
filepath_or_buffer_id,
):
+ if filepath_or_buffer_id == "buffer":
+ filepath_or_buffer = StringIO()
+ elif filepath_or_buffer_id == "pathlike":
+ filepath_or_buffer = tmp_path / "foo"
+ else:
+ filepath_or_buffer = str(tmp_path / "foo")
+
df = DataFrame([data])
if method in ["to_latex"]: # uses styler implementation
pytest.importorskip("jinja2")
@@ -2281,7 +2238,17 @@ def test_filepath_or_buffer_arg(
else:
expected = getattr(df, method)()
getattr(df, method)(buf=filepath_or_buffer, encoding=encoding)
- assert_filepath_or_buffer_equals(expected)
+ encoding = encoding or "utf-8"
+ if filepath_or_buffer_id == "string":
+ with open(filepath_or_buffer, encoding=encoding) as f:
+ result = f.read()
+ elif filepath_or_buffer_id == "pathlike":
+ result = filepath_or_buffer.read_text(encoding=encoding)
+ elif filepath_or_buffer_id == "buffer":
+ result = filepath_or_buffer.getvalue()
+ assert result == expected
+ if filepath_or_buffer_id == "buffer":
+ assert not filepath_or_buffer.closed
@pytest.mark.parametrize("method", ["to_string", "to_html", "to_latex"])
diff --git a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
index b7bb057bc538e..015b27d0b3606 100644
--- a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
+++ b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
@@ -132,17 +132,6 @@ def sa(self):
def ia(self):
return array([10], dtype="Int64")
- @pytest.fixture
- def df(self, da, dc, sa, ia):
- return DataFrame(
- {
- "A": da,
- "B": dc,
- "C": sa,
- "D": ia,
- }
- )
-
def test_build_date_series(self, da):
s = Series(da, name="a")
s.index.name = "id"
@@ -243,8 +232,15 @@ def test_build_int64_series(self, ia):
assert result == expected
- def test_to_json(self, df):
- df = df.copy()
+ def test_to_json(self, da, dc, sa, ia):
+ df = DataFrame(
+ {
+ "A": da,
+ "B": dc,
+ "C": sa,
+ "D": ia,
+ }
+ )
df.index.name = "idx"
result = df.to_json(orient="table", date_format="iso")
result = json.loads(result, object_pairs_hook=OrderedDict)
diff --git a/pandas/tests/io/json/test_normalize.py b/pandas/tests/io/json/test_normalize.py
index 3c6517a872b76..7914d40ea8aaa 100644
--- a/pandas/tests/io/json/test_normalize.py
+++ b/pandas/tests/io/json/test_normalize.py
@@ -78,17 +78,6 @@ def state_data():
]
-@pytest.fixture
-def author_missing_data():
- return [
- {"info": None},
- {
- "info": {"created_at": "11/08/1993", "last_updated": "26/05/2012"},
- "author_name": {"first": "Jane", "last_name": "Doe"},
- },
- ]
-
-
@pytest.fixture
def missing_metadata():
return [
@@ -120,23 +109,6 @@ def missing_metadata():
]
-@pytest.fixture
-def max_level_test_input_data():
- """
- input data to test json_normalize with max_level param
- """
- return [
- {
- "CreatedBy": {"Name": "User001"},
- "Lookup": {
- "TextField": "Some text",
- "UserField": {"Id": "ID001", "Name": "Name001"},
- },
- "Image": {"a": "b"},
- }
- ]
-
-
class TestJSONNormalize:
def test_simple_records(self):
recs = [
@@ -424,8 +396,15 @@ def test_non_ascii_key(self):
result = json_normalize(json.loads(testjson))
tm.assert_frame_equal(result, expected)
- def test_missing_field(self, author_missing_data):
+ def test_missing_field(self):
# GH20030:
+ author_missing_data = [
+ {"info": None},
+ {
+ "info": {"created_at": "11/08/1993", "last_updated": "26/05/2012"},
+ "author_name": {"first": "Jane", "last_name": "Doe"},
+ },
+ ]
result = json_normalize(author_missing_data)
ex_data = [
{
@@ -843,8 +822,18 @@ def test_nonetype_multiple_levels(self):
),
],
)
- def test_with_max_level(self, max_level, expected, max_level_test_input_data):
+ def test_with_max_level(self, max_level, expected):
# GH23843: Enhanced JSON normalize
+ max_level_test_input_data = [
+ {
+ "CreatedBy": {"Name": "User001"},
+ "Lookup": {
+ "TextField": "Some text",
+ "UserField": {"Id": "ID001", "Name": "Name001"},
+ },
+ "Image": {"a": "b"},
+ }
+ ]
output = nested_to_record(max_level_test_input_data, max_level=max_level)
assert output == expected
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 9fa46222bce1a..7254fd7cb345d 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -93,17 +93,6 @@ def assert_json_roundtrip_equal(result, expected, orient):
class TestPandasContainer:
- @pytest.fixture
- def categorical_frame(self):
- data = {
- c: np.random.default_rng(i).standard_normal(30)
- for i, c in enumerate(list("ABCD"))
- }
- cat = ["bah"] * 5 + ["bar"] * 5 + ["baz"] * 5 + ["foo"] * 15
- data["E"] = list(reversed(cat))
- data["sort"] = np.arange(30, dtype="int64")
- return DataFrame(data, index=pd.CategoricalIndex(cat, name="E"))
-
@pytest.fixture
def datetime_series(self):
# Same as usual datetime_series, but with index freq set to None,
@@ -249,7 +238,7 @@ def test_roundtrip_str_axes(self, orient, convert_axes, dtype):
@pytest.mark.parametrize("convert_axes", [True, False])
def test_roundtrip_categorical(
- self, request, orient, categorical_frame, convert_axes, using_infer_string
+ self, request, orient, convert_axes, using_infer_string
):
# TODO: create a better frame to test with and improve coverage
if orient in ("index", "columns"):
@@ -259,6 +248,14 @@ def test_roundtrip_categorical(
)
)
+ data = {
+ c: np.random.default_rng(i).standard_normal(30)
+ for i, c in enumerate(list("ABCD"))
+ }
+ cat = ["bah"] * 5 + ["bar"] * 5 + ["baz"] * 5 + ["foo"] * 15
+ data["E"] = list(reversed(cat))
+ data["sort"] = np.arange(30, dtype="int64")
+ categorical_frame = DataFrame(data, index=pd.CategoricalIndex(cat, name="E"))
data = StringIO(categorical_frame.to_json(orient=orient))
result = read_json(data, orient=orient, convert_axes=convert_axes)
diff --git a/pandas/tests/io/sas/test_xport.py b/pandas/tests/io/sas/test_xport.py
index 766c9c37d55b9..30ca70d7e0009 100644
--- a/pandas/tests/io/sas/test_xport.py
+++ b/pandas/tests/io/sas/test_xport.py
@@ -19,31 +19,12 @@ def numeric_as_float(data):
class TestXport:
- @pytest.fixture
- def file01(self, datapath):
- return datapath("io", "sas", "data", "DEMO_G.xpt")
-
- @pytest.fixture
- def file02(self, datapath):
- return datapath("io", "sas", "data", "SSHSV1_A.xpt")
-
- @pytest.fixture
- def file03(self, datapath):
- return datapath("io", "sas", "data", "DRXFCD_G.xpt")
-
- @pytest.fixture
- def file04(self, datapath):
- return datapath("io", "sas", "data", "paxraw_d_short.xpt")
-
- @pytest.fixture
- def file05(self, datapath):
- return datapath("io", "sas", "data", "DEMO_PUF.cpt")
-
@pytest.mark.slow
- def test1_basic(self, file01):
+ def test1_basic(self, datapath):
# Tests with DEMO_G.xpt (all numeric file)
# Compare to this
+ file01 = datapath("io", "sas", "data", "DEMO_G.xpt")
data_csv = pd.read_csv(file01.replace(".xpt", ".csv"))
numeric_as_float(data_csv)
@@ -78,10 +59,11 @@ def test1_basic(self, file01):
data = read_sas(file01)
tm.assert_frame_equal(data, data_csv)
- def test1_index(self, file01):
+ def test1_index(self, datapath):
# Tests with DEMO_G.xpt using index (all numeric file)
# Compare to this
+ file01 = datapath("io", "sas", "data", "DEMO_G.xpt")
data_csv = pd.read_csv(file01.replace(".xpt", ".csv"))
data_csv = data_csv.set_index("SEQN")
numeric_as_float(data_csv)
@@ -100,9 +82,10 @@ def test1_index(self, file01):
data = reader.get_chunk()
tm.assert_frame_equal(data, data_csv.iloc[0:10, :], check_index_type=False)
- def test1_incremental(self, file01):
+ def test1_incremental(self, datapath):
# Test with DEMO_G.xpt, reading full file incrementally
+ file01 = datapath("io", "sas", "data", "DEMO_G.xpt")
data_csv = pd.read_csv(file01.replace(".xpt", ".csv"))
data_csv = data_csv.set_index("SEQN")
numeric_as_float(data_csv)
@@ -113,9 +96,10 @@ def test1_incremental(self, file01):
tm.assert_frame_equal(data, data_csv, check_index_type=False)
- def test2(self, file02):
+ def test2(self, datapath):
# Test with SSHSV1_A.xpt
+ file02 = datapath("io", "sas", "data", "SSHSV1_A.xpt")
# Compare to this
data_csv = pd.read_csv(file02.replace(".xpt", ".csv"))
numeric_as_float(data_csv)
@@ -123,10 +107,11 @@ def test2(self, file02):
data = read_sas(file02)
tm.assert_frame_equal(data, data_csv)
- def test2_binary(self, file02):
+ def test2_binary(self, datapath):
# Test with SSHSV1_A.xpt, read as a binary file
# Compare to this
+ file02 = datapath("io", "sas", "data", "SSHSV1_A.xpt")
data_csv = pd.read_csv(file02.replace(".xpt", ".csv"))
numeric_as_float(data_csv)
@@ -137,31 +122,32 @@ def test2_binary(self, file02):
tm.assert_frame_equal(data, data_csv)
- def test_multiple_types(self, file03):
+ def test_multiple_types(self, datapath):
# Test with DRXFCD_G.xpt (contains text and numeric variables)
# Compare to this
+ file03 = datapath("io", "sas", "data", "DRXFCD_G.xpt")
data_csv = pd.read_csv(file03.replace(".xpt", ".csv"))
data = read_sas(file03, encoding="utf-8")
tm.assert_frame_equal(data, data_csv)
- def test_truncated_float_support(self, file04):
+ def test_truncated_float_support(self, datapath):
# Test with paxraw_d_short.xpt, a shortened version of:
# http://wwwn.cdc.gov/Nchs/Nhanes/2005-2006/PAXRAW_D.ZIP
# This file has truncated floats (5 bytes in this case).
# GH 11713
-
+ file04 = datapath("io", "sas", "data", "paxraw_d_short.xpt")
data_csv = pd.read_csv(file04.replace(".xpt", ".csv"))
data = read_sas(file04, format="xport")
tm.assert_frame_equal(data.astype("int64"), data_csv)
- def test_cport_header_found_raises(self, file05):
+ def test_cport_header_found_raises(self, datapath):
# Test with DEMO_PUF.cpt, the beginning of puf2019_1_fall.xpt
# from https://www.cms.gov/files/zip/puf2019.zip
# (despite the extension, it's a cpt file)
msg = "Header record indicates a CPORT file, which is not readable."
with pytest.raises(ValueError, match=msg):
- read_sas(file05, format="xport")
+ read_sas(datapath("io", "sas", "data", "DEMO_PUF.cpt"), format="xport")
diff --git a/pandas/tests/io/test_orc.py b/pandas/tests/io/test_orc.py
index a4021311fc963..b4a8c713d99ab 100644
--- a/pandas/tests/io/test_orc.py
+++ b/pandas/tests/io/test_orc.py
@@ -27,21 +27,6 @@ def dirpath(datapath):
return datapath("io", "data", "orc")
-@pytest.fixture(
- params=[
- np.array([1, 20], dtype="uint64"),
- pd.Series(["a", "b", "a"], dtype="category"),
- [pd.Interval(left=0, right=2), pd.Interval(left=0, right=5)],
- [pd.Period("2022-01-03", freq="D"), pd.Period("2022-01-04", freq="D")],
- ]
-)
-def orc_writer_dtypes_not_supported(request):
- # Examples of dataframes with dtypes for which conversion to ORC
- # hasn't been implemented yet, that is, Category, unsigned integers,
- # interval, period and sparse.
- return pd.DataFrame({"unimpl": request.param})
-
-
def test_orc_reader_empty(dirpath):
columns = [
"boolean1",
@@ -294,14 +279,24 @@ def test_orc_roundtrip_bytesio():
tm.assert_equal(expected, got)
+@pytest.mark.parametrize(
+ "orc_writer_dtypes_not_supported",
+ [
+ np.array([1, 20], dtype="uint64"),
+ pd.Series(["a", "b", "a"], dtype="category"),
+ [pd.Interval(left=0, right=2), pd.Interval(left=0, right=5)],
+ [pd.Period("2022-01-03", freq="D"), pd.Period("2022-01-04", freq="D")],
+ ],
+)
def test_orc_writer_dtypes_not_supported(orc_writer_dtypes_not_supported):
# GH44554
# PyArrow gained ORC write support with the current argument order
pytest.importorskip("pyarrow")
+ df = pd.DataFrame({"unimpl": orc_writer_dtypes_not_supported})
msg = "The dtype of one or more columns is not supported yet."
with pytest.raises(NotImplementedError, match=msg):
- orc_writer_dtypes_not_supported.to_orc()
+ df.to_orc()
def test_orc_dtype_backend_pyarrow():
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index e6488bcc4568f..21a38c43f4294 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -44,54 +44,6 @@ def get_test_data(ngroups=8, n=50):
return arr
-def get_series():
- return [
- Series([1], dtype="int64"),
- Series([1], dtype="Int64"),
- Series([1.23]),
- Series(["foo"]),
- Series([True]),
- Series([pd.Timestamp("2018-01-01")]),
- Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
- ]
-
-
-def get_series_na():
- return [
- Series([np.nan], dtype="Int64"),
- Series([np.nan], dtype="float"),
- Series([np.nan], dtype="object"),
- Series([pd.NaT]),
- ]
-
-
-@pytest.fixture(params=get_series(), ids=lambda x: x.dtype.name)
-def series_of_dtype(request):
- """
- A parametrized fixture returning a variety of Series of different
- dtypes
- """
- return request.param
-
-
-@pytest.fixture(params=get_series(), ids=lambda x: x.dtype.name)
-def series_of_dtype2(request):
- """
- A duplicate of the series_of_dtype fixture, so that it can be used
- twice by a single function
- """
- return request.param
-
-
-@pytest.fixture(params=get_series_na(), ids=lambda x: x.dtype.name)
-def series_of_dtype_all_na(request):
- """
- A parametrized fixture returning a variety of Series with all NA
- values
- """
- return request.param
-
-
@pytest.fixture
def dfs_for_indicator():
df1 = DataFrame({"col1": [0, 1], "col_conflict": [1, 2], "col_left": ["a", "b"]})
@@ -140,13 +92,6 @@ def left(self):
}
)
- @pytest.fixture
- def right(self):
- return DataFrame(
- {"v2": np.random.default_rng(2).standard_normal(4)},
- index=["d", "b", "c", "a"],
- )
-
def test_merge_inner_join_empty(self):
# GH 15328
df_empty = DataFrame()
@@ -230,7 +175,11 @@ def test_merge_index_singlekey_inner(self):
expected = left.join(right, on="key").loc[result.index]
tm.assert_frame_equal(result, expected.loc[:, result.columns])
- def test_merge_misspecified(self, df, df2, left, right):
+ def test_merge_misspecified(self, df, df2, left):
+ right = DataFrame(
+ {"v2": np.random.default_rng(2).standard_normal(4)},
+ index=["d", "b", "c", "a"],
+ )
msg = "Must pass right_on or right_index=True"
with pytest.raises(pd.errors.MergeError, match=msg):
merge(left, right, left_index=True)
@@ -571,6 +520,30 @@ def check2(exp, kwarg):
check1(exp_in, kwarg)
check2(exp_out, kwarg)
+ @pytest.mark.parametrize(
+ "series_of_dtype",
+ [
+ Series([1], dtype="int64"),
+ Series([1], dtype="Int64"),
+ Series([1.23]),
+ Series(["foo"]),
+ Series([True]),
+ Series([pd.Timestamp("2018-01-01")]),
+ Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
+ ],
+ )
+ @pytest.mark.parametrize(
+ "series_of_dtype2",
+ [
+ Series([1], dtype="int64"),
+ Series([1], dtype="Int64"),
+ Series([1.23]),
+ Series(["foo"]),
+ Series([True]),
+ Series([pd.Timestamp("2018-01-01")]),
+ Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
+ ],
+ )
def test_merge_empty_frame(self, series_of_dtype, series_of_dtype2):
# GH 25183
df = DataFrame(
@@ -589,6 +562,27 @@ def test_merge_empty_frame(self, series_of_dtype, series_of_dtype2):
actual = df_empty.merge(df, on="key")
tm.assert_frame_equal(actual, expected)
+ @pytest.mark.parametrize(
+ "series_of_dtype",
+ [
+ Series([1], dtype="int64"),
+ Series([1], dtype="Int64"),
+ Series([1.23]),
+ Series(["foo"]),
+ Series([True]),
+ Series([pd.Timestamp("2018-01-01")]),
+ Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
+ ],
+ )
+ @pytest.mark.parametrize(
+ "series_of_dtype_all_na",
+ [
+ Series([np.nan], dtype="Int64"),
+ Series([np.nan], dtype="float"),
+ Series([np.nan], dtype="object"),
+ Series([pd.NaT]),
+ ],
+ )
def test_merge_all_na_column(self, series_of_dtype, series_of_dtype_all_na):
# GH 25183
df_left = DataFrame(
@@ -2134,16 +2128,6 @@ def test_merge_on_int_array(self):
tm.assert_frame_equal(result, expected)
-@pytest.fixture
-def left_df():
- return DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
-
-
-@pytest.fixture
-def right_df():
- return DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
-
-
class TestMergeOnIndexes:
@pytest.mark.parametrize(
"how, sort, expected",
@@ -2192,7 +2176,9 @@ class TestMergeOnIndexes:
),
],
)
- def test_merge_on_indexes(self, left_df, right_df, how, sort, expected):
+ def test_merge_on_indexes(self, how, sort, expected):
+ left_df = DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
+ right_df = DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
result = merge(
left_df, right_df, left_index=True, right_index=True, how=how, sort=sort
)
diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py
index 33502f576dd2f..00df8064d5190 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -604,486 +604,6 @@ def tolerance(self):
df["ask"] = df["ask"].astype("float64")
return self.prep_data(df)
- @pytest.fixture
- def allow_exact_matches(self, datapath):
- df = pd.DataFrame(
- [
- [
- "20160525 13:30:00.023",
- "MSFT",
- "51.95",
- "75",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.038",
- "MSFT",
- "51.95",
- "155",
- "NASDAQ",
- "51.95",
- "51.95",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.77",
- "100",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.92",
- "100",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.93",
- "200",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.93",
- "300",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.93",
- "600",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.93",
- "44",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.074",
- "AAPL",
- "98.67",
- "478343",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.67",
- "478343",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.66",
- "6",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "30",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "75",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "20",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "35",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "10",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
- ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "1000",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "200",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "300",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "400",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "600",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "200",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.078",
- "MSFT",
- "51.95",
- "783",
- "NASDAQ",
- "51.95",
- "51.95",
- ],
- [
- "20160525 13:30:00.078",
- "MSFT",
- "51.95",
- "100",
- "NASDAQ",
- "51.95",
- "51.95",
- ],
- [
- "20160525 13:30:00.078",
- "MSFT",
- "51.95",
- "100",
- "NASDAQ",
- "51.95",
- "51.95",
- ],
- ],
- columns="time,ticker,price,quantity,marketCenter,bid,ask".split(","),
- )
- df["price"] = df["price"].astype("float64")
- df["quantity"] = df["quantity"].astype("int64")
- df["bid"] = df["bid"].astype("float64")
- df["ask"] = df["ask"].astype("float64")
- return self.prep_data(df)
-
- @pytest.fixture
- def allow_exact_matches_and_tolerance(self):
- df = pd.DataFrame(
- [
- [
- "20160525 13:30:00.023",
- "MSFT",
- "51.95",
- "75",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.038",
- "MSFT",
- "51.95",
- "155",
- "NASDAQ",
- "51.95",
- "51.95",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.77",
- "100",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.92",
- "100",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.93",
- "200",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.93",
- "300",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.93",
- "600",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.048",
- "GOOG",
- "720.93",
- "44",
- "NASDAQ",
- "720.5",
- "720.93",
- ],
- [
- "20160525 13:30:00.074",
- "AAPL",
- "98.67",
- "478343",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.67",
- "478343",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.66",
- "6",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "30",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "75",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "20",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "35",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- [
- "20160525 13:30:00.075",
- "AAPL",
- "98.65",
- "10",
- "NASDAQ",
- np.nan,
- np.nan,
- ],
- ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
- ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "1000",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "200",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "300",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "400",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "600",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.076",
- "AAPL",
- "98.56",
- "200",
- "ARCA",
- "98.55",
- "98.56",
- ],
- [
- "20160525 13:30:00.078",
- "MSFT",
- "51.95",
- "783",
- "NASDAQ",
- "51.95",
- "51.95",
- ],
- [
- "20160525 13:30:00.078",
- "MSFT",
- "51.95",
- "100",
- "NASDAQ",
- "51.95",
- "51.95",
- ],
- [
- "20160525 13:30:00.078",
- "MSFT",
- "51.95",
- "100",
- "NASDAQ",
- "51.95",
- "51.95",
- ],
- ],
- columns="time,ticker,price,quantity,marketCenter,bid,ask".split(","),
- )
- df["price"] = df["price"].astype("float64")
- df["quantity"] = df["quantity"].astype("int64")
- df["bid"] = df["bid"].astype("float64")
- df["ask"] = df["ask"].astype("float64")
- return self.prep_data(df)
-
def test_examples1(self):
"""doc-string examples"""
left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
@@ -2620,11 +2140,247 @@ def test_index_tolerance(self, trades, quotes, tolerance):
)
tm.assert_frame_equal(result, expected)
- def test_allow_exact_matches(self, trades, quotes, allow_exact_matches):
+ def test_allow_exact_matches(self, trades, quotes):
result = merge_asof(
trades, quotes, on="time", by="ticker", allow_exact_matches=False
)
- expected = allow_exact_matches
+ df = pd.DataFrame(
+ [
+ [
+ "20160525 13:30:00.023",
+ "MSFT",
+ "51.95",
+ "75",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.038",
+ "MSFT",
+ "51.95",
+ "155",
+ "NASDAQ",
+ "51.95",
+ "51.95",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.77",
+ "100",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.92",
+ "100",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.93",
+ "200",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.93",
+ "300",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.93",
+ "600",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.93",
+ "44",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.074",
+ "AAPL",
+ "98.67",
+ "478343",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.67",
+ "478343",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.66",
+ "6",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "30",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "75",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "20",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "35",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "10",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
+ ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "1000",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "200",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "300",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "400",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "600",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "200",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.078",
+ "MSFT",
+ "51.95",
+ "783",
+ "NASDAQ",
+ "51.95",
+ "51.95",
+ ],
+ [
+ "20160525 13:30:00.078",
+ "MSFT",
+ "51.95",
+ "100",
+ "NASDAQ",
+ "51.95",
+ "51.95",
+ ],
+ [
+ "20160525 13:30:00.078",
+ "MSFT",
+ "51.95",
+ "100",
+ "NASDAQ",
+ "51.95",
+ "51.95",
+ ],
+ ],
+ columns="time,ticker,price,quantity,marketCenter,bid,ask".split(","),
+ )
+ df["price"] = df["price"].astype("float64")
+ df["quantity"] = df["quantity"].astype("int64")
+ df["bid"] = df["bid"].astype("float64")
+ df["ask"] = df["ask"].astype("float64")
+ expected = self.prep_data(df)
tm.assert_frame_equal(result, expected)
def test_allow_exact_matches_forward(self):
@@ -2657,9 +2413,7 @@ def test_allow_exact_matches_nearest(self):
)
tm.assert_frame_equal(result, expected)
- def test_allow_exact_matches_and_tolerance(
- self, trades, quotes, allow_exact_matches_and_tolerance
- ):
+ def test_allow_exact_matches_and_tolerance(self, trades, quotes):
result = merge_asof(
trades,
quotes,
@@ -2668,7 +2422,243 @@ def test_allow_exact_matches_and_tolerance(
tolerance=Timedelta("100ms"),
allow_exact_matches=False,
)
- expected = allow_exact_matches_and_tolerance
+ df = pd.DataFrame(
+ [
+ [
+ "20160525 13:30:00.023",
+ "MSFT",
+ "51.95",
+ "75",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.038",
+ "MSFT",
+ "51.95",
+ "155",
+ "NASDAQ",
+ "51.95",
+ "51.95",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.77",
+ "100",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.92",
+ "100",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.93",
+ "200",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.93",
+ "300",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.93",
+ "600",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.048",
+ "GOOG",
+ "720.93",
+ "44",
+ "NASDAQ",
+ "720.5",
+ "720.93",
+ ],
+ [
+ "20160525 13:30:00.074",
+ "AAPL",
+ "98.67",
+ "478343",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.67",
+ "478343",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.66",
+ "6",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "30",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "75",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "20",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "35",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ [
+ "20160525 13:30:00.075",
+ "AAPL",
+ "98.65",
+ "10",
+ "NASDAQ",
+ np.nan,
+ np.nan,
+ ],
+ ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
+ ["20160525 13:30:00.075", "AAPL", "98.55", "6", "ARCA", np.nan, np.nan],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "1000",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "200",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "300",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "400",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "600",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.076",
+ "AAPL",
+ "98.56",
+ "200",
+ "ARCA",
+ "98.55",
+ "98.56",
+ ],
+ [
+ "20160525 13:30:00.078",
+ "MSFT",
+ "51.95",
+ "783",
+ "NASDAQ",
+ "51.95",
+ "51.95",
+ ],
+ [
+ "20160525 13:30:00.078",
+ "MSFT",
+ "51.95",
+ "100",
+ "NASDAQ",
+ "51.95",
+ "51.95",
+ ],
+ [
+ "20160525 13:30:00.078",
+ "MSFT",
+ "51.95",
+ "100",
+ "NASDAQ",
+ "51.95",
+ "51.95",
+ ],
+ ],
+ columns="time,ticker,price,quantity,marketCenter,bid,ask".split(","),
+ )
+ df["price"] = df["price"].astype("float64")
+ df["quantity"] = df["quantity"].astype("int64")
+ df["bid"] = df["bid"].astype("float64")
+ df["ask"] = df["ask"].astype("float64")
+ expected = self.prep_data(df)
tm.assert_frame_equal(result, expected)
def test_allow_exact_matches_and_tolerance2(self):
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 6564ac0fd7e8a..af156a1da87f2 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -30,12 +30,6 @@
from pandas.core.reshape.pivot import pivot_table
-@pytest.fixture(params=[([0] * 4, [1] * 4), (range(3), range(1, 4))])
-def interval_values(request, closed):
- left, right = request.param
- return Categorical(pd.IntervalIndex.from_arrays(left, right, closed))
-
-
class TestPivotTable:
@pytest.fixture
def data(self):
@@ -303,8 +297,13 @@ def test_pivot_with_non_observable_dropna_multi_cat(self, dropna):
tm.assert_frame_equal(result, expected)
- def test_pivot_with_interval_index(self, interval_values, dropna):
+ @pytest.mark.parametrize(
+ "left_right", [([0] * 4, [1] * 4), (range(3), range(1, 4))]
+ )
+ def test_pivot_with_interval_index(self, left_right, dropna, closed):
# GH 25814
+ left, right = left_right
+ interval_values = Categorical(pd.IntervalIndex.from_arrays(left, right, closed))
df = DataFrame({"A": interval_values, "B": 1})
msg = "The default value of observed=False is deprecated"
diff --git a/pandas/tests/series/methods/test_convert_dtypes.py b/pandas/tests/series/methods/test_convert_dtypes.py
index b0a920ba02cad..f6f3a3b0fb07e 100644
--- a/pandas/tests/series/methods/test_convert_dtypes.py
+++ b/pandas/tests/series/methods/test_convert_dtypes.py
@@ -8,187 +8,180 @@
import pandas as pd
import pandas._testing as tm
-# Each test case consists of a tuple with the data and dtype to create the
-# test Series, the default dtype for the expected result (which is valid
-# for most cases), and the specific cases where the result deviates from
-# this default. Those overrides are defined as a dict with (keyword, val) as
-# dictionary key. In case of multiple items, the last override takes precedence.
-
-
-@pytest.fixture(
- params=[
- (
- # data
- [1, 2, 3],
- # original dtype
- np.dtype("int32"),
- # default expected dtype
- "Int32",
- # exceptions on expected dtype
- {("convert_integer", False): np.dtype("int32")},
- ),
- (
- [1, 2, 3],
- np.dtype("int64"),
- "Int64",
- {("convert_integer", False): np.dtype("int64")},
- ),
- (
- ["x", "y", "z"],
- np.dtype("O"),
- pd.StringDtype(),
- {("convert_string", False): np.dtype("O")},
- ),
- (
- [True, False, np.nan],
- np.dtype("O"),
- pd.BooleanDtype(),
- {("convert_boolean", False): np.dtype("O")},
- ),
- (
- ["h", "i", np.nan],
- np.dtype("O"),
- pd.StringDtype(),
- {("convert_string", False): np.dtype("O")},
- ),
- ( # GH32117
- ["h", "i", 1],
- np.dtype("O"),
- np.dtype("O"),
- {},
- ),
- (
- [10, np.nan, 20],
- np.dtype("float"),
- "Int64",
- {
- ("convert_integer", False, "convert_floating", True): "Float64",
- ("convert_integer", False, "convert_floating", False): np.dtype(
- "float"
- ),
- },
- ),
- (
- [np.nan, 100.5, 200],
- np.dtype("float"),
- "Float64",
- {("convert_floating", False): np.dtype("float")},
- ),
- (
- [3, 4, 5],
- "Int8",
- "Int8",
- {},
- ),
- (
- [[1, 2], [3, 4], [5]],
- None,
- np.dtype("O"),
- {},
- ),
- (
- [4, 5, 6],
- np.dtype("uint32"),
- "UInt32",
- {("convert_integer", False): np.dtype("uint32")},
- ),
- (
- [-10, 12, 13],
- np.dtype("i1"),
- "Int8",
- {("convert_integer", False): np.dtype("i1")},
- ),
- (
- [1.2, 1.3],
- np.dtype("float32"),
- "Float32",
- {("convert_floating", False): np.dtype("float32")},
- ),
- (
- [1, 2.0],
- object,
- "Int64",
- {
- ("convert_integer", False): "Float64",
- ("convert_integer", False, "convert_floating", False): np.dtype(
- "float"
- ),
- ("infer_objects", False): np.dtype("object"),
- },
- ),
- (
- [1, 2.5],
- object,
- "Float64",
- {
- ("convert_floating", False): np.dtype("float"),
- ("infer_objects", False): np.dtype("object"),
- },
- ),
- (["a", "b"], pd.CategoricalDtype(), pd.CategoricalDtype(), {}),
- (
- pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("s"),
- pd.DatetimeTZDtype(tz="UTC"),
- pd.DatetimeTZDtype(tz="UTC"),
- {},
- ),
- (
- pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ms"),
- pd.DatetimeTZDtype(tz="UTC"),
- pd.DatetimeTZDtype(tz="UTC"),
- {},
- ),
- (
- pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("us"),
- pd.DatetimeTZDtype(tz="UTC"),
- pd.DatetimeTZDtype(tz="UTC"),
- {},
- ),
- (
- pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
- pd.DatetimeTZDtype(tz="UTC"),
- pd.DatetimeTZDtype(tz="UTC"),
- {},
- ),
- (
- pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
- "datetime64[ns]",
- np.dtype("datetime64[ns]"),
- {},
- ),
- (
- pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
- object,
- np.dtype("datetime64[ns]"),
- {("infer_objects", False): np.dtype("object")},
- ),
- (
- pd.period_range("1/1/2011", freq="M", periods=3),
- None,
- pd.PeriodDtype("M"),
- {},
- ),
- (
- pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]),
- None,
- pd.IntervalDtype("int64", "right"),
- {},
- ),
- ]
-)
-def test_cases(request):
- return request.param
-
class TestSeriesConvertDtypes:
+ @pytest.mark.parametrize(
+ "data, maindtype, expected_default, expected_other",
+ [
+ (
+ # data
+ [1, 2, 3],
+ # original dtype
+ np.dtype("int32"),
+ # default expected dtype
+ "Int32",
+ # exceptions on expected dtype
+ {("convert_integer", False): np.dtype("int32")},
+ ),
+ (
+ [1, 2, 3],
+ np.dtype("int64"),
+ "Int64",
+ {("convert_integer", False): np.dtype("int64")},
+ ),
+ (
+ ["x", "y", "z"],
+ np.dtype("O"),
+ pd.StringDtype(),
+ {("convert_string", False): np.dtype("O")},
+ ),
+ (
+ [True, False, np.nan],
+ np.dtype("O"),
+ pd.BooleanDtype(),
+ {("convert_boolean", False): np.dtype("O")},
+ ),
+ (
+ ["h", "i", np.nan],
+ np.dtype("O"),
+ pd.StringDtype(),
+ {("convert_string", False): np.dtype("O")},
+ ),
+ ( # GH32117
+ ["h", "i", 1],
+ np.dtype("O"),
+ np.dtype("O"),
+ {},
+ ),
+ (
+ [10, np.nan, 20],
+ np.dtype("float"),
+ "Int64",
+ {
+ ("convert_integer", False, "convert_floating", True): "Float64",
+ ("convert_integer", False, "convert_floating", False): np.dtype(
+ "float"
+ ),
+ },
+ ),
+ (
+ [np.nan, 100.5, 200],
+ np.dtype("float"),
+ "Float64",
+ {("convert_floating", False): np.dtype("float")},
+ ),
+ (
+ [3, 4, 5],
+ "Int8",
+ "Int8",
+ {},
+ ),
+ (
+ [[1, 2], [3, 4], [5]],
+ None,
+ np.dtype("O"),
+ {},
+ ),
+ (
+ [4, 5, 6],
+ np.dtype("uint32"),
+ "UInt32",
+ {("convert_integer", False): np.dtype("uint32")},
+ ),
+ (
+ [-10, 12, 13],
+ np.dtype("i1"),
+ "Int8",
+ {("convert_integer", False): np.dtype("i1")},
+ ),
+ (
+ [1.2, 1.3],
+ np.dtype("float32"),
+ "Float32",
+ {("convert_floating", False): np.dtype("float32")},
+ ),
+ (
+ [1, 2.0],
+ object,
+ "Int64",
+ {
+ ("convert_integer", False): "Float64",
+ ("convert_integer", False, "convert_floating", False): np.dtype(
+ "float"
+ ),
+ ("infer_objects", False): np.dtype("object"),
+ },
+ ),
+ (
+ [1, 2.5],
+ object,
+ "Float64",
+ {
+ ("convert_floating", False): np.dtype("float"),
+ ("infer_objects", False): np.dtype("object"),
+ },
+ ),
+ (["a", "b"], pd.CategoricalDtype(), pd.CategoricalDtype(), {}),
+ (
+ pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("s"),
+ pd.DatetimeTZDtype(tz="UTC"),
+ pd.DatetimeTZDtype(tz="UTC"),
+ {},
+ ),
+ (
+ pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ms"),
+ pd.DatetimeTZDtype(tz="UTC"),
+ pd.DatetimeTZDtype(tz="UTC"),
+ {},
+ ),
+ (
+ pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("us"),
+ pd.DatetimeTZDtype(tz="UTC"),
+ pd.DatetimeTZDtype(tz="UTC"),
+ {},
+ ),
+ (
+ pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
+ pd.DatetimeTZDtype(tz="UTC"),
+ pd.DatetimeTZDtype(tz="UTC"),
+ {},
+ ),
+ (
+ pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
+ "datetime64[ns]",
+ np.dtype("datetime64[ns]"),
+ {},
+ ),
+ (
+ pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]).as_unit("ns"),
+ object,
+ np.dtype("datetime64[ns]"),
+ {("infer_objects", False): np.dtype("object")},
+ ),
+ (
+ pd.period_range("1/1/2011", freq="M", periods=3),
+ None,
+ pd.PeriodDtype("M"),
+ {},
+ ),
+ (
+ pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]),
+ None,
+ pd.IntervalDtype("int64", "right"),
+ {},
+ ),
+ ],
+ )
@pytest.mark.parametrize("params", product(*[(True, False)] * 5))
def test_convert_dtypes(
self,
- test_cases,
+ data,
+ maindtype,
+ expected_default,
+ expected_other,
params,
using_infer_string,
):
- data, maindtype, expected_default, expected_other = test_cases
if (
hasattr(data, "dtype")
and lib.is_np_dtype(data.dtype, "M")
diff --git a/pandas/tests/series/methods/test_nlargest.py b/pandas/tests/series/methods/test_nlargest.py
index e8de1cd89e397..bf13ea04ca9f9 100644
--- a/pandas/tests/series/methods/test_nlargest.py
+++ b/pandas/tests/series/methods/test_nlargest.py
@@ -2,8 +2,6 @@
Note: for naming purposes, most tests are title with as e.g. "test_nlargest_foo"
but are implicitly also testing nsmallest_foo.
"""
-from itertools import product
-
import numpy as np
import pytest
@@ -11,68 +9,6 @@
from pandas import Series
import pandas._testing as tm
-main_dtypes = [
- "datetime",
- "datetimetz",
- "timedelta",
- "int8",
- "int16",
- "int32",
- "int64",
- "float32",
- "float64",
- "uint8",
- "uint16",
- "uint32",
- "uint64",
-]
-
-
-@pytest.fixture
-def s_main_dtypes():
- """
- A DataFrame with many dtypes
-
- * datetime
- * datetimetz
- * timedelta
- * [u]int{8,16,32,64}
- * float{32,64}
-
- The columns are the name of the dtype.
- """
- df = pd.DataFrame(
- {
- "datetime": pd.to_datetime(["2003", "2002", "2001", "2002", "2005"]),
- "datetimetz": pd.to_datetime(
- ["2003", "2002", "2001", "2002", "2005"]
- ).tz_localize("US/Eastern"),
- "timedelta": pd.to_timedelta(["3d", "2d", "1d", "2d", "5d"]),
- }
- )
-
- for dtype in [
- "int8",
- "int16",
- "int32",
- "int64",
- "float32",
- "float64",
- "uint8",
- "uint16",
- "uint32",
- "uint64",
- ]:
- df[dtype] = Series([3, 2, 1, 2, 5], dtype=dtype)
-
- return df
-
-
-@pytest.fixture(params=main_dtypes)
-def s_main_dtypes_split(request, s_main_dtypes):
- """Each series in s_main_dtypes."""
- return s_main_dtypes[request.param]
-
def assert_check_nselect_boundary(vals, dtype, method):
# helper function for 'test_boundary_{dtype}' tests
@@ -96,19 +32,36 @@ class TestSeriesNLargestNSmallest:
Series(list("abcde"), dtype="category"),
],
)
- def test_nlargest_error(self, r):
+ @pytest.mark.parametrize("method", ["nlargest", "nsmallest"])
+ @pytest.mark.parametrize("arg", [2, 5, 0, -1])
+ def test_nlargest_error(self, r, method, arg):
dt = r.dtype
msg = f"Cannot use method 'n(largest|smallest)' with dtype {dt}"
- args = 2, len(r), 0, -1
- methods = r.nlargest, r.nsmallest
- for method, arg in product(methods, args):
- with pytest.raises(TypeError, match=msg):
- method(arg)
+ with pytest.raises(TypeError, match=msg):
+ getattr(r, method)(arg)
- def test_nsmallest_nlargest(self, s_main_dtypes_split):
+ @pytest.mark.parametrize(
+ "data",
+ [
+ pd.to_datetime(["2003", "2002", "2001", "2002", "2005"]),
+ pd.to_datetime(["2003", "2002", "2001", "2002", "2005"], utc=True),
+ pd.to_timedelta(["3d", "2d", "1d", "2d", "5d"]),
+ np.array([3, 2, 1, 2, 5], dtype="int8"),
+ np.array([3, 2, 1, 2, 5], dtype="int16"),
+ np.array([3, 2, 1, 2, 5], dtype="int32"),
+ np.array([3, 2, 1, 2, 5], dtype="int64"),
+ np.array([3, 2, 1, 2, 5], dtype="uint8"),
+ np.array([3, 2, 1, 2, 5], dtype="uint16"),
+ np.array([3, 2, 1, 2, 5], dtype="uint32"),
+ np.array([3, 2, 1, 2, 5], dtype="uint64"),
+ np.array([3, 2, 1, 2, 5], dtype="float32"),
+ np.array([3, 2, 1, 2, 5], dtype="float64"),
+ ],
+ )
+ def test_nsmallest_nlargest(self, data):
# float, int, datetime64 (use i8), timedelts64 (same),
# object that are numbers, object that are strings
- ser = s_main_dtypes_split
+ ser = Series(data)
tm.assert_series_equal(ser.nsmallest(2), ser.iloc[[2, 1]])
tm.assert_series_equal(ser.nsmallest(2, keep="last"), ser.iloc[[2, 3]])
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index 51ce73ef54300..10776fe5d050f 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -2,6 +2,7 @@
Testing that we work in the downstream packages
"""
import array
+from functools import partial
import subprocess
import sys
@@ -9,7 +10,6 @@
import pytest
from pandas.errors import IntCastingNaNError
-import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
@@ -261,46 +261,25 @@ def __radd__(self, other):
assert right + left is left
-@pytest.fixture(
- params=[
- "memoryview",
- "array",
- pytest.param("dask", marks=td.skip_if_no("dask.array")),
- pytest.param("xarray", marks=td.skip_if_no("xarray")),
- ]
-)
-def array_likes(request):
- """
- Fixture giving a numpy array and a parametrized 'data' object, which can
- be a memoryview, array, dask or xarray object created from the numpy array.
- """
- # GH#24539 recognize e.g xarray, dask, ...
- arr = np.array([1, 2, 3], dtype=np.int64)
-
- name = request.param
- if name == "memoryview":
- data = memoryview(arr)
- elif name == "array":
- data = array.array("i", arr)
- elif name == "dask":
- import dask.array
-
- data = dask.array.array(arr)
- elif name == "xarray":
- import xarray as xr
-
- data = xr.DataArray(arr)
-
- return arr, data
-
-
@pytest.mark.parametrize("dtype", ["M8[ns]", "m8[ns]"])
-def test_from_obscure_array(dtype, array_likes):
+@pytest.mark.parametrize(
+ "box", [memoryview, partial(array.array, "i"), "dask", "xarray"]
+)
+def test_from_obscure_array(dtype, box):
# GH#24539 recognize e.g xarray, dask, ...
# Note: we dont do this for PeriodArray bc _from_sequence won't accept
# an array of integers
# TODO: could check with arraylike of Period objects
- arr, data = array_likes
+ # GH#24539 recognize e.g xarray, dask, ...
+ arr = np.array([1, 2, 3], dtype=np.int64)
+ if box == "dask":
+ da = pytest.importorskip("dask.array")
+ data = da.array(arr)
+ elif box == "xarray":
+ xr = pytest.importorskip("xarray")
+ data = xr.DataArray(arr)
+ else:
+ data = box(arr)
cls = {"M8[ns]": DatetimeArray, "m8[ns]": TimedeltaArray}[dtype]
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 5b856bc632a1d..cb94427ae8961 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -3300,37 +3300,6 @@ def units(request):
return request.param
-@pytest.fixture
-def epoch_1960():
- """Timestamp at 1960-01-01."""
- return Timestamp("1960-01-01")
-
-
-@pytest.fixture
-def units_from_epochs():
- return list(range(5))
-
-
-@pytest.fixture(params=["timestamp", "pydatetime", "datetime64", "str_1960"])
-def epochs(epoch_1960, request):
- """Timestamp at 1960-01-01 in various forms.
-
- * Timestamp
- * datetime.datetime
- * numpy.datetime64
- * str
- """
- assert request.param in {"timestamp", "pydatetime", "datetime64", "str_1960"}
- if request.param == "timestamp":
- return epoch_1960
- elif request.param == "pydatetime":
- return epoch_1960.to_pydatetime()
- elif request.param == "datetime64":
- return epoch_1960.to_datetime64()
- else:
- return str(epoch_1960)
-
-
@pytest.fixture
def julian_dates():
return date_range("2014-1-1", periods=10).to_julian_date().values
@@ -3388,7 +3357,18 @@ def test_invalid_origin(self, unit):
with pytest.raises(ValueError, match=msg):
to_datetime("2005-01-01", origin="1960-01-01", unit=unit)
- def test_epoch(self, units, epochs, epoch_1960, units_from_epochs):
+ @pytest.mark.parametrize(
+ "epochs",
+ [
+ Timestamp(1960, 1, 1),
+ datetime(1960, 1, 1),
+ "1960-01-01",
+ np.datetime64("1960-01-01"),
+ ],
+ )
+ def test_epoch(self, units, epochs):
+ epoch_1960 = Timestamp(1960, 1, 1)
+ units_from_epochs = list(range(5))
expected = Series(
[pd.Timedelta(x, unit=units) + epoch_1960 for x in units_from_epochs]
)
@@ -3405,7 +3385,7 @@ def test_epoch(self, units, epochs, epoch_1960, units_from_epochs):
(datetime(1, 1, 1), OutOfBoundsDatetime),
],
)
- def test_invalid_origins(self, origin, exc, units, units_from_epochs):
+ def test_invalid_origins(self, origin, exc, units):
msg = "|".join(
[
f"origin {origin} is Out of Bounds",
@@ -3414,7 +3394,7 @@ def test_invalid_origins(self, origin, exc, units, units_from_epochs):
]
)
with pytest.raises(exc, match=msg):
- to_datetime(units_from_epochs, unit=units, origin=origin)
+ to_datetime(list(range(5)), unit=units, origin=origin)
def test_invalid_origins_tzinfo(self):
# GH16842
diff --git a/pandas/tests/tseries/offsets/test_common.py b/pandas/tests/tseries/offsets/test_common.py
index aa4e22f71ad66..3792878973c15 100644
--- a/pandas/tests/tseries/offsets/test_common.py
+++ b/pandas/tests/tseries/offsets/test_common.py
@@ -106,15 +106,6 @@ def _offset(request):
return request.param
-@pytest.fixture
-def dt(_offset):
- if _offset in (CBMonthBegin, CBMonthEnd, BDay):
- return Timestamp(2008, 1, 1)
- elif _offset is (CustomBusinessHour, BusinessHour):
- return Timestamp(2014, 7, 1, 10, 00)
- return Timestamp(2008, 1, 2)
-
-
def test_apply_out_of_range(request, tz_naive_fixture, _offset):
tz = tz_naive_fixture
diff --git a/pandas/tests/tseries/offsets/test_custom_business_month.py b/pandas/tests/tseries/offsets/test_custom_business_month.py
index d226302e042d3..b74b210c3b191 100644
--- a/pandas/tests/tseries/offsets/test_custom_business_month.py
+++ b/pandas/tests/tseries/offsets/test_custom_business_month.py
@@ -62,30 +62,18 @@ def test_copy(self, _offset):
class TestCustomBusinessMonthBegin:
- @pytest.fixture
- def _offset(self):
- return CBMonthBegin
-
- @pytest.fixture
- def offset(self):
- return CBMonthBegin()
-
- @pytest.fixture
- def offset2(self):
- return CBMonthBegin(2)
-
- def test_different_normalize_equals(self, _offset):
+ def test_different_normalize_equals(self):
# GH#21404 changed __eq__ to return False when `normalize` does not match
- offset = _offset()
- offset2 = _offset(normalize=True)
+ offset = CBMonthBegin()
+ offset2 = CBMonthBegin(normalize=True)
assert offset != offset2
- def test_repr(self, offset, offset2):
- assert repr(offset) == "<CustomBusinessMonthBegin>"
- assert repr(offset2) == "<2 * CustomBusinessMonthBegins>"
+ def test_repr(self):
+ assert repr(CBMonthBegin()) == "<CustomBusinessMonthBegin>"
+ assert repr(CBMonthBegin(2)) == "<2 * CustomBusinessMonthBegins>"
- def test_add_datetime(self, dt, offset2):
- assert offset2 + dt == datetime(2008, 3, 3)
+ def test_add_datetime(self, dt):
+ assert CBMonthBegin(2) + dt == datetime(2008, 3, 3)
def testRollback1(self):
assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31)
@@ -252,30 +240,18 @@ def test_apply_with_extra_offset(self, case):
class TestCustomBusinessMonthEnd:
- @pytest.fixture
- def _offset(self):
- return CBMonthEnd
-
- @pytest.fixture
- def offset(self):
- return CBMonthEnd()
-
- @pytest.fixture
- def offset2(self):
- return CBMonthEnd(2)
-
- def test_different_normalize_equals(self, _offset):
+ def test_different_normalize_equals(self):
# GH#21404 changed __eq__ to return False when `normalize` does not match
- offset = _offset()
- offset2 = _offset(normalize=True)
+ offset = CBMonthEnd()
+ offset2 = CBMonthEnd(normalize=True)
assert offset != offset2
- def test_repr(self, offset, offset2):
- assert repr(offset) == "<CustomBusinessMonthEnd>"
- assert repr(offset2) == "<2 * CustomBusinessMonthEnds>"
+ def test_repr(self):
+ assert repr(CBMonthEnd()) == "<CustomBusinessMonthEnd>"
+ assert repr(CBMonthEnd(2)) == "<2 * CustomBusinessMonthEnds>"
- def test_add_datetime(self, dt, offset2):
- assert offset2 + dt == datetime(2008, 2, 29)
+ def test_add_datetime(self, dt):
+ assert CBMonthEnd(2) + dt == datetime(2008, 2, 29)
def testRollback1(self):
assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31)
diff --git a/pandas/tests/util/test_assert_produces_warning.py b/pandas/tests/util/test_assert_produces_warning.py
index 5c27a3ee79d4a..88e9f0d8fccee 100644
--- a/pandas/tests/util/test_assert_produces_warning.py
+++ b/pandas/tests/util/test_assert_produces_warning.py
@@ -13,26 +13,6 @@
import pandas._testing as tm
-@pytest.fixture(
- params=[
- RuntimeWarning,
- ResourceWarning,
- UserWarning,
- FutureWarning,
- DeprecationWarning,
- PerformanceWarning,
- DtypeWarning,
- ],
-)
-def category(request):
- """
- Return unique warning.
-
- Useful for testing behavior of tm.assert_produces_warning with various categories.
- """
- return request.param
-
-
@pytest.fixture(
params=[
(RuntimeWarning, UserWarning),
@@ -73,6 +53,18 @@ def test_assert_produces_warning_honors_filter():
f()
+@pytest.mark.parametrize(
+ "category",
+ [
+ RuntimeWarning,
+ ResourceWarning,
+ UserWarning,
+ FutureWarning,
+ DeprecationWarning,
+ PerformanceWarning,
+ DtypeWarning,
+ ],
+)
@pytest.mark.parametrize(
"message, match",
[
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/56625 | 2023-12-26T19:42:27Z | 2024-01-03T00:49:57Z | 2024-01-03T00:49:57Z | 2024-01-03T00:50:00Z |
Backport PR #56617 on branch 2.2.x (TYP: some return types from ruff) | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 2a070e9a49b97..7f3fc95ce00cc 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -32,6 +32,8 @@ repos:
# TODO: remove autofixe-only rules when they are checked by ruff
name: ruff-selected-autofixes
alias: ruff-selected-autofixes
+ files: ^pandas
+ exclude: ^pandas/tests
args: [--select, "ANN001,ANN2", --fix-only, --exit-non-zero-on-fix]
- repo: https://github.com/jendrikseipp/vulture
rev: 'v2.10'
diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index d1481639ca5a0..5ee94b74c527e 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -431,7 +431,7 @@ Optional libraries below the lowest tested version may still work, but are not c
+-----------------+-----------------+---------+
| Package | Minimum Version | Changed |
+=================+=================+=========+
-| mypy (dev) | 1.7.1 | X |
+| mypy (dev) | 1.8.0 | X |
+-----------------+-----------------+---------+
| | | X |
+-----------------+-----------------+---------+
diff --git a/environment.yml b/environment.yml
index 74317d47e2e53..58eb69ad1f070 100644
--- a/environment.yml
+++ b/environment.yml
@@ -76,7 +76,7 @@ dependencies:
# code checks
- flake8=6.1.0 # run in subprocess over docstring examples
- - mypy=1.7.1 # pre-commit uses locally installed mypy
+ - mypy=1.8.0 # pre-commit uses locally installed mypy
- tokenize-rt # scripts/check_for_inconsistent_pandas_namespace.py
- pre-commit>=3.6.0
diff --git a/pandas/_testing/asserters.py b/pandas/_testing/asserters.py
index e342f76dc724b..800b03707540f 100644
--- a/pandas/_testing/asserters.py
+++ b/pandas/_testing/asserters.py
@@ -4,6 +4,7 @@
from typing import (
TYPE_CHECKING,
Literal,
+ NoReturn,
cast,
)
@@ -143,7 +144,7 @@ def assert_almost_equal(
)
-def _check_isinstance(left, right, cls):
+def _check_isinstance(left, right, cls) -> None:
"""
Helper method for our assert_* methods that ensures that
the two objects being compared have the right type before
@@ -576,7 +577,7 @@ def assert_timedelta_array_equal(
def raise_assert_detail(
obj, message, left, right, diff=None, first_diff=None, index_values=None
-):
+) -> NoReturn:
__tracebackhide__ = True
msg = f"""{obj} are different
@@ -664,7 +665,7 @@ def _get_base(obj):
if left_base is right_base:
raise AssertionError(f"{repr(left_base)} is {repr(right_base)}")
- def _raise(left, right, err_msg):
+ def _raise(left, right, err_msg) -> NoReturn:
if err_msg is None:
if left.shape != right.shape:
raise_assert_detail(
diff --git a/pandas/_version.py b/pandas/_version.py
index 5d610b5e1ea7e..f8a960630126d 100644
--- a/pandas/_version.py
+++ b/pandas/_version.py
@@ -386,7 +386,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
return pieces
-def plus_or_dot(pieces):
+def plus_or_dot(pieces) -> str:
"""Return a + if we don't already have one, else return a ."""
if "+" in pieces.get("closest-tag", ""):
return "."
diff --git a/pandas/core/computation/expr.py b/pandas/core/computation/expr.py
index 4770f403b1bdb..b5861fbaebe9c 100644
--- a/pandas/core/computation/expr.py
+++ b/pandas/core/computation/expr.py
@@ -695,8 +695,8 @@ def visit_Call(self, node, side=None, **kwargs):
if not isinstance(key, ast.keyword):
# error: "expr" has no attribute "id"
raise ValueError(
- "keyword error in function call " # type: ignore[attr-defined]
- f"'{node.func.id}'"
+ "keyword error in function call "
+ f"'{node.func.id}'" # type: ignore[attr-defined]
)
if key.arg:
diff --git a/pandas/io/html.py b/pandas/io/html.py
index 5d5bf079784be..26e71c9546ffd 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -269,7 +269,7 @@ def _attr_getter(self, obj, attr):
# Both lxml and BeautifulSoup have the same implementation:
return obj.get(attr)
- def _href_getter(self, obj):
+ def _href_getter(self, obj) -> str | None:
"""
Return a href if the DOM node contains a child <a> or None.
@@ -392,7 +392,7 @@ def _parse_tables(self, document, match, attrs):
"""
raise AbstractMethodError(self)
- def _equals_tag(self, obj, tag):
+ def _equals_tag(self, obj, tag) -> bool:
"""
Return whether an individual DOM node matches a tag
@@ -629,7 +629,7 @@ def _href_getter(self, obj) -> str | None:
def _text_getter(self, obj):
return obj.text
- def _equals_tag(self, obj, tag):
+ def _equals_tag(self, obj, tag) -> bool:
return obj.name == tag
def _parse_td(self, row):
@@ -758,7 +758,7 @@ def _parse_tables(self, document, match, kwargs):
raise ValueError(f"No tables found matching regex {repr(pattern)}")
return tables
- def _equals_tag(self, obj, tag):
+ def _equals_tag(self, obj, tag) -> bool:
return obj.tag == tag
def _build_doc(self):
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index ed66e46b300f7..4c490c6b2cda2 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -255,7 +255,7 @@ def __init__(
self.is_copy = None
self._format_axes()
- def _format_axes(self):
+ def _format_axes(self) -> None:
raise AbstractMethodError(self)
def write(self) -> str:
@@ -287,7 +287,7 @@ def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
else:
return self.obj
- def _format_axes(self):
+ def _format_axes(self) -> None:
if not self.obj.index.is_unique and self.orient == "index":
raise ValueError(f"Series index must be unique for orient='{self.orient}'")
@@ -304,7 +304,7 @@ def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
obj_to_write = self.obj
return obj_to_write
- def _format_axes(self):
+ def _format_axes(self) -> None:
"""
Try to format axes if they are datelike.
"""
@@ -1193,7 +1193,7 @@ def parse(self):
self._try_convert_types()
return self.obj
- def _parse(self):
+ def _parse(self) -> None:
raise AbstractMethodError(self)
@final
@@ -1217,7 +1217,7 @@ def _convert_axes(self) -> None:
new_axis = Index(new_ser, dtype=new_ser.dtype, copy=False)
setattr(self.obj, axis_name, new_axis)
- def _try_convert_types(self):
+ def _try_convert_types(self) -> None:
raise AbstractMethodError(self)
@final
diff --git a/pandas/io/parsers/arrow_parser_wrapper.py b/pandas/io/parsers/arrow_parser_wrapper.py
index 66a7ccacf675b..890b22154648e 100644
--- a/pandas/io/parsers/arrow_parser_wrapper.py
+++ b/pandas/io/parsers/arrow_parser_wrapper.py
@@ -41,7 +41,7 @@ def __init__(self, src: ReadBuffer[bytes], **kwds) -> None:
self._parse_kwds()
- def _parse_kwds(self):
+ def _parse_kwds(self) -> None:
"""
Validates keywords before passing to pyarrow.
"""
@@ -104,7 +104,7 @@ def _get_pyarrow_options(self) -> None:
] = None # PyArrow raises an exception by default
elif on_bad_lines == ParserBase.BadLineHandleMethod.WARN:
- def handle_warning(invalid_row):
+ def handle_warning(invalid_row) -> str:
warnings.warn(
f"Expected {invalid_row.expected_columns} columns, but found "
f"{invalid_row.actual_columns}: {invalid_row.text}",
@@ -219,7 +219,7 @@ def _finalize_pandas_output(self, frame: DataFrame) -> DataFrame:
raise ValueError(e)
return frame
- def _validate_usecols(self, usecols):
+ def _validate_usecols(self, usecols) -> None:
if lib.is_list_like(usecols) and not all(isinstance(x, str) for x in usecols):
raise ValueError(
"The pyarrow engine does not allow 'usecols' to be integer "
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 50611197ad7dd..1139519d2bcd3 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -1707,7 +1707,7 @@ def info(self) -> str:
# ------------------------------------------------------------------------
# private methods
- def _check_if_open(self):
+ def _check_if_open(self) -> None:
if not self.is_open:
raise ClosedFileError(f"{self._path} file is not open!")
diff --git a/pandas/io/sas/sas_xport.py b/pandas/io/sas/sas_xport.py
index e68f4789f0a06..11b2ed0ee7316 100644
--- a/pandas/io/sas/sas_xport.py
+++ b/pandas/io/sas/sas_xport.py
@@ -288,7 +288,7 @@ def close(self) -> None:
def _get_row(self):
return self.filepath_or_buffer.read(80).decode()
- def _read_header(self):
+ def _read_header(self) -> None:
self.filepath_or_buffer.seek(0)
# read file header
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index b0fa6bc6e90c4..3a58daf681cfb 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -1514,7 +1514,7 @@ def _create_sql_schema(
keys: list[str] | None = None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
pass
@@ -2073,7 +2073,7 @@ def _create_sql_schema(
keys: list[str] | None = None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
table = SQLTable(
table_name,
self,
@@ -2433,7 +2433,7 @@ def _create_sql_schema(
keys: list[str] | None = None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
raise NotImplementedError("not implemented for adbc")
@@ -2879,7 +2879,7 @@ def _create_sql_schema(
keys=None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
table = SQLiteTable(
table_name,
self,
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index 0f097c6059c7c..a4d8054ea4f8c 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -687,7 +687,7 @@ def __init__(
self._prepare_value_labels()
- def _prepare_value_labels(self):
+ def _prepare_value_labels(self) -> None:
"""Encode value labels."""
self.text_len = 0
diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py
index 479a5e19dc1c5..2979903edf360 100644
--- a/pandas/plotting/_matplotlib/core.py
+++ b/pandas/plotting/_matplotlib/core.py
@@ -662,7 +662,7 @@ def _ensure_frame(self, data) -> DataFrame:
return data
@final
- def _compute_plot_data(self):
+ def _compute_plot_data(self) -> None:
data = self.data
# GH15079 reconstruct data if by is defined
@@ -699,7 +699,7 @@ def _compute_plot_data(self):
self.data = numeric_data.apply(type(self)._convert_to_ndarray)
- def _make_plot(self, fig: Figure):
+ def _make_plot(self, fig: Figure) -> None:
raise AbstractMethodError(self)
@final
@@ -745,7 +745,7 @@ def _post_plot_logic(self, ax: Axes, data) -> None:
"""Post process for each axes. Overridden in child classes"""
@final
- def _adorn_subplots(self, fig: Figure):
+ def _adorn_subplots(self, fig: Figure) -> None:
"""Common post process unrelated to data"""
if len(self.axes) > 0:
all_axes = self._get_subplots(fig)
@@ -1323,7 +1323,7 @@ def __init__(
c = self.data.columns[c]
self.c = c
- def _make_plot(self, fig: Figure):
+ def _make_plot(self, fig: Figure) -> None:
x, y, c, data = self.x, self.y, self.c, self.data
ax = self.axes[0]
diff --git a/pandas/util/_validators.py b/pandas/util/_validators.py
index a47f622216ef7..cb0b4d549f49e 100644
--- a/pandas/util/_validators.py
+++ b/pandas/util/_validators.py
@@ -26,7 +26,7 @@
BoolishNoneT = TypeVar("BoolishNoneT", bool, int, None)
-def _check_arg_length(fname, args, max_fname_arg_count, compat_args):
+def _check_arg_length(fname, args, max_fname_arg_count, compat_args) -> None:
"""
Checks whether 'args' has length of at most 'compat_args'. Raises
a TypeError if that is not the case, similar to in Python when a
@@ -46,7 +46,7 @@ def _check_arg_length(fname, args, max_fname_arg_count, compat_args):
)
-def _check_for_default_values(fname, arg_val_dict, compat_args):
+def _check_for_default_values(fname, arg_val_dict, compat_args) -> None:
"""
Check that the keys in `arg_val_dict` are mapped to their
default values as specified in `compat_args`.
@@ -125,7 +125,7 @@ def validate_args(fname, args, max_fname_arg_count, compat_args) -> None:
_check_for_default_values(fname, kwargs, compat_args)
-def _check_for_invalid_keys(fname, kwargs, compat_args):
+def _check_for_invalid_keys(fname, kwargs, compat_args) -> None:
"""
Checks whether 'kwargs' contains any keys that are not
in 'compat_args' and raises a TypeError if there is one.
diff --git a/requirements-dev.txt b/requirements-dev.txt
index cbfb6336b2e16..5a63e59e1db88 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -53,7 +53,7 @@ moto
flask
asv>=0.6.1
flake8==6.1.0
-mypy==1.7.1
+mypy==1.8.0
tokenize-rt
pre-commit>=3.6.0
gitpython
| Backport PR #56617: TYP: some return types from ruff | https://api.github.com/repos/pandas-dev/pandas/pulls/56624 | 2023-12-26T19:38:30Z | 2023-12-26T23:50:48Z | 2023-12-26T23:50:48Z | 2023-12-26T23:50:48Z |
DEPR: Remove array manager branches from tests | diff --git a/pandas/conftest.py b/pandas/conftest.py
index 983272d79081e..046cda259eefd 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -1877,14 +1877,6 @@ def indexer_ial(request):
return request.param
-@pytest.fixture
-def using_array_manager() -> bool:
- """
- Fixture to check if the array manager is being used.
- """
- return _get_option("mode.data_manager", silent=True) == "array"
-
-
@pytest.fixture
def using_copy_on_write() -> bool:
"""
diff --git a/pandas/tests/apply/test_frame_apply.py b/pandas/tests/apply/test_frame_apply.py
index b7eac6b8f0ea1..0839f005305a5 100644
--- a/pandas/tests/apply/test_frame_apply.py
+++ b/pandas/tests/apply/test_frame_apply.py
@@ -1487,7 +1487,7 @@ def test_apply_dtype(col):
tm.assert_series_equal(result, expected)
-def test_apply_mutating(using_array_manager, using_copy_on_write, warn_copy_on_write):
+def test_apply_mutating(using_copy_on_write, warn_copy_on_write):
# GH#35462 case where applied func pins a new BlockManager to a row
df = DataFrame({"a": range(100), "b": range(100, 200)})
df_orig = df.copy()
@@ -1505,7 +1505,7 @@ def func(row):
result = df.apply(func, axis=1)
tm.assert_frame_equal(result, expected)
- if using_copy_on_write or using_array_manager:
+ if using_copy_on_write:
# INFO(CoW) With copy on write, mutating a viewing row doesn't mutate the parent
# INFO(ArrayManager) With BlockManager, the row is a view and mutated in place,
# with ArrayManager the row is not a view, and thus not mutated in place
diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index d8c1786b6b422..ebcd7cbd963d7 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -586,16 +586,12 @@ def test_df_div_zero_series_does_not_commute(self):
# ------------------------------------------------------------------
# Mod By Zero
- def test_df_mod_zero_df(self, using_array_manager):
+ def test_df_mod_zero_df(self):
# GH#3590, modulo as ints
df = pd.DataFrame({"first": [3, 4, 5, 8], "second": [0, 0, 0, 3]})
# this is technically wrong, as the integer portion is coerced to float
first = Series([0, 0, 0, 0])
- if not using_array_manager:
- # INFO(ArrayManager) BlockManager doesn't preserve dtype per column
- # while ArrayManager performs op column-wisedoes and thus preserves
- # dtype if possible
- first = first.astype("float64")
+ first = first.astype("float64")
second = Series([np.nan, np.nan, np.nan, 0])
expected = pd.DataFrame({"first": first, "second": second})
result = df % df
diff --git a/pandas/tests/arithmetic/test_timedelta64.py b/pandas/tests/arithmetic/test_timedelta64.py
index 007d1e670e1e0..b2007209dd5b9 100644
--- a/pandas/tests/arithmetic/test_timedelta64.py
+++ b/pandas/tests/arithmetic/test_timedelta64.py
@@ -1736,9 +1736,7 @@ def test_td64_div_object_mixed_result(self, box_with_array):
# ------------------------------------------------------------------
# __floordiv__, __rfloordiv__
- def test_td64arr_floordiv_td64arr_with_nat(
- self, box_with_array, using_array_manager
- ):
+ def test_td64arr_floordiv_td64arr_with_nat(self, box_with_array):
# GH#35529
box = box_with_array
xbox = np.ndarray if box is pd.array else box
@@ -1751,11 +1749,6 @@ def test_td64arr_floordiv_td64arr_with_nat(
expected = np.array([1.0, 1.0, np.nan], dtype=np.float64)
expected = tm.box_expected(expected, xbox)
- if box is DataFrame and using_array_manager:
- # INFO(ArrayManager) floordiv returns integer, and ArrayManager
- # performs ops column-wise and thus preserves int64 dtype for
- # columns without missing values
- expected[[0, 1]] = expected[[0, 1]].astype("int64")
with tm.maybe_produces_warning(
RuntimeWarning, box is pd.array, check_stacklevel=False
diff --git a/pandas/tests/copy_view/test_array.py b/pandas/tests/copy_view/test_array.py
index 9a3f83e0293f5..13f42cce4fe69 100644
--- a/pandas/tests/copy_view/test_array.py
+++ b/pandas/tests/copy_view/test_array.py
@@ -48,7 +48,7 @@ def test_series_values(using_copy_on_write, method):
[lambda df: df.values, lambda df: np.asarray(df)],
ids=["values", "asarray"],
)
-def test_dataframe_values(using_copy_on_write, using_array_manager, method):
+def test_dataframe_values(using_copy_on_write, method):
df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
df_orig = df.copy()
@@ -70,10 +70,7 @@ def test_dataframe_values(using_copy_on_write, using_array_manager, method):
else:
assert arr.flags.writeable is True
arr[0, 0] = 0
- if not using_array_manager:
- assert df.iloc[0, 0] == 0
- else:
- tm.assert_frame_equal(df, df_orig)
+ assert df.iloc[0, 0] == 0
def test_series_to_numpy(using_copy_on_write):
@@ -157,11 +154,10 @@ def test_dataframe_array_ea_dtypes(using_copy_on_write):
assert arr.flags.writeable is True
-def test_dataframe_array_string_dtype(using_copy_on_write, using_array_manager):
+def test_dataframe_array_string_dtype(using_copy_on_write):
df = DataFrame({"a": ["a", "b"]}, dtype="string")
arr = np.asarray(df)
- if not using_array_manager:
- assert np.shares_memory(arr, get_array(df, "a"))
+ assert np.shares_memory(arr, get_array(df, "a"))
if using_copy_on_write:
assert arr.flags.writeable is False
else:
diff --git a/pandas/tests/copy_view/test_constructors.py b/pandas/tests/copy_view/test_constructors.py
index 1aa458a625028..c325e49e8156e 100644
--- a/pandas/tests/copy_view/test_constructors.py
+++ b/pandas/tests/copy_view/test_constructors.py
@@ -339,16 +339,11 @@ def test_dataframe_from_dict_of_series_with_dtype(index):
@pytest.mark.parametrize("copy", [False, None, True])
-def test_frame_from_numpy_array(using_copy_on_write, copy, using_array_manager):
+def test_frame_from_numpy_array(using_copy_on_write, copy):
arr = np.array([[1, 2], [3, 4]])
df = DataFrame(arr, copy=copy)
- if (
- using_copy_on_write
- and copy is not False
- or copy is True
- or (using_array_manager and copy is None)
- ):
+ if using_copy_on_write and copy is not False or copy is True:
assert not np.shares_memory(get_array(df, 0), arr)
else:
assert np.shares_memory(get_array(df, 0), arr)
diff --git a/pandas/tests/copy_view/test_indexing.py b/pandas/tests/copy_view/test_indexing.py
index 6f3850ab64daa..9afc98e558c11 100644
--- a/pandas/tests/copy_view/test_indexing.py
+++ b/pandas/tests/copy_view/test_indexing.py
@@ -140,15 +140,11 @@ def test_subset_row_slice(backend, using_copy_on_write, warn_copy_on_write):
@pytest.mark.parametrize(
"dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
)
-def test_subset_column_slice(
- backend, using_copy_on_write, warn_copy_on_write, using_array_manager, dtype
-):
+def test_subset_column_slice(backend, using_copy_on_write, warn_copy_on_write, dtype):
# Case: taking a subset of the columns of a DataFrame using a slice
# + afterwards modifying the subset
dtype_backend, DataFrame, _ = backend
- single_block = (
- dtype == "int64" and dtype_backend == "numpy"
- ) and not using_array_manager
+ single_block = dtype == "int64" and dtype_backend == "numpy"
df = DataFrame(
{"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
)
@@ -176,7 +172,7 @@ def test_subset_column_slice(
tm.assert_frame_equal(subset, expected)
# original parent dataframe is not modified (also not for BlockManager case,
# except for single block)
- if not using_copy_on_write and (using_array_manager or single_block):
+ if not using_copy_on_write and single_block:
df_orig.iloc[0, 1] = 0
tm.assert_frame_equal(df, df_orig)
else:
@@ -201,7 +197,6 @@ def test_subset_loc_rows_columns(
dtype,
row_indexer,
column_indexer,
- using_array_manager,
using_copy_on_write,
warn_copy_on_write,
):
@@ -224,14 +219,7 @@ def test_subset_loc_rows_columns(
mutate_parent = (
isinstance(row_indexer, slice)
and isinstance(column_indexer, slice)
- and (
- using_array_manager
- or (
- dtype == "int64"
- and dtype_backend == "numpy"
- and not using_copy_on_write
- )
- )
+ and (dtype == "int64" and dtype_backend == "numpy" and not using_copy_on_write)
)
# modifying the subset never modifies the parent
@@ -265,7 +253,6 @@ def test_subset_iloc_rows_columns(
dtype,
row_indexer,
column_indexer,
- using_array_manager,
using_copy_on_write,
warn_copy_on_write,
):
@@ -288,14 +275,7 @@ def test_subset_iloc_rows_columns(
mutate_parent = (
isinstance(row_indexer, slice)
and isinstance(column_indexer, slice)
- and (
- using_array_manager
- or (
- dtype == "int64"
- and dtype_backend == "numpy"
- and not using_copy_on_write
- )
- )
+ and (dtype == "int64" and dtype_backend == "numpy" and not using_copy_on_write)
)
# modifying the subset never modifies the parent
@@ -422,7 +402,7 @@ def test_subset_set_column(backend, using_copy_on_write, warn_copy_on_write):
"dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
)
def test_subset_set_column_with_loc(
- backend, using_copy_on_write, warn_copy_on_write, using_array_manager, dtype
+ backend, using_copy_on_write, warn_copy_on_write, dtype
):
# Case: setting a single column with loc on a viewing subset
# -> subset.loc[:, col] = value
@@ -440,10 +420,7 @@ def test_subset_set_column_with_loc(
subset.loc[:, "a"] = np.array([10, 11], dtype="int64")
else:
with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(
- None,
- raise_on_extra_warnings=not using_array_manager,
- ):
+ with tm.assert_produces_warning(None):
subset.loc[:, "a"] = np.array([10, 11], dtype="int64")
subset._mgr._verify_integrity()
@@ -461,9 +438,7 @@ def test_subset_set_column_with_loc(
tm.assert_frame_equal(df, df_orig)
-def test_subset_set_column_with_loc2(
- backend, using_copy_on_write, warn_copy_on_write, using_array_manager
-):
+def test_subset_set_column_with_loc2(backend, using_copy_on_write, warn_copy_on_write):
# Case: setting a single column with loc on a viewing subset
# -> subset.loc[:, col] = value
# separate test for case of DataFrame of a single column -> takes a separate
@@ -480,10 +455,7 @@ def test_subset_set_column_with_loc2(
subset.loc[:, "a"] = 0
else:
with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(
- None,
- raise_on_extra_warnings=not using_array_manager,
- ):
+ with tm.assert_produces_warning(None):
subset.loc[:, "a"] = 0
subset._mgr._verify_integrity()
@@ -600,7 +572,6 @@ def test_subset_chained_getitem(
method,
dtype,
using_copy_on_write,
- using_array_manager,
warn_copy_on_write,
):
# Case: creating a subset using multiple, chained getitem calls using views
@@ -614,17 +585,10 @@ def test_subset_chained_getitem(
# when not using CoW, it depends on whether we have a single block or not
# and whether we are slicing the columns -> in that case we have a view
test_callspec = request.node.callspec.id
- if not using_array_manager:
- subset_is_view = test_callspec in (
- "numpy-single-block-column-iloc-slice",
- "numpy-single-block-column-loc-slice",
- )
- else:
- # with ArrayManager, it doesn't matter whether we have
- # single vs mixed block or numpy vs nullable dtypes
- subset_is_view = test_callspec.endswith(
- ("column-iloc-slice", "column-loc-slice")
- )
+ subset_is_view = test_callspec in (
+ "numpy-single-block-column-iloc-slice",
+ "numpy-single-block-column-loc-slice",
+ )
# modify subset -> don't modify parent
subset = method(df)
@@ -726,9 +690,7 @@ def test_subset_chained_getitem_series(
assert subset.iloc[0] == 0
-def test_subset_chained_single_block_row(
- using_copy_on_write, using_array_manager, warn_copy_on_write
-):
+def test_subset_chained_single_block_row(using_copy_on_write, warn_copy_on_write):
# not parametrizing this for dtype backend, since this explicitly tests single block
df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
df_orig = df.copy()
@@ -737,7 +699,7 @@ def test_subset_chained_single_block_row(
subset = df[:].iloc[0].iloc[0:2]
with tm.assert_cow_warning(warn_copy_on_write):
subset.iloc[0] = 0
- if using_copy_on_write or using_array_manager:
+ if using_copy_on_write:
tm.assert_frame_equal(df, df_orig)
else:
assert df.iloc[0, 0] == 0
@@ -747,7 +709,7 @@ def test_subset_chained_single_block_row(
with tm.assert_cow_warning(warn_copy_on_write):
df.iloc[0, 0] = 0
expected = Series([1, 4], index=["a", "b"], name=0)
- if using_copy_on_write or using_array_manager:
+ if using_copy_on_write:
tm.assert_series_equal(subset, expected)
else:
assert subset.iloc[0] == 0
@@ -967,9 +929,7 @@ def test_del_series(backend):
# Accessing column as Series
-def test_column_as_series(
- backend, using_copy_on_write, warn_copy_on_write, using_array_manager
-):
+def test_column_as_series(backend, using_copy_on_write, warn_copy_on_write):
# Case: selecting a single column now also uses Copy-on-Write
dtype_backend, DataFrame, Series = backend
df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
@@ -979,7 +939,7 @@ def test_column_as_series(
assert np.shares_memory(get_array(s, "a"), get_array(df, "a"))
- if using_copy_on_write or using_array_manager:
+ if using_copy_on_write:
s[0] = 0
else:
if warn_copy_on_write:
@@ -1004,7 +964,7 @@ def test_column_as_series(
def test_column_as_series_set_with_upcast(
- backend, using_copy_on_write, using_array_manager, warn_copy_on_write
+ backend, using_copy_on_write, warn_copy_on_write
):
# Case: selecting a single column now also uses Copy-on-Write -> when
# setting a value causes an upcast, we don't need to update the parent
@@ -1019,7 +979,7 @@ def test_column_as_series_set_with_upcast(
with pytest.raises(TypeError, match="Invalid value"):
s[0] = "foo"
expected = Series([1, 2, 3], name="a")
- elif using_copy_on_write or warn_copy_on_write or using_array_manager:
+ elif using_copy_on_write or warn_copy_on_write:
# TODO(CoW-warn) assert the FutureWarning for CoW is also raised
with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
s[0] = "foo"
@@ -1063,7 +1023,6 @@ def test_column_as_series_no_item_cache(
method,
using_copy_on_write,
warn_copy_on_write,
- using_array_manager,
):
# Case: selecting a single column (which now also uses Copy-on-Write to protect
# the view) should always give a new object (i.e. not make use of a cache)
@@ -1080,7 +1039,7 @@ def test_column_as_series_no_item_cache(
else:
assert s1 is s2
- if using_copy_on_write or using_array_manager:
+ if using_copy_on_write:
s1.iloc[0] = 0
elif warn_copy_on_write:
with tm.assert_cow_warning():
@@ -1181,9 +1140,7 @@ def test_series_midx_slice(using_copy_on_write, warn_copy_on_write):
tm.assert_series_equal(ser, expected)
-def test_getitem_midx_slice(
- using_copy_on_write, warn_copy_on_write, using_array_manager
-):
+def test_getitem_midx_slice(using_copy_on_write, warn_copy_on_write):
df = DataFrame({("a", "x"): [1, 2], ("a", "y"): 1, ("b", "x"): 2})
df_orig = df.copy()
new_df = df[("a",)]
@@ -1191,8 +1148,7 @@ def test_getitem_midx_slice(
if using_copy_on_write:
assert not new_df._mgr._has_no_reference(0)
- if not using_array_manager:
- assert np.shares_memory(get_array(df, ("a", "x")), get_array(new_df, "x"))
+ assert np.shares_memory(get_array(df, ("a", "x")), get_array(new_df, "x"))
if using_copy_on_write:
new_df.iloc[0, 0] = 100
tm.assert_frame_equal(df_orig, df)
diff --git a/pandas/tests/copy_view/test_methods.py b/pandas/tests/copy_view/test_methods.py
index 862aebdc70a9d..590829b6dc759 100644
--- a/pandas/tests/copy_view/test_methods.py
+++ b/pandas/tests/copy_view/test_methods.py
@@ -119,9 +119,7 @@ def test_copy_shallow(using_copy_on_write, warn_copy_on_write):
"set_flags",
],
)
-def test_methods_copy_keyword(
- request, method, copy, using_copy_on_write, using_array_manager
-):
+def test_methods_copy_keyword(request, method, copy, using_copy_on_write):
index = None
if "to_timestamp" in request.node.callspec.id:
index = period_range("2012-01-01", freq="D", periods=3)
@@ -145,7 +143,7 @@ def test_methods_copy_keyword(
if request.node.callspec.id.startswith("reindex-"):
# TODO copy=False without CoW still returns a copy in this case
- if not using_copy_on_write and not using_array_manager and copy is False:
+ if not using_copy_on_write and copy is False:
share_memory = False
if share_memory:
@@ -227,11 +225,10 @@ def test_methods_series_copy_keyword(request, method, copy, using_copy_on_write)
@pytest.mark.parametrize("copy", [True, None, False])
-def test_transpose_copy_keyword(using_copy_on_write, copy, using_array_manager):
+def test_transpose_copy_keyword(using_copy_on_write, copy):
df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
result = df.transpose(copy=copy)
share_memory = using_copy_on_write or copy is False or copy is None
- share_memory = share_memory and not using_array_manager
if share_memory:
assert np.shares_memory(get_array(df, "a"), get_array(result, 0))
@@ -1718,11 +1715,8 @@ def test_get(using_copy_on_write, warn_copy_on_write, key):
@pytest.mark.parametrize(
"dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
)
-def test_xs(
- using_copy_on_write, warn_copy_on_write, using_array_manager, axis, key, dtype
-):
- single_block = (dtype == "int64") and not using_array_manager
- is_view = single_block or (using_array_manager and axis == 1)
+def test_xs(using_copy_on_write, warn_copy_on_write, axis, key, dtype):
+ single_block = dtype == "int64"
df = DataFrame(
{"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
)
@@ -1735,7 +1729,7 @@ def test_xs(
elif using_copy_on_write:
assert result._mgr._has_no_reference(0)
- if using_copy_on_write or (is_view and not warn_copy_on_write):
+ if using_copy_on_write or (single_block and not warn_copy_on_write):
result.iloc[0] = 0
elif warn_copy_on_write:
with tm.assert_cow_warning(single_block or axis == 1):
@@ -1753,9 +1747,7 @@ def test_xs(
@pytest.mark.parametrize("axis", [0, 1])
@pytest.mark.parametrize("key, level", [("l1", 0), (2, 1)])
-def test_xs_multiindex(
- using_copy_on_write, warn_copy_on_write, using_array_manager, key, level, axis
-):
+def test_xs_multiindex(using_copy_on_write, warn_copy_on_write, key, level, axis):
arr = np.arange(18).reshape(6, 3)
index = MultiIndex.from_product([["l1", "l2"], [1, 2, 3]], names=["lev1", "lev2"])
df = DataFrame(arr, index=index, columns=list("abc"))
@@ -1772,7 +1764,7 @@ def test_xs_multiindex(
if warn_copy_on_write:
warn = FutureWarning if level == 0 else None
- elif not using_copy_on_write and not using_array_manager:
+ elif not using_copy_on_write:
warn = SettingWithCopyWarning
else:
warn = None
@@ -1884,12 +1876,12 @@ def test_inplace_arithmetic_series_with_reference(
@pytest.mark.parametrize("copy", [True, False])
-def test_transpose(using_copy_on_write, copy, using_array_manager):
+def test_transpose(using_copy_on_write, copy):
df = DataFrame({"a": [1, 2, 3], "b": 1})
df_orig = df.copy()
result = df.transpose(copy=copy)
- if not copy and not using_array_manager or using_copy_on_write:
+ if not copy or using_copy_on_write:
assert np.shares_memory(get_array(df, "a"), get_array(result, 0))
else:
assert not np.shares_memory(get_array(df, "a"), get_array(result, 0))
diff --git a/pandas/tests/copy_view/test_replace.py b/pandas/tests/copy_view/test_replace.py
index 6d16bc3083883..1a0a77b332743 100644
--- a/pandas/tests/copy_view/test_replace.py
+++ b/pandas/tests/copy_view/test_replace.py
@@ -118,7 +118,7 @@ def test_replace_mask_all_false_second_block(using_copy_on_write):
# assert np.shares_memory(get_array(df, "d"), get_array(df2, "d"))
-def test_replace_coerce_single_column(using_copy_on_write, using_array_manager):
+def test_replace_coerce_single_column(using_copy_on_write):
df = DataFrame({"a": [1.5, 2, 3], "b": 100.5})
df_orig = df.copy()
@@ -128,7 +128,7 @@ def test_replace_coerce_single_column(using_copy_on_write, using_array_manager):
assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
- elif not using_array_manager:
+ else:
assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
diff --git a/pandas/tests/extension/base/setitem.py b/pandas/tests/extension/base/setitem.py
index ca19845041e23..9dd0a2eba6c0d 100644
--- a/pandas/tests/extension/base/setitem.py
+++ b/pandas/tests/extension/base/setitem.py
@@ -397,10 +397,6 @@ def test_setitem_series(self, data, full_indexer):
def test_setitem_frame_2d_values(self, data):
# GH#44514
df = pd.DataFrame({"A": data})
-
- # Avoiding using_array_manager fixture
- # https://github.com/pandas-dev/pandas/pull/44514#discussion_r754002410
- using_array_manager = isinstance(df._mgr, pd.core.internals.ArrayManager)
using_copy_on_write = pd.options.mode.copy_on_write
blk_data = df._mgr.arrays[0]
@@ -415,7 +411,7 @@ def test_setitem_frame_2d_values(self, data):
df.iloc[:] = df.values
tm.assert_frame_equal(df, orig)
- if not using_array_manager and not using_copy_on_write:
+ if not using_copy_on_write:
# GH#33457 Check that this setting occurred in-place
# FIXME(ArrayManager): this should work there too
assert df._mgr.arrays[0] is blk_data
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index 97e7ae15c6c63..7837adec0c9e0 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -739,7 +739,7 @@ def test_getitem_setitem_boolean_multi(self):
expected.loc[[0, 2], [1]] = 5
tm.assert_frame_equal(df, expected)
- def test_getitem_setitem_float_labels(self, using_array_manager):
+ def test_getitem_setitem_float_labels(self):
index = Index([1.5, 2, 3, 4, 5])
df = DataFrame(np.random.default_rng(2).standard_normal((5, 5)), index=index)
@@ -1110,16 +1110,14 @@ def test_iloc_col(self):
expected = df.reindex(columns=df.columns[[1, 2, 4, 6]])
tm.assert_frame_equal(result, expected)
- def test_iloc_col_slice_view(
- self, using_array_manager, using_copy_on_write, warn_copy_on_write
- ):
+ def test_iloc_col_slice_view(self, using_copy_on_write, warn_copy_on_write):
df = DataFrame(
np.random.default_rng(2).standard_normal((4, 10)), columns=range(0, 20, 2)
)
original = df.copy()
subset = df.iloc[:, slice(4, 8)]
- if not using_array_manager and not using_copy_on_write:
+ if not using_copy_on_write:
# verify slice is view
assert np.shares_memory(df[8]._values, subset[8]._values)
@@ -1617,7 +1615,7 @@ def test_setitem(self):
)
-def test_object_casting_indexing_wraps_datetimelike(using_array_manager):
+def test_object_casting_indexing_wraps_datetimelike():
# GH#31649, check the indexing methods all the way down the stack
df = DataFrame(
{
@@ -1639,10 +1637,6 @@ def test_object_casting_indexing_wraps_datetimelike(using_array_manager):
assert isinstance(ser.values[1], Timestamp)
assert isinstance(ser.values[2], pd.Timedelta)
- if using_array_manager:
- # remainder of the test checking BlockManager internals
- return
-
mgr = df._mgr
mgr._rebuild_blknos_and_blklocs()
arr = mgr.fast_xs(0).array
diff --git a/pandas/tests/frame/indexing/test_insert.py b/pandas/tests/frame/indexing/test_insert.py
index 7e702bdc993bd..b9fc5dc195026 100644
--- a/pandas/tests/frame/indexing/test_insert.py
+++ b/pandas/tests/frame/indexing/test_insert.py
@@ -71,15 +71,10 @@ def test_insert_with_columns_dups(self):
)
tm.assert_frame_equal(df, exp)
- def test_insert_item_cache(self, using_array_manager, using_copy_on_write):
+ def test_insert_item_cache(self, using_copy_on_write):
df = DataFrame(np.random.default_rng(2).standard_normal((4, 3)))
ser = df[0]
-
- if using_array_manager:
- expected_warning = None
- else:
- # with BlockManager warn about high fragmentation of single dtype
- expected_warning = PerformanceWarning
+ expected_warning = PerformanceWarning
with tm.assert_produces_warning(expected_warning):
for n in range(100):
diff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py
index e802a56ecbc81..f031cb2218e31 100644
--- a/pandas/tests/frame/indexing/test_setitem.py
+++ b/pandas/tests/frame/indexing/test_setitem.py
@@ -1208,9 +1208,7 @@ def test_setitem_always_copy(self, float_frame):
assert notna(s[5:10]).all()
@pytest.mark.parametrize("consolidate", [True, False])
- def test_setitem_partial_column_inplace(
- self, consolidate, using_array_manager, using_copy_on_write
- ):
+ def test_setitem_partial_column_inplace(self, consolidate, using_copy_on_write):
# This setting should be in-place, regardless of whether frame is
# single-block or multi-block
# GH#304 this used to be incorrectly not-inplace, in which case
@@ -1220,12 +1218,11 @@ def test_setitem_partial_column_inplace(
{"x": [1.1, 2.1, 3.1, 4.1], "y": [5.1, 6.1, 7.1, 8.1]}, index=[0, 1, 2, 3]
)
df.insert(2, "z", np.nan)
- if not using_array_manager:
- if consolidate:
- df._consolidate_inplace()
- assert len(df._mgr.blocks) == 1
- else:
- assert len(df._mgr.blocks) == 2
+ if consolidate:
+ df._consolidate_inplace()
+ assert len(df._mgr.blocks) == 1
+ else:
+ assert len(df._mgr.blocks) == 2
zvals = df["z"]._values
@@ -1254,7 +1251,7 @@ def test_setitem_duplicate_columns_not_inplace(self):
@pytest.mark.parametrize(
"value", [1, np.array([[1], [1]], dtype="int64"), [[1], [1]]]
)
- def test_setitem_same_dtype_not_inplace(self, value, using_array_manager):
+ def test_setitem_same_dtype_not_inplace(self, value):
# GH#39510
cols = ["A", "B"]
df = DataFrame(0, index=[0, 1], columns=cols)
diff --git a/pandas/tests/frame/indexing/test_xs.py b/pandas/tests/frame/indexing/test_xs.py
index be809e3a17c8e..535137edd16cf 100644
--- a/pandas/tests/frame/indexing/test_xs.py
+++ b/pandas/tests/frame/indexing/test_xs.py
@@ -122,9 +122,7 @@ def test_xs_keep_level(self):
result = df.xs((2008, "sat"), level=["year", "day"], drop_level=False)
tm.assert_frame_equal(result, expected)
- def test_xs_view(
- self, using_array_manager, using_copy_on_write, warn_copy_on_write
- ):
+ def test_xs_view(self, using_copy_on_write, warn_copy_on_write):
# in 0.14 this will return a view if possible a copy otherwise, but
# this is numpy dependent
@@ -135,13 +133,6 @@ def test_xs_view(
with tm.raises_chained_assignment_error():
dm.xs(2)[:] = 20
tm.assert_frame_equal(dm, df_orig)
- elif using_array_manager:
- # INFO(ArrayManager) with ArrayManager getting a row as a view is
- # not possible
- msg = r"\nA value is trying to be set on a copy of a slice from a DataFrame"
- with pytest.raises(SettingWithCopyError, match=msg):
- dm.xs(2)[:] = 20
- assert not (dm.xs(2) == 20).any()
else:
with tm.raises_chained_assignment_error():
dm.xs(2)[:] = 20
@@ -400,9 +391,7 @@ def test_xs_droplevel_false(self):
expected = DataFrame({"a": [1]})
tm.assert_frame_equal(result, expected)
- def test_xs_droplevel_false_view(
- self, using_array_manager, using_copy_on_write, warn_copy_on_write
- ):
+ def test_xs_droplevel_false_view(self, using_copy_on_write, warn_copy_on_write):
# GH#37832
df = DataFrame([[1, 2, 3]], columns=Index(["a", "b", "c"]))
result = df.xs("a", axis=1, drop_level=False)
@@ -427,9 +416,6 @@ def test_xs_droplevel_false_view(
if using_copy_on_write:
# with copy on write the subset is never modified
expected = DataFrame({"a": [1]})
- elif using_array_manager:
- # Here the behavior is consistent
- expected = DataFrame({"a": [2]})
else:
# FIXME: iloc does not update the array inplace using
# "split" path
diff --git a/pandas/tests/frame/methods/test_equals.py b/pandas/tests/frame/methods/test_equals.py
index d0b9d96cafa0d..88b3fec02182b 100644
--- a/pandas/tests/frame/methods/test_equals.py
+++ b/pandas/tests/frame/methods/test_equals.py
@@ -14,11 +14,11 @@ def test_dataframe_not_equal(self):
df2 = DataFrame({"a": ["s", "d"], "b": [1, 2]})
assert df1.equals(df2) is False
- def test_equals_different_blocks(self, using_array_manager, using_infer_string):
+ def test_equals_different_blocks(self, using_infer_string):
# GH#9330
df0 = DataFrame({"A": ["x", "y"], "B": [1, 2], "C": ["w", "z"]})
df1 = df0.reset_index()[["A", "B", "C"]]
- if not using_array_manager and not using_infer_string:
+ if not using_infer_string:
# this assert verifies that the above operations have
# induced a block rearrangement
assert df0._mgr.blocks[0].dtype != df1._mgr.blocks[0].dtype
diff --git a/pandas/tests/frame/methods/test_interpolate.py b/pandas/tests/frame/methods/test_interpolate.py
index e0641fcb65bd3..a93931a970687 100644
--- a/pandas/tests/frame/methods/test_interpolate.py
+++ b/pandas/tests/frame/methods/test_interpolate.py
@@ -52,12 +52,8 @@ def test_interpolate_datetimelike_values(self, frame_or_series):
expected_td = frame_or_series(orig - orig[0])
tm.assert_equal(res_td, expected_td)
- def test_interpolate_inplace(self, frame_or_series, using_array_manager, request):
+ def test_interpolate_inplace(self, frame_or_series, request):
# GH#44749
- if using_array_manager and frame_or_series is DataFrame:
- mark = pytest.mark.xfail(reason=".values-based in-place check is invalid")
- request.applymarker(mark)
-
obj = frame_or_series([1, np.nan, 2])
orig = obj.values
@@ -474,14 +470,8 @@ def test_interp_string_axis(self, axis_name, axis_number):
@pytest.mark.parametrize("multiblock", [True, False])
@pytest.mark.parametrize("method", ["ffill", "bfill", "pad"])
- def test_interp_fillna_methods(
- self, request, axis, multiblock, method, using_array_manager
- ):
+ def test_interp_fillna_methods(self, request, axis, multiblock, method):
# GH 12918
- if using_array_manager and axis in (1, "columns"):
- # TODO(ArrayManager) support axis=1
- td.mark_array_manager_not_yet_implemented(request)
-
df = DataFrame(
{
"A": [1.0, 2.0, 3.0, 4.0, np.nan, 5.0],
diff --git a/pandas/tests/frame/methods/test_quantile.py b/pandas/tests/frame/methods/test_quantile.py
index 0f27eae1a3bfc..e31e29b1b0cb2 100644
--- a/pandas/tests/frame/methods/test_quantile.py
+++ b/pandas/tests/frame/methods/test_quantile.py
@@ -45,9 +45,7 @@ def test_quantile_sparse(self, df, expected):
expected = expected.astype("Sparse[float]")
tm.assert_series_equal(result, expected)
- def test_quantile(
- self, datetime_frame, interp_method, using_array_manager, request
- ):
+ def test_quantile(self, datetime_frame, interp_method, request):
interpolation, method = interp_method
df = datetime_frame
result = df.quantile(
@@ -63,11 +61,6 @@ def test_quantile(
tm.assert_series_equal(result, expected)
else:
tm.assert_index_equal(result.index, expected.index)
- request.applymarker(
- pytest.mark.xfail(
- using_array_manager, reason="Name set incorrectly for arraymanager"
- )
- )
assert result.name == expected.name
result = df.quantile(
@@ -83,11 +76,6 @@ def test_quantile(
tm.assert_series_equal(result, expected)
else:
tm.assert_index_equal(result.index, expected.index)
- request.applymarker(
- pytest.mark.xfail(
- using_array_manager, reason="Name set incorrectly for arraymanager"
- )
- )
assert result.name == expected.name
def test_empty(self, interp_method):
@@ -97,7 +85,7 @@ def test_empty(self, interp_method):
)
assert np.isnan(q["x"]) and np.isnan(q["y"])
- def test_non_numeric_exclusion(self, interp_method, request, using_array_manager):
+ def test_non_numeric_exclusion(self, interp_method, request):
interpolation, method = interp_method
df = DataFrame({"col1": ["A", "A", "B", "B"], "col2": [1, 2, 3, 4]})
rs = df.quantile(
@@ -106,11 +94,9 @@ def test_non_numeric_exclusion(self, interp_method, request, using_array_manager
xp = df.median(numeric_only=True).rename(0.5)
if interpolation == "nearest":
xp = (xp + 0.5).astype(np.int64)
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
tm.assert_series_equal(rs, xp)
- def test_axis(self, interp_method, request, using_array_manager):
+ def test_axis(self, interp_method):
# axis
interpolation, method = interp_method
df = DataFrame({"A": [1, 2, 3], "B": [2, 3, 4]}, index=[1, 2, 3])
@@ -118,8 +104,6 @@ def test_axis(self, interp_method, request, using_array_manager):
expected = Series([1.5, 2.5, 3.5], index=[1, 2, 3], name=0.5)
if interpolation == "nearest":
expected = expected.astype(np.int64)
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
tm.assert_series_equal(result, expected)
result = df.quantile(
@@ -134,7 +118,7 @@ def test_axis(self, interp_method, request, using_array_manager):
expected = expected.astype(np.int64)
tm.assert_frame_equal(result, expected, check_index_type=True)
- def test_axis_numeric_only_true(self, interp_method, request, using_array_manager):
+ def test_axis_numeric_only_true(self, interp_method):
# We may want to break API in the future to change this
# so that we exclude non-numeric along the same axis
# See GH #7312
@@ -146,11 +130,9 @@ def test_axis_numeric_only_true(self, interp_method, request, using_array_manage
expected = Series([3.0, 4.0], index=[0, 1], name=0.5)
if interpolation == "nearest":
expected = expected.astype(np.int64)
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
tm.assert_series_equal(result, expected)
- def test_quantile_date_range(self, interp_method, request, using_array_manager):
+ def test_quantile_date_range(self, interp_method):
# GH 2460
interpolation, method = interp_method
dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
@@ -163,12 +145,10 @@ def test_quantile_date_range(self, interp_method, request, using_array_manager):
expected = Series(
["2016-01-02 00:00:00"], name=0.5, dtype="datetime64[ns, US/Pacific]"
)
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
tm.assert_series_equal(result, expected)
- def test_quantile_axis_mixed(self, interp_method, request, using_array_manager):
+ def test_quantile_axis_mixed(self, interp_method):
# mixed on axis=1
interpolation, method = interp_method
df = DataFrame(
@@ -185,8 +165,6 @@ def test_quantile_axis_mixed(self, interp_method, request, using_array_manager):
expected = Series([1.5, 2.5, 3.5], name=0.5)
if interpolation == "nearest":
expected -= 0.5
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
tm.assert_series_equal(result, expected)
# must raise
@@ -194,11 +172,9 @@ def test_quantile_axis_mixed(self, interp_method, request, using_array_manager):
with pytest.raises(TypeError, match=msg):
df.quantile(0.5, axis=1, numeric_only=False)
- def test_quantile_axis_parameter(self, interp_method, request, using_array_manager):
+ def test_quantile_axis_parameter(self, interp_method):
# GH 9543/9544
interpolation, method = interp_method
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
df = DataFrame({"A": [1, 2, 3], "B": [2, 3, 4]}, index=[1, 2, 3])
result = df.quantile(0.5, axis=0, interpolation=interpolation, method=method)
@@ -312,7 +288,7 @@ def test_quantile_interpolation_int(self, int_frame):
assert q1["A"] == np.percentile(df["A"], 10)
tm.assert_series_equal(q, q1)
- def test_quantile_multi(self, interp_method, request, using_array_manager):
+ def test_quantile_multi(self, interp_method):
interpolation, method = interp_method
df = DataFrame([[1, 1, 1], [2, 2, 2], [3, 3, 3]], columns=["a", "b", "c"])
result = df.quantile([0.25, 0.5], interpolation=interpolation, method=method)
@@ -323,11 +299,9 @@ def test_quantile_multi(self, interp_method, request, using_array_manager):
)
if interpolation == "nearest":
expected = expected.astype(np.int64)
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
tm.assert_frame_equal(result, expected)
- def test_quantile_multi_axis_1(self, interp_method, request, using_array_manager):
+ def test_quantile_multi_axis_1(self, interp_method):
interpolation, method = interp_method
df = DataFrame([[1, 1, 1], [2, 2, 2], [3, 3, 3]], columns=["a", "b", "c"])
result = df.quantile(
@@ -338,8 +312,6 @@ def test_quantile_multi_axis_1(self, interp_method, request, using_array_manager
)
if interpolation == "nearest":
expected = expected.astype(np.int64)
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
tm.assert_frame_equal(result, expected)
def test_quantile_multi_empty(self, interp_method):
@@ -443,10 +415,8 @@ def test_quantile_invalid(self, invalid, datetime_frame, interp_method):
with pytest.raises(ValueError, match=msg):
datetime_frame.quantile(invalid, interpolation=interpolation, method=method)
- def test_quantile_box(self, interp_method, request, using_array_manager):
+ def test_quantile_box(self, interp_method):
interpolation, method = interp_method
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
df = DataFrame(
{
"A": [
@@ -574,10 +544,8 @@ def test_quantile_box_nat(self):
)
tm.assert_frame_equal(res, exp)
- def test_quantile_nan(self, interp_method, request, using_array_manager):
+ def test_quantile_nan(self, interp_method):
interpolation, method = interp_method
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
# GH 14357 - float block where some cols have missing values
df = DataFrame({"a": np.arange(1, 6.0), "b": np.arange(1, 6.0)})
df.iloc[-1, 1] = np.nan
@@ -621,10 +589,8 @@ def test_quantile_nan(self, interp_method, request, using_array_manager):
exp = DataFrame({"a": [3.0, 4.0], "b": [np.nan, np.nan]}, index=[0.5, 0.75])
tm.assert_frame_equal(res, exp)
- def test_quantile_nat(self, interp_method, request, using_array_manager, unit):
+ def test_quantile_nat(self, interp_method, unit):
interpolation, method = interp_method
- if method == "table" and using_array_manager:
- request.applymarker(pytest.mark.xfail(reason="Axis name incorrectly set."))
# full NaT column
df = DataFrame({"a": [pd.NaT, pd.NaT, pd.NaT]}, dtype=f"M8[{unit}]")
@@ -757,9 +723,7 @@ def test_quantile_empty_no_columns(self, interp_method):
expected.columns.name = "captain tightpants"
tm.assert_frame_equal(result, expected)
- def test_quantile_item_cache(
- self, using_array_manager, interp_method, using_copy_on_write
- ):
+ def test_quantile_item_cache(self, interp_method, using_copy_on_write):
# previous behavior incorrect retained an invalid _item_cache entry
interpolation, method = interp_method
df = DataFrame(
@@ -767,8 +731,7 @@ def test_quantile_item_cache(
)
df["D"] = df["A"] * 2
ser = df["A"]
- if not using_array_manager:
- assert len(df._mgr.blocks) == 2
+ assert len(df._mgr.blocks) == 2
df.quantile(numeric_only=False, interpolation=interpolation, method=method)
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
index b21aa2d687682..907ff67eac7a1 100644
--- a/pandas/tests/frame/methods/test_shift.py
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -423,13 +423,12 @@ def test_shift_duplicate_columns(self):
tm.assert_frame_equal(shifted[0], shifted[1])
tm.assert_frame_equal(shifted[0], shifted[2])
- def test_shift_axis1_multiple_blocks(self, using_array_manager):
+ def test_shift_axis1_multiple_blocks(self):
# GH#35488
df1 = DataFrame(np.random.default_rng(2).integers(1000, size=(5, 3)))
df2 = DataFrame(np.random.default_rng(2).integers(1000, size=(5, 2)))
df3 = pd.concat([df1, df2], axis=1)
- if not using_array_manager:
- assert len(df3._mgr.blocks) == 2
+ assert len(df3._mgr.blocks) == 2
result = df3.shift(2, axis=1)
@@ -449,8 +448,7 @@ def test_shift_axis1_multiple_blocks(self, using_array_manager):
# Case with periods < 0
# rebuild df3 because `take` call above consolidated
df3 = pd.concat([df1, df2], axis=1)
- if not using_array_manager:
- assert len(df3._mgr.blocks) == 2
+ assert len(df3._mgr.blocks) == 2
result = df3.shift(-2, axis=1)
expected = df3.take([2, 3, 4, -1, -1], axis=1)
diff --git a/pandas/tests/frame/methods/test_sort_values.py b/pandas/tests/frame/methods/test_sort_values.py
index f2f02058a534e..be75efcdfe9d3 100644
--- a/pandas/tests/frame/methods/test_sort_values.py
+++ b/pandas/tests/frame/methods/test_sort_values.py
@@ -598,15 +598,14 @@ def test_sort_values_nat_na_position_default(self):
result = expected.sort_values(["A", "date"])
tm.assert_frame_equal(result, expected)
- def test_sort_values_item_cache(self, using_array_manager, using_copy_on_write):
+ def test_sort_values_item_cache(self, using_copy_on_write):
# previous behavior incorrect retained an invalid _item_cache entry
df = DataFrame(
np.random.default_rng(2).standard_normal((4, 3)), columns=["A", "B", "C"]
)
df["D"] = df["A"] * 2
ser = df["A"]
- if not using_array_manager:
- assert len(df._mgr.blocks) == 2
+ assert len(df._mgr.blocks) == 2
df.sort_values(by="A")
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 42ce658701355..ecaf826c46d9b 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -13,8 +13,6 @@
from pandas._config import using_pyarrow_string_dtype
-import pandas.util._test_decorators as td
-
import pandas as pd
from pandas import (
DataFrame,
@@ -894,15 +892,11 @@ def test_df_add_2d_array_collike_broadcasts(self):
tm.assert_frame_equal(result, expected)
def test_df_arith_2d_array_rowlike_broadcasts(
- self, request, all_arithmetic_operators, using_array_manager
+ self, request, all_arithmetic_operators
):
# GH#23000
opname = all_arithmetic_operators
- if using_array_manager and opname in ("__rmod__", "__rfloordiv__"):
- # TODO(ArrayManager) decide on dtypes
- td.mark_array_manager_not_yet_implemented(request)
-
arr = np.arange(6).reshape(3, 2)
df = DataFrame(arr, columns=[True, False], index=["A", "B", "C"])
@@ -921,15 +915,11 @@ def test_df_arith_2d_array_rowlike_broadcasts(
tm.assert_frame_equal(result, expected)
def test_df_arith_2d_array_collike_broadcasts(
- self, request, all_arithmetic_operators, using_array_manager
+ self, request, all_arithmetic_operators
):
# GH#23000
opname = all_arithmetic_operators
- if using_array_manager and opname in ("__rmod__", "__rfloordiv__"):
- # TODO(ArrayManager) decide on dtypes
- td.mark_array_manager_not_yet_implemented(request)
-
arr = np.arange(6).reshape(3, 2)
df = DataFrame(arr, columns=[True, False], index=["A", "B", "C"])
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 6e818d79d5ba8..8ff69472ea113 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -84,16 +84,15 @@ def test_constructor_from_ndarray_with_str_dtype(self):
expected = DataFrame(arr.astype(str), dtype=object)
tm.assert_frame_equal(df, expected)
- def test_constructor_from_2d_datetimearray(self, using_array_manager):
+ def test_constructor_from_2d_datetimearray(self):
dti = date_range("2016-01-01", periods=6, tz="US/Pacific")
dta = dti._data.reshape(3, 2)
df = DataFrame(dta)
expected = DataFrame({0: dta[:, 0], 1: dta[:, 1]})
tm.assert_frame_equal(df, expected)
- if not using_array_manager:
- # GH#44724 big performance hit if we de-consolidate
- assert len(df._mgr.blocks) == 1
+ # GH#44724 big performance hit if we de-consolidate
+ assert len(df._mgr.blocks) == 1
def test_constructor_dict_with_tzaware_scalar(self):
# GH#42505
@@ -310,10 +309,10 @@ def test_constructor_dtype_nocast_view_dataframe(
assert df.values[0, 0] == 99
def test_constructor_dtype_nocast_view_2d_array(
- self, using_array_manager, using_copy_on_write, warn_copy_on_write
+ self, using_copy_on_write, warn_copy_on_write
):
df = DataFrame([[1, 2], [3, 4]], dtype="int64")
- if not using_array_manager and not using_copy_on_write:
+ if not using_copy_on_write:
should_be_view = DataFrame(df.values, dtype=df[0].dtype)
# TODO(CoW-warn) this should warn
# with tm.assert_cow_warning(warn_copy_on_write):
@@ -2147,35 +2146,19 @@ def test_constructor_frame_shallow_copy(self, float_frame):
cop.index = np.arange(len(cop))
tm.assert_frame_equal(float_frame, orig)
- def test_constructor_ndarray_copy(
- self, float_frame, using_array_manager, using_copy_on_write
- ):
- if not using_array_manager:
- arr = float_frame.values.copy()
- df = DataFrame(arr)
-
- arr[5] = 5
- if using_copy_on_write:
- assert not (df.values[5] == 5).all()
- else:
- assert (df.values[5] == 5).all()
+ def test_constructor_ndarray_copy(self, float_frame, using_copy_on_write):
+ arr = float_frame.values.copy()
+ df = DataFrame(arr)
- df = DataFrame(arr, copy=True)
- arr[6] = 6
- assert not (df.values[6] == 6).all()
+ arr[5] = 5
+ if using_copy_on_write:
+ assert not (df.values[5] == 5).all()
else:
- arr = float_frame.values.copy()
- # default: copy to ensure contiguous arrays
- df = DataFrame(arr)
- assert df._mgr.arrays[0].flags.c_contiguous
- arr[0, 0] = 100
- assert df.iloc[0, 0] != 100
-
- # manually specify copy=False
- df = DataFrame(arr, copy=False)
- assert not df._mgr.arrays[0].flags.c_contiguous
- arr[0, 0] = 1000
- assert df.iloc[0, 0] == 1000
+ assert (df.values[5] == 5).all()
+
+ df = DataFrame(arr, copy=True)
+ arr[6] = 6
+ assert not (df.values[6] == 6).all()
def test_constructor_series_copy(self, float_frame):
series = float_frame._series
@@ -2328,15 +2311,10 @@ def test_check_dtype_empty_numeric_column(self, dtype):
@pytest.mark.parametrize(
"dtype", tm.STRING_DTYPES + tm.BYTES_DTYPES + tm.OBJECT_DTYPES
)
- def test_check_dtype_empty_string_column(self, request, dtype, using_array_manager):
+ def test_check_dtype_empty_string_column(self, request, dtype):
# GH24386: Ensure dtypes are set correctly for an empty DataFrame.
# Empty DataFrame is generated via dictionary data with non-overlapping columns.
data = DataFrame({"a": [1, 2]}, columns=["b"], dtype=dtype)
-
- if using_array_manager and dtype in tm.BYTES_DTYPES:
- # TODO(ArrayManager) astype to bytes dtypes does not yet give object dtype
- td.mark_array_manager_not_yet_implemented(request)
-
assert data.b.dtype.name == "object"
def test_to_frame_with_falsey_names(self):
@@ -2515,17 +2493,8 @@ def test_dict_nocopy(
copy,
any_numeric_ea_dtype,
any_numpy_dtype,
- using_array_manager,
using_copy_on_write,
):
- if (
- using_array_manager
- and not copy
- and any_numpy_dtype not in tm.STRING_DTYPES + tm.BYTES_DTYPES
- ):
- # TODO(ArrayManager) properly honor copy keyword for dict input
- td.mark_array_manager_not_yet_implemented(request)
-
a = np.array([1, 2], dtype=any_numpy_dtype)
b = np.array([3, 4], dtype=any_numpy_dtype)
if b.dtype.kind in ["S", "U"]:
diff --git a/pandas/tests/frame/test_nonunique_indexes.py b/pandas/tests/frame/test_nonunique_indexes.py
index 34f172e900ab7..1e9aa2325e880 100644
--- a/pandas/tests/frame/test_nonunique_indexes.py
+++ b/pandas/tests/frame/test_nonunique_indexes.py
@@ -284,7 +284,7 @@ def test_multi_dtype2(self):
expected = DataFrame([[1, 2, "foo", "bar"]], columns=["a", "a.1", "a.2", "a.3"])
tm.assert_frame_equal(df, expected)
- def test_dups_across_blocks(self, using_array_manager):
+ def test_dups_across_blocks(self):
# dups across blocks
df_float = DataFrame(
np.random.default_rng(2).standard_normal((10, 3)), dtype="float64"
@@ -299,9 +299,8 @@ def test_dups_across_blocks(self, using_array_manager):
)
df = pd.concat([df_float, df_int, df_bool, df_object, df_dt], axis=1)
- if not using_array_manager:
- assert len(df._mgr.blknos) == len(df.columns)
- assert len(df._mgr.blklocs) == len(df.columns)
+ assert len(df._mgr.blknos) == len(df.columns)
+ assert len(df._mgr.blklocs) == len(df.columns)
# testing iloc
for i in range(len(df.columns)):
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index 66145c32c18d7..512b5d6ace469 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -817,17 +817,8 @@ def test_std_timedelta64_skipna_false(self):
@pytest.mark.parametrize(
"values", [["2022-01-01", "2022-01-02", pd.NaT, "2022-01-03"], 4 * [pd.NaT]]
)
- def test_std_datetime64_with_nat(
- self, values, skipna, using_array_manager, request, unit
- ):
+ def test_std_datetime64_with_nat(self, values, skipna, request, unit):
# GH#51335
- if using_array_manager and (
- not skipna or all(value is pd.NaT for value in values)
- ):
- mark = pytest.mark.xfail(
- reason="GH#51446: Incorrect type inference on NaT in reduction result"
- )
- request.applymarker(mark)
dti = to_datetime(values).as_unit(unit)
df = DataFrame({"a": dti})
result = df.std(skipna=skipna)
@@ -1926,14 +1917,8 @@ def test_df_empty_nullable_min_count_1(self, opname, dtype, exp_dtype):
tm.assert_series_equal(result, expected)
-def test_sum_timedelta64_skipna_false(using_array_manager, request):
+def test_sum_timedelta64_skipna_false():
# GH#17235
- if using_array_manager:
- mark = pytest.mark.xfail(
- reason="Incorrect type inference on NaT in reduction result"
- )
- request.applymarker(mark)
-
arr = np.arange(8).astype(np.int64).view("m8[s]").reshape(4, 2)
arr[-1, -1] = "Nat"
diff --git a/pandas/tests/frame/test_stack_unstack.py b/pandas/tests/frame/test_stack_unstack.py
index 6e1e743eb60de..ea66290ab0417 100644
--- a/pandas/tests/frame/test_stack_unstack.py
+++ b/pandas/tests/frame/test_stack_unstack.py
@@ -72,13 +72,12 @@ def test_stack_mixed_level(self, future_stack):
expected = expected[["a", "b"]]
tm.assert_frame_equal(result, expected)
- def test_unstack_not_consolidated(self, using_array_manager):
+ def test_unstack_not_consolidated(self):
# Gh#34708
df = DataFrame({"x": [1, 2, np.nan], "y": [3.0, 4, np.nan]})
df2 = df[["x"]]
df2["y"] = df["y"]
- if not using_array_manager:
- assert len(df2._mgr.blocks) == 2
+ assert len(df2._mgr.blocks) == 2
res = df2.unstack()
expected = df.unstack()
@@ -969,7 +968,7 @@ def test_unstack_nan_index2(self):
right = DataFrame(vals, columns=cols, index=idx)
tm.assert_frame_equal(left, right)
- def test_unstack_nan_index3(self, using_array_manager):
+ def test_unstack_nan_index3(self):
# GH7401
df = DataFrame(
{
@@ -991,10 +990,6 @@ def test_unstack_nan_index3(self, using_array_manager):
)
right = DataFrame(vals, columns=cols, index=idx)
- if using_array_manager:
- # INFO(ArrayManager) with ArrayManager preserve dtype where possible
- cols = right.columns[[1, 2, 3, 5]]
- right[cols] = right[cols].astype(df["C"].dtype)
tm.assert_frame_equal(left, right)
def test_unstack_nan_index4(self):
@@ -1498,7 +1493,7 @@ def test_stack_positional_level_duplicate_column_names(future_stack):
tm.assert_frame_equal(result, expected)
-def test_unstack_non_slice_like_blocks(using_array_manager):
+def test_unstack_non_slice_like_blocks():
# Case where the mgr_locs of a DataFrame's underlying blocks are not slice-like
mi = MultiIndex.from_product([range(5), ["A", "B", "C"]])
@@ -1511,8 +1506,7 @@ def test_unstack_non_slice_like_blocks(using_array_manager):
},
index=mi,
)
- if not using_array_manager:
- assert any(not x.mgr_locs.is_slice_like for x in df._mgr.blocks)
+ assert any(not x.mgr_locs.is_slice_like for x in df._mgr.blocks)
res = df.unstack()
@@ -2354,7 +2348,7 @@ def test_unstack_group_index_overflow(self, future_stack):
result = s.unstack(4)
assert result.shape == (500, 2)
- def test_unstack_with_missing_int_cast_to_float(self, using_array_manager):
+ def test_unstack_with_missing_int_cast_to_float(self):
# https://github.com/pandas-dev/pandas/issues/37115
df = DataFrame(
{
@@ -2366,8 +2360,7 @@ def test_unstack_with_missing_int_cast_to_float(self, using_array_manager):
# add another int column to get 2 blocks
df["is_"] = 1
- if not using_array_manager:
- assert len(df._mgr.blocks) == 2
+ assert len(df._mgr.blocks) == 2
result = df.unstack("b")
result[("is_", "ca")] = result[("is_", "ca")].fillna(0)
@@ -2380,10 +2373,6 @@ def test_unstack_with_missing_int_cast_to_float(self, using_array_manager):
names=[None, "b"],
),
)
- if using_array_manager:
- # INFO(ArrayManager) with ArrayManager preserve dtype where possible
- expected[("v", "cb")] = expected[("v", "cb")].astype("int64")
- expected[("is_", "cb")] = expected[("is_", "cb")].astype("int64")
tm.assert_frame_equal(result, expected)
def test_unstack_with_level_has_nan(self):
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 4c903e691add1..3cc06ae4d2387 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -2050,9 +2050,7 @@ def test_pivot_table_values_key_error():
@pytest.mark.parametrize(
"op", ["idxmax", "idxmin", "min", "max", "sum", "prod", "skew"]
)
-def test_empty_groupby(
- columns, keys, values, method, op, using_array_manager, dropna, using_infer_string
-):
+def test_empty_groupby(columns, keys, values, method, op, dropna, using_infer_string):
# GH8093 & GH26411
override_dtype = None
diff --git a/pandas/tests/groupby/test_reductions.py b/pandas/tests/groupby/test_reductions.py
index 425079f943aba..8333dba439be9 100644
--- a/pandas/tests/groupby/test_reductions.py
+++ b/pandas/tests/groupby/test_reductions.py
@@ -362,7 +362,7 @@ def test_max_min_non_numeric():
assert "ss" in result
-def test_max_min_object_multiple_columns(using_array_manager):
+def test_max_min_object_multiple_columns():
# GH#41111 case where the aggregation is valid for some columns but not
# others; we split object blocks column-wise, consistent with
# DataFrame._reduce
@@ -375,8 +375,7 @@ def test_max_min_object_multiple_columns(using_array_manager):
}
)
df._consolidate_inplace() # should already be consolidate, but double-check
- if not using_array_manager:
- assert len(df._mgr.blocks) == 2
+ assert len(df._mgr.blocks) == 2
gb = df.groupby("A")
diff --git a/pandas/tests/indexing/test_chaining_and_caching.py b/pandas/tests/indexing/test_chaining_and_caching.py
index b97df376ac47f..ca796463f4a1e 100644
--- a/pandas/tests/indexing/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/test_chaining_and_caching.py
@@ -213,7 +213,7 @@ def test_detect_chained_assignment(self, using_copy_on_write):
@pytest.mark.arm_slow
def test_detect_chained_assignment_raises(
- self, using_array_manager, using_copy_on_write, warn_copy_on_write
+ self, using_copy_on_write, warn_copy_on_write
):
# test with the chaining
df = DataFrame(
@@ -236,7 +236,7 @@ def test_detect_chained_assignment_raises(
df["A"][0] = -5
with tm.raises_chained_assignment_error():
df["A"][1] = np.nan
- elif not using_array_manager:
+ else:
with pytest.raises(SettingWithCopyError, match=msg):
with tm.raises_chained_assignment_error():
df["A"][0] = -5
@@ -246,14 +246,6 @@ def test_detect_chained_assignment_raises(
df["A"][1] = np.nan
assert df["A"]._is_copy is None
- else:
- # INFO(ArrayManager) for ArrayManager it doesn't matter that it's
- # a mixed dataframe
- df["A"][0] = -5
- df["A"][1] = -6
- expected = DataFrame([[-5, 2], [-6, 3]], columns=list("AB"))
- expected["B"] = expected["B"].astype("float64")
- tm.assert_frame_equal(df, expected)
@pytest.mark.arm_slow
def test_detect_chained_assignment_fails(
@@ -297,7 +289,7 @@ def test_detect_chained_assignment_doc_example(
@pytest.mark.arm_slow
def test_detect_chained_assignment_object_dtype(
- self, using_array_manager, using_copy_on_write, warn_copy_on_write
+ self, using_copy_on_write, warn_copy_on_write
):
expected = DataFrame({"A": [111, "bbb", "ccc"], "B": [1, 2, 3]})
df = DataFrame(
@@ -317,18 +309,13 @@ def test_detect_chained_assignment_object_dtype(
with tm.raises_chained_assignment_error():
df["A"][0] = 111
tm.assert_frame_equal(df, expected)
- elif not using_array_manager:
+ else:
with pytest.raises(SettingWithCopyError, match=msg):
with tm.raises_chained_assignment_error():
df["A"][0] = 111
df.loc[0, "A"] = 111
tm.assert_frame_equal(df, expected)
- else:
- # INFO(ArrayManager) for ArrayManager it doesn't matter that it's
- # a mixed dataframe
- df["A"][0] = 111
- tm.assert_frame_equal(df, expected)
@pytest.mark.arm_slow
def test_detect_chained_assignment_is_copy_pickle(self):
@@ -453,7 +440,7 @@ def test_detect_chained_assignment_undefined_column(
@pytest.mark.arm_slow
def test_detect_chained_assignment_changing_dtype(
- self, using_array_manager, using_copy_on_write, warn_copy_on_write
+ self, using_copy_on_write, warn_copy_on_write
):
# Mixed type setting but same dtype & changing dtype
df = DataFrame(
@@ -485,15 +472,9 @@ def test_detect_chained_assignment_changing_dtype(
with pytest.raises(SettingWithCopyError, match=msg):
df.loc[2]["C"] = "foo"
- if not using_array_manager:
- with pytest.raises(SettingWithCopyError, match=msg):
- with tm.raises_chained_assignment_error():
- df["C"][2] = "foo"
- else:
- # INFO(ArrayManager) for ArrayManager it doesn't matter if it's
- # changing the dtype or not
- df["C"][2] = "foo"
- assert df.loc[2, "C"] == "foo"
+ with pytest.raises(SettingWithCopyError, match=msg):
+ with tm.raises_chained_assignment_error():
+ df["C"][2] = "foo"
def test_setting_with_copy_bug(self, using_copy_on_write, warn_copy_on_write):
# operating on a copy
diff --git a/pandas/tests/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index 409eca42f404b..a1d8577d534f5 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -72,13 +72,12 @@ class TestiLocBaseIndependent:
],
)
@pytest.mark.parametrize("indexer", [tm.loc, tm.iloc])
- def test_iloc_setitem_fullcol_categorical(self, indexer, key, using_array_manager):
+ def test_iloc_setitem_fullcol_categorical(self, indexer, key):
frame = DataFrame({0: range(3)}, dtype=object)
cat = Categorical(["alpha", "beta", "gamma"])
- if not using_array_manager:
- assert frame._mgr.blocks[0]._can_hold_element(cat)
+ assert frame._mgr.blocks[0]._can_hold_element(cat)
df = frame.copy()
orig_vals = df.values
@@ -86,8 +85,7 @@ def test_iloc_setitem_fullcol_categorical(self, indexer, key, using_array_manage
indexer(df)[key, 0] = cat
expected = DataFrame({0: cat}).astype(object)
- if not using_array_manager:
- assert np.shares_memory(df[0].values, orig_vals)
+ assert np.shares_memory(df[0].values, orig_vals)
tm.assert_frame_equal(df, expected)
@@ -520,9 +518,7 @@ def test_iloc_setitem_dups(self):
df.iloc[[1, 0], [0, 1]] = df.iloc[[1, 0], [0, 1]].reset_index(drop=True)
tm.assert_frame_equal(df, expected)
- def test_iloc_setitem_frame_duplicate_columns_multiple_blocks(
- self, using_array_manager
- ):
+ def test_iloc_setitem_frame_duplicate_columns_multiple_blocks(self):
# Same as the "assign back to self" check in test_iloc_setitem_dups
# but on a DataFrame with multiple blocks
df = DataFrame([[0, 1], [2, 3]], columns=["B", "B"])
@@ -530,14 +526,12 @@ def test_iloc_setitem_frame_duplicate_columns_multiple_blocks(
# setting float values that can be held by existing integer arrays
# is inplace
df.iloc[:, 0] = df.iloc[:, 0].astype("f8")
- if not using_array_manager:
- assert len(df._mgr.blocks) == 1
+ assert len(df._mgr.blocks) == 1
# if the assigned values cannot be held by existing integer arrays,
# we cast
df.iloc[:, 0] = df.iloc[:, 0] + 0.5
- if not using_array_manager:
- assert len(df._mgr.blocks) == 2
+ assert len(df._mgr.blocks) == 2
expected = df.copy()
@@ -632,7 +626,7 @@ def test_iloc_getitem_labelled_frame(self):
with pytest.raises(ValueError, match=msg):
df.iloc["j", "D"]
- def test_iloc_getitem_doc_issue(self, using_array_manager):
+ def test_iloc_getitem_doc_issue(self):
# multi axis slicing issue with single block
# surfaced in GH 6059
@@ -662,8 +656,7 @@ def test_iloc_getitem_doc_issue(self, using_array_manager):
columns = list(range(0, 8, 2))
df = DataFrame(arr, index=index, columns=columns)
- if not using_array_manager:
- df._mgr.blocks[0].mgr_locs
+ df._mgr.blocks[0].mgr_locs
result = df.iloc[1:5, 2:4]
expected = DataFrame(arr[1:5, 2:4], index=index[1:5], columns=columns[2:4])
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexing/test_indexing.py b/pandas/tests/indexing/test_indexing.py
index 57f45f867254d..45ec968714aff 100644
--- a/pandas/tests/indexing/test_indexing.py
+++ b/pandas/tests/indexing/test_indexing.py
@@ -77,9 +77,7 @@ def test_setitem_ndarray_1d_2(self):
"ignore:Series.__getitem__ treating keys as positions is deprecated:"
"FutureWarning"
)
- def test_getitem_ndarray_3d(
- self, index, frame_or_series, indexer_sli, using_array_manager
- ):
+ def test_getitem_ndarray_3d(self, index, frame_or_series, indexer_sli):
# GH 25567
obj = gen_obj(frame_or_series, index)
idxr = indexer_sli(obj)
@@ -88,12 +86,8 @@ def test_getitem_ndarray_3d(
msgs = []
if frame_or_series is Series and indexer_sli in [tm.setitem, tm.iloc]:
msgs.append(r"Wrong number of dimensions. values.ndim > ndim \[3 > 1\]")
- if using_array_manager:
- msgs.append("Passed array should be 1-dimensional")
if frame_or_series is Series or indexer_sli is tm.iloc:
msgs.append(r"Buffer has wrong number of dimensions \(expected 1, got 3\)")
- if using_array_manager:
- msgs.append("indexer should be 1-dimensional")
if indexer_sli is tm.loc or (
frame_or_series is Series and indexer_sli is tm.setitem
):
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index fb0adc56c401b..da10555e60301 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -1490,7 +1490,7 @@ def test_loc_setitem_datetimeindex_tz(self, idxer, tz_naive_fixture):
result.loc[:, idxer] = expected
tm.assert_frame_equal(result, expected)
- def test_loc_setitem_time_key(self, using_array_manager):
+ def test_loc_setitem_time_key(self):
index = date_range("2012-01-01", "2012-01-05", freq="30min")
df = DataFrame(
np.random.default_rng(2).standard_normal((len(index), 5)), index=index
@@ -1505,9 +1505,6 @@ def test_loc_setitem_time_key(self, using_array_manager):
result = result.loc[akey]
expected = df.loc[akey].copy()
expected.loc[:] = 0
- if using_array_manager:
- # TODO(ArrayManager) we are still overwriting columns
- expected = expected.astype(float)
tm.assert_frame_equal(result, expected)
result = df.copy()
@@ -1520,9 +1517,6 @@ def test_loc_setitem_time_key(self, using_array_manager):
result = result.loc[bkey]
expected = df.loc[bkey].copy()
expected.loc[:] = 0
- if using_array_manager:
- # TODO(ArrayManager) we are still overwriting columns
- expected = expected.astype(float)
tm.assert_frame_equal(result, expected)
result = df.copy()
diff --git a/pandas/tests/indexing/test_partial.py b/pandas/tests/indexing/test_partial.py
index ca551024b4c1f..b0a041ed5b69c 100644
--- a/pandas/tests/indexing/test_partial.py
+++ b/pandas/tests/indexing/test_partial.py
@@ -279,7 +279,7 @@ def test_partial_setting(self):
s.iat[3] = 5.0
@pytest.mark.filterwarnings("ignore:Setting a value on a view:FutureWarning")
- def test_partial_setting_frame(self, using_array_manager):
+ def test_partial_setting_frame(self):
df_orig = DataFrame(
np.arange(6).reshape(3, 2), columns=["A", "B"], dtype="int64"
)
@@ -292,8 +292,6 @@ def test_partial_setting_frame(self, using_array_manager):
df.iloc[4, 2] = 5.0
msg = "index 2 is out of bounds for axis 0 with size 2"
- if using_array_manager:
- msg = "list index out of range"
with pytest.raises(IndexError, match=msg):
df.iat[4, 2] = 5.0
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index e4b94177eedb2..8fc02cc7799ed 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1003,7 +1003,7 @@ def test_filter_row_groups(self, pa):
result = read_parquet(path, pa, filters=[("a", "==", 0)])
assert len(result) == 1
- def test_read_parquet_manager(self, pa, using_array_manager):
+ def test_read_parquet_manager(self, pa):
# ensure that read_parquet honors the pandas.options.mode.data_manager option
df = pd.DataFrame(
np.random.default_rng(2).standard_normal((10, 3)), columns=["A", "B", "C"]
@@ -1012,10 +1012,7 @@ def test_read_parquet_manager(self, pa, using_array_manager):
with tm.ensure_clean() as path:
df.to_parquet(path, engine=pa)
result = read_parquet(path, pa)
- if using_array_manager:
- assert isinstance(result._mgr, pd.core.internals.ArrayManager)
- else:
- assert isinstance(result._mgr, pd.core.internals.BlockManager)
+ assert isinstance(result._mgr, pd.core.internals.BlockManager)
def test_read_dtype_backend_pyarrow_config(self, pa, df_full):
import pyarrow
diff --git a/pandas/tests/reshape/concat/test_append.py b/pandas/tests/reshape/concat/test_append.py
index 81ca227fb7afb..3fb6a3fb61396 100644
--- a/pandas/tests/reshape/concat/test_append.py
+++ b/pandas/tests/reshape/concat/test_append.py
@@ -328,16 +328,13 @@ def test_append_empty_frame_to_series_with_dateutil_tz(self):
result = df._append([ser, ser], ignore_index=True)
tm.assert_frame_equal(result, expected)
- def test_append_empty_tz_frame_with_datetime64ns(self, using_array_manager):
+ def test_append_empty_tz_frame_with_datetime64ns(self):
# https://github.com/pandas-dev/pandas/issues/35460
df = DataFrame(columns=["a"]).astype("datetime64[ns, UTC]")
# pd.NaT gets inferred as tz-naive, so append result is tz-naive
result = df._append({"a": pd.NaT}, ignore_index=True)
- if using_array_manager:
- expected = DataFrame({"a": [pd.NaT]}, dtype=object)
- else:
- expected = DataFrame({"a": [np.nan]}, dtype=object)
+ expected = DataFrame({"a": [np.nan]}, dtype=object)
tm.assert_frame_equal(result, expected)
# also test with typed value to append
@@ -356,9 +353,7 @@ def test_append_empty_tz_frame_with_datetime64ns(self, using_array_manager):
"dtype_str", ["datetime64[ns, UTC]", "datetime64[ns]", "Int64", "int64"]
)
@pytest.mark.parametrize("val", [1, "NaT"])
- def test_append_empty_frame_with_timedelta64ns_nat(
- self, dtype_str, val, using_array_manager
- ):
+ def test_append_empty_frame_with_timedelta64ns_nat(self, dtype_str, val):
# https://github.com/pandas-dev/pandas/issues/35460
df = DataFrame(columns=["a"]).astype(dtype_str)
@@ -366,7 +361,7 @@ def test_append_empty_frame_with_timedelta64ns_nat(
result = df._append(other, ignore_index=True)
expected = other.astype(object)
- if isinstance(val, str) and dtype_str != "int64" and not using_array_manager:
+ if isinstance(val, str) and dtype_str != "int64":
# TODO: expected used to be `other.astype(object)` which is a more
# reasonable result. This was changed when tightening
# assert_frame_equal's treatment of mismatched NAs to match the
diff --git a/pandas/tests/reshape/concat/test_concat.py b/pandas/tests/reshape/concat/test_concat.py
index 9e34d02091e69..2cc91992f1fd7 100644
--- a/pandas/tests/reshape/concat/test_concat.py
+++ b/pandas/tests/reshape/concat/test_concat.py
@@ -44,7 +44,7 @@ def test_append_concat(self):
assert isinstance(result.index, PeriodIndex)
assert result.index[0] == s1.index[0]
- def test_concat_copy(self, using_array_manager, using_copy_on_write):
+ def test_concat_copy(self, using_copy_on_write):
df = DataFrame(np.random.default_rng(2).standard_normal((4, 3)))
df2 = DataFrame(np.random.default_rng(2).integers(0, 10, size=4).reshape(4, 1))
df3 = DataFrame({5: "foo"}, index=range(4))
@@ -72,18 +72,14 @@ def test_concat_copy(self, using_array_manager, using_copy_on_write):
elif arr.dtype.kind in ["i", "u"]:
assert arr.base is df2._mgr.arrays[0].base
elif arr.dtype == object:
- if using_array_manager:
- # we get the same array object, which has no base
- assert arr is df3._mgr.arrays[0]
- else:
- assert arr.base is not None
+ assert arr.base is not None
# Float block was consolidated.
df4 = DataFrame(np.random.default_rng(2).standard_normal((4, 1)))
result = concat([df, df2, df3, df4], axis=1, copy=False)
for arr in result._mgr.arrays:
if arr.dtype.kind == "f":
- if using_array_manager or using_copy_on_write:
+ if using_copy_on_write:
# this is a view on some array in either df or df4
assert any(
np.shares_memory(arr, other)
diff --git a/pandas/tests/reshape/concat/test_datetimes.py b/pandas/tests/reshape/concat/test_datetimes.py
index 71ddff7438254..77485788faa02 100644
--- a/pandas/tests/reshape/concat/test_datetimes.py
+++ b/pandas/tests/reshape/concat/test_datetimes.py
@@ -214,9 +214,7 @@ def test_concat_NaT_dataframes(self, tz):
@pytest.mark.parametrize("tz1", [None, "UTC"])
@pytest.mark.parametrize("tz2", [None, "UTC"])
@pytest.mark.parametrize("item", [pd.NaT, Timestamp("20150101")])
- def test_concat_NaT_dataframes_all_NaT_axis_0(
- self, tz1, tz2, item, using_array_manager
- ):
+ def test_concat_NaT_dataframes_all_NaT_axis_0(self, tz1, tz2, item):
# GH 12396
# tz-naive
@@ -228,7 +226,7 @@ def test_concat_NaT_dataframes_all_NaT_axis_0(
expected = expected.apply(lambda x: x.dt.tz_localize(tz2))
if tz1 != tz2:
expected = expected.astype(object)
- if item is pd.NaT and not using_array_manager:
+ if item is pd.NaT:
# GH#18463
# TODO: setting nan here is to keep the test passing as we
# make assert_frame_equal stricter, but is nan really the
@@ -567,7 +565,7 @@ def test_concat_multiindex_datetime_nat():
tm.assert_frame_equal(result, expected)
-def test_concat_float_datetime64(using_array_manager):
+def test_concat_float_datetime64():
# GH#32934
df_time = DataFrame({"A": pd.array(["2000"], dtype="datetime64[ns]")})
df_float = DataFrame({"A": pd.array([1.0], dtype="float64")})
@@ -592,15 +590,8 @@ def test_concat_float_datetime64(using_array_manager):
result = concat([df_time.iloc[:0], df_float])
tm.assert_frame_equal(result, expected)
- if not using_array_manager:
- expected = DataFrame({"A": pd.array(["2000"], dtype="datetime64[ns]")})
- msg = "The behavior of DataFrame concatenation with empty or all-NA entries"
- with tm.assert_produces_warning(FutureWarning, match=msg):
- result = concat([df_time, df_float.iloc[:0]])
- tm.assert_frame_equal(result, expected)
- else:
- expected = DataFrame({"A": pd.array(["2000"], dtype="datetime64[ns]")}).astype(
- {"A": "object"}
- )
+ expected = DataFrame({"A": pd.array(["2000"], dtype="datetime64[ns]")})
+ msg = "The behavior of DataFrame concatenation with empty or all-NA entries"
+ with tm.assert_produces_warning(FutureWarning, match=msg):
result = concat([df_time, df_float.iloc[:0]])
- tm.assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index d7a343ae9f152..9f832c7b1d1ca 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -316,7 +316,7 @@ def test_merge_copy(self):
merged["d"] = "peekaboo"
assert (right["d"] == "bar").all()
- def test_merge_nocopy(self, using_array_manager):
+ def test_merge_nocopy(self):
left = DataFrame({"a": 0, "b": 1}, index=range(10))
right = DataFrame({"c": "foo", "d": "bar"}, index=range(10))
@@ -702,7 +702,7 @@ def _constructor(self):
assert isinstance(result, NotADataFrame)
- def test_join_append_timedeltas(self, using_array_manager):
+ def test_join_append_timedeltas(self):
# timedelta64 issues with join/merge
# GH 5695
@@ -712,8 +712,6 @@ def test_join_append_timedeltas(self, using_array_manager):
df = DataFrame(columns=list("dt"))
msg = "The behavior of DataFrame concatenation with empty or all-NA entries"
warn = FutureWarning
- if using_array_manager:
- warn = None
with tm.assert_produces_warning(warn, match=msg):
df = concat([df, d], ignore_index=True)
result = concat([df, d], ignore_index=True)
@@ -723,9 +721,6 @@ def test_join_append_timedeltas(self, using_array_manager):
"t": [timedelta(0, 22500), timedelta(0, 22500)],
}
)
- if using_array_manager:
- # TODO(ArrayManager) decide on exact casting rules in concat
- expected = expected.astype(object)
tm.assert_frame_equal(result, expected)
def test_join_append_timedeltas2(self):
diff --git a/pandas/tests/reshape/test_crosstab.py b/pandas/tests/reshape/test_crosstab.py
index 136e76986df9d..8a30b63cf0e17 100644
--- a/pandas/tests/reshape/test_crosstab.py
+++ b/pandas/tests/reshape/test_crosstab.py
@@ -459,7 +459,7 @@ def test_crosstab_normalize_arrays(self):
)
tm.assert_frame_equal(test_case, norm_sum)
- def test_crosstab_with_empties(self, using_array_manager):
+ def test_crosstab_with_empties(self):
# Check handling of empties
df = DataFrame(
{
@@ -484,9 +484,6 @@ def test_crosstab_with_empties(self, using_array_manager):
index=Index([1, 2], name="a", dtype="int64"),
columns=Index([3, 4], name="b"),
)
- if using_array_manager:
- # INFO(ArrayManager) column without NaNs can preserve int dtype
- nans[3] = nans[3].astype("int64")
calculated = crosstab(df.a, df.b, values=df.c, aggfunc="count", normalize=False)
tm.assert_frame_equal(nans, calculated)
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 18a449b4d0c67..bf2717be4d7ae 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -1277,7 +1277,7 @@ def test_pivot_table_with_margins_set_margin_name(self, margin_name, data):
margins_name=margin_name,
)
- def test_pivot_timegrouper(self, using_array_manager):
+ def test_pivot_timegrouper(self):
df = DataFrame(
{
"Branch": "A A A A A A A B".split(),
@@ -1331,9 +1331,6 @@ def test_pivot_timegrouper(self, using_array_manager):
)
expected.index.name = "Date"
expected.columns.name = "Buyer"
- if using_array_manager:
- # INFO(ArrayManager) column without NaNs can preserve int dtype
- expected["Carl"] = expected["Carl"].astype("int64")
result = pivot_table(
df,
@@ -2370,7 +2367,7 @@ def test_pivot_table_datetime_warning(self):
)
tm.assert_frame_equal(result, expected)
- def test_pivot_table_with_mixed_nested_tuples(self, using_array_manager):
+ def test_pivot_table_with_mixed_nested_tuples(self):
# GH 50342
df = DataFrame(
{
@@ -2434,9 +2431,6 @@ def test_pivot_table_with_mixed_nested_tuples(self, using_array_manager):
[["bar", "bar", "foo", "foo"], ["one", "two"] * 2], names=["A", "B"]
),
)
- if using_array_manager:
- # INFO(ArrayManager) column without NaNs can preserve int dtype
- expected["small"] = expected["small"].astype("int64")
tm.assert_frame_equal(result, expected)
def test_pivot_table_aggfunc_nunique_with_different_values(self):
diff --git a/pandas/tests/reshape/test_pivot_multilevel.py b/pandas/tests/reshape/test_pivot_multilevel.py
index 08ef29440825f..2c9d54c3db72c 100644
--- a/pandas/tests/reshape/test_pivot_multilevel.py
+++ b/pandas/tests/reshape/test_pivot_multilevel.py
@@ -197,7 +197,7 @@ def test_pivot_list_like_columns(
tm.assert_frame_equal(result, expected)
-def test_pivot_multiindexed_rows_and_cols(using_array_manager):
+def test_pivot_multiindexed_rows_and_cols():
# GH 36360
df = pd.DataFrame(
@@ -225,9 +225,7 @@ def test_pivot_multiindexed_rows_and_cols(using_array_manager):
),
index=Index([0, 1], dtype="int64", name="idx_L0"),
)
- if not using_array_manager:
- # BlockManager does not preserve the dtypes
- expected = expected.astype("float64")
+ expected = expected.astype("float64")
tm.assert_frame_equal(res, expected)
diff --git a/pandas/tests/series/methods/test_reindex.py b/pandas/tests/series/methods/test_reindex.py
index 6f0c8d751a92a..1a4a390da1323 100644
--- a/pandas/tests/series/methods/test_reindex.py
+++ b/pandas/tests/series/methods/test_reindex.py
@@ -318,7 +318,7 @@ def test_reindex_fill_value():
@td.skip_array_manager_not_yet_implemented
@pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
@pytest.mark.parametrize("fill_value", ["string", 0, Timedelta(0)])
-def test_reindex_fill_value_datetimelike_upcast(dtype, fill_value, using_array_manager):
+def test_reindex_fill_value_datetimelike_upcast(dtype, fill_value):
# https://github.com/pandas-dev/pandas/issues/42921
if dtype == "timedelta64[ns]" and fill_value == Timedelta(0):
# use the scalar that is not compatible with the dtype for this test
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index da069afe5e709..866bfb995a6d5 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -2187,13 +2187,12 @@ def test_series_constructor_infer_multiindex(self, container, data):
class TestSeriesConstructorInternals:
- def test_constructor_no_pandas_array(self, using_array_manager):
+ def test_constructor_no_pandas_array(self):
ser = Series([1, 2, 3])
result = Series(ser.array)
tm.assert_series_equal(ser, result)
- if not using_array_manager:
- assert isinstance(result._mgr.blocks[0], NumpyBlock)
- assert result._mgr.blocks[0].is_numeric
+ assert isinstance(result._mgr.blocks[0], NumpyBlock)
+ assert result._mgr.blocks[0].is_numeric
@td.skip_array_manager_invalid_test
def test_from_array(self):
diff --git a/pandas/tests/series/test_reductions.py b/pandas/tests/series/test_reductions.py
index 76353ab25fca6..e200f7d9933aa 100644
--- a/pandas/tests/series/test_reductions.py
+++ b/pandas/tests/series/test_reductions.py
@@ -163,7 +163,7 @@ def test_validate_stat_keepdims():
np.sum(ser, keepdims=True)
-def test_mean_with_convertible_string_raises(using_array_manager, using_infer_string):
+def test_mean_with_convertible_string_raises(using_infer_string):
# GH#44008
ser = Series(["1", "2"])
if using_infer_string:
@@ -177,19 +177,15 @@ def test_mean_with_convertible_string_raises(using_array_manager, using_infer_st
ser.mean()
df = ser.to_frame()
- if not using_array_manager:
- msg = r"Could not convert \['12'\] to numeric|does not support"
+ msg = r"Could not convert \['12'\] to numeric|does not support"
with pytest.raises(TypeError, match=msg):
df.mean()
-def test_mean_dont_convert_j_to_complex(using_array_manager):
+def test_mean_dont_convert_j_to_complex():
# GH#36703
df = pd.DataFrame([{"db": "J", "numeric": 123}])
- if using_array_manager:
- msg = "Could not convert string 'J' to numeric"
- else:
- msg = r"Could not convert \['J'\] to numeric|does not support"
+ msg = r"Could not convert \['J'\] to numeric|does not support"
with pytest.raises(TypeError, match=msg):
df.mean()
@@ -204,15 +200,14 @@ def test_mean_dont_convert_j_to_complex(using_array_manager):
np.mean(df["db"].astype("string").array)
-def test_median_with_convertible_string_raises(using_array_manager):
+def test_median_with_convertible_string_raises():
# GH#34671 this _could_ return a string "2", but definitely not float 2.0
msg = r"Cannot convert \['1' '2' '3'\] to numeric|does not support"
ser = Series(["1", "2", "3"])
with pytest.raises(TypeError, match=msg):
ser.median()
- if not using_array_manager:
- msg = r"Cannot convert \[\['1' '2' '3'\]\] to numeric|does not support"
+ msg = r"Cannot convert \[\['1' '2' '3'\]\] to numeric|does not support"
df = ser.to_frame()
with pytest.raises(TypeError, match=msg):
df.median()
| This started annoying me while adjusting tests for CoW, so ripping it out already | https://api.github.com/repos/pandas-dev/pandas/pulls/56621 | 2023-12-25T23:45:06Z | 2023-12-26T19:35:02Z | 2023-12-26T19:35:02Z | 2023-12-26T19:41:25Z |
Backport PR #56615 on branch 2.2.x (CI: Fix deprecation warnings) | diff --git a/pandas/tests/io/parser/common/test_chunksize.py b/pandas/tests/io/parser/common/test_chunksize.py
index 5e47bcc1c5b0e..9660b283a491b 100644
--- a/pandas/tests/io/parser/common/test_chunksize.py
+++ b/pandas/tests/io/parser/common/test_chunksize.py
@@ -223,7 +223,7 @@ def test_chunks_have_consistent_numerical_type(all_parsers, monkeypatch):
warn = None
if parser.engine == "pyarrow":
warn = DeprecationWarning
- depr_msg = "Passing a BlockManager to DataFrame"
+ depr_msg = "Passing a BlockManager to DataFrame|make_block is deprecated"
with tm.assert_produces_warning(warn, match=depr_msg, check_stacklevel=False):
with monkeypatch.context() as m:
m.setattr(libparsers, "DEFAULT_BUFFER_HEURISTIC", heuristic)
@@ -254,7 +254,8 @@ def test_warn_if_chunks_have_mismatched_type(all_parsers):
if parser.engine == "pyarrow":
df = parser.read_csv_check_warnings(
DeprecationWarning,
- "Passing a BlockManager to DataFrame is deprecated",
+ "Passing a BlockManager to DataFrame is deprecated|"
+ "make_block is deprecated",
buf,
check_stacklevel=False,
)
diff --git a/pandas/tests/io/parser/common/test_read_errors.py b/pandas/tests/io/parser/common/test_read_errors.py
index 4a4ae2b259289..db8b586d22fc0 100644
--- a/pandas/tests/io/parser/common/test_read_errors.py
+++ b/pandas/tests/io/parser/common/test_read_errors.py
@@ -171,7 +171,7 @@ def test_suppress_error_output(all_parsers):
warn = None
if parser.engine == "pyarrow":
warn = DeprecationWarning
- msg = "Passing a BlockManager to DataFrame"
+ msg = "Passing a BlockManager to DataFrame|make_block is deprecated"
with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
result = parser.read_csv(StringIO(data), on_bad_lines="skip")
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index ad7cdad363e78..e4b94177eedb2 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1000,9 +1000,7 @@ def test_filter_row_groups(self, pa):
df = pd.DataFrame({"a": list(range(3))})
with tm.ensure_clean() as path:
df.to_parquet(path, engine=pa)
- result = read_parquet(
- path, pa, filters=[("a", "==", 0)], use_legacy_dataset=False
- )
+ result = read_parquet(path, pa, filters=[("a", "==", 0)])
assert len(result) == 1
def test_read_parquet_manager(self, pa, using_array_manager):
| Backport PR #56615: CI: Fix deprecation warnings | https://api.github.com/repos/pandas-dev/pandas/pulls/56620 | 2023-12-25T20:36:19Z | 2023-12-26T19:32:53Z | 2023-12-26T19:32:53Z | 2023-12-26T19:32:53Z |
TYP: some return types from ruff | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 2a070e9a49b97..7f3fc95ce00cc 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -32,6 +32,8 @@ repos:
# TODO: remove autofixe-only rules when they are checked by ruff
name: ruff-selected-autofixes
alias: ruff-selected-autofixes
+ files: ^pandas
+ exclude: ^pandas/tests
args: [--select, "ANN001,ANN2", --fix-only, --exit-non-zero-on-fix]
- repo: https://github.com/jendrikseipp/vulture
rev: 'v2.10'
diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index d1481639ca5a0..5ee94b74c527e 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -431,7 +431,7 @@ Optional libraries below the lowest tested version may still work, but are not c
+-----------------+-----------------+---------+
| Package | Minimum Version | Changed |
+=================+=================+=========+
-| mypy (dev) | 1.7.1 | X |
+| mypy (dev) | 1.8.0 | X |
+-----------------+-----------------+---------+
| | | X |
+-----------------+-----------------+---------+
diff --git a/environment.yml b/environment.yml
index 74317d47e2e53..58eb69ad1f070 100644
--- a/environment.yml
+++ b/environment.yml
@@ -76,7 +76,7 @@ dependencies:
# code checks
- flake8=6.1.0 # run in subprocess over docstring examples
- - mypy=1.7.1 # pre-commit uses locally installed mypy
+ - mypy=1.8.0 # pre-commit uses locally installed mypy
- tokenize-rt # scripts/check_for_inconsistent_pandas_namespace.py
- pre-commit>=3.6.0
diff --git a/pandas/_testing/asserters.py b/pandas/_testing/asserters.py
index e342f76dc724b..800b03707540f 100644
--- a/pandas/_testing/asserters.py
+++ b/pandas/_testing/asserters.py
@@ -4,6 +4,7 @@
from typing import (
TYPE_CHECKING,
Literal,
+ NoReturn,
cast,
)
@@ -143,7 +144,7 @@ def assert_almost_equal(
)
-def _check_isinstance(left, right, cls):
+def _check_isinstance(left, right, cls) -> None:
"""
Helper method for our assert_* methods that ensures that
the two objects being compared have the right type before
@@ -576,7 +577,7 @@ def assert_timedelta_array_equal(
def raise_assert_detail(
obj, message, left, right, diff=None, first_diff=None, index_values=None
-):
+) -> NoReturn:
__tracebackhide__ = True
msg = f"""{obj} are different
@@ -664,7 +665,7 @@ def _get_base(obj):
if left_base is right_base:
raise AssertionError(f"{repr(left_base)} is {repr(right_base)}")
- def _raise(left, right, err_msg):
+ def _raise(left, right, err_msg) -> NoReturn:
if err_msg is None:
if left.shape != right.shape:
raise_assert_detail(
diff --git a/pandas/_version.py b/pandas/_version.py
index 5d610b5e1ea7e..f8a960630126d 100644
--- a/pandas/_version.py
+++ b/pandas/_version.py
@@ -386,7 +386,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
return pieces
-def plus_or_dot(pieces):
+def plus_or_dot(pieces) -> str:
"""Return a + if we don't already have one, else return a ."""
if "+" in pieces.get("closest-tag", ""):
return "."
diff --git a/pandas/core/computation/expr.py b/pandas/core/computation/expr.py
index 4770f403b1bdb..b5861fbaebe9c 100644
--- a/pandas/core/computation/expr.py
+++ b/pandas/core/computation/expr.py
@@ -695,8 +695,8 @@ def visit_Call(self, node, side=None, **kwargs):
if not isinstance(key, ast.keyword):
# error: "expr" has no attribute "id"
raise ValueError(
- "keyword error in function call " # type: ignore[attr-defined]
- f"'{node.func.id}'"
+ "keyword error in function call "
+ f"'{node.func.id}'" # type: ignore[attr-defined]
)
if key.arg:
diff --git a/pandas/io/html.py b/pandas/io/html.py
index 5d5bf079784be..26e71c9546ffd 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -269,7 +269,7 @@ def _attr_getter(self, obj, attr):
# Both lxml and BeautifulSoup have the same implementation:
return obj.get(attr)
- def _href_getter(self, obj):
+ def _href_getter(self, obj) -> str | None:
"""
Return a href if the DOM node contains a child <a> or None.
@@ -392,7 +392,7 @@ def _parse_tables(self, document, match, attrs):
"""
raise AbstractMethodError(self)
- def _equals_tag(self, obj, tag):
+ def _equals_tag(self, obj, tag) -> bool:
"""
Return whether an individual DOM node matches a tag
@@ -629,7 +629,7 @@ def _href_getter(self, obj) -> str | None:
def _text_getter(self, obj):
return obj.text
- def _equals_tag(self, obj, tag):
+ def _equals_tag(self, obj, tag) -> bool:
return obj.name == tag
def _parse_td(self, row):
@@ -758,7 +758,7 @@ def _parse_tables(self, document, match, kwargs):
raise ValueError(f"No tables found matching regex {repr(pattern)}")
return tables
- def _equals_tag(self, obj, tag):
+ def _equals_tag(self, obj, tag) -> bool:
return obj.tag == tag
def _build_doc(self):
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index ed66e46b300f7..4c490c6b2cda2 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -255,7 +255,7 @@ def __init__(
self.is_copy = None
self._format_axes()
- def _format_axes(self):
+ def _format_axes(self) -> None:
raise AbstractMethodError(self)
def write(self) -> str:
@@ -287,7 +287,7 @@ def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
else:
return self.obj
- def _format_axes(self):
+ def _format_axes(self) -> None:
if not self.obj.index.is_unique and self.orient == "index":
raise ValueError(f"Series index must be unique for orient='{self.orient}'")
@@ -304,7 +304,7 @@ def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
obj_to_write = self.obj
return obj_to_write
- def _format_axes(self):
+ def _format_axes(self) -> None:
"""
Try to format axes if they are datelike.
"""
@@ -1193,7 +1193,7 @@ def parse(self):
self._try_convert_types()
return self.obj
- def _parse(self):
+ def _parse(self) -> None:
raise AbstractMethodError(self)
@final
@@ -1217,7 +1217,7 @@ def _convert_axes(self) -> None:
new_axis = Index(new_ser, dtype=new_ser.dtype, copy=False)
setattr(self.obj, axis_name, new_axis)
- def _try_convert_types(self):
+ def _try_convert_types(self) -> None:
raise AbstractMethodError(self)
@final
diff --git a/pandas/io/parsers/arrow_parser_wrapper.py b/pandas/io/parsers/arrow_parser_wrapper.py
index 66a7ccacf675b..890b22154648e 100644
--- a/pandas/io/parsers/arrow_parser_wrapper.py
+++ b/pandas/io/parsers/arrow_parser_wrapper.py
@@ -41,7 +41,7 @@ def __init__(self, src: ReadBuffer[bytes], **kwds) -> None:
self._parse_kwds()
- def _parse_kwds(self):
+ def _parse_kwds(self) -> None:
"""
Validates keywords before passing to pyarrow.
"""
@@ -104,7 +104,7 @@ def _get_pyarrow_options(self) -> None:
] = None # PyArrow raises an exception by default
elif on_bad_lines == ParserBase.BadLineHandleMethod.WARN:
- def handle_warning(invalid_row):
+ def handle_warning(invalid_row) -> str:
warnings.warn(
f"Expected {invalid_row.expected_columns} columns, but found "
f"{invalid_row.actual_columns}: {invalid_row.text}",
@@ -219,7 +219,7 @@ def _finalize_pandas_output(self, frame: DataFrame) -> DataFrame:
raise ValueError(e)
return frame
- def _validate_usecols(self, usecols):
+ def _validate_usecols(self, usecols) -> None:
if lib.is_list_like(usecols) and not all(isinstance(x, str) for x in usecols):
raise ValueError(
"The pyarrow engine does not allow 'usecols' to be integer "
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 50611197ad7dd..1139519d2bcd3 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -1707,7 +1707,7 @@ def info(self) -> str:
# ------------------------------------------------------------------------
# private methods
- def _check_if_open(self):
+ def _check_if_open(self) -> None:
if not self.is_open:
raise ClosedFileError(f"{self._path} file is not open!")
diff --git a/pandas/io/sas/sas_xport.py b/pandas/io/sas/sas_xport.py
index e68f4789f0a06..11b2ed0ee7316 100644
--- a/pandas/io/sas/sas_xport.py
+++ b/pandas/io/sas/sas_xport.py
@@ -288,7 +288,7 @@ def close(self) -> None:
def _get_row(self):
return self.filepath_or_buffer.read(80).decode()
- def _read_header(self):
+ def _read_header(self) -> None:
self.filepath_or_buffer.seek(0)
# read file header
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index b0fa6bc6e90c4..3a58daf681cfb 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -1514,7 +1514,7 @@ def _create_sql_schema(
keys: list[str] | None = None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
pass
@@ -2073,7 +2073,7 @@ def _create_sql_schema(
keys: list[str] | None = None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
table = SQLTable(
table_name,
self,
@@ -2433,7 +2433,7 @@ def _create_sql_schema(
keys: list[str] | None = None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
raise NotImplementedError("not implemented for adbc")
@@ -2879,7 +2879,7 @@ def _create_sql_schema(
keys=None,
dtype: DtypeArg | None = None,
schema: str | None = None,
- ):
+ ) -> str:
table = SQLiteTable(
table_name,
self,
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index 0f097c6059c7c..a4d8054ea4f8c 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -687,7 +687,7 @@ def __init__(
self._prepare_value_labels()
- def _prepare_value_labels(self):
+ def _prepare_value_labels(self) -> None:
"""Encode value labels."""
self.text_len = 0
diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py
index 479a5e19dc1c5..2979903edf360 100644
--- a/pandas/plotting/_matplotlib/core.py
+++ b/pandas/plotting/_matplotlib/core.py
@@ -662,7 +662,7 @@ def _ensure_frame(self, data) -> DataFrame:
return data
@final
- def _compute_plot_data(self):
+ def _compute_plot_data(self) -> None:
data = self.data
# GH15079 reconstruct data if by is defined
@@ -699,7 +699,7 @@ def _compute_plot_data(self):
self.data = numeric_data.apply(type(self)._convert_to_ndarray)
- def _make_plot(self, fig: Figure):
+ def _make_plot(self, fig: Figure) -> None:
raise AbstractMethodError(self)
@final
@@ -745,7 +745,7 @@ def _post_plot_logic(self, ax: Axes, data) -> None:
"""Post process for each axes. Overridden in child classes"""
@final
- def _adorn_subplots(self, fig: Figure):
+ def _adorn_subplots(self, fig: Figure) -> None:
"""Common post process unrelated to data"""
if len(self.axes) > 0:
all_axes = self._get_subplots(fig)
@@ -1323,7 +1323,7 @@ def __init__(
c = self.data.columns[c]
self.c = c
- def _make_plot(self, fig: Figure):
+ def _make_plot(self, fig: Figure) -> None:
x, y, c, data = self.x, self.y, self.c, self.data
ax = self.axes[0]
diff --git a/pandas/util/_validators.py b/pandas/util/_validators.py
index a47f622216ef7..cb0b4d549f49e 100644
--- a/pandas/util/_validators.py
+++ b/pandas/util/_validators.py
@@ -26,7 +26,7 @@
BoolishNoneT = TypeVar("BoolishNoneT", bool, int, None)
-def _check_arg_length(fname, args, max_fname_arg_count, compat_args):
+def _check_arg_length(fname, args, max_fname_arg_count, compat_args) -> None:
"""
Checks whether 'args' has length of at most 'compat_args'. Raises
a TypeError if that is not the case, similar to in Python when a
@@ -46,7 +46,7 @@ def _check_arg_length(fname, args, max_fname_arg_count, compat_args):
)
-def _check_for_default_values(fname, arg_val_dict, compat_args):
+def _check_for_default_values(fname, arg_val_dict, compat_args) -> None:
"""
Check that the keys in `arg_val_dict` are mapped to their
default values as specified in `compat_args`.
@@ -125,7 +125,7 @@ def validate_args(fname, args, max_fname_arg_count, compat_args) -> None:
_check_for_default_values(fname, kwargs, compat_args)
-def _check_for_invalid_keys(fname, kwargs, compat_args):
+def _check_for_invalid_keys(fname, kwargs, compat_args) -> None:
"""
Checks whether 'kwargs' contains any keys that are not
in 'compat_args' and raises a TypeError if there is one.
diff --git a/requirements-dev.txt b/requirements-dev.txt
index cbfb6336b2e16..5a63e59e1db88 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -53,7 +53,7 @@ moto
flask
asv>=0.6.1
flake8==6.1.0
-mypy==1.7.1
+mypy==1.8.0
tokenize-rt
pre-commit>=3.6.0
gitpython
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/56617 | 2023-12-25T16:43:41Z | 2023-12-26T19:37:35Z | 2023-12-26T19:37:35Z | 2024-01-17T02:49:58Z |
BUG: Add limit_area to EA ffill/bfill | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 15e98cbb2a4d7..a1ecbe586483e 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -321,7 +321,7 @@ Other enhancements
- :meth:`DataFrame.apply` now allows the usage of numba (via ``engine="numba"``) to JIT compile the passed function, allowing for potential speedups (:issue:`54666`)
- :meth:`ExtensionArray._explode` interface method added to allow extension type implementations of the ``explode`` method (:issue:`54833`)
- :meth:`ExtensionArray.duplicated` added to allow extension type implementations of the ``duplicated`` method (:issue:`55255`)
-- :meth:`Series.ffill`, :meth:`Series.bfill`, :meth:`DataFrame.ffill`, and :meth:`DataFrame.bfill` have gained the argument ``limit_area`` (:issue:`56492`)
+- :meth:`Series.ffill`, :meth:`Series.bfill`, :meth:`DataFrame.ffill`, and :meth:`DataFrame.bfill` have gained the argument ``limit_area``; 3rd party :class:`.ExtensionArray` authors need to add this argument to the method ``_pad_or_backfill`` (:issue:`56492`)
- Allow passing ``read_only``, ``data_only`` and ``keep_links`` arguments to openpyxl using ``engine_kwargs`` of :func:`read_excel` (:issue:`55027`)
- Implement masked algorithms for :meth:`Series.value_counts` (:issue:`54984`)
- Implemented :meth:`Series.dt` methods and attributes for :class:`ArrowDtype` with ``pyarrow.duration`` type (:issue:`52284`)
diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index 9ece12cf51a7b..0da121c36644a 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -305,7 +305,12 @@ def _fill_mask_inplace(
func(self._ndarray.T, limit=limit, mask=mask.T)
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
mask = self.isna()
if mask.any():
@@ -315,7 +320,7 @@ def _pad_or_backfill(
npvalues = self._ndarray.T
if copy:
npvalues = npvalues.copy()
- func(npvalues, limit=limit, mask=mask.T)
+ func(npvalues, limit=limit, limit_area=limit_area, mask=mask.T)
npvalues = npvalues.T
if copy:
diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index d7c4d695e6951..2a2b3f1dcc050 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -1025,13 +1025,18 @@ def dropna(self) -> Self:
return type(self)(pc.drop_null(self._pa_array))
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
if not self._hasna:
# TODO(CoW): Not necessary anymore when CoW is the default
return self.copy()
- if limit is None:
+ if limit is None and limit_area is None:
method = missing.clean_fill_method(method)
try:
if method == "pad":
@@ -1047,7 +1052,9 @@ def _pad_or_backfill(
# TODO(3.0): after EA.fillna 'method' deprecation is enforced, we can remove
# this method entirely.
- return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
+ return super()._pad_or_backfill(
+ method=method, limit=limit, limit_area=limit_area, copy=copy
+ )
@doc(ExtensionArray.fillna)
def fillna(
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index e530b28cba88a..5f3d66d17a9bc 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -70,6 +70,7 @@
unique,
)
from pandas.core.array_algos.quantile import quantile_with_mask
+from pandas.core.missing import _fill_limit_area_1d
from pandas.core.sorting import (
nargminmax,
nargsort,
@@ -957,7 +958,12 @@ def interpolate(
)
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
"""
Pad or backfill values, used by Series/DataFrame ffill and bfill.
@@ -1015,6 +1021,12 @@ def _pad_or_backfill(
DeprecationWarning,
stacklevel=find_stack_level(),
)
+ if limit_area is not None:
+ raise NotImplementedError(
+ f"{type(self).__name__} does not implement limit_area "
+ "(added in pandas 2.2). 3rd-party ExtnsionArray authors "
+ "need to add this argument to _pad_or_backfill."
+ )
return self.fillna(method=method, limit=limit)
mask = self.isna()
@@ -1024,6 +1036,8 @@ def _pad_or_backfill(
meth = missing.clean_fill_method(method)
npmask = np.asarray(mask)
+ if limit_area is not None and not npmask.all():
+ _fill_limit_area_1d(npmask, limit_area)
if meth == "pad":
indexer = libalgos.get_fill_indexer(npmask, limit=limit)
return self.take(indexer, allow_fill=True)
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 7d2d98f71b38c..febea079527e6 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -891,11 +891,18 @@ def max(self, *, axis: AxisInt | None = None, skipna: bool = True) -> IntervalOr
return obj[indexer]
def _pad_or_backfill( # pylint: disable=useless-parent-delegation
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
# TODO(3.0): after EA.fillna 'method' deprecation is enforced, we can remove
# this method entirely.
- return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
+ return super()._pad_or_backfill(
+ method=method, limit=limit, limit_area=limit_area, copy=copy
+ )
def fillna(
self, value=None, method=None, limit: int | None = None, copy: bool = True
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index c1bac9cfcb02f..be7895fdb0275 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -193,7 +193,12 @@ def __getitem__(self, item: PositionalIndexer) -> Self | Any:
return self._simple_new(self._data[item], newmask)
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
mask = self._mask
@@ -205,7 +210,21 @@ def _pad_or_backfill(
if copy:
npvalues = npvalues.copy()
new_mask = new_mask.copy()
+ elif limit_area is not None:
+ mask = mask.copy()
func(npvalues, limit=limit, mask=new_mask)
+
+ if limit_area is not None and not mask.all():
+ mask = mask.T
+ neg_mask = ~mask
+ first = neg_mask.argmax()
+ last = len(neg_mask) - neg_mask[::-1].argmax() - 1
+ if limit_area == "inside":
+ new_mask[:first] |= mask[:first]
+ new_mask[last + 1 :] |= mask[last + 1 :]
+ elif limit_area == "outside":
+ new_mask[first + 1 : last] |= mask[first + 1 : last]
+
if copy:
return self._simple_new(npvalues.T, new_mask.T)
else:
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index df5ec356175bf..90a691d1beb69 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -810,12 +810,19 @@ def searchsorted(
return m8arr.searchsorted(npvalue, side=side, sorter=sorter)
def _pad_or_backfill(
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
# view as dt64 so we get treated as timelike in core.missing,
# similar to dtl._period_dispatch
dta = self.view("M8[ns]")
- result = dta._pad_or_backfill(method=method, limit=limit, copy=copy)
+ result = dta._pad_or_backfill(
+ method=method, limit=limit, limit_area=limit_area, copy=copy
+ )
if copy:
return cast("Self", result.view(self.dtype))
else:
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index db670e1ea4816..b2d2e82c7a81f 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -718,11 +718,18 @@ def isna(self) -> Self: # type: ignore[override]
return type(self)(mask, fill_value=False, dtype=dtype)
def _pad_or_backfill( # pylint: disable=useless-parent-delegation
- self, *, method: FillnaOptions, limit: int | None = None, copy: bool = True
+ self,
+ *,
+ method: FillnaOptions,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ copy: bool = True,
) -> Self:
# TODO(3.0): We can remove this method once deprecation for fillna method
# keyword is enforced.
- return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
+ return super()._pad_or_backfill(
+ method=method, limit=limit, limit_area=limit_area, copy=copy
+ )
def fillna(
self,
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 20eff9315bc80..fa409f00e9ff6 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1,6 +1,7 @@
from __future__ import annotations
from functools import wraps
+import inspect
import re
from typing import (
TYPE_CHECKING,
@@ -2256,11 +2257,21 @@ def pad_or_backfill(
) -> list[Block]:
values = self.values
+ kwargs: dict[str, Any] = {"method": method, "limit": limit}
+ if "limit_area" in inspect.signature(values._pad_or_backfill).parameters:
+ kwargs["limit_area"] = limit_area
+ elif limit_area is not None:
+ raise NotImplementedError(
+ f"{type(values).__name__} does not implement limit_area "
+ "(added in pandas 2.2). 3rd-party ExtnsionArray authors "
+ "need to add this argument to _pad_or_backfill."
+ )
+
if values.ndim == 2 and axis == 1:
# NDArrayBackedExtensionArray.fillna assumes axis=0
- new_values = values.T._pad_or_backfill(method=method, limit=limit).T
+ new_values = values.T._pad_or_backfill(**kwargs).T
else:
- new_values = values._pad_or_backfill(method=method, limit=limit)
+ new_values = values._pad_or_backfill(**kwargs)
return [self.make_block_same_class(new_values)]
diff --git a/pandas/core/missing.py b/pandas/core/missing.py
index 0d857f6b21517..cd76883d50541 100644
--- a/pandas/core/missing.py
+++ b/pandas/core/missing.py
@@ -3,10 +3,7 @@
"""
from __future__ import annotations
-from functools import (
- partial,
- wraps,
-)
+from functools import wraps
from typing import (
TYPE_CHECKING,
Any,
@@ -823,6 +820,7 @@ def _interpolate_with_limit_area(
values,
method=method,
limit=limit,
+ limit_area=limit_area,
)
if limit_area == "inside":
@@ -863,27 +861,6 @@ def pad_or_backfill_inplace(
-----
Modifies values in-place.
"""
- if limit_area is not None:
- np.apply_along_axis(
- # error: Argument 1 to "apply_along_axis" has incompatible type
- # "partial[None]"; expected
- # "Callable[..., Union[_SupportsArray[dtype[<nothing>]],
- # Sequence[_SupportsArray[dtype[<nothing>]]],
- # Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]],
- # Sequence[Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]]],
- # Sequence[Sequence[Sequence[Sequence[_
- # SupportsArray[dtype[<nothing>]]]]]]]]"
- partial( # type: ignore[arg-type]
- _interpolate_with_limit_area,
- method=method,
- limit=limit,
- limit_area=limit_area,
- ),
- axis,
- values,
- )
- return
-
transf = (lambda x: x) if axis == 0 else (lambda x: x.T)
# reshape a 1 dim if needed
@@ -897,8 +874,7 @@ def pad_or_backfill_inplace(
func = get_fill_func(method, ndim=2)
# _pad_2d and _backfill_2d both modify tvalues inplace
- func(tvalues, limit=limit)
- return
+ func(tvalues, limit=limit, limit_area=limit_area)
def _fillna_prep(
@@ -909,7 +885,6 @@ def _fillna_prep(
if mask is None:
mask = isna(values)
- mask = mask.view(np.uint8)
return mask
@@ -919,16 +894,23 @@ def _datetimelike_compat(func: F) -> F:
"""
@wraps(func)
- def new_func(values, limit: int | None = None, mask=None):
+ def new_func(
+ values,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ mask=None,
+ ):
if needs_i8_conversion(values.dtype):
if mask is None:
# This needs to occur before casting to int64
mask = isna(values)
- result, mask = func(values.view("i8"), limit=limit, mask=mask)
+ result, mask = func(
+ values.view("i8"), limit=limit, limit_area=limit_area, mask=mask
+ )
return result.view(values.dtype), mask
- return func(values, limit=limit, mask=mask)
+ return func(values, limit=limit, limit_area=limit_area, mask=mask)
return cast(F, new_func)
@@ -937,9 +919,12 @@ def new_func(values, limit: int | None = None, mask=None):
def _pad_1d(
values: np.ndarray,
limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
mask: npt.NDArray[np.bool_] | None = None,
) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
mask = _fillna_prep(values, mask)
+ if limit_area is not None and not mask.all():
+ _fill_limit_area_1d(mask, limit_area)
algos.pad_inplace(values, mask, limit=limit)
return values, mask
@@ -948,9 +933,12 @@ def _pad_1d(
def _backfill_1d(
values: np.ndarray,
limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
mask: npt.NDArray[np.bool_] | None = None,
) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
mask = _fillna_prep(values, mask)
+ if limit_area is not None and not mask.all():
+ _fill_limit_area_1d(mask, limit_area)
algos.backfill_inplace(values, mask, limit=limit)
return values, mask
@@ -959,9 +947,12 @@ def _backfill_1d(
def _pad_2d(
values: np.ndarray,
limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
mask: npt.NDArray[np.bool_] | None = None,
) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
mask = _fillna_prep(values, mask)
+ if limit_area is not None:
+ _fill_limit_area_2d(mask, limit_area)
if values.size:
algos.pad_2d_inplace(values, mask, limit=limit)
@@ -970,9 +961,14 @@ def _pad_2d(
@_datetimelike_compat
def _backfill_2d(
- values, limit: int | None = None, mask: npt.NDArray[np.bool_] | None = None
+ values,
+ limit: int | None = None,
+ limit_area: Literal["inside", "outside"] | None = None,
+ mask: npt.NDArray[np.bool_] | None = None,
):
mask = _fillna_prep(values, mask)
+ if limit_area is not None:
+ _fill_limit_area_2d(mask, limit_area)
if values.size:
algos.backfill_2d_inplace(values, mask, limit=limit)
@@ -982,6 +978,63 @@ def _backfill_2d(
return values, mask
+def _fill_limit_area_1d(
+ mask: npt.NDArray[np.bool_], limit_area: Literal["outside", "inside"]
+) -> None:
+ """Prepare 1d mask for ffill/bfill with limit_area.
+
+ Caller is responsible for checking at least one value of mask is False.
+ When called, mask will no longer faithfully represent when
+ the corresponding are NA or not.
+
+ Parameters
+ ----------
+ mask : np.ndarray[bool, ndim=1]
+ Mask representing NA values when filling.
+ limit_area : { "outside", "inside" }
+ Whether to limit filling to outside or inside the outer most non-NA value.
+ """
+ neg_mask = ~mask
+ first = neg_mask.argmax()
+ last = len(neg_mask) - neg_mask[::-1].argmax() - 1
+ if limit_area == "inside":
+ mask[:first] = False
+ mask[last + 1 :] = False
+ elif limit_area == "outside":
+ mask[first + 1 : last] = False
+
+
+def _fill_limit_area_2d(
+ mask: npt.NDArray[np.bool_], limit_area: Literal["outside", "inside"]
+) -> None:
+ """Prepare 2d mask for ffill/bfill with limit_area.
+
+ When called, mask will no longer faithfully represent when
+ the corresponding are NA or not.
+
+ Parameters
+ ----------
+ mask : np.ndarray[bool, ndim=1]
+ Mask representing NA values when filling.
+ limit_area : { "outside", "inside" }
+ Whether to limit filling to outside or inside the outer most non-NA value.
+ """
+ neg_mask = ~mask.T
+ if limit_area == "outside":
+ # Identify inside
+ la_mask = (
+ np.maximum.accumulate(neg_mask, axis=0)
+ & np.maximum.accumulate(neg_mask[::-1], axis=0)[::-1]
+ )
+ else:
+ # Identify outside
+ la_mask = (
+ ~np.maximum.accumulate(neg_mask, axis=0)
+ | ~np.maximum.accumulate(neg_mask[::-1], axis=0)[::-1]
+ )
+ mask[la_mask.T] = False
+
+
_fill_methods = {"pad": _pad_1d, "backfill": _backfill_1d}
diff --git a/pandas/tests/extension/base/missing.py b/pandas/tests/extension/base/missing.py
index ffb7a24b4b390..dbd6682c12123 100644
--- a/pandas/tests/extension/base/missing.py
+++ b/pandas/tests/extension/base/missing.py
@@ -77,6 +77,28 @@ def test_fillna_limit_pad(self, data_missing):
expected = pd.Series(data_missing.take([1, 1, 1, 0, 1]))
tm.assert_series_equal(result, expected)
+ @pytest.mark.parametrize(
+ "limit_area, input_ilocs, expected_ilocs",
+ [
+ ("outside", [1, 0, 0, 0, 1], [1, 0, 0, 0, 1]),
+ ("outside", [1, 0, 1, 0, 1], [1, 0, 1, 0, 1]),
+ ("outside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 1]),
+ ("outside", [0, 1, 0, 1, 0], [0, 1, 0, 1, 1]),
+ ("inside", [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [1, 0, 1, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 0]),
+ ("inside", [0, 1, 0, 1, 0], [0, 1, 1, 1, 0]),
+ ],
+ )
+ def test_ffill_limit_area(
+ self, data_missing, limit_area, input_ilocs, expected_ilocs
+ ):
+ # GH#56616
+ arr = data_missing.take(input_ilocs)
+ result = pd.Series(arr).ffill(limit_area=limit_area)
+ expected = pd.Series(data_missing.take(expected_ilocs))
+ tm.assert_series_equal(result, expected)
+
@pytest.mark.filterwarnings(
"ignore:Series.fillna with 'method' is deprecated:FutureWarning"
)
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index 49f29b2194cae..9971f527c14d0 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -156,6 +156,36 @@ def test_fillna_limit_pad(self, data_missing):
):
super().test_fillna_limit_pad(data_missing)
+ @pytest.mark.parametrize(
+ "limit_area, input_ilocs, expected_ilocs",
+ [
+ ("outside", [1, 0, 0, 0, 1], [1, 0, 0, 0, 1]),
+ ("outside", [1, 0, 1, 0, 1], [1, 0, 1, 0, 1]),
+ ("outside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 1]),
+ ("outside", [0, 1, 0, 1, 0], [0, 1, 0, 1, 1]),
+ ("inside", [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [1, 0, 1, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 0]),
+ ("inside", [0, 1, 0, 1, 0], [0, 1, 1, 1, 0]),
+ ],
+ )
+ def test_ffill_limit_area(
+ self, data_missing, limit_area, input_ilocs, expected_ilocs
+ ):
+ # GH#56616
+ msg = "ExtensionArray.fillna 'method' keyword is deprecated"
+ with tm.assert_produces_warning(
+ DeprecationWarning,
+ match=msg,
+ check_stacklevel=False,
+ raise_on_extra_warnings=False,
+ ):
+ msg = "DecimalArray does not implement limit_area"
+ with pytest.raises(NotImplementedError, match=msg):
+ super().test_ffill_limit_area(
+ data_missing, limit_area, input_ilocs, expected_ilocs
+ )
+
def test_fillna_limit_backfill(self, data_missing):
msg = "Series.fillna with 'method' is deprecated"
with tm.assert_produces_warning(
diff --git a/pandas/tests/extension/json/array.py b/pandas/tests/extension/json/array.py
index d3d9dcc4a4712..31f44f886add7 100644
--- a/pandas/tests/extension/json/array.py
+++ b/pandas/tests/extension/json/array.py
@@ -235,6 +235,10 @@ def _values_for_argsort(self):
frozen = [tuple(x.items()) for x in self]
return construct_1d_object_array_from_listlike(frozen)
+ def _pad_or_backfill(self, *, method, limit=None, copy=True):
+ # GH#56616 - test EA method without limit_area argument
+ return super()._pad_or_backfill(method=method, limit=limit, copy=copy)
+
def make_data():
# TODO: Use a regular dict. See _NDFrameIndexer._setitem_with_indexer
diff --git a/pandas/tests/extension/json/test_json.py b/pandas/tests/extension/json/test_json.py
index 5319291f2ea01..9de4f17a27333 100644
--- a/pandas/tests/extension/json/test_json.py
+++ b/pandas/tests/extension/json/test_json.py
@@ -149,6 +149,29 @@ def test_fillna_frame(self):
"""We treat dictionaries as a mapping in fillna, not a scalar."""
super().test_fillna_frame()
+ @pytest.mark.parametrize(
+ "limit_area, input_ilocs, expected_ilocs",
+ [
+ ("outside", [1, 0, 0, 0, 1], [1, 0, 0, 0, 1]),
+ ("outside", [1, 0, 1, 0, 1], [1, 0, 1, 0, 1]),
+ ("outside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 1]),
+ ("outside", [0, 1, 0, 1, 0], [0, 1, 0, 1, 1]),
+ ("inside", [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [1, 0, 1, 0, 1], [1, 1, 1, 1, 1]),
+ ("inside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 0]),
+ ("inside", [0, 1, 0, 1, 0], [0, 1, 1, 1, 0]),
+ ],
+ )
+ def test_ffill_limit_area(
+ self, data_missing, limit_area, input_ilocs, expected_ilocs
+ ):
+ # GH#56616
+ msg = "JSONArray does not implement limit_area"
+ with pytest.raises(NotImplementedError, match=msg):
+ super().test_ffill_limit_area(
+ data_missing, limit_area, input_ilocs, expected_ilocs
+ )
+
@unhashable
def test_value_counts(self, all_data, dropna):
super().test_value_counts(all_data, dropna)
diff --git a/pandas/tests/frame/methods/test_fillna.py b/pandas/tests/frame/methods/test_fillna.py
index 4131138a7c588..4f661b14ef201 100644
--- a/pandas/tests/frame/methods/test_fillna.py
+++ b/pandas/tests/frame/methods/test_fillna.py
@@ -858,41 +858,29 @@ def test_pad_backfill_deprecated(func):
@pytest.mark.parametrize(
"data, expected_data, method, kwargs",
(
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, 3.0, 3.0, 3.0, 7.0, np.nan, np.nan],
"ffill",
{"limit_area": "inside"},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, 3.0, np.nan, np.nan, 7.0, np.nan, np.nan],
"ffill",
{"limit_area": "inside", "limit": 1},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, 7.0],
"ffill",
{"limit_area": "outside"},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, np.nan],
"ffill",
{"limit_area": "outside", "limit": 1},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
(
[np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
@@ -906,41 +894,29 @@ def test_pad_backfill_deprecated(func):
"ffill",
{"limit_area": "outside", "limit": 1},
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, 7.0, 7.0, 7.0, 7.0, np.nan, np.nan],
"bfill",
{"limit_area": "inside"},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, np.nan, 3.0, np.nan, np.nan, 7.0, 7.0, np.nan, np.nan],
"bfill",
{"limit_area": "inside", "limit": 1},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[3.0, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan],
"bfill",
{"limit_area": "outside"},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
- pytest.param(
+ (
[np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
[np.nan, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan],
"bfill",
{"limit_area": "outside", "limit": 1},
- marks=pytest.mark.xfail(
- reason="GH#41813 - limit_area applied to the wrong axis"
- ),
),
),
)
diff --git a/scripts/validate_unwanted_patterns.py b/scripts/validate_unwanted_patterns.py
index 89b67ddd9f5b6..0d724779abfda 100755
--- a/scripts/validate_unwanted_patterns.py
+++ b/scripts/validate_unwanted_patterns.py
@@ -58,6 +58,7 @@
"_iLocIndexer",
# TODO(3.0): GH#55043 - remove upon removal of ArrayManager
"_get_option",
+ "_fill_limit_area_1d",
}
| - [x] closes #41813 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
Follow up to #56531.
This is slightly complicated by the `EA.fillna` deprecation.
- If `EA.fillna` is implemented, we raise whenever `limit_area` is not None
- If `EA._pad_or_backfill` is implemented and does not have a `limit_area` arg, we raise when `limit_area` is not None
My plan is to introduce a deprecation in 3.1 whenever `_pad_or_backfill` gets called (regardless of whether `limit_area` is `None`) informing EA authors they need to add this argument. Assuming this is a good way to do, I'll open a tracking issue for this.
For dtypes where the corresponding `mask` is not used after filling (e.g. `NDArrayBackedExtensionArray`), this takes a shortcut by modifying mask prior to filling. Compared to implementing `limit_area` after filling, this saves 1 or 2 copies (depending on the EA) and extra computation, at the cost of making `mask` no longer necessarily represent NA values. | https://api.github.com/repos/pandas-dev/pandas/pulls/56616 | 2023-12-25T14:00:50Z | 2024-01-03T22:14:32Z | 2024-01-03T22:14:32Z | 2024-01-04T03:27:34Z |
CI: Fix deprecation warnings | diff --git a/pandas/tests/io/parser/common/test_chunksize.py b/pandas/tests/io/parser/common/test_chunksize.py
index 5e47bcc1c5b0e..9660b283a491b 100644
--- a/pandas/tests/io/parser/common/test_chunksize.py
+++ b/pandas/tests/io/parser/common/test_chunksize.py
@@ -223,7 +223,7 @@ def test_chunks_have_consistent_numerical_type(all_parsers, monkeypatch):
warn = None
if parser.engine == "pyarrow":
warn = DeprecationWarning
- depr_msg = "Passing a BlockManager to DataFrame"
+ depr_msg = "Passing a BlockManager to DataFrame|make_block is deprecated"
with tm.assert_produces_warning(warn, match=depr_msg, check_stacklevel=False):
with monkeypatch.context() as m:
m.setattr(libparsers, "DEFAULT_BUFFER_HEURISTIC", heuristic)
@@ -254,7 +254,8 @@ def test_warn_if_chunks_have_mismatched_type(all_parsers):
if parser.engine == "pyarrow":
df = parser.read_csv_check_warnings(
DeprecationWarning,
- "Passing a BlockManager to DataFrame is deprecated",
+ "Passing a BlockManager to DataFrame is deprecated|"
+ "make_block is deprecated",
buf,
check_stacklevel=False,
)
diff --git a/pandas/tests/io/parser/common/test_read_errors.py b/pandas/tests/io/parser/common/test_read_errors.py
index 4a4ae2b259289..db8b586d22fc0 100644
--- a/pandas/tests/io/parser/common/test_read_errors.py
+++ b/pandas/tests/io/parser/common/test_read_errors.py
@@ -171,7 +171,7 @@ def test_suppress_error_output(all_parsers):
warn = None
if parser.engine == "pyarrow":
warn = DeprecationWarning
- msg = "Passing a BlockManager to DataFrame"
+ msg = "Passing a BlockManager to DataFrame|make_block is deprecated"
with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
result = parser.read_csv(StringIO(data), on_bad_lines="skip")
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index ad7cdad363e78..e4b94177eedb2 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1000,9 +1000,7 @@ def test_filter_row_groups(self, pa):
df = pd.DataFrame({"a": list(range(3))})
with tm.ensure_clean() as path:
df.to_parquet(path, engine=pa)
- result = read_parquet(
- path, pa, filters=[("a", "==", 0)], use_legacy_dataset=False
- )
+ result = read_parquet(path, pa, filters=[("a", "==", 0)])
assert len(result) == 1
def test_read_parquet_manager(self, pa, using_array_manager):
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/56615 | 2023-12-24T18:23:39Z | 2023-12-25T20:35:20Z | 2023-12-25T20:35:20Z | 2023-12-25T20:35:23Z |
DEPR: Remove SettingWithCopyWarning | diff --git a/doc/source/reference/testing.rst b/doc/source/reference/testing.rst
index a5d61703aceed..1f164d1aa98b4 100644
--- a/doc/source/reference/testing.rst
+++ b/doc/source/reference/testing.rst
@@ -58,8 +58,6 @@ Exceptions and warnings
errors.PossiblePrecisionLoss
errors.PyperclipException
errors.PyperclipWindowsException
- errors.SettingWithCopyError
- errors.SettingWithCopyWarning
errors.SpecificationError
errors.UndefinedVariableError
errors.UnsortedIndexError
diff --git a/doc/source/user_guide/advanced.rst b/doc/source/user_guide/advanced.rst
index 453536098cfbb..f7ab466e92d93 100644
--- a/doc/source/user_guide/advanced.rst
+++ b/doc/source/user_guide/advanced.rst
@@ -11,13 +11,6 @@ and :ref:`other advanced indexing features <advanced.index_types>`.
See the :ref:`Indexing and Selecting Data <indexing>` for general indexing documentation.
-.. warning::
-
- Whether a copy or a reference is returned for a setting operation may
- depend on the context. This is sometimes called ``chained assignment`` and
- should be avoided. See :ref:`Returning a View versus Copy
- <indexing.view_versus_copy>`.
-
See the :ref:`cookbook<cookbook.selection>` for some advanced strategies.
.. _advanced.hierarchical:
@@ -402,6 +395,7 @@ slicers on a single axis.
Furthermore, you can *set* the values using the following methods.
.. ipython:: python
+ :okwarning:
df2 = dfmi.copy()
df2.loc(axis=0)[:, :, ["C1", "C3"]] = -10
diff --git a/doc/source/user_guide/indexing.rst b/doc/source/user_guide/indexing.rst
index 7c8d3b9e1c869..24cdbad41fe60 100644
--- a/doc/source/user_guide/indexing.rst
+++ b/doc/source/user_guide/indexing.rst
@@ -29,13 +29,6 @@ this area.
production code, we recommended that you take advantage of the optimized
pandas data access methods exposed in this chapter.
-.. warning::
-
- Whether a copy or a reference is returned for a setting operation, may
- depend on the context. This is sometimes called ``chained assignment`` and
- should be avoided. See :ref:`Returning a View versus Copy
- <indexing.view_versus_copy>`.
-
See the :ref:`MultiIndex / Advanced Indexing <advanced>` for ``MultiIndex`` and more advanced indexing documentation.
See the :ref:`cookbook<cookbook.selection>` for some advanced strategies.
@@ -299,12 +292,6 @@ largely as a convenience since it is such a common operation.
Selection by label
------------------
-.. warning::
-
- Whether a copy or a reference is returned for a setting operation, may depend on the context.
- This is sometimes called ``chained assignment`` and should be avoided.
- See :ref:`Returning a View versus Copy <indexing.view_versus_copy>`.
-
.. warning::
``.loc`` is strict when you present slicers that are not compatible (or convertible) with the index type. For example
@@ -445,12 +432,6 @@ For more information about duplicate labels, see
Selection by position
---------------------
-.. warning::
-
- Whether a copy or a reference is returned for a setting operation, may depend on the context.
- This is sometimes called ``chained assignment`` and should be avoided.
- See :ref:`Returning a View versus Copy <indexing.view_versus_copy>`.
-
pandas provides a suite of methods in order to get **purely integer based indexing**. The semantics follow closely Python and NumPy slicing. These are ``0-based`` indexing. When slicing, the start bound is *included*, while the upper bound is *excluded*. Trying to use a non-integer, even a **valid** label will raise an ``IndexError``.
The ``.iloc`` attribute is the primary access method. The following are valid inputs:
@@ -1722,234 +1703,10 @@ You can assign a custom index to the ``index`` attribute:
df_idx.index = pd.Index([10, 20, 30, 40], name="a")
df_idx
-.. _indexing.view_versus_copy:
-
-Returning a view versus a copy
-------------------------------
-
-.. warning::
-
- :ref:`Copy-on-Write <copy_on_write>`
- will become the new default in pandas 3.0. This means that chained indexing will
- never work. As a consequence, the ``SettingWithCopyWarning`` won't be necessary
- anymore.
- See :ref:`this section <copy_on_write_chained_assignment>`
- for more context.
- We recommend turning Copy-on-Write on to leverage the improvements with
-
- ```
- pd.options.mode.copy_on_write = True
- ```
-
- even before pandas 3.0 is available.
-
-When setting values in a pandas object, care must be taken to avoid what is called
-``chained indexing``. Here is an example.
-
-.. ipython:: python
-
- dfmi = pd.DataFrame([list('abcd'),
- list('efgh'),
- list('ijkl'),
- list('mnop')],
- columns=pd.MultiIndex.from_product([['one', 'two'],
- ['first', 'second']]))
- dfmi
-
-Compare these two access methods:
-
-.. ipython:: python
-
- dfmi['one']['second']
-
-.. ipython:: python
-
- dfmi.loc[:, ('one', 'second')]
-
-These both yield the same results, so which should you use? It is instructive to understand the order
-of operations on these and why method 2 (``.loc``) is much preferred over method 1 (chained ``[]``).
-
-``dfmi['one']`` selects the first level of the columns and returns a DataFrame that is singly-indexed.
-Then another Python operation ``dfmi_with_one['second']`` selects the series indexed by ``'second'``.
-This is indicated by the variable ``dfmi_with_one`` because pandas sees these operations as separate events.
-e.g. separate calls to ``__getitem__``, so it has to treat them as linear operations, they happen one after another.
-
-Contrast this to ``df.loc[:,('one','second')]`` which passes a nested tuple of ``(slice(None),('one','second'))`` to a single call to
-``__getitem__``. This allows pandas to deal with this as a single entity. Furthermore this order of operations *can* be significantly
-faster, and allows one to index *both* axes if so desired.
-
Why does assignment fail when using chained indexing?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. warning::
-
- :ref:`Copy-on-Write <copy_on_write>`
- will become the new default in pandas 3.0. This means that chained indexing will
- never work. As a consequence, the ``SettingWithCopyWarning`` won't be necessary
- anymore.
- See :ref:`this section <copy_on_write_chained_assignment>`
- for more context.
- We recommend turning Copy-on-Write on to leverage the improvements with
-
- ```
- pd.options.mode.copy_on_write = True
- ```
-
- even before pandas 3.0 is available.
-
-The problem in the previous section is just a performance issue. What's up with
-the ``SettingWithCopy`` warning? We don't **usually** throw warnings around when
-you do something that might cost a few extra milliseconds!
-
-But it turns out that assigning to the product of chained indexing has
-inherently unpredictable results. To see this, think about how the Python
-interpreter executes this code:
-
-.. code-block:: python
-
- dfmi.loc[:, ('one', 'second')] = value
- # becomes
- dfmi.loc.__setitem__((slice(None), ('one', 'second')), value)
-
-But this code is handled differently:
-
-.. code-block:: python
-
- dfmi['one']['second'] = value
- # becomes
- dfmi.__getitem__('one').__setitem__('second', value)
-
-See that ``__getitem__`` in there? Outside of simple cases, it's very hard to
-predict whether it will return a view or a copy (it depends on the memory layout
-of the array, about which pandas makes no guarantees), and therefore whether
-the ``__setitem__`` will modify ``dfmi`` or a temporary object that gets thrown
-out immediately afterward. **That's** what ``SettingWithCopy`` is warning you
-about!
-
-.. note:: You may be wondering whether we should be concerned about the ``loc``
- property in the first example. But ``dfmi.loc`` is guaranteed to be ``dfmi``
- itself with modified indexing behavior, so ``dfmi.loc.__getitem__`` /
- ``dfmi.loc.__setitem__`` operate on ``dfmi`` directly. Of course,
- ``dfmi.loc.__getitem__(idx)`` may be a view or a copy of ``dfmi``.
-
-Sometimes a ``SettingWithCopy`` warning will arise at times when there's no
-obvious chained indexing going on. **These** are the bugs that
-``SettingWithCopy`` is designed to catch! pandas is probably trying to warn you
-that you've done this:
-
-.. code-block:: python
-
- def do_something(df):
- foo = df[['bar', 'baz']] # Is foo a view? A copy? Nobody knows!
- # ... many lines here ...
- # We don't know whether this will modify df or not!
- foo['quux'] = value
- return foo
-
-Yikes!
-
-.. _indexing.evaluation_order:
-
-Evaluation order matters
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. warning::
-
- :ref:`Copy-on-Write <copy_on_write>`
- will become the new default in pandas 3.0. This means than chained indexing will
- never work. As a consequence, the ``SettingWithCopyWarning`` won't be necessary
- anymore.
- See :ref:`this section <copy_on_write_chained_assignment>`
- for more context.
- We recommend turning Copy-on-Write on to leverage the improvements with
-
- ```
- pd.options.mode.copy_on_write = True
- ```
-
- even before pandas 3.0 is available.
-
-When you use chained indexing, the order and type of the indexing operation
-partially determine whether the result is a slice into the original object, or
-a copy of the slice.
-
-pandas has the ``SettingWithCopyWarning`` because assigning to a copy of a
-slice is frequently not intentional, but a mistake caused by chained indexing
-returning a copy where a slice was expected.
-
-If you would like pandas to be more or less trusting about assignment to a
-chained indexing expression, you can set the :ref:`option <options>`
-``mode.chained_assignment`` to one of these values:
-
-* ``'warn'``, the default, means a ``SettingWithCopyWarning`` is printed.
-* ``'raise'`` means pandas will raise a ``SettingWithCopyError``
- you have to deal with.
-* ``None`` will suppress the warnings entirely.
-
-.. ipython:: python
- :okwarning:
-
- dfb = pd.DataFrame({'a': ['one', 'one', 'two',
- 'three', 'two', 'one', 'six'],
- 'c': np.arange(7)})
-
- # This will show the SettingWithCopyWarning
- # but the frame values will be set
- dfb['c'][dfb['a'].str.startswith('o')] = 42
-
-This however is operating on a copy and will not work.
-
-.. ipython:: python
- :okwarning:
- :okexcept:
-
- with pd.option_context('mode.chained_assignment','warn'):
- dfb[dfb['a'].str.startswith('o')]['c'] = 42
-
-A chained assignment can also crop up in setting in a mixed dtype frame.
-
-.. note::
-
- These setting rules apply to all of ``.loc/.iloc``.
-
-The following is the recommended access method using ``.loc`` for multiple items (using ``mask``) and a single item using a fixed index:
-
-.. ipython:: python
-
- dfc = pd.DataFrame({'a': ['one', 'one', 'two',
- 'three', 'two', 'one', 'six'],
- 'c': np.arange(7)})
- dfd = dfc.copy()
- # Setting multiple items using a mask
- mask = dfd['a'].str.startswith('o')
- dfd.loc[mask, 'c'] = 42
- dfd
-
- # Setting a single item
- dfd = dfc.copy()
- dfd.loc[2, 'a'] = 11
- dfd
-
-The following *can* work at times, but it is not guaranteed to, and therefore should be avoided:
-
-.. ipython:: python
- :okwarning:
-
- dfd = dfc.copy()
- dfd['a'][2] = 111
- dfd
-
-Last, the subsequent example will **not** work at all, and so should be avoided:
-
-.. ipython:: python
- :okwarning:
- :okexcept:
-
- with pd.option_context('mode.chained_assignment','raise'):
- dfd.loc[0]['a'] = 1111
-
-.. warning::
-
- The chained assignment warnings / exceptions are aiming to inform the user of a possibly invalid
- assignment. There may be false positives; situations where a chained assignment is inadvertently
- reported.
+:ref:`Copy-on-Write <copy_on_write>` is the new default with pandas 3.0.
+This means than chained indexing will never work.
+See :ref:`this section <copy_on_write_chained_assignment>`
+for more context.
diff --git a/doc/source/whatsnew/v0.13.0.rst b/doc/source/whatsnew/v0.13.0.rst
index f2e29121760ab..a624e81d17db9 100644
--- a/doc/source/whatsnew/v0.13.0.rst
+++ b/doc/source/whatsnew/v0.13.0.rst
@@ -172,7 +172,7 @@ API changes
statistical mode(s) by axis/Series. (:issue:`5367`)
- Chained assignment will now by default warn if the user is assigning to a copy. This can be changed
- with the option ``mode.chained_assignment``, allowed options are ``raise/warn/None``. See :ref:`the docs<indexing.view_versus_copy>`.
+ with the option ``mode.chained_assignment``, allowed options are ``raise/warn/None``.
.. ipython:: python
diff --git a/doc/source/whatsnew/v0.13.1.rst b/doc/source/whatsnew/v0.13.1.rst
index 8c85868e1aedb..483dd15a8467a 100644
--- a/doc/source/whatsnew/v0.13.1.rst
+++ b/doc/source/whatsnew/v0.13.1.rst
@@ -24,8 +24,8 @@ Highlights include:
.. warning::
0.13.1 fixes a bug that was caused by a combination of having numpy < 1.8, and doing
- chained assignment on a string-like array. Please review :ref:`the docs<indexing.view_versus_copy>`,
- chained indexing can have unexpected results and should generally be avoided.
+ chained assignment on a string-like array.
+ Chained indexing can have unexpected results and should generally be avoided.
This would previously segfault:
diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 8fa1361cc30c1..f4cd57af105dd 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -383,7 +383,7 @@ Other enhancements
- Added ``validate`` argument to :meth:`DataFrame.join` (:issue:`46622`)
- Added ``numeric_only`` argument to :meth:`.Resampler.sum`, :meth:`.Resampler.prod`, :meth:`.Resampler.min`, :meth:`.Resampler.max`, :meth:`.Resampler.first`, and :meth:`.Resampler.last` (:issue:`46442`)
- ``times`` argument in :class:`.ExponentialMovingWindow` now accepts ``np.timedelta64`` (:issue:`47003`)
-- :class:`.DataError`, :class:`.SpecificationError`, :class:`.SettingWithCopyError`, :class:`.SettingWithCopyWarning`, :class:`.NumExprClobberingError`, :class:`.UndefinedVariableError`, :class:`.IndexingError`, :class:`.PyperclipException`, :class:`.PyperclipWindowsException`, :class:`.CSSWarning`, :class:`.PossibleDataLossError`, :class:`.ClosedFileError`, :class:`.IncompatibilityWarning`, :class:`.AttributeConflictWarning`, :class:`.DatabaseError`, :class:`.PossiblePrecisionLoss`, :class:`.ValueLabelTypeMismatch`, :class:`.InvalidColumnName`, and :class:`.CategoricalConversionWarning` are now exposed in ``pandas.errors`` (:issue:`27656`)
+- :class:`.DataError`, :class:`.SpecificationError`, ``SettingWithCopyError``, ``SettingWithCopyWarning``, :class:`.NumExprClobberingError`, :class:`.UndefinedVariableError`, :class:`.IndexingError`, :class:`.PyperclipException`, :class:`.PyperclipWindowsException`, :class:`.CSSWarning`, :class:`.PossibleDataLossError`, :class:`.ClosedFileError`, :class:`.IncompatibilityWarning`, :class:`.AttributeConflictWarning`, :class:`.DatabaseError`, :class:`.PossiblePrecisionLoss`, :class:`.ValueLabelTypeMismatch`, :class:`.InvalidColumnName`, and :class:`.CategoricalConversionWarning` are now exposed in ``pandas.errors`` (:issue:`27656`)
- Added ``check_like`` argument to :func:`testing.assert_series_equal` (:issue:`47247`)
- Add support for :meth:`.DataFrameGroupBy.ohlc` and :meth:`.SeriesGroupBy.ohlc` for extension array dtypes (:issue:`37493`)
- Allow reading compressed SAS files with :func:`read_sas` (e.g., ``.sas7bdat.gz`` files)
diff --git a/pandas/_config/__init__.py b/pandas/_config/__init__.py
index 9784303fc0b87..c43d59654b44c 100644
--- a/pandas/_config/__init__.py
+++ b/pandas/_config/__init__.py
@@ -34,11 +34,6 @@ def using_copy_on_write() -> bool:
return True
-def using_nullable_dtypes() -> bool:
- _mode_options = _global_config["mode"]
- return _mode_options["nullable_dtypes"]
-
-
def using_pyarrow_string_dtype() -> bool:
_mode_options = _global_config["future"]
return _mode_options["infer_string"]
diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index ebd714f9c14d4..7ae65ba11a752 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -16,8 +16,6 @@
import numpy as np
-from pandas._config import option_context
-
from pandas._libs import lib
from pandas._libs.internals import BlockValuesRefs
from pandas._typing import (
@@ -1076,14 +1074,12 @@ def apply_series_generator(self) -> tuple[ResType, Index]:
results = {}
- with option_context("mode.chained_assignment", None):
- for i, v in enumerate(series_gen):
- # ignore SettingWithCopy here in case the user mutates
- results[i] = self.func(v, *self.args, **self.kwargs)
- if isinstance(results[i], ABCSeries):
- # If we have a view on v, we need to make a copy because
- # series_generator will swap out the underlying data
- results[i] = results[i].copy(deep=False)
+ for i, v in enumerate(series_gen):
+ results[i] = self.func(v, *self.args, **self.kwargs)
+ if isinstance(results[i], ABCSeries):
+ # If we have a view on v, we need to make a copy because
+ # series_generator will swap out the underlying data
+ results[i] = results[i].copy(deep=False)
return results, res_index
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index b8b5df6e5145b..afa680d064c4a 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1446,12 +1446,8 @@ def style(self) -> Styler:
@Appender(_shared_docs["items"])
def items(self) -> Iterable[tuple[Hashable, Series]]:
- if self.columns.is_unique and hasattr(self, "_item_cache"):
- for k in self.columns:
- yield k, self._get_item_cache(k)
- else:
- for i, k in enumerate(self.columns):
- yield k, self._ixs(i, axis=1)
+ for i, k in enumerate(self.columns):
+ yield k, self._ixs(i, axis=1)
def iterrows(self) -> Iterable[tuple[Hashable, Series]]:
"""
@@ -3921,24 +3917,14 @@ def _ixs(self, i: int, axis: AxisInt = 0) -> Series:
if axis == 0:
new_mgr = self._mgr.fast_xs(i)
- # if we are a copy, mark as such
- copy = isinstance(new_mgr.array, np.ndarray) and new_mgr.array.base is None
result = self._constructor_sliced_from_mgr(new_mgr, axes=new_mgr.axes)
result._name = self.index[i]
- result = result.__finalize__(self)
- result._set_is_copy(self, copy=copy)
- return result
+ return result.__finalize__(self)
# icol
else:
- label = self.columns[i]
-
col_mgr = self._mgr.iget(i)
- result = self._box_col_values(col_mgr, i)
-
- # this is a cached value, mark it so
- result._set_as_cached(label, self)
- return result
+ return self._box_col_values(col_mgr, i)
def _get_column_array(self, i: int) -> ArrayLike:
"""
@@ -3998,7 +3984,7 @@ def __getitem__(self, key):
and key in self.columns
or key in self.columns.drop_duplicates(keep=False)
):
- return self._get_item_cache(key)
+ return self._get_item(key)
elif is_mi and self.columns.is_unique and key in self.columns:
return self._getitem_multilevel(key)
@@ -4037,7 +4023,7 @@ def __getitem__(self, key):
if isinstance(indexer, slice):
return self._slice(indexer, axis=1)
- data = self._take_with_is_copy(indexer, axis=1)
+ data = self.take(indexer, axis=1)
if is_single_key:
# What does looking for a single key in a non-unique index return?
@@ -4046,7 +4032,7 @@ def __getitem__(self, key):
# - we have a MultiIndex on columns (test on self.columns, #21309)
if data.shape[1] == 1 and not isinstance(self.columns, MultiIndex):
# GH#26490 using data[key] can cause RecursionError
- return data._get_item_cache(key)
+ return data._get_item(key)
return data
@@ -4075,7 +4061,7 @@ def _getitem_bool_array(self, key):
return self.copy(deep=None)
indexer = key.nonzero()[0]
- return self._take_with_is_copy(indexer, axis=0)
+ return self.take(indexer, axis=0)
def _getitem_multilevel(self, key):
# self.columns is a MultiIndex
@@ -4105,7 +4091,6 @@ def _getitem_multilevel(self, key):
result, index=self.index, name=key
)
- result._set_is_copy(self)
return result
else:
# loc is neither a slice nor ndarray, so must be an int
@@ -4134,7 +4119,7 @@ def _get_value(self, index, col, takeable: bool = False) -> Scalar:
series = self._ixs(col, axis=1)
return series._values[index]
- series = self._get_item_cache(col)
+ series = self._get_item(col)
engine = self.index._engine
if not isinstance(self.index, MultiIndex):
@@ -4226,7 +4211,6 @@ def _setitem_slice(self, key: slice, value) -> None:
# NB: we can't just use self.loc[key] = value because that
# operates on labels and we need to operate positional for
# backwards-compat, xref GH#31469
- self._check_setitem_copy()
self.iloc[key] = value
def _setitem_array(self, key, value):
@@ -4239,7 +4223,6 @@ def _setitem_array(self, key, value):
)
key = check_bool_indexer(self.index, key)
indexer = key.nonzero()[0]
- self._check_setitem_copy()
if isinstance(value, DataFrame):
# GH#39931 reindex since iloc does not align
value = value.reindex(self.index.take(indexer))
@@ -4326,7 +4309,6 @@ def _setitem_frame(self, key, value) -> None:
"Must pass DataFrame or 2-d ndarray with boolean values only"
)
- self._check_setitem_copy()
self._where(-key, value, inplace=True)
def _set_item_frame_value(self, key, value: DataFrame) -> None:
@@ -4388,7 +4370,6 @@ def _iset_item_mgr(
) -> None:
# when called from _set_item_mgr loc can be anything returned from get_loc
self._mgr.iset(loc, value, inplace=inplace, refs=refs)
- self._clear_item_cache()
def _set_item_mgr(
self, key, value: ArrayLike, refs: BlockValuesRefs | None = None
@@ -4401,12 +4382,6 @@ def _set_item_mgr(
else:
self._iset_item_mgr(loc, value, refs=refs)
- # check if we are modifying a copy
- # try to set first as we want an invalid
- # value exception to occur first
- if len(self):
- self._check_setitem_copy()
-
def _iset_item(self, loc: int, value: Series, inplace: bool = True) -> None:
# We are only called from _replace_columnwise which guarantees that
# no reindex is necessary
@@ -4417,12 +4392,6 @@ def _iset_item(self, loc: int, value: Series, inplace: bool = True) -> None:
else:
self._iset_item_mgr(loc, value._values.copy(), inplace=True)
- # check if we are modifying a copy
- # try to set first as we want an invalid
- # value exception to occur first
- if len(self):
- self._check_setitem_copy()
-
def _set_item(self, key, value) -> None:
"""
Add series to DataFrame in specified column.
@@ -4473,7 +4442,6 @@ def _set_value(
icol = self.columns.get_loc(col)
iindex = self.index.get_loc(index)
self._mgr.column_setitem(icol, iindex, value, inplace_only=True)
- self._clear_item_cache()
except (KeyError, TypeError, ValueError, LossySetitemError):
# get_loc might raise a KeyError for missing labels (falling back
@@ -4485,7 +4453,6 @@ def _set_value(
self.iloc[index, col] = value
else:
self.loc[index, col] = value
- self._item_cache.pop(col, None)
except InvalidIndexError as ii_err:
# GH48729: Seems like you are trying to assign a value to a
@@ -4529,50 +4496,9 @@ def _box_col_values(self, values: SingleBlockManager, loc: int) -> Series:
obj._name = name
return obj.__finalize__(self)
- # ----------------------------------------------------------------------
- # Lookup Caching
-
- def _clear_item_cache(self) -> None:
- self._item_cache.clear()
-
- def _get_item_cache(self, item: Hashable) -> Series:
- """Return the cached item, item represents a label indexer."""
- if using_copy_on_write():
- loc = self.columns.get_loc(item)
- return self._ixs(loc, axis=1)
-
- cache = self._item_cache
- res = cache.get(item)
- if res is None:
- # All places that call _get_item_cache have unique columns,
- # pending resolution of GH#33047
-
- loc = self.columns.get_loc(item)
- res = self._ixs(loc, axis=1)
-
- cache[item] = res
-
- # for a chain
- res._is_copy = self._is_copy
- return res
-
- def _reset_cacher(self) -> None:
- # no-op for DataFrame
- pass
-
- def _maybe_cache_changed(self, item, value: Series, inplace: bool) -> None:
- """
- The object has called back to us saying maybe it has changed.
- """
- loc = self._info_axis.get_loc(item)
- arraylike = value._values
-
- old = self._ixs(loc, axis=1)
- if old._values is value._values and inplace:
- # GH#46149 avoid making unnecessary copies/block-splitting
- return
-
- self._mgr.iset(loc, arraylike, inplace=inplace)
+ def _get_item(self, item: Hashable) -> Series:
+ loc = self.columns.get_loc(item)
+ return self._ixs(loc, axis=1)
# ----------------------------------------------------------------------
# Unsorted
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 490a47d16871c..7433a4138da0b 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -5,7 +5,6 @@
from copy import deepcopy
import datetime as dt
from functools import partial
-import gc
from json import loads
import operator
import pickle
@@ -23,7 +22,6 @@
overload,
)
import warnings
-import weakref
import numpy as np
@@ -98,8 +96,6 @@
AbstractMethodError,
ChainedAssignmentError,
InvalidIndexError,
- SettingWithCopyError,
- SettingWithCopyWarning,
)
from pandas.errors.cow import (
_chained_assignment_method_msg,
@@ -253,10 +249,8 @@ class NDFrame(PandasObject, indexing.IndexingMixin):
_internal_names: list[str] = [
"_mgr",
- "_cacher",
"_item_cache",
"_cache",
- "_is_copy",
"_name",
"_metadata",
"_flags",
@@ -265,7 +259,6 @@ class NDFrame(PandasObject, indexing.IndexingMixin):
_accessors: set[str] = set()
_hidden_attrs: frozenset[str] = frozenset([])
_metadata: list[str] = []
- _is_copy: weakref.ReferenceType[NDFrame] | str | None = None
_mgr: Manager
_attrs: dict[Hashable, Any]
_typ: str
@@ -274,9 +267,7 @@ class NDFrame(PandasObject, indexing.IndexingMixin):
# Constructors
def __init__(self, data: Manager) -> None:
- object.__setattr__(self, "_is_copy", None)
object.__setattr__(self, "_mgr", data)
- object.__setattr__(self, "_item_cache", {})
object.__setattr__(self, "_attrs", {})
object.__setattr__(self, "_flags", Flags(self, allows_duplicate_labels=True))
@@ -788,7 +779,6 @@ def _set_axis(self, axis: AxisInt, labels: AnyArrayLike | list) -> None:
"""
labels = ensure_index(labels)
self._mgr.set_axis(axis, labels)
- self._clear_item_cache()
@final
def swapaxes(self, axis1: Axis, axis2: Axis, copy: bool_t | None = None) -> Self:
@@ -1106,7 +1096,6 @@ def _rename(
new_index = ax._transform_index(f, level=level)
result._set_axis_nocheck(new_index, axis=axis_no, inplace=True, copy=False)
- result._clear_item_cache()
if inplace:
self._update_inplace(result)
@@ -2194,8 +2183,6 @@ def __setstate__(self, state) -> None:
elif len(state) == 2:
raise NotImplementedError("Pre-0.12 pickles are no longer supported")
- self._item_cache: dict[Hashable, Series] = {}
-
# ----------------------------------------------------------------------
# Rendering Methods
@@ -3963,44 +3950,6 @@ def to_csv(
storage_options=storage_options,
)
- # ----------------------------------------------------------------------
- # Lookup Caching
-
- def _reset_cacher(self) -> None:
- """
- Reset the cacher.
- """
- raise AbstractMethodError(self)
-
- def _maybe_update_cacher(
- self,
- clear: bool_t = False,
- verify_is_copy: bool_t = True,
- inplace: bool_t = False,
- ) -> None:
- """
- See if we need to update our parent cacher if clear, then clear our
- cache.
-
- Parameters
- ----------
- clear : bool, default False
- Clear the item cache.
- verify_is_copy : bool, default True
- Provide is_copy checks.
- """
- if using_copy_on_write():
- return
-
- if verify_is_copy:
- self._check_setitem_copy(t="referent")
-
- if clear:
- self._clear_item_cache()
-
- def _clear_item_cache(self) -> None:
- raise AbstractMethodError(self)
-
# ----------------------------------------------------------------------
# Indexing Methods
@@ -4119,23 +4068,6 @@ class max_speed
self, method="take"
)
- @final
- def _take_with_is_copy(self, indices, axis: Axis = 0) -> Self:
- """
- Internal version of the `take` method that sets the `_is_copy`
- attribute to keep track of the parent dataframe (using in indexing
- for the SettingWithCopyWarning).
-
- For Series this does the same as the public take (it never sets `_is_copy`).
-
- See the docstring of `take` for full explanation of the parameters.
- """
- result = self.take(indices=indices, axis=axis)
- # Maybe set copy if we didn't actually change the index.
- if self.ndim == 2 and not result._get_axis(axis).equals(self._get_axis(axis)):
- result._set_is_copy(self)
- return result
-
@final
def xs(
self,
@@ -4283,9 +4215,9 @@ class animal locomotion
if isinstance(loc, np.ndarray):
if loc.dtype == np.bool_:
(inds,) = loc.nonzero()
- return self._take_with_is_copy(inds, axis=axis)
+ return self.take(inds, axis=axis)
else:
- return self._take_with_is_copy(loc, axis=axis)
+ return self.take(loc, axis=axis)
if not is_scalar(loc):
new_index = index[loc]
@@ -4311,9 +4243,6 @@ class animal locomotion
result = self.iloc[loc]
result.index = new_index
- # this could be a view
- # but only in a single-dtyped view sliceable case
- result._set_is_copy(self, copy=not result._is_view)
return result
def __getitem__(self, item):
@@ -4349,111 +4278,8 @@ def _slice(self, slobj: slice, axis: AxisInt = 0) -> Self:
new_mgr = self._mgr.get_slice(slobj, axis=axis)
result = self._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
result = result.__finalize__(self)
-
- # this could be a view
- # but only in a single-dtyped view sliceable case
- is_copy = axis != 0 or result._is_view
- result._set_is_copy(self, copy=is_copy)
return result
- @final
- def _set_is_copy(self, ref: NDFrame, copy: bool_t = True) -> None:
- if not copy:
- self._is_copy = None
- else:
- assert ref is not None
- self._is_copy = weakref.ref(ref)
-
- def _check_is_chained_assignment_possible(self) -> bool_t:
- """
- Check if we are a view, have a cacher, and are of mixed type.
- If so, then force a setitem_copy check.
-
- Should be called just near setting a value
-
- Will return a boolean if it we are a view and are cached, but a
- single-dtype meaning that the cacher should be updated following
- setting.
- """
- if self._is_copy:
- self._check_setitem_copy(t="referent")
- return False
-
- @final
- def _check_setitem_copy(self, t: str = "setting", force: bool_t = False) -> None:
- """
-
- Parameters
- ----------
- t : str, the type of setting error
- force : bool, default False
- If True, then force showing an error.
-
- validate if we are doing a setitem on a chained copy.
-
- It is technically possible to figure out that we are setting on
- a copy even WITH a multi-dtyped pandas object. In other words, some
- blocks may be views while other are not. Currently _is_view will ALWAYS
- return False for multi-blocks to avoid having to handle this case.
-
- df = DataFrame(np.arange(0,9), columns=['count'])
- df['group'] = 'b'
-
- # This technically need not raise SettingWithCopy if both are view
- # (which is not generally guaranteed but is usually True. However,
- # this is in general not a good practice and we recommend using .loc.
- df.iloc[0:5]['group'] = 'a'
-
- """
- if using_copy_on_write():
- return
-
- # return early if the check is not needed
- if not (force or self._is_copy):
- return
-
- value = config.get_option("mode.chained_assignment")
- if value is None:
- return
-
- # see if the copy is not actually referred; if so, then dissolve
- # the copy weakref
- if self._is_copy is not None and not isinstance(self._is_copy, str):
- r = self._is_copy()
- if not gc.get_referents(r) or (r is not None and r.shape == self.shape):
- self._is_copy = None
- return
-
- # a custom message
- if isinstance(self._is_copy, str):
- t = self._is_copy
-
- elif t == "referent":
- t = (
- "\n"
- "A value is trying to be set on a copy of a slice from a "
- "DataFrame\n\n"
- "See the caveats in the documentation: "
- "https://pandas.pydata.org/pandas-docs/stable/user_guide/"
- "indexing.html#returning-a-view-versus-a-copy"
- )
-
- else:
- t = (
- "\n"
- "A value is trying to be set on a copy of a slice from a "
- "DataFrame.\n"
- "Try using .loc[row_indexer,col_indexer] = value "
- "instead\n\nSee the caveats in the documentation: "
- "https://pandas.pydata.org/pandas-docs/stable/user_guide/"
- "indexing.html#returning-a-view-versus-a-copy"
- )
-
- if value == "raise":
- raise SettingWithCopyError(t)
- if value == "warn":
- warnings.warn(t, SettingWithCopyWarning, stacklevel=find_stack_level())
-
@final
def __delitem__(self, key) -> None:
"""
@@ -4486,12 +4312,6 @@ def __delitem__(self, key) -> None:
loc = self.axes[-1].get_loc(key)
self._mgr = self._mgr.idelete(loc)
- # delete from the caches
- try:
- del self._item_cache[key]
- except KeyError:
- pass
-
# ----------------------------------------------------------------------
# Unsorted
@@ -4861,22 +4681,17 @@ def _drop_axis(
return result.__finalize__(self)
@final
- def _update_inplace(self, result, verify_is_copy: bool_t = True) -> None:
+ def _update_inplace(self, result) -> None:
"""
Replace self internals with result.
Parameters
----------
result : same type as self
- verify_is_copy : bool, default True
- Provide is_copy checks.
"""
# NOTE: This does *not* call __finalize__ and that's an explicit
# decision that we may revisit in the future.
- self._reset_cache()
- self._clear_item_cache()
self._mgr = result._mgr
- self._maybe_update_cacher(verify_is_copy=verify_is_copy, inplace=True)
@final
def add_prefix(self, prefix: str, axis: Axis | None = None) -> Self:
@@ -6352,26 +6167,11 @@ def _dir_additions(self) -> set[str]:
# ----------------------------------------------------------------------
# Consolidation of internals
- @final
- def _protect_consolidate(self, f):
- """
- Consolidate _mgr -- if the blocks have changed, then clear the
- cache
- """
- blocks_before = len(self._mgr.blocks)
- result = f()
- if len(self._mgr.blocks) != blocks_before:
- self._clear_item_cache()
- return result
-
@final
def _consolidate_inplace(self) -> None:
"""Consolidate data in place and return None"""
- def f() -> None:
- self._mgr = self._mgr.consolidate()
-
- self._protect_consolidate(f)
+ self._mgr = self._mgr.consolidate()
@final
def _consolidate(self):
@@ -6383,8 +6183,7 @@ def _consolidate(self):
-------
consolidated : same type as caller
"""
- f = lambda: self._mgr.consolidate()
- cons_data = self._protect_consolidate(f)
+ cons_data = self._mgr.consolidate()
return self._constructor_from_mgr(cons_data, axes=cons_data.axes).__finalize__(
self
)
@@ -6790,7 +6589,6 @@ def copy(self, deep: bool_t | None = True) -> Self:
dtype: object
"""
data = self._mgr.copy(deep=deep)
- self._clear_item_cache()
return self._constructor_from_mgr(data, axes=data.axes).__finalize__(
self, method="copy"
)
@@ -9183,7 +8981,7 @@ def at_time(self, time, asof: bool_t = False, axis: Axis | None = None) -> Self:
raise TypeError("Index must be DatetimeIndex")
indexer = index.indexer_at_time(time, asof=asof)
- return self._take_with_is_copy(indexer, axis=axis)
+ return self.take(indexer, axis=axis)
@final
def between_time(
@@ -9268,7 +9066,7 @@ def between_time(
include_start=left_inclusive,
include_end=right_inclusive,
)
- return self._take_with_is_copy(indexer, axis=axis)
+ return self.take(indexer, axis=axis)
@final
@doc(klass=_shared_doc_kwargs["klass"])
@@ -12481,14 +12279,9 @@ def _inplace_method(self, other, op) -> Self:
"""
result = op(self, other)
- # Delete cacher
- self._reset_cacher()
-
# this makes sure that we are aligned like the input
- # we are updating inplace so we want to ignore is_copy
- self._update_inplace(
- result.reindex_like(self, copy=False), verify_is_copy=False
- )
+ # we are updating inplace
+ self._update_inplace(result.reindex_like(self, copy=False))
return self
@final
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 64f882e5a146c..fa79b23b8209e 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -34,8 +34,6 @@ class providing the base-class of operations.
import numpy as np
-from pandas._config.config import option_context
-
from pandas._libs import (
Timestamp,
lib,
@@ -1742,32 +1740,28 @@ def f(g):
if not include_groups:
return self._python_apply_general(f, self._obj_with_exclusions)
- # ignore SettingWithCopy here in case the user mutates
- with option_context("mode.chained_assignment", None):
- try:
- result = self._python_apply_general(f, self._selected_obj)
- if (
- not isinstance(self.obj, Series)
- and self._selection is None
- and self._selected_obj.shape != self._obj_with_exclusions.shape
- ):
- warnings.warn(
- message=_apply_groupings_depr.format(
- type(self).__name__, "apply"
- ),
- category=DeprecationWarning,
- stacklevel=find_stack_level(),
- )
- except TypeError:
- # gh-20949
- # try again, with .apply acting as a filtering
- # operation, by excluding the grouping column
- # This would normally not be triggered
- # except if the udf is trying an operation that
- # fails on *some* columns, e.g. a numeric operation
- # on a string grouper column
-
- return self._python_apply_general(f, self._obj_with_exclusions)
+ try:
+ result = self._python_apply_general(f, self._selected_obj)
+ if (
+ not isinstance(self.obj, Series)
+ and self._selection is None
+ and self._selected_obj.shape != self._obj_with_exclusions.shape
+ ):
+ warnings.warn(
+ message=_apply_groupings_depr.format(type(self).__name__, "apply"),
+ category=DeprecationWarning,
+ stacklevel=find_stack_level(),
+ )
+ except TypeError:
+ # gh-20949
+ # try again, with .apply acting as a filtering
+ # operation, by excluding the grouping column
+ # This would normally not be triggered
+ # except if the udf is trying an operation that
+ # fails on *some* columns, e.g. a numeric operation
+ # on a string grouper column
+
+ return self._python_apply_general(f, self._obj_with_exclusions)
return result
diff --git a/pandas/core/indexes/accessors.py b/pandas/core/indexes/accessors.py
index 7e3ba4089ff60..1a24ae8530c12 100644
--- a/pandas/core/indexes/accessors.py
+++ b/pandas/core/indexes/accessors.py
@@ -106,16 +106,7 @@ def _delegate_property_get(self, name: str):
else:
index = self._parent.index
# return the result as a Series
- result = Series(result, index=index, name=self.name).__finalize__(self._parent)
-
- # setting this object will show a SettingWithCopyWarning/Error
- result._is_copy = (
- "modifications to a property of a datetimelike "
- "object are not supported and are discarded. "
- "Change values on the original."
- )
-
- return result
+ return Series(result, index=index, name=self.name).__finalize__(self._parent)
def _delegate_property_set(self, name: str, value, *args, **kwargs):
raise ValueError(
@@ -134,19 +125,10 @@ def _delegate_method(self, name: str, *args, **kwargs):
if not is_list_like(result):
return result
- result = Series(result, index=self._parent.index, name=self.name).__finalize__(
+ return Series(result, index=self._parent.index, name=self.name).__finalize__(
self._parent
)
- # setting this object will show a SettingWithCopyWarning/Error
- result._is_copy = (
- "modifications to a method of a datetimelike "
- "object are not supported and are discarded. "
- "Change values on the original."
- )
-
- return result
-
@delegate_names(
delegate=ArrowExtensionArray,
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index b58c3179dec09..ab06dd3ea5af0 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -1194,7 +1194,7 @@ def _getbool_axis(self, key, axis: AxisInt):
labels = self.obj._get_axis(axis)
key = check_bool_indexer(labels, key)
inds = key.nonzero()[0]
- return self.obj._take_with_is_copy(inds, axis=axis)
+ return self.obj.take(inds, axis=axis)
@doc(IndexingMixin.loc)
@@ -1697,7 +1697,7 @@ def _get_list_axis(self, key, axis: AxisInt):
`axis` can only be zero.
"""
try:
- return self.obj._take_with_is_copy(key, axis=axis)
+ return self.obj.take(key, axis=axis)
except IndexError as err:
# re-raise with different error message, e.g. test_getitem_ndarray_3d
raise IndexError("positional indexers are out-of-bounds") from err
@@ -1905,8 +1905,6 @@ def _setitem_with_indexer(self, indexer, value, name: str = "iloc") -> None:
reindexers, allow_dups=True
)
self.obj._mgr = new_obj._mgr
- self.obj._maybe_update_cacher(clear=True)
- self.obj._is_copy = None
nindexer.append(labels.get_loc(key))
@@ -2154,8 +2152,6 @@ def _setitem_single_column(self, loc: int, value, plane_indexer) -> None:
# falling back to casting if necessary)
self.obj._mgr.column_setitem(loc, plane_indexer, value)
- self.obj._clear_item_cache()
-
def _setitem_single_block(self, indexer, value, name: str) -> None:
"""
_setitem_with_indexer for the case when we have a single Block.
@@ -2191,12 +2187,8 @@ def _setitem_single_block(self, indexer, value, name: str) -> None:
if isinstance(value, ABCDataFrame) and name != "iloc":
value = self._align_frame(indexer, value)._values
- # check for chained assignment
- self.obj._check_is_chained_assignment_possible()
-
# actually do the set
self.obj._mgr = self.obj._mgr.setitem(indexer=indexer, value=value)
- self.obj._maybe_update_cacher(clear=True, inplace=True)
def _setitem_with_indexer_missing(self, indexer, value):
"""
@@ -2262,7 +2254,6 @@ def _setitem_with_indexer_missing(self, indexer, value):
self.obj._mgr = self.obj._constructor(
new_values, index=new_index, name=self.obj.name
)._mgr
- self.obj._maybe_update_cacher(clear=True)
elif self.ndim == 2:
if not len(self.obj.columns):
@@ -2306,7 +2297,6 @@ def _setitem_with_indexer_missing(self, indexer, value):
self.obj._mgr = df._mgr
else:
self.obj._mgr = self.obj._append(value)._mgr
- self.obj._maybe_update_cacher(clear=True)
def _ensure_iterable_column_indexer(self, column_indexer):
"""
diff --git a/pandas/core/interchange/from_dataframe.py b/pandas/core/interchange/from_dataframe.py
index 73f492c83c2ff..390f5e0d0d5ae 100644
--- a/pandas/core/interchange/from_dataframe.py
+++ b/pandas/core/interchange/from_dataframe.py
@@ -10,7 +10,6 @@
import numpy as np
from pandas.compat._optional import import_optional_dependency
-from pandas.errors import SettingWithCopyError
import pandas as pd
from pandas.core.interchange.dataframe_protocol import (
@@ -548,9 +547,5 @@ def set_nulls(
# cast the `data` to nullable float dtype.
data = data.astype(float)
data[null_pos] = None
- except SettingWithCopyError:
- # `SettingWithCopyError` may happen for datetime-like with missing values.
- data = data.copy()
- data[null_pos] = None
return data
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index fa54fde2ece84..5a8a14168d504 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -690,7 +690,7 @@ def is_view(self) -> bool:
# e.g. [ b.values.base is not None for b in self.blocks ]
# but then we have the case of possibly some blocks being a view
# and some blocks not. setting in theory is possible on the non-view
- # blocks w/o causing a SettingWithCopy raise/warn. But this is a bit
+ # blocks. But this is a bit
# complicated
return False
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 94be7bdbaca16..e9d340237c234 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -22,7 +22,6 @@
overload,
)
import warnings
-import weakref
import numpy as np
@@ -1239,7 +1238,6 @@ def __setitem__(self, key, value) -> None:
check_dict_or_set_indexers(key)
key = com.apply_if_callable(key, self)
- cacher_needs_updating = self._check_is_chained_assignment_possible()
if key is Ellipsis:
key = slice(None)
@@ -1317,9 +1315,6 @@ def __setitem__(self, key, value) -> None:
else:
self._set_with(key, value)
- if cacher_needs_updating:
- self._maybe_update_cacher(inplace=True)
-
def _set_with_engine(self, key, value) -> None:
loc = self.index.get_loc(key)
@@ -1371,7 +1366,6 @@ def _set_values(self, key, value) -> None:
key = key._values
self._mgr = self._mgr.setitem(indexer=key, value=value)
- self._maybe_update_cacher()
def _set_value(self, label, value, takeable: bool = False) -> None:
"""
@@ -1400,84 +1394,6 @@ def _set_value(self, label, value, takeable: bool = False) -> None:
self._set_values(loc, value)
- # ----------------------------------------------------------------------
- # Lookup Caching
-
- @property
- def _is_cached(self) -> bool:
- """Return boolean indicating if self is cached or not."""
- return getattr(self, "_cacher", None) is not None
-
- def _get_cacher(self):
- """return my cacher or None"""
- cacher = getattr(self, "_cacher", None)
- if cacher is not None:
- cacher = cacher[1]()
- return cacher
-
- def _reset_cacher(self) -> None:
- """
- Reset the cacher.
- """
- if hasattr(self, "_cacher"):
- del self._cacher
-
- def _set_as_cached(self, item, cacher) -> None:
- """
- Set the _cacher attribute on the calling object with a weakref to
- cacher.
- """
- if using_copy_on_write():
- return
- self._cacher = (item, weakref.ref(cacher))
-
- def _clear_item_cache(self) -> None:
- # no-op for Series
- pass
-
- def _check_is_chained_assignment_possible(self) -> bool:
- """
- See NDFrame._check_is_chained_assignment_possible.__doc__
- """
- if self._is_view and self._is_cached:
- ref = self._get_cacher()
- if ref is not None and ref._is_mixed_type:
- self._check_setitem_copy(t="referent", force=True)
- return True
- return super()._check_is_chained_assignment_possible()
-
- def _maybe_update_cacher(
- self, clear: bool = False, verify_is_copy: bool = True, inplace: bool = False
- ) -> None:
- """
- See NDFrame._maybe_update_cacher.__doc__
- """
- # for CoW, we never want to update the parent DataFrame cache
- # if the Series changed, but don't keep track of any cacher
- if using_copy_on_write():
- return
- cacher = getattr(self, "_cacher", None)
- if cacher is not None:
- ref: DataFrame = cacher[1]()
-
- # we are trying to reference a dead referent, hence
- # a copy
- if ref is None:
- del self._cacher
- elif len(self) == len(ref) and self.name in ref.columns:
- # GH#42530 self.name must be in ref.columns
- # to ensure column still in dataframe
- # otherwise, either self or ref has swapped in new arrays
- ref._maybe_cache_changed(cacher[0], self, inplace=inplace)
- else:
- # GH#33675 we have swapped in a new array, so parent
- # reference to self is now invalid
- ref._item_cache.pop(cacher[0], None)
-
- super()._maybe_update_cacher(
- clear=clear, verify_is_copy=verify_is_copy, inplace=inplace
- )
-
# ----------------------------------------------------------------------
# Unsorted
@@ -3578,7 +3494,6 @@ def update(self, other: Series | Sequence | Mapping) -> None:
mask = notna(other)
self._mgr = self._mgr.putmask(mask=mask, new=other)
- self._maybe_update_cacher()
# ----------------------------------------------------------------------
# Reindexing, sorting
@@ -3782,13 +3697,6 @@ def sort_values(
# Validate the axis parameter
self._get_axis_number(axis)
- # GH 5856/5853
- if inplace and self._is_cached:
- raise ValueError(
- "This Series is a view of some other array, to "
- "sort in-place you must create a copy"
- )
-
if is_list_like(ascending):
ascending = cast(Sequence[bool], ascending)
if len(ascending) != 1:
diff --git a/pandas/errors/__init__.py b/pandas/errors/__init__.py
index 52b896dc01e8f..97db508bda1b4 100644
--- a/pandas/errors/__init__.py
+++ b/pandas/errors/__init__.py
@@ -408,50 +408,6 @@ class SpecificationError(Exception):
"""
-class SettingWithCopyError(ValueError):
- """
- Exception raised when trying to set on a copied slice from a ``DataFrame``.
-
- The ``mode.chained_assignment`` needs to be set to set to 'raise.' This can
- happen unintentionally when chained indexing.
-
- For more information on evaluation order,
- see :ref:`the user guide<indexing.evaluation_order>`.
-
- For more information on view vs. copy,
- see :ref:`the user guide<indexing.view_versus_copy>`.
-
- Examples
- --------
- >>> pd.options.mode.chained_assignment = 'raise'
- >>> df = pd.DataFrame({'A': [1, 1, 1, 2, 2]}, columns=['A'])
- >>> df.loc[0:3]['A'] = 'a' # doctest: +SKIP
- ... # SettingWithCopyError: A value is trying to be set on a copy of a...
- """
-
-
-class SettingWithCopyWarning(Warning):
- """
- Warning raised when trying to set on a copied slice from a ``DataFrame``.
-
- The ``mode.chained_assignment`` needs to be set to set to 'warn.'
- 'Warn' is the default option. This can happen unintentionally when
- chained indexing.
-
- For more information on evaluation order,
- see :ref:`the user guide<indexing.evaluation_order>`.
-
- For more information on view vs. copy,
- see :ref:`the user guide<indexing.view_versus_copy>`.
-
- Examples
- --------
- >>> df = pd.DataFrame({'A': [1, 1, 1, 2, 2]}, columns=['A'])
- >>> df.loc[0:3]['A'] = 'a' # doctest: +SKIP
- ... # SettingWithCopyWarning: A value is trying to be set on a copy of a...
- """
-
-
class ChainedAssignmentError(Warning):
"""
Warning raised when trying to set using chained assignment.
@@ -462,8 +418,8 @@ class ChainedAssignmentError(Warning):
Copy-on-Write always behaves as a copy. Thus, assigning through a chain
can never update the original Series or DataFrame.
- For more information on view vs. copy,
- see :ref:`the user guide<indexing.view_versus_copy>`.
+ For more information on Copy-on-Write,
+ see :ref:`the user guide<copy_on_write>`.
Examples
--------
@@ -787,8 +743,6 @@ class InvalidComparison(Exception):
"PossiblePrecisionLoss",
"PyperclipException",
"PyperclipWindowsException",
- "SettingWithCopyError",
- "SettingWithCopyWarning",
"SpecificationError",
"UndefinedVariableError",
"UnsortedIndexError",
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index 594fb8651f8f0..cea34cdfb0b9d 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -251,8 +251,6 @@ def __init__(
self.default_handler = default_handler
self.index = index
self.indent = indent
-
- self.is_copy = None
self._format_axes()
def _format_axes(self) -> None:
diff --git a/pandas/tests/copy_view/test_chained_assignment_deprecation.py b/pandas/tests/copy_view/test_chained_assignment_deprecation.py
index cfa9cf64357b6..e1a76e66c107f 100644
--- a/pandas/tests/copy_view/test_chained_assignment_deprecation.py
+++ b/pandas/tests/copy_view/test_chained_assignment_deprecation.py
@@ -1,15 +1,9 @@
import numpy as np
import pytest
-from pandas.errors import (
- ChainedAssignmentError,
- SettingWithCopyWarning,
-)
+from pandas.errors import ChainedAssignmentError
-from pandas import (
- DataFrame,
- option_context,
-)
+from pandas import DataFrame
import pandas._testing as tm
@@ -53,15 +47,11 @@ def test_series_setitem(indexer, using_copy_on_write):
assert "ChainedAssignmentError" in record[0].message.args[0]
-@pytest.mark.filterwarnings("ignore::pandas.errors.SettingWithCopyWarning")
@pytest.mark.parametrize(
"indexer", ["a", ["a", "b"], slice(0, 2), np.array([True, False, True])]
)
-def test_frame_setitem(indexer, using_copy_on_write):
+def test_frame_setitem(indexer):
df = DataFrame({"a": [1, 2, 3, 4, 5], "b": 1})
- extra_warnings = () if using_copy_on_write else (SettingWithCopyWarning,)
-
- with option_context("chained_assignment", "warn"):
- with tm.raises_chained_assignment_error(extra_warnings=extra_warnings):
- df[0:3][indexer] = 10
+ with tm.raises_chained_assignment_error():
+ df[0:3][indexer] = 10
diff --git a/pandas/tests/copy_view/test_clip.py b/pandas/tests/copy_view/test_clip.py
index 9be9ba6f144c4..c18a2e1e65d26 100644
--- a/pandas/tests/copy_view/test_clip.py
+++ b/pandas/tests/copy_view/test_clip.py
@@ -1,9 +1,6 @@
import numpy as np
-from pandas import (
- DataFrame,
- option_context,
-)
+from pandas import DataFrame
import pandas._testing as tm
from pandas.tests.copy_view.util import get_array
@@ -89,9 +86,7 @@ def test_clip_chained_inplace(using_copy_on_write):
df["a"].clip(1, 2, inplace=True)
with tm.assert_produces_warning(None):
- with option_context("mode.chained_assignment", None):
- df[["a"]].clip(1, 2, inplace=True)
+ df[["a"]].clip(1, 2, inplace=True)
with tm.assert_produces_warning(None):
- with option_context("mode.chained_assignment", None):
- df[df["a"] > 1].clip(1, 2, inplace=True)
+ df[df["a"] > 1].clip(1, 2, inplace=True)
diff --git a/pandas/tests/copy_view/test_indexing.py b/pandas/tests/copy_view/test_indexing.py
index 69fb8fe2c6f63..da72e89b23ca0 100644
--- a/pandas/tests/copy_view/test_indexing.py
+++ b/pandas/tests/copy_view/test_indexing.py
@@ -1,8 +1,6 @@
import numpy as np
import pytest
-from pandas.errors import SettingWithCopyWarning
-
from pandas.core.dtypes.common import is_float_dtype
import pandas as pd
@@ -59,17 +57,10 @@ def test_subset_column_selection(backend, using_copy_on_write):
subset = df[["a", "c"]]
- if using_copy_on_write:
- # the subset shares memory ...
- assert np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
- # ... but uses CoW when being modified
- subset.iloc[0, 0] = 0
- else:
- assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
- # INFO this no longer raise warning since pandas 1.4
- # with pd.option_context("chained_assignment", "warn"):
- # with tm.assert_produces_warning(SettingWithCopyWarning):
- subset.iloc[0, 0] = 0
+ # the subset shares memory ...
+ assert np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+ # ... but uses CoW when being modified
+ subset.iloc[0, 0] = 0
assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
@@ -113,37 +104,24 @@ def test_subset_row_slice(backend, using_copy_on_write):
assert np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
- if using_copy_on_write:
- subset.iloc[0, 0] = 0
- assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
-
- else:
- # INFO this no longer raise warning since pandas 1.4
- # with pd.option_context("chained_assignment", "warn"):
- # with tm.assert_produces_warning(SettingWithCopyWarning):
- subset.iloc[0, 0] = 0
+ subset.iloc[0, 0] = 0
+ assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
subset._mgr._verify_integrity()
expected = DataFrame({"a": [0, 3], "b": [5, 6], "c": [0.2, 0.3]}, index=range(1, 3))
tm.assert_frame_equal(subset, expected)
- if using_copy_on_write:
- # original parent dataframe is not modified (CoW)
- tm.assert_frame_equal(df, df_orig)
- else:
- # original parent dataframe is actually updated
- df_orig.iloc[1, 0] = 0
- tm.assert_frame_equal(df, df_orig)
+ # original parent dataframe is not modified (CoW)
+ tm.assert_frame_equal(df, df_orig)
@pytest.mark.parametrize(
"dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
)
-def test_subset_column_slice(backend, using_copy_on_write, dtype):
+def test_subset_column_slice(backend, dtype):
# Case: taking a subset of the columns of a DataFrame using a slice
# + afterwards modifying the subset
dtype_backend, DataFrame, _ = backend
- single_block = dtype == "int64" and dtype_backend == "numpy"
df = DataFrame(
{"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
)
@@ -152,27 +130,16 @@ def test_subset_column_slice(backend, using_copy_on_write, dtype):
subset = df.iloc[:, 1:]
subset._mgr._verify_integrity()
- if using_copy_on_write:
- assert np.shares_memory(get_array(subset, "b"), get_array(df, "b"))
+ assert np.shares_memory(get_array(subset, "b"), get_array(df, "b"))
- subset.iloc[0, 0] = 0
- assert not np.shares_memory(get_array(subset, "b"), get_array(df, "b"))
- else:
- # we only get a warning in case of a single block
- warn = SettingWithCopyWarning if single_block else None
- with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(warn):
- subset.iloc[0, 0] = 0
+ subset.iloc[0, 0] = 0
+ assert not np.shares_memory(get_array(subset, "b"), get_array(df, "b"))
expected = DataFrame({"b": [0, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)})
tm.assert_frame_equal(subset, expected)
# original parent dataframe is not modified (also not for BlockManager case,
# except for single block)
- if not using_copy_on_write and single_block:
- df_orig.iloc[0, 1] = 0
- tm.assert_frame_equal(df, df_orig)
- else:
- tm.assert_frame_equal(df, df_orig)
+ tm.assert_frame_equal(df, df_orig)
@pytest.mark.parametrize(
@@ -288,7 +255,7 @@ def test_subset_iloc_rows_columns(
[slice(0, 2), np.array([True, True, False]), np.array([0, 1])],
ids=["slice", "mask", "array"],
)
-def test_subset_set_with_row_indexer(backend, indexer_si, indexer, using_copy_on_write):
+def test_subset_set_with_row_indexer(backend, indexer_si, indexer):
# Case: setting values with a row indexer on a viewing subset
# subset[indexer] = value and subset.iloc[indexer] = value
_, DataFrame, _ = backend
@@ -303,29 +270,17 @@ def test_subset_set_with_row_indexer(backend, indexer_si, indexer, using_copy_on
):
pytest.skip("setitem with labels selects on columns")
- if using_copy_on_write:
- indexer_si(subset)[indexer] = 0
- else:
- # INFO iloc no longer raises warning since pandas 1.4
- warn = SettingWithCopyWarning if indexer_si is tm.setitem else None
- with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(warn):
- indexer_si(subset)[indexer] = 0
+ indexer_si(subset)[indexer] = 0
expected = DataFrame(
{"a": [0, 0, 4], "b": [0, 0, 7], "c": [0.0, 0.0, 0.4]}, index=range(1, 4)
)
tm.assert_frame_equal(subset, expected)
- if using_copy_on_write:
- # original parent dataframe is not modified (CoW)
- tm.assert_frame_equal(df, df_orig)
- else:
- # original parent dataframe is actually updated
- df_orig[1:3] = 0
- tm.assert_frame_equal(df, df_orig)
+ # original parent dataframe is not modified (CoW)
+ tm.assert_frame_equal(df, df_orig)
-def test_subset_set_with_mask(backend, using_copy_on_write):
+def test_subset_set_with_mask(backend):
# Case: setting values with a mask on a viewing subset: subset[mask] = value
_, DataFrame, _ = backend
df = DataFrame({"a": [1, 2, 3, 4], "b": [4, 5, 6, 7], "c": [0.1, 0.2, 0.3, 0.4]})
@@ -334,28 +289,16 @@ def test_subset_set_with_mask(backend, using_copy_on_write):
mask = subset > 3
- if using_copy_on_write:
- subset[mask] = 0
- else:
- with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(SettingWithCopyWarning):
- subset[mask] = 0
+ subset[mask] = 0
expected = DataFrame(
{"a": [2, 3, 0], "b": [0, 0, 0], "c": [0.20, 0.3, 0.4]}, index=range(1, 4)
)
tm.assert_frame_equal(subset, expected)
- if using_copy_on_write:
- # original parent dataframe is not modified (CoW)
- tm.assert_frame_equal(df, df_orig)
- else:
- # original parent dataframe is actually updated
- df_orig.loc[3, "a"] = 0
- df_orig.loc[1:3, "b"] = 0
- tm.assert_frame_equal(df, df_orig)
+ tm.assert_frame_equal(df, df_orig)
-def test_subset_set_column(backend, using_copy_on_write):
+def test_subset_set_column(backend):
# Case: setting a single column on a viewing subset -> subset[col] = value
dtype_backend, DataFrame, _ = backend
df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
@@ -367,13 +310,7 @@ def test_subset_set_column(backend, using_copy_on_write):
else:
arr = pd.array([10, 11], dtype="Int64")
- if using_copy_on_write:
- subset["a"] = arr
- else:
- with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(SettingWithCopyWarning):
- subset["a"] = arr
-
+ subset["a"] = arr
subset._mgr._verify_integrity()
expected = DataFrame(
{"a": [10, 11], "b": [5, 6], "c": [0.2, 0.3]}, index=range(1, 3)
@@ -459,17 +396,11 @@ def test_subset_set_columns(backend, using_copy_on_write, dtype):
df_orig = df.copy()
subset = df[1:3]
- if using_copy_on_write:
- subset[["a", "c"]] = 0
- else:
- with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(SettingWithCopyWarning):
- subset[["a", "c"]] = 0
+ subset[["a", "c"]] = 0
subset._mgr._verify_integrity()
- if using_copy_on_write:
- # first and third column should certainly have no references anymore
- assert all(subset._mgr._has_no_reference(i) for i in [0, 2])
+ # first and third column should certainly have no references anymore
+ assert all(subset._mgr._has_no_reference(i) for i in [0, 2])
expected = DataFrame({"a": [0, 0], "b": [5, 6], "c": [0, 0]}, index=range(1, 3))
if dtype_backend == "nullable":
# there is not yet a global option, so overriding a column by setting a scalar
@@ -582,7 +513,7 @@ def test_subset_chained_getitem(
@pytest.mark.parametrize(
"dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
)
-def test_subset_chained_getitem_column(backend, dtype, using_copy_on_write):
+def test_subset_chained_getitem_column(backend, dtype):
# Case: creating a subset using multiple, chained getitem calls using views
# still needs to guarantee proper CoW behaviour
dtype_backend, DataFrame, Series = backend
@@ -593,22 +524,14 @@ def test_subset_chained_getitem_column(backend, dtype, using_copy_on_write):
# modify subset -> don't modify parent
subset = df[:]["a"][0:2]
- df._clear_item_cache()
subset.iloc[0] = 0
- if using_copy_on_write:
- tm.assert_frame_equal(df, df_orig)
- else:
- assert df.iloc[0, 0] == 0
+ tm.assert_frame_equal(df, df_orig)
# modify parent -> don't modify subset
subset = df[:]["a"][0:2]
- df._clear_item_cache()
df.iloc[0, 0] = 0
expected = Series([1, 2], name="a")
- if using_copy_on_write:
- tm.assert_series_equal(subset, expected)
- else:
- assert subset.iloc[0] == 0
+ tm.assert_series_equal(subset, expected)
@pytest.mark.parametrize(
@@ -877,7 +800,7 @@ def test_del_series(backend):
# Accessing column as Series
-def test_column_as_series(backend, using_copy_on_write):
+def test_column_as_series(backend):
# Case: selecting a single column now also uses Copy-on-Write
dtype_backend, DataFrame, Series = backend
df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
@@ -886,28 +809,17 @@ def test_column_as_series(backend, using_copy_on_write):
s = df["a"]
assert np.shares_memory(get_array(s, "a"), get_array(df, "a"))
-
- if using_copy_on_write:
- s[0] = 0
- else:
- warn = SettingWithCopyWarning if dtype_backend == "numpy" else None
- with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(warn):
- s[0] = 0
+ s[0] = 0
expected = Series([0, 2, 3], name="a")
tm.assert_series_equal(s, expected)
- if using_copy_on_write:
- # assert not np.shares_memory(s.values, get_array(df, "a"))
- tm.assert_frame_equal(df, df_orig)
- # ensure cached series on getitem is not the changed series
- tm.assert_series_equal(df["a"], df_orig["a"])
- else:
- df_orig.iloc[0, 0] = 0
- tm.assert_frame_equal(df, df_orig)
+ # assert not np.shares_memory(s.values, get_array(df, "a"))
+ tm.assert_frame_equal(df, df_orig)
+ # ensure cached series on getitem is not the changed series
+ tm.assert_series_equal(df["a"], df_orig["a"])
-def test_column_as_series_set_with_upcast(backend, using_copy_on_write):
+def test_column_as_series_set_with_upcast(backend):
# Case: selecting a single column now also uses Copy-on-Write -> when
# setting a value causes an upcast, we don't need to update the parent
# DataFrame through the cache mechanism
@@ -920,32 +832,15 @@ def test_column_as_series_set_with_upcast(backend, using_copy_on_write):
with pytest.raises(TypeError, match="Invalid value"):
s[0] = "foo"
expected = Series([1, 2, 3], name="a")
- elif using_copy_on_write:
+ else:
with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
s[0] = "foo"
expected = Series(["foo", 2, 3], dtype=object, name="a")
- else:
- with pd.option_context("chained_assignment", "warn"):
- msg = "|".join(
- [
- "A value is trying to be set on a copy of a slice from a DataFrame",
- "Setting an item of incompatible dtype is deprecated",
- ]
- )
- with tm.assert_produces_warning(
- (SettingWithCopyWarning, FutureWarning), match=msg
- ):
- s[0] = "foo"
- expected = Series(["foo", 2, 3], dtype=object, name="a")
tm.assert_series_equal(s, expected)
- if using_copy_on_write:
- tm.assert_frame_equal(df, df_orig)
- # ensure cached series on getitem is not the changed series
- tm.assert_series_equal(df["a"], df_orig["a"])
- else:
- df_orig["a"] = expected
- tm.assert_frame_equal(df, df_orig)
+ tm.assert_frame_equal(df, df_orig)
+ # ensure cached series on getitem is not the changed series
+ tm.assert_series_equal(df["a"], df_orig["a"])
@pytest.mark.parametrize(
@@ -957,12 +852,7 @@ def test_column_as_series_set_with_upcast(backend, using_copy_on_write):
],
ids=["getitem", "loc", "iloc"],
)
-def test_column_as_series_no_item_cache(
- request,
- backend,
- method,
- using_copy_on_write,
-):
+def test_column_as_series_no_item_cache(request, backend, method):
# Case: selecting a single column (which now also uses Copy-on-Write to protect
# the view) should always give a new object (i.e. not make use of a cache)
dtype_backend, DataFrame, _ = backend
@@ -972,25 +862,12 @@ def test_column_as_series_no_item_cache(
s1 = method(df)
s2 = method(df)
- is_iloc = "iloc" in request.node.name
- if using_copy_on_write or is_iloc:
- assert s1 is not s2
- else:
- assert s1 is s2
+ assert s1 is not s2
- if using_copy_on_write:
- s1.iloc[0] = 0
- else:
- warn = SettingWithCopyWarning if dtype_backend == "numpy" else None
- with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(warn):
- s1.iloc[0] = 0
+ s1.iloc[0] = 0
- if using_copy_on_write:
- tm.assert_series_equal(s2, df_orig["a"])
- tm.assert_frame_equal(df, df_orig)
- else:
- assert s2.iloc[0] == 0
+ tm.assert_series_equal(s2, df_orig["a"])
+ tm.assert_frame_equal(df, df_orig)
# TODO add tests for other indexing methods on the Series
@@ -1074,23 +951,16 @@ def test_series_midx_slice(using_copy_on_write):
tm.assert_series_equal(ser, expected)
-def test_getitem_midx_slice(using_copy_on_write):
+def test_getitem_midx_slice():
df = DataFrame({("a", "x"): [1, 2], ("a", "y"): 1, ("b", "x"): 2})
df_orig = df.copy()
new_df = df[("a",)]
- if using_copy_on_write:
- assert not new_df._mgr._has_no_reference(0)
+ assert not new_df._mgr._has_no_reference(0)
assert np.shares_memory(get_array(df, ("a", "x")), get_array(new_df, "x"))
- if using_copy_on_write:
- new_df.iloc[0, 0] = 100
- tm.assert_frame_equal(df_orig, df)
- else:
- with pd.option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(SettingWithCopyWarning):
- new_df.iloc[0, 0] = 100
- assert df.iloc[0, 0] == 100
+ new_df.iloc[0, 0] = 100
+ tm.assert_frame_equal(df_orig, df)
def test_series_midx_tuples_slice(using_copy_on_write):
diff --git a/pandas/tests/copy_view/test_methods.py b/pandas/tests/copy_view/test_methods.py
index b3bd63e1c7e4c..011d18f8e609f 100644
--- a/pandas/tests/copy_view/test_methods.py
+++ b/pandas/tests/copy_view/test_methods.py
@@ -1,8 +1,6 @@
import numpy as np
import pytest
-from pandas.errors import SettingWithCopyWarning
-
import pandas as pd
from pandas import (
DataFrame,
@@ -12,7 +10,6 @@
Series,
Timestamp,
date_range,
- option_context,
period_range,
)
import pandas._testing as tm
@@ -1540,12 +1537,10 @@ def test_chained_where_mask(using_copy_on_write, func):
getattr(df["a"], func)(df["a"] > 2, 5, inplace=True)
with tm.assert_produces_warning(None):
- with option_context("mode.chained_assignment", None):
- getattr(df[["a"]], func)(df["a"] > 2, 5, inplace=True)
+ getattr(df[["a"]], func)(df["a"] > 2, 5, inplace=True)
with tm.assert_produces_warning(None):
- with option_context("mode.chained_assignment", None):
- getattr(df[df["a"] > 1], func)(df["a"] > 2, 5, inplace=True)
+ getattr(df[df["a"] > 1], func)(df["a"] > 2, 5, inplace=True)
def test_asfreq_noop(using_copy_on_write):
@@ -1667,23 +1662,10 @@ def test_get(using_copy_on_write, key):
result = df.get(key)
- if using_copy_on_write:
- assert np.shares_memory(get_array(result, "a"), get_array(df, "a"))
- result.iloc[0] = 0
- assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
- tm.assert_frame_equal(df, df_orig)
- else:
- # for non-CoW it depends on whether we got a Series or DataFrame if it
- # is a view or copy or triggers a warning or not
- warn = SettingWithCopyWarning if isinstance(key, list) else None
- with option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(warn):
- result.iloc[0] = 0
-
- if isinstance(key, list):
- tm.assert_frame_equal(df, df_orig)
- else:
- assert df.iloc[0, 0] == 0
+ assert np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+ result.iloc[0] = 0
+ assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+ tm.assert_frame_equal(df, df_orig)
@pytest.mark.parametrize("axis, key", [(0, 0), (1, "a")])
@@ -1701,20 +1683,13 @@ def test_xs(using_copy_on_write, axis, key, dtype):
if axis == 1 or single_block:
assert np.shares_memory(get_array(df, "a"), get_array(result))
- elif using_copy_on_write:
+ else:
assert result._mgr._has_no_reference(0)
if using_copy_on_write or single_block:
result.iloc[0] = 0
- else:
- with option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(SettingWithCopyWarning):
- result.iloc[0] = 0
- if using_copy_on_write or (not single_block and axis == 0):
- tm.assert_frame_equal(df, df_orig)
- else:
- assert df.iloc[0, 0] == 0
+ tm.assert_frame_equal(df, df_orig)
@pytest.mark.parametrize("axis", [0, 1])
@@ -1733,14 +1708,7 @@ def test_xs_multiindex(using_copy_on_write, key, level, axis):
assert np.shares_memory(
get_array(df, df.columns[0]), get_array(result, result.columns[0])
)
-
- if not using_copy_on_write:
- warn = SettingWithCopyWarning
- else:
- warn = None
- with option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(warn):
- result.iloc[0, 0] = 0
+ result.iloc[0, 0] = 0
tm.assert_frame_equal(df, df_orig)
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index c8787ac0b364e..b48ad7e3481b9 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -13,7 +13,6 @@
from pandas.errors import (
InvalidIndexError,
PerformanceWarning,
- SettingWithCopyError,
)
from pandas.core.dtypes.common import is_integer
@@ -287,7 +286,7 @@ def test_setattr_column(self):
df.foobar = 5
assert (df.foobar == 5).all()
- def test_setitem(self, float_frame, using_copy_on_write, using_infer_string):
+ def test_setitem(self, float_frame, using_infer_string):
# not sure what else to do here
series = float_frame["A"][::2]
float_frame["col5"] = series
@@ -322,13 +321,8 @@ def test_setitem(self, float_frame, using_copy_on_write, using_infer_string):
# so raise/warn
smaller = float_frame[:2]
- msg = r"\nA value is trying to be set on a copy of a slice from a DataFrame"
- if using_copy_on_write:
- # With CoW, adding a new column doesn't raise a warning
- smaller["col10"] = ["1", "2"]
- else:
- with pytest.raises(SettingWithCopyError, match=msg):
- smaller["col10"] = ["1", "2"]
+ # With CoW, adding a new column doesn't raise a warning
+ smaller["col10"] = ["1", "2"]
if using_infer_string:
assert smaller["col10"].dtype == "string"
diff --git a/pandas/tests/frame/indexing/test_xs.py b/pandas/tests/frame/indexing/test_xs.py
index dc2f0b61e3ba0..96ae1050ed15a 100644
--- a/pandas/tests/frame/indexing/test_xs.py
+++ b/pandas/tests/frame/indexing/test_xs.py
@@ -3,8 +3,6 @@
import numpy as np
import pytest
-from pandas.errors import SettingWithCopyError
-
from pandas import (
DataFrame,
Index,
@@ -122,21 +120,16 @@ def test_xs_keep_level(self):
result = df.xs((2008, "sat"), level=["year", "day"], drop_level=False)
tm.assert_frame_equal(result, expected)
- def test_xs_view(self, using_copy_on_write):
+ def test_xs_view(self):
# in 0.14 this will return a view if possible a copy otherwise, but
# this is numpy dependent
dm = DataFrame(np.arange(20.0).reshape(4, 5), index=range(4), columns=range(5))
df_orig = dm.copy()
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- dm.xs(2)[:] = 20
- tm.assert_frame_equal(dm, df_orig)
- else:
- with tm.raises_chained_assignment_error():
- dm.xs(2)[:] = 20
- assert (dm.xs(2) == 20).all()
+ with tm.raises_chained_assignment_error():
+ dm.xs(2)[:] = 20
+ tm.assert_frame_equal(dm, df_orig)
class TestXSWithMultiIndex:
@@ -194,42 +187,22 @@ def test_xs_level_eq_2(self):
result = df.xs("c", level=2)
tm.assert_frame_equal(result, expected)
- def test_xs_setting_with_copy_error(
- self,
- multiindex_dataframe_random_data,
- using_copy_on_write,
- ):
+ def test_xs_setting_with_copy_error(self, multiindex_dataframe_random_data):
# this is a copy in 0.14
df = multiindex_dataframe_random_data
df_orig = df.copy()
result = df.xs("two", level="second")
- if using_copy_on_write:
- result[:] = 10
- else:
- # setting this will give a SettingWithCopyError
- # as we are trying to write a view
- msg = "A value is trying to be set on a copy of a slice from a DataFrame"
- with pytest.raises(SettingWithCopyError, match=msg):
- result[:] = 10
+ result[:] = 10
tm.assert_frame_equal(df, df_orig)
- def test_xs_setting_with_copy_error_multiple(
- self, four_level_index_dataframe, using_copy_on_write
- ):
+ def test_xs_setting_with_copy_error_multiple(self, four_level_index_dataframe):
# this is a copy in 0.14
df = four_level_index_dataframe
df_orig = df.copy()
result = df.xs(("a", 4), level=["one", "four"])
- if using_copy_on_write:
- result[:] = 10
- else:
- # setting this will give a SettingWithCopyError
- # as we are trying to write a view
- msg = "A value is trying to be set on a copy of a slice from a DataFrame"
- with pytest.raises(SettingWithCopyError, match=msg):
- result[:] = 10
+ result[:] = 10
tm.assert_frame_equal(df, df_orig)
@pytest.mark.parametrize("key, level", [("one", "second"), (["one"], ["second"])])
diff --git a/pandas/tests/frame/methods/test_asof.py b/pandas/tests/frame/methods/test_asof.py
index 4a8adf89b3aef..029aa3a5b8f05 100644
--- a/pandas/tests/frame/methods/test_asof.py
+++ b/pandas/tests/frame/methods/test_asof.py
@@ -163,19 +163,6 @@ def test_time_zone_aware_index(self, stamp, expected):
result = df.asof(stamp)
tm.assert_series_equal(result, expected)
- def test_is_copy(self, date_range_frame):
- # GH-27357, GH-30784: ensure the result of asof is an actual copy and
- # doesn't track the parent dataframe / doesn't give SettingWithCopy warnings
- df = date_range_frame.astype({"A": "float"})
- N = 50
- df.loc[df.index[15:30], "A"] = np.nan
- dates = date_range("1/1/1990", periods=N * 3, freq="25s")
-
- result = df.asof(dates)
-
- with tm.assert_produces_warning(None):
- result["C"] = 1
-
def test_asof_periodindex_mismatched_freq(self):
N = 50
rng = period_range("1/1/1990", periods=N, freq="h")
diff --git a/pandas/tests/frame/methods/test_sample.py b/pandas/tests/frame/methods/test_sample.py
index e65225a33a479..91d735a8b2fa7 100644
--- a/pandas/tests/frame/methods/test_sample.py
+++ b/pandas/tests/frame/methods/test_sample.py
@@ -333,7 +333,7 @@ def test_sample_aligns_weights_with_frame(self):
def test_sample_is_copy(self):
# GH#27357, GH#30784: ensure the result of sample is an actual copy and
- # doesn't track the parent dataframe / doesn't give SettingWithCopy warnings
+ # doesn't track the parent dataframe
df = DataFrame(
np.random.default_rng(2).standard_normal((10, 3)), columns=["a", "b", "c"]
)
diff --git a/pandas/tests/frame/methods/test_sort_values.py b/pandas/tests/frame/methods/test_sort_values.py
index b33ca95bd4180..768c85644c977 100644
--- a/pandas/tests/frame/methods/test_sort_values.py
+++ b/pandas/tests/frame/methods/test_sort_values.py
@@ -331,21 +331,15 @@ def test_sort_values_datetimes(self):
df2 = df.sort_values(by=["C", "B"])
tm.assert_frame_equal(df1, df2)
- def test_sort_values_frame_column_inplace_sort_exception(
- self, float_frame, using_copy_on_write
- ):
+ def test_sort_values_frame_column_inplace_sort_exception(self, float_frame):
s = float_frame["A"]
float_frame_orig = float_frame.copy()
- if using_copy_on_write:
- # INFO(CoW) Series is a new object, so can be changed inplace
- # without modifying original datafame
- s.sort_values(inplace=True)
- tm.assert_series_equal(s, float_frame_orig["A"].sort_values())
- # column in dataframe is not changed
- tm.assert_frame_equal(float_frame, float_frame_orig)
- else:
- with pytest.raises(ValueError, match="This Series is a view"):
- s.sort_values(inplace=True)
+ # INFO(CoW) Series is a new object, so can be changed inplace
+ # without modifying original datafame
+ s.sort_values(inplace=True)
+ tm.assert_series_equal(s, float_frame_orig["A"].sort_values())
+ # column in dataframe is not changed
+ tm.assert_frame_equal(float_frame, float_frame_orig)
cp = s.copy()
cp.sort_values() # it works!
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index 67bebddaa63ca..0bfde350c259b 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -577,10 +577,9 @@ def f(group):
assert result["d"].dtype == np.float64
# this is by definition a mutating operation!
- with pd.option_context("mode.chained_assignment", None):
- for key, group in grouped:
- res = f(group)
- tm.assert_frame_equal(res, result.loc[key])
+ for key, group in grouped:
+ res = f(group)
+ tm.assert_frame_equal(res, result.loc[key])
@pytest.mark.parametrize(
diff --git a/pandas/tests/indexes/multi/test_get_set.py b/pandas/tests/indexes/multi/test_get_set.py
index 6eeaeb6711d03..dd4bba42eda6f 100644
--- a/pandas/tests/indexes/multi/test_get_set.py
+++ b/pandas/tests/indexes/multi/test_get_set.py
@@ -332,10 +332,8 @@ def test_set_value_keeps_names():
index=idx,
)
df = df.sort_index()
- assert df._is_copy is None
assert df.index.names == ("Name", "Number")
df.at[("grethe", "4"), "one"] = 99.34
- assert df._is_copy is None
assert df.index.names == ("Name", "Number")
diff --git a/pandas/tests/indexing/multiindex/test_chaining_and_caching.py b/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
index 24a111e283365..c70c0ee10afd6 100644
--- a/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/multiindex/test_chaining_and_caching.py
@@ -1,8 +1,6 @@
import numpy as np
-import pytest
from pandas._libs import index as libindex
-from pandas.errors import SettingWithCopyError
from pandas import (
DataFrame,
@@ -12,7 +10,7 @@
import pandas._testing as tm
-def test_detect_chained_assignment(using_copy_on_write):
+def test_detect_chained_assignment():
# Inplace ops, originally from:
# https://stackoverflow.com/questions/20508968/series-fillna-in-a-multiindex-dataframe-does-not-fill-is-this-a-bug
a = [12, 23]
@@ -29,14 +27,8 @@ def test_detect_chained_assignment(using_copy_on_write):
multiind = MultiIndex.from_tuples(tuples, names=["part", "side"])
zed = DataFrame(events, index=["a", "b"], columns=multiind)
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- zed["eyes"]["right"].fillna(value=555, inplace=True)
- else:
- msg = "A value is trying to be set on a copy of a slice from a DataFrame"
- with pytest.raises(SettingWithCopyError, match=msg):
- with tm.assert_produces_warning(None):
- zed["eyes"]["right"].fillna(value=555, inplace=True)
+ with tm.raises_chained_assignment_error():
+ zed["eyes"]["right"].fillna(value=555, inplace=True)
def test_cache_updating(using_copy_on_write):
diff --git a/pandas/tests/indexing/multiindex/test_setitem.py b/pandas/tests/indexing/multiindex/test_setitem.py
index 17b00244c70f5..d731f796637ea 100644
--- a/pandas/tests/indexing/multiindex/test_setitem.py
+++ b/pandas/tests/indexing/multiindex/test_setitem.py
@@ -1,8 +1,6 @@
import numpy as np
import pytest
-from pandas.errors import SettingWithCopyError
-
import pandas as pd
from pandas import (
DataFrame,
@@ -522,38 +520,21 @@ def test_frame_setitem_view_direct(
assert (df["foo"].values == 0).all()
-def test_frame_setitem_copy_raises(
- multiindex_dataframe_random_data, using_copy_on_write
-):
+def test_frame_setitem_copy_raises(multiindex_dataframe_random_data):
# will raise/warn as its chained assignment
df = multiindex_dataframe_random_data.T
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df["foo"]["one"] = 2
- else:
- msg = "A value is trying to be set on a copy of a slice from a DataFrame"
- with pytest.raises(SettingWithCopyError, match=msg):
- with tm.raises_chained_assignment_error():
- df["foo"]["one"] = 2
+ with tm.raises_chained_assignment_error():
+ df["foo"]["one"] = 2
-def test_frame_setitem_copy_no_write(
- multiindex_dataframe_random_data, using_copy_on_write
-):
+def test_frame_setitem_copy_no_write(multiindex_dataframe_random_data):
frame = multiindex_dataframe_random_data.T
expected = frame
df = frame.copy()
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df["foo"]["one"] = 2
- else:
- msg = "A value is trying to be set on a copy of a slice from a DataFrame"
- with pytest.raises(SettingWithCopyError, match=msg):
- with tm.raises_chained_assignment_error():
- df["foo"]["one"] = 2
+ with tm.raises_chained_assignment_error():
+ df["foo"]["one"] = 2
- result = df
- tm.assert_frame_equal(result, expected)
+ tm.assert_frame_equal(df, expected)
def test_frame_setitem_partial_multiindex():
diff --git a/pandas/tests/indexing/test_chaining_and_caching.py b/pandas/tests/indexing/test_chaining_and_caching.py
index 6dbe4f2b3ed3a..7945d88c4a7dc 100644
--- a/pandas/tests/indexing/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/test_chaining_and_caching.py
@@ -3,11 +3,6 @@
import numpy as np
import pytest
-from pandas.errors import (
- SettingWithCopyError,
- SettingWithCopyWarning,
-)
-
import pandas as pd
from pandas import (
DataFrame,
@@ -47,11 +42,7 @@ def test_slice_consolidate_invalidate_item_cache(self, using_copy_on_write):
# Assignment to wrong series
with tm.raises_chained_assignment_error():
df["bb"].iloc[0] = 0.17
- df._clear_item_cache()
- if not using_copy_on_write:
- tm.assert_almost_equal(df["bb"][0], 0.17)
- else:
- tm.assert_almost_equal(df["bb"][0], 2.2)
+ tm.assert_almost_equal(df["bb"][0], 2.2)
@pytest.mark.parametrize("do_ref", [True, False])
def test_setitem_cache_updating(self, do_ref):
@@ -116,16 +107,10 @@ def test_altering_series_clears_parent_cache(self, using_copy_on_write):
df = DataFrame([[1, 2], [3, 4]], index=["a", "b"], columns=["A", "B"])
ser = df["A"]
- if using_copy_on_write:
- assert "A" not in df._item_cache
- else:
- assert "A" in df._item_cache
-
# Adding a new entry to ser swaps in a new array, so "A" needs to
# be removed from df._item_cache
ser["c"] = 5
assert len(ser) == 3
- assert "A" not in df._item_cache
assert df["A"] is not ser
assert len(df["A"]) == 2
@@ -192,7 +177,6 @@ def test_detect_chained_assignment(self, using_copy_on_write):
np.arange(4).reshape(2, 2), columns=list("AB"), dtype="int64"
)
df_original = df.copy()
- assert df._is_copy is None
with tm.raises_chained_assignment_error():
df["A"][0] = -5
@@ -204,7 +188,7 @@ def test_detect_chained_assignment(self, using_copy_on_write):
tm.assert_frame_equal(df, expected)
@pytest.mark.arm_slow
- def test_detect_chained_assignment_raises(self, using_copy_on_write):
+ def test_detect_chained_assignment_raises(self):
# test with the chaining
df = DataFrame(
{
@@ -213,27 +197,14 @@ def test_detect_chained_assignment_raises(self, using_copy_on_write):
}
)
df_original = df.copy()
- assert df._is_copy is None
-
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df["A"][0] = -5
- with tm.raises_chained_assignment_error():
- df["A"][1] = -6
- tm.assert_frame_equal(df, df_original)
- else:
- with pytest.raises(SettingWithCopyError, match=msg):
- with tm.raises_chained_assignment_error():
- df["A"][0] = -5
-
- with pytest.raises(SettingWithCopyError, match=msg):
- with tm.raises_chained_assignment_error():
- df["A"][1] = np.nan
-
- assert df["A"]._is_copy is None
+ with tm.raises_chained_assignment_error():
+ df["A"][0] = -5
+ with tm.raises_chained_assignment_error():
+ df["A"][1] = -6
+ tm.assert_frame_equal(df, df_original)
@pytest.mark.arm_slow
- def test_detect_chained_assignment_fails(self, using_copy_on_write):
+ def test_detect_chained_assignment_fails(self):
# Using a copy (the chain), fails
df = DataFrame(
{
@@ -242,15 +213,11 @@ def test_detect_chained_assignment_fails(self, using_copy_on_write):
}
)
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df.loc[0]["A"] = -5
- else:
- with pytest.raises(SettingWithCopyError, match=msg):
- df.loc[0]["A"] = -5
+ with tm.raises_chained_assignment_error():
+ df.loc[0]["A"] = -5
@pytest.mark.arm_slow
- def test_detect_chained_assignment_doc_example(self, using_copy_on_write):
+ def test_detect_chained_assignment_doc_example(self):
# Doc example
df = DataFrame(
{
@@ -258,45 +225,26 @@ def test_detect_chained_assignment_doc_example(self, using_copy_on_write):
"c": Series(range(7), dtype="int64"),
}
)
- assert df._is_copy is None
indexer = df.a.str.startswith("o")
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df[indexer]["c"] = 42
- else:
- with pytest.raises(SettingWithCopyError, match=msg):
- df[indexer]["c"] = 42
+ with tm.raises_chained_assignment_error():
+ df[indexer]["c"] = 42
@pytest.mark.arm_slow
- def test_detect_chained_assignment_object_dtype(self, using_copy_on_write):
- expected = DataFrame({"A": [111, "bbb", "ccc"], "B": [1, 2, 3]})
+ def test_detect_chained_assignment_object_dtype(self):
df = DataFrame(
{"A": Series(["aaa", "bbb", "ccc"], dtype=object), "B": [1, 2, 3]}
)
df_original = df.copy()
- if not using_copy_on_write:
- with pytest.raises(SettingWithCopyError, match=msg):
- df.loc[0]["A"] = 111
-
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df["A"][0] = 111
- tm.assert_frame_equal(df, df_original)
- else:
- with pytest.raises(SettingWithCopyError, match=msg):
- with tm.raises_chained_assignment_error():
- df["A"][0] = 111
-
- df.loc[0, "A"] = 111
- tm.assert_frame_equal(df, expected)
+ with tm.raises_chained_assignment_error():
+ df["A"][0] = 111
+ tm.assert_frame_equal(df, df_original)
@pytest.mark.arm_slow
def test_detect_chained_assignment_is_copy_pickle(self):
# gh-5475: Make sure that is_copy is picked up reconstruction
df = DataFrame({"A": [1, 2]})
- assert df._is_copy is None
with tm.ensure_clean("__tmp__pickle") as path:
df.to_pickle(path)
@@ -304,68 +252,12 @@ def test_detect_chained_assignment_is_copy_pickle(self):
df2["B"] = df2["A"]
df2["B"] = df2["A"]
- @pytest.mark.arm_slow
- def test_detect_chained_assignment_setting_entire_column(self):
- # gh-5597: a spurious raise as we are setting the entire column here
-
- df = random_text(100000)
-
- # Always a copy
- x = df.iloc[[0, 1, 2]]
- assert x._is_copy is not None
-
- x = df.iloc[[0, 1, 2, 4]]
- assert x._is_copy is not None
-
- # Explicitly copy
- indexer = df.letters.apply(lambda x: len(x) > 10)
- df = df.loc[indexer].copy()
-
- assert df._is_copy is None
- df["letters"] = df["letters"].apply(str.lower)
-
- @pytest.mark.arm_slow
- def test_detect_chained_assignment_implicit_take(self):
- # Implicitly take
- df = random_text(100000)
- indexer = df.letters.apply(lambda x: len(x) > 10)
- df = df.loc[indexer]
-
- assert df._is_copy is not None
- df["letters"] = df["letters"].apply(str.lower)
-
- @pytest.mark.arm_slow
- def test_detect_chained_assignment_implicit_take2(self, using_copy_on_write):
- if using_copy_on_write:
- pytest.skip("_is_copy is not always set for CoW")
- # Implicitly take 2
- df = random_text(100000)
- indexer = df.letters.apply(lambda x: len(x) > 10)
-
- df = df.loc[indexer]
- assert df._is_copy is not None
- df.loc[:, "letters"] = df["letters"].apply(str.lower)
-
- # with the enforcement of #45333 in 2.0, the .loc[:, letters] setting
- # is inplace, so df._is_copy remains non-None.
- assert df._is_copy is not None
-
- df["letters"] = df["letters"].apply(str.lower)
- assert df._is_copy is None
-
@pytest.mark.arm_slow
def test_detect_chained_assignment_str(self):
df = random_text(100000)
indexer = df.letters.apply(lambda x: len(x) > 10)
df.loc[indexer, "letters"] = df.loc[indexer, "letters"].apply(str.lower)
- @pytest.mark.arm_slow
- def test_detect_chained_assignment_is_copy(self):
- # an identical take, so no copy
- df = DataFrame({"a": [1]}).dropna()
- assert df._is_copy is None
- df["a"] += 1
-
@pytest.mark.arm_slow
def test_detect_chained_assignment_sorting(self):
df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
@@ -390,24 +282,18 @@ def test_detect_chained_assignment_false_positives(self):
str(df)
@pytest.mark.arm_slow
- def test_detect_chained_assignment_undefined_column(self, using_copy_on_write):
+ def test_detect_chained_assignment_undefined_column(self):
# from SO:
# https://stackoverflow.com/questions/24054495/potential-bug-setting-value-for-undefined-column-using-iloc
df = DataFrame(np.arange(0, 9), columns=["count"])
df["group"] = "b"
df_original = df.copy()
-
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df.iloc[0:5]["group"] = "a"
- tm.assert_frame_equal(df, df_original)
- else:
- with pytest.raises(SettingWithCopyError, match=msg):
- with tm.raises_chained_assignment_error():
- df.iloc[0:5]["group"] = "a"
+ with tm.raises_chained_assignment_error():
+ df.iloc[0:5]["group"] = "a"
+ tm.assert_frame_equal(df, df_original)
@pytest.mark.arm_slow
- def test_detect_chained_assignment_changing_dtype(self, using_copy_on_write):
+ def test_detect_chained_assignment_changing_dtype(self):
# Mixed type setting but same dtype & changing dtype
df = DataFrame(
{
@@ -419,44 +305,25 @@ def test_detect_chained_assignment_changing_dtype(self, using_copy_on_write):
)
df_original = df.copy()
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df.loc[2]["D"] = "foo"
- with tm.raises_chained_assignment_error():
- df.loc[2]["C"] = "foo"
- tm.assert_frame_equal(df, df_original)
- with tm.raises_chained_assignment_error(extra_warnings=(FutureWarning,)):
- df["C"][2] = "foo"
- if using_copy_on_write:
- tm.assert_frame_equal(df, df_original)
- else:
- assert df.loc[2, "C"] == "foo"
- else:
- with pytest.raises(SettingWithCopyError, match=msg):
- df.loc[2]["D"] = "foo"
-
- with pytest.raises(SettingWithCopyError, match=msg):
- df.loc[2]["C"] = "foo"
-
- with pytest.raises(SettingWithCopyError, match=msg):
- with tm.raises_chained_assignment_error():
- df["C"][2] = "foo"
+ with tm.raises_chained_assignment_error():
+ df.loc[2]["D"] = "foo"
+ with tm.raises_chained_assignment_error():
+ df.loc[2]["C"] = "foo"
+ tm.assert_frame_equal(df, df_original)
+ with tm.raises_chained_assignment_error(extra_warnings=(FutureWarning,)):
+ df["C"][2] = "foo"
+ tm.assert_frame_equal(df, df_original)
- def test_setting_with_copy_bug(self, using_copy_on_write):
+ def test_setting_with_copy_bug(self):
# operating on a copy
df = DataFrame(
{"a": list(range(4)), "b": list("ab.."), "c": ["a", "b", np.nan, "d"]}
)
df_original = df.copy()
mask = pd.isna(df.c)
-
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df[["c"]][mask] = df[["b"]][mask]
- tm.assert_frame_equal(df, df_original)
- else:
- with pytest.raises(SettingWithCopyError, match=msg):
- df[["c"]][mask] = df[["b"]][mask]
+ with tm.raises_chained_assignment_error():
+ df[["c"]][mask] = df[["b"]][mask]
+ tm.assert_frame_equal(df, df_original)
def test_setting_with_copy_bug_no_warning(self):
# invalid warning as we are returning a new object
@@ -467,20 +334,10 @@ def test_setting_with_copy_bug_no_warning(self):
# this should not raise
df2["y"] = ["g", "h", "i"]
- def test_detect_chained_assignment_warnings_errors(self, using_copy_on_write):
+ def test_detect_chained_assignment_warnings_errors(self):
df = DataFrame({"A": ["aaa", "bbb", "ccc"], "B": [1, 2, 3]})
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- df.loc[0]["A"] = 111
- return
-
- with option_context("chained_assignment", "warn"):
- with tm.assert_produces_warning(SettingWithCopyWarning):
- df.loc[0]["A"] = 111
-
- with option_context("chained_assignment", "raise"):
- with pytest.raises(SettingWithCopyError, match=msg):
- df.loc[0]["A"] = 111
+ with tm.raises_chained_assignment_error():
+ df.loc[0]["A"] = 111
@pytest.mark.parametrize("rhs", [3, DataFrame({0: [1, 2, 3, 4]})])
def test_detect_chained_assignment_warning_stacklevel(
@@ -490,15 +347,9 @@ def test_detect_chained_assignment_warning_stacklevel(
df = DataFrame(np.arange(25).reshape(5, 5))
df_original = df.copy()
chained = df.loc[:3]
- with option_context("chained_assignment", "warn"):
- if not using_copy_on_write:
- with tm.assert_produces_warning(SettingWithCopyWarning) as t:
- chained[2] = rhs
- assert t[0].filename == __file__
- else:
- # INFO(CoW) no warning, and original dataframe not changed
- chained[2] = rhs
- tm.assert_frame_equal(df, df_original)
+ # INFO(CoW) no warning, and original dataframe not changed
+ chained[2] = rhs
+ tm.assert_frame_equal(df, df_original)
def test_chained_getitem_with_lists(self):
# GH6394
diff --git a/pandas/tests/series/accessors/test_dt_accessor.py b/pandas/tests/series/accessors/test_dt_accessor.py
index 9de14b3a7c112..17492f17132fd 100644
--- a/pandas/tests/series/accessors/test_dt_accessor.py
+++ b/pandas/tests/series/accessors/test_dt_accessor.py
@@ -12,7 +12,6 @@
import pytz
from pandas._libs.tslibs.timezones import maybe_get_tz
-from pandas.errors import SettingWithCopyError
from pandas.core.dtypes.common import (
is_integer_dtype,
@@ -281,21 +280,15 @@ def test_dt_accessor_ambiguous_freq_conversions(self):
expected = Series(exp_values, name="xxx")
tm.assert_series_equal(ser, expected)
- def test_dt_accessor_not_writeable(self, using_copy_on_write):
+ def test_dt_accessor_not_writeable(self):
# no setting allowed
ser = Series(date_range("20130101", periods=5, freq="D"), name="xxx")
with pytest.raises(ValueError, match="modifications"):
ser.dt.hour = 5
# trying to set a copy
- msg = "modifications to a property of a datetimelike.+not supported"
- with pd.option_context("chained_assignment", "raise"):
- if using_copy_on_write:
- with tm.raises_chained_assignment_error():
- ser.dt.hour[0] = 5
- else:
- with pytest.raises(SettingWithCopyError, match=msg):
- ser.dt.hour[0] = 5
+ with tm.raises_chained_assignment_error():
+ ser.dt.hour[0] = 5
@pytest.mark.parametrize(
"method, dates",
diff --git a/pandas/tests/series/methods/test_sort_values.py b/pandas/tests/series/methods/test_sort_values.py
index cb83bc5833fba..bd548eb80e182 100644
--- a/pandas/tests/series/methods/test_sort_values.py
+++ b/pandas/tests/series/methods/test_sort_values.py
@@ -79,17 +79,8 @@ def test_sort_values(self, datetime_series, using_copy_on_write):
# Series.sort_values operating on a view
df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
s = df.iloc[:, 0]
-
- msg = (
- "This Series is a view of some other array, to sort in-place "
- "you must create a copy"
- )
- if using_copy_on_write:
- s.sort_values(inplace=True)
- tm.assert_series_equal(s, df.iloc[:, 0].sort_values())
- else:
- with pytest.raises(ValueError, match=msg):
- s.sort_values(inplace=True)
+ s.sort_values(inplace=True)
+ tm.assert_series_equal(s, df.iloc[:, 0].sort_values())
def test_sort_values_categorical(self):
cat = Series(Categorical(["a", "b", "b", "a"], ordered=False))
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index feba0e86c6b32..ead36ee08b407 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -46,6 +46,8 @@ def test_dask(df):
pd.set_option("compute.use_numexpr", olduse)
+# TODO(CoW) see https://github.com/pandas-dev/pandas/pull/51082
+@pytest.mark.skip(reason="not implemented with CoW")
def test_dask_ufunc():
# dask sets "compute.use_numexpr" to False, so catch the current value
# and ensure to reset it afterwards to avoid impacting other tests
diff --git a/pandas/tests/test_errors.py b/pandas/tests/test_errors.py
index c99751dca6c9d..c5c4b234eb129 100644
--- a/pandas/tests/test_errors.py
+++ b/pandas/tests/test_errors.py
@@ -37,8 +37,6 @@
"PossibleDataLossError",
"PossiblePrecisionLoss",
"PyperclipException",
- "SettingWithCopyError",
- "SettingWithCopyWarning",
"SpecificationError",
"UnsortedIndexError",
"UnsupportedFunctionCall",
| 🥳
We shouldn't merge before the actual release is out
**`_item_cache` removal**
closes #50547
closes #29411
closes #21391
**SettingWIthCopyWarning removal**
closes #18752
closes #9767
closes #14150
closes #16550
closes #17505
closes #38270
closes #39418
closes #39448
closes #41891
closes #45513
closes #50209
closes #55451
**Others Matt thinks**
closes #19102
| https://api.github.com/repos/pandas-dev/pandas/pulls/56614 | 2023-12-24T18:17:19Z | 2024-02-04T15:18:21Z | 2024-02-04T15:18:21Z | 2024-02-05T07:50:34Z |
BUG: Added raising when merging datetime columns with timedelta columns | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 5b955aa45219a..e13c81b59de20 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -822,6 +822,7 @@ Reshaping
- Bug in :func:`merge_asof` raising ``TypeError`` when ``by`` dtype is not ``object``, ``int64``, or ``uint64`` (:issue:`22794`)
- Bug in :func:`merge_asof` raising incorrect error for string dtype (:issue:`56444`)
- Bug in :func:`merge_asof` when using a :class:`Timedelta` tolerance on a :class:`ArrowDtype` column (:issue:`56486`)
+- Bug in :func:`merge` not raising when merging datetime columns with timedelta columns (:issue:`56455`)
- Bug in :func:`merge` not raising when merging string columns with numeric columns (:issue:`56441`)
- Bug in :func:`merge` returning columns in incorrect order when left and/or right is empty (:issue:`51929`)
- Bug in :meth:`DataFrame.melt` where an exception was raised if ``var_name`` was not a string (:issue:`55948`)
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index f4903023e8059..4aff99dc42250 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -1526,6 +1526,11 @@ def _maybe_coerce_merge_keys(self) -> None:
) or (lk.dtype.kind == "M" and rk.dtype.kind == "M"):
# allows datetime with different resolutions
continue
+ # datetime and timedelta not allowed
+ elif lk.dtype.kind == "M" and rk.dtype.kind == "m":
+ raise ValueError(msg)
+ elif lk.dtype.kind == "m" and rk.dtype.kind == "M":
+ raise ValueError(msg)
elif is_object_dtype(lk.dtype) and is_object_dtype(rk.dtype):
continue
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 9f832c7b1d1ca..2505d9163a6d2 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -2983,3 +2983,23 @@ def test_merge_empty_frames_column_order(left_empty, right_empty):
elif right_empty:
expected.loc[:, ["C", "D"]] = np.nan
tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("how", ["left", "right", "inner", "outer"])
+def test_merge_datetime_and_timedelta(how):
+ left = DataFrame({"key": Series([1, None], dtype="datetime64[ns]")})
+ right = DataFrame({"key": Series([1], dtype="timedelta64[ns]")})
+
+ msg = (
+ f"You are trying to merge on {left['key'].dtype} and {right['key'].dtype} "
+ "columns for key 'key'. If you wish to proceed you should use pd.concat"
+ )
+ with pytest.raises(ValueError, match=re.escape(msg)):
+ left.merge(right, on="key", how=how)
+
+ msg = (
+ f"You are trying to merge on {right['key'].dtype} and {left['key'].dtype} "
+ "columns for key 'key'. If you wish to proceed you should use pd.concat"
+ )
+ with pytest.raises(ValueError, match=re.escape(msg)):
+ right.merge(left, on="key", how=how)
| - [x] closes #56455
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/56613 | 2023-12-24T15:05:23Z | 2023-12-28T17:33:26Z | 2023-12-28T17:33:26Z | 2023-12-28T17:33:36Z |
Backport PR #56595 on branch 2.2.x (TST/CLN: Inline seldom used fixture) | diff --git a/pandas/tests/arrays/categorical/conftest.py b/pandas/tests/arrays/categorical/conftest.py
deleted file mode 100644
index 37249210f28f4..0000000000000
--- a/pandas/tests/arrays/categorical/conftest.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import pytest
-
-from pandas import Categorical
-
-
-@pytest.fixture
-def factor():
- """Fixture returning a Categorical object"""
- return Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
diff --git a/pandas/tests/arrays/categorical/test_api.py b/pandas/tests/arrays/categorical/test_api.py
index b4215b4a6fe21..a939ee5f6f53f 100644
--- a/pandas/tests/arrays/categorical/test_api.py
+++ b/pandas/tests/arrays/categorical/test_api.py
@@ -385,7 +385,8 @@ def test_remove_unused_categories(self):
class TestCategoricalAPIWithFactor:
- def test_describe(self, factor):
+ def test_describe(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
# string type
desc = factor.describe()
assert factor.ordered
diff --git a/pandas/tests/arrays/categorical/test_indexing.py b/pandas/tests/arrays/categorical/test_indexing.py
index 3377c411a7084..5e1c5c64fa660 100644
--- a/pandas/tests/arrays/categorical/test_indexing.py
+++ b/pandas/tests/arrays/categorical/test_indexing.py
@@ -21,7 +21,8 @@
class TestCategoricalIndexingWithFactor:
- def test_getitem(self, factor):
+ def test_getitem(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
assert factor[0] == "a"
assert factor[-1] == "c"
@@ -31,7 +32,8 @@ def test_getitem(self, factor):
subf = factor[np.asarray(factor) == "c"]
tm.assert_numpy_array_equal(subf._codes, np.array([2, 2, 2], dtype=np.int8))
- def test_setitem(self, factor):
+ def test_setitem(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
# int/positional
c = factor.copy()
c[0] = "b"
diff --git a/pandas/tests/arrays/categorical/test_operators.py b/pandas/tests/arrays/categorical/test_operators.py
index 16b941eab4830..4174d2adc810b 100644
--- a/pandas/tests/arrays/categorical/test_operators.py
+++ b/pandas/tests/arrays/categorical/test_operators.py
@@ -17,7 +17,8 @@ def test_categories_none_comparisons(self):
factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
tm.assert_categorical_equal(factor, factor)
- def test_comparisons(self, factor):
+ def test_comparisons(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
result = factor[factor == "a"]
expected = factor[np.asarray(factor) == "a"]
tm.assert_categorical_equal(result, expected)
diff --git a/pandas/tests/arrays/categorical/test_repr.py b/pandas/tests/arrays/categorical/test_repr.py
index d6f93fbbd912f..ef0315130215c 100644
--- a/pandas/tests/arrays/categorical/test_repr.py
+++ b/pandas/tests/arrays/categorical/test_repr.py
@@ -17,7 +17,8 @@
class TestCategoricalReprWithFactor:
- def test_print(self, factor, using_infer_string):
+ def test_print(self, using_infer_string):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
if using_infer_string:
expected = [
"['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c']",
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index 5db0aa5cf510f..bac9548b932c1 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -10,8 +10,6 @@
)
import pandas._testing as tm
-START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
-
class TestDatetimeIndexOps:
def test_infer_freq(self, freq_sample):
@@ -26,6 +24,7 @@ def test_infer_freq(self, freq_sample):
class TestBusinessDatetimeIndex:
@pytest.fixture
def rng(self, freq):
+ START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
return bdate_range(START, END, freq=freq)
def test_comparison(self, rng):
diff --git a/pandas/tests/tseries/offsets/conftest.py b/pandas/tests/tseries/offsets/conftest.py
deleted file mode 100644
index 2fc846353dcb5..0000000000000
--- a/pandas/tests/tseries/offsets/conftest.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import datetime
-
-import pytest
-
-from pandas._libs.tslibs import Timestamp
-
-
-@pytest.fixture
-def dt():
- """
- Fixture for common Timestamp.
- """
- return Timestamp(datetime.datetime(2008, 1, 2))
diff --git a/pandas/tests/tseries/offsets/test_common.py b/pandas/tests/tseries/offsets/test_common.py
index 5b80b8b1c4ab4..aa4e22f71ad66 100644
--- a/pandas/tests/tseries/offsets/test_common.py
+++ b/pandas/tests/tseries/offsets/test_common.py
@@ -250,7 +250,8 @@ def test_sub(date, offset_box, offset2):
[BusinessHour, BusinessHour()],
],
)
-def test_Mult1(offset_box, offset1, dt):
+def test_Mult1(offset_box, offset1):
+ dt = Timestamp(2008, 1, 2)
assert dt + 10 * offset1 == dt + offset_box(10)
assert dt + 5 * offset1 == dt + offset_box(5)
| Backport PR #56595: TST/CLN: Inline seldom used fixture | https://api.github.com/repos/pandas-dev/pandas/pulls/56612 | 2023-12-24T14:20:09Z | 2023-12-24T16:46:25Z | 2023-12-24T16:46:25Z | 2023-12-24T16:46:25Z |
CLN/TST: Resample fixtures | diff --git a/pandas/tests/resample/conftest.py b/pandas/tests/resample/conftest.py
index 1033d908eb22d..6c45ece5d8fb9 100644
--- a/pandas/tests/resample/conftest.py
+++ b/pandas/tests/resample/conftest.py
@@ -1,13 +1,5 @@
-from datetime import datetime
-
-import numpy as np
import pytest
-from pandas import (
- DataFrame,
- Series,
-)
-
# The various methods we support
downsample_methods = [
"min",
@@ -39,105 +31,3 @@ def downsample_method(request):
def resample_method(request):
"""Fixture for parametrization of Grouper resample methods."""
return request.param
-
-
-@pytest.fixture
-def _index_start():
- """Fixture for parametrization of index, series and frame."""
- return datetime(2005, 1, 1)
-
-
-@pytest.fixture
-def _index_end():
- """Fixture for parametrization of index, series and frame."""
- return datetime(2005, 1, 10)
-
-
-@pytest.fixture
-def _index_freq():
- """Fixture for parametrization of index, series and frame."""
- return "D"
-
-
-@pytest.fixture
-def _index_name():
- """Fixture for parametrization of index, series and frame."""
- return None
-
-
-@pytest.fixture
-def index(_index_factory, _index_start, _index_end, _index_freq, _index_name):
- """
- Fixture for parametrization of date_range, period_range and
- timedelta_range indexes
- """
- return _index_factory(_index_start, _index_end, freq=_index_freq, name=_index_name)
-
-
-@pytest.fixture
-def _static_values(index):
- """
- Fixture for parametrization of values used in parametrization of
- Series and DataFrames with date_range, period_range and
- timedelta_range indexes
- """
- return np.arange(len(index))
-
-
-@pytest.fixture
-def _series_name():
- """
- Fixture for parametrization of Series name for Series used with
- date_range, period_range and timedelta_range indexes
- """
- return None
-
-
-@pytest.fixture
-def series(index, _series_name, _static_values):
- """
- Fixture for parametrization of Series with date_range, period_range and
- timedelta_range indexes
- """
- return Series(_static_values, index=index, name=_series_name)
-
-
-@pytest.fixture
-def empty_series_dti(series):
- """
- Fixture for parametrization of empty Series with date_range,
- period_range and timedelta_range indexes
- """
- return series[:0]
-
-
-@pytest.fixture
-def frame(index, _series_name, _static_values):
- """
- Fixture for parametrization of DataFrame with date_range, period_range
- and timedelta_range indexes
- """
- # _series_name is intentionally unused
- return DataFrame({"value": _static_values}, index=index)
-
-
-@pytest.fixture
-def empty_frame_dti(series):
- """
- Fixture for parametrization of empty DataFrame with date_range,
- period_range and timedelta_range indexes
- """
- index = series.index[:0]
- return DataFrame(index=index)
-
-
-@pytest.fixture
-def series_and_frame(frame_or_series, series, frame):
- """
- Fixture for parametrization of Series and DataFrame with date_range,
- period_range and timedelta_range indexes
- """
- if frame_or_series == Series:
- return series
- if frame_or_series == DataFrame:
- return frame
diff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py
index 50644e33e45e1..f20518c7be98a 100644
--- a/pandas/tests/resample/test_base.py
+++ b/pandas/tests/resample/test_base.py
@@ -21,54 +21,41 @@
from pandas.core.indexes.timedeltas import timedelta_range
from pandas.core.resample import _asfreq_compat
-# a fixture value can be overridden by the test parameter value. Note that the
-# value of the fixture can be overridden this way even if the test doesn't use
-# it directly (doesn't mention it in the function prototype).
-# see https://docs.pytest.org/en/latest/fixture.html#override-a-fixture-with-direct-test-parametrization # noqa: E501
-# in this module we override the fixture values defined in conftest.py
-# tuples of '_index_factory,_series_name,_index_start,_index_end'
-DATE_RANGE = (date_range, "dti", datetime(2005, 1, 1), datetime(2005, 1, 10))
-PERIOD_RANGE = (period_range, "pi", datetime(2005, 1, 1), datetime(2005, 1, 10))
-TIMEDELTA_RANGE = (timedelta_range, "tdi", "1 day", "10 day")
-
-all_ts = pytest.mark.parametrize(
- "_index_factory,_series_name,_index_start,_index_end",
- [DATE_RANGE, PERIOD_RANGE, TIMEDELTA_RANGE],
-)
-
-
-@pytest.fixture
-def create_index(_index_factory):
- def _create_index(*args, **kwargs):
- """return the _index_factory created using the args, kwargs"""
- return _index_factory(*args, **kwargs)
-
- return _create_index
-
@pytest.mark.parametrize("freq", ["2D", "1h"])
@pytest.mark.parametrize(
- "_index_factory,_series_name,_index_start,_index_end", [DATE_RANGE, TIMEDELTA_RANGE]
+ "index",
+ [
+ timedelta_range("1 day", "10 day", freq="D"),
+ date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
+ ],
)
-def test_asfreq(series_and_frame, freq, create_index):
- obj = series_and_frame
+@pytest.mark.parametrize("klass", [DataFrame, Series])
+def test_asfreq(klass, index, freq):
+ obj = klass(range(len(index)), index=index)
+ idx_range = date_range if isinstance(index, DatetimeIndex) else timedelta_range
result = obj.resample(freq).asfreq()
- new_index = create_index(obj.index[0], obj.index[-1], freq=freq)
+ new_index = idx_range(obj.index[0], obj.index[-1], freq=freq)
expected = obj.reindex(new_index)
tm.assert_almost_equal(result, expected)
@pytest.mark.parametrize(
- "_index_factory,_series_name,_index_start,_index_end", [DATE_RANGE, TIMEDELTA_RANGE]
+ "index",
+ [
+ timedelta_range("1 day", "10 day", freq="D"),
+ date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
+ ],
)
-def test_asfreq_fill_value(series, create_index):
+def test_asfreq_fill_value(index):
# test for fill value during resampling, issue 3715
- ser = series
+ ser = Series(range(len(index)), index=index, name="a")
+ idx_range = date_range if isinstance(index, DatetimeIndex) else timedelta_range
result = ser.resample("1h").asfreq()
- new_index = create_index(ser.index[0], ser.index[-1], freq="1h")
+ new_index = idx_range(ser.index[0], ser.index[-1], freq="1h")
expected = ser.reindex(new_index)
tm.assert_series_equal(result, expected)
@@ -76,15 +63,22 @@ def test_asfreq_fill_value(series, create_index):
frame = ser.astype("float").to_frame("value")
frame.iloc[1] = None
result = frame.resample("1h").asfreq(fill_value=4.0)
- new_index = create_index(frame.index[0], frame.index[-1], freq="1h")
+ new_index = idx_range(frame.index[0], frame.index[-1], freq="1h")
expected = frame.reindex(new_index, fill_value=4.0)
tm.assert_frame_equal(result, expected)
-@all_ts
-def test_resample_interpolate(frame):
+@pytest.mark.parametrize(
+ "index",
+ [
+ timedelta_range("1 day", "10 day", freq="D"),
+ date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
+ period_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
+ ],
+)
+def test_resample_interpolate(index):
# GH#12925
- df = frame
+ df = DataFrame(range(len(index)), index=index)
warn = None
if isinstance(df.index, PeriodIndex):
warn = FutureWarning
@@ -106,12 +100,19 @@ def test_raises_on_non_datetimelike_index():
xp.resample("YE")
-@all_ts
+@pytest.mark.parametrize(
+ "index",
+ [
+ PeriodIndex([], freq="D", name="a"),
+ DatetimeIndex([], name="a"),
+ TimedeltaIndex([], name="a"),
+ ],
+)
@pytest.mark.parametrize("freq", ["ME", "D", "h"])
-def test_resample_empty_series(freq, empty_series_dti, resample_method):
+def test_resample_empty_series(freq, index, resample_method):
# GH12771 & GH12868
- ser = empty_series_dti
+ ser = Series(index=index, dtype=float)
if freq == "ME" and isinstance(ser.index, TimedeltaIndex):
msg = (
"Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
@@ -147,7 +148,6 @@ def test_resample_empty_series(freq, empty_series_dti, resample_method):
assert result.index.freq == expected.index.freq
-@all_ts
@pytest.mark.parametrize(
"freq",
[
@@ -156,11 +156,10 @@ def test_resample_empty_series(freq, empty_series_dti, resample_method):
"h",
],
)
-def test_resample_nat_index_series(freq, series, resample_method):
+def test_resample_nat_index_series(freq, resample_method):
# GH39227
- ser = series.copy()
- ser.index = PeriodIndex([NaT] * len(ser), freq=freq)
+ ser = Series(range(5), index=PeriodIndex([NaT] * 5, freq=freq))
msg = "Resampling with a PeriodIndex is deprecated"
with tm.assert_produces_warning(FutureWarning, match=msg):
@@ -179,12 +178,19 @@ def test_resample_nat_index_series(freq, series, resample_method):
assert result.index.freq == expected.index.freq
-@all_ts
+@pytest.mark.parametrize(
+ "index",
+ [
+ PeriodIndex([], freq="D", name="a"),
+ DatetimeIndex([], name="a"),
+ TimedeltaIndex([], name="a"),
+ ],
+)
@pytest.mark.parametrize("freq", ["ME", "D", "h"])
@pytest.mark.parametrize("resample_method", ["count", "size"])
-def test_resample_count_empty_series(freq, empty_series_dti, resample_method):
+def test_resample_count_empty_series(freq, index, resample_method):
# GH28427
- ser = empty_series_dti
+ ser = Series(index=index)
if freq == "ME" and isinstance(ser.index, TimedeltaIndex):
msg = (
"Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
@@ -213,11 +219,13 @@ def test_resample_count_empty_series(freq, empty_series_dti, resample_method):
tm.assert_series_equal(result, expected)
-@all_ts
+@pytest.mark.parametrize(
+ "index", [DatetimeIndex([]), TimedeltaIndex([]), PeriodIndex([], freq="D")]
+)
@pytest.mark.parametrize("freq", ["ME", "D", "h"])
-def test_resample_empty_dataframe(empty_frame_dti, freq, resample_method):
+def test_resample_empty_dataframe(index, freq, resample_method):
# GH13212
- df = empty_frame_dti
+ df = DataFrame(index=index)
# count retains dimensions too
if freq == "ME" and isinstance(df.index, TimedeltaIndex):
msg = (
@@ -261,12 +269,13 @@ def test_resample_empty_dataframe(empty_frame_dti, freq, resample_method):
# test size for GH13212 (currently stays as df)
-@all_ts
+@pytest.mark.parametrize(
+ "index", [DatetimeIndex([]), TimedeltaIndex([]), PeriodIndex([], freq="D")]
+)
@pytest.mark.parametrize("freq", ["ME", "D", "h"])
-def test_resample_count_empty_dataframe(freq, empty_frame_dti):
+def test_resample_count_empty_dataframe(freq, index):
# GH28427
-
- empty_frame_dti["a"] = []
+ empty_frame_dti = DataFrame(index=index, columns=Index(["a"], dtype=object))
if freq == "ME" and isinstance(empty_frame_dti.index, TimedeltaIndex):
msg = (
@@ -295,12 +304,14 @@ def test_resample_count_empty_dataframe(freq, empty_frame_dti):
tm.assert_frame_equal(result, expected)
-@all_ts
+@pytest.mark.parametrize(
+ "index", [DatetimeIndex([]), TimedeltaIndex([]), PeriodIndex([], freq="D")]
+)
@pytest.mark.parametrize("freq", ["ME", "D", "h"])
-def test_resample_size_empty_dataframe(freq, empty_frame_dti):
+def test_resample_size_empty_dataframe(freq, index):
# GH28427
- empty_frame_dti["a"] = []
+ empty_frame_dti = DataFrame(index=index, columns=Index(["a"], dtype=object))
if freq == "ME" and isinstance(empty_frame_dti.index, TimedeltaIndex):
msg = (
@@ -361,27 +372,34 @@ def test_resample_empty_dtypes(index, dtype, resample_method):
pass
-@all_ts
+@pytest.mark.parametrize(
+ "index",
+ [
+ PeriodIndex([], freq="D", name="a"),
+ DatetimeIndex([], name="a"),
+ TimedeltaIndex([], name="a"),
+ ],
+)
@pytest.mark.parametrize("freq", ["ME", "D", "h"])
-def test_apply_to_empty_series(empty_series_dti, freq):
+def test_apply_to_empty_series(index, freq):
# GH 14313
- ser = empty_series_dti
+ ser = Series(index=index)
- if freq == "ME" and isinstance(empty_series_dti.index, TimedeltaIndex):
+ if freq == "ME" and isinstance(ser.index, TimedeltaIndex):
msg = (
"Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
"e.g. '24h' or '3D', not <MonthEnd>"
)
with pytest.raises(ValueError, match=msg):
- empty_series_dti.resample(freq)
+ ser.resample(freq)
return
- elif freq == "ME" and isinstance(empty_series_dti.index, PeriodIndex):
+ elif freq == "ME" and isinstance(ser.index, PeriodIndex):
# index is PeriodIndex, so convert to corresponding Period freq
freq = "M"
msg = "Resampling with a PeriodIndex"
warn = None
- if isinstance(empty_series_dti.index, PeriodIndex):
+ if isinstance(ser.index, PeriodIndex):
warn = FutureWarning
with tm.assert_produces_warning(warn, match=msg):
@@ -394,9 +412,17 @@ def test_apply_to_empty_series(empty_series_dti, freq):
tm.assert_series_equal(result, expected, check_dtype=False)
-@all_ts
-def test_resampler_is_iterable(series):
+@pytest.mark.parametrize(
+ "index",
+ [
+ timedelta_range("1 day", "10 day", freq="D"),
+ date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
+ period_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
+ ],
+)
+def test_resampler_is_iterable(index):
# GH 15314
+ series = Series(range(len(index)), index=index)
freq = "h"
tg = Grouper(freq=freq, convention="start")
msg = "Resampling with a PeriodIndex"
@@ -414,16 +440,23 @@ def test_resampler_is_iterable(series):
tm.assert_series_equal(rv, gv)
-@all_ts
-def test_resample_quantile(series):
+@pytest.mark.parametrize(
+ "index",
+ [
+ timedelta_range("1 day", "10 day", freq="D"),
+ date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
+ period_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D"),
+ ],
+)
+def test_resample_quantile(index):
# GH 15023
- ser = series
+ ser = Series(range(len(index)), index=index)
q = 0.75
freq = "h"
msg = "Resampling with a PeriodIndex"
warn = None
- if isinstance(series.index, PeriodIndex):
+ if isinstance(ser.index, PeriodIndex):
warn = FutureWarning
with tm.assert_produces_warning(warn, match=msg):
result = ser.resample(freq).quantile(q)
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 80583f5d3c5f2..0dfe9877c4f86 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -36,21 +36,6 @@
from pandas.tseries.offsets import Minute
-@pytest.fixture()
-def _index_factory():
- return date_range
-
-
-@pytest.fixture
-def _index_freq():
- return "Min"
-
-
-@pytest.fixture
-def _static_values(index):
- return np.random.default_rng(2).random(len(index))
-
-
@pytest.fixture(params=["s", "ms", "us", "ns"])
def unit(request):
return request.param
@@ -69,7 +54,8 @@ def _simple_date_range_series(start, end, freq="D"):
return _simple_date_range_series
-def test_custom_grouper(index, unit):
+def test_custom_grouper(unit):
+ index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="Min")
dti = index.as_unit(unit)
s = Series(np.array([1] * len(dti)), index=dti, dtype="int64")
@@ -105,7 +91,8 @@ def test_custom_grouper(index, unit):
tm.assert_series_equal(result, expect)
-def test_custom_grouper_df(index, unit):
+def test_custom_grouper_df(unit):
+ index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D")
b = Grouper(freq=Minute(5), closed="right", label="right")
dti = index.as_unit(unit)
df = DataFrame(
@@ -117,10 +104,6 @@ def test_custom_grouper_df(index, unit):
assert len(r.index) == 2593
-@pytest.mark.parametrize(
- "_index_start,_index_end,_index_name",
- [("1/1/2000 00:00:00", "1/1/2000 00:13:00", "index")],
-)
@pytest.mark.parametrize(
"closed, expected",
[
@@ -142,8 +125,10 @@ def test_custom_grouper_df(index, unit):
),
],
)
-def test_resample_basic(series, closed, expected, unit):
- s = series
+def test_resample_basic(closed, expected, unit):
+ index = date_range("1/1/2000 00:00:00", "1/1/2000 00:13:00", freq="Min")
+ s = Series(range(len(index)), index=index)
+ s.index.name = "index"
s.index = s.index.as_unit(unit)
expected = expected(s)
expected.index = expected.index.as_unit(unit)
@@ -175,8 +160,10 @@ def test_resample_integerarray(unit):
tm.assert_series_equal(result, expected)
-def test_resample_basic_grouper(series, unit):
- s = series
+def test_resample_basic_grouper(unit):
+ index = date_range("1/1/2000 00:00:00", "1/1/2000 00:13:00", freq="Min")
+ s = Series(range(len(index)), index=index)
+ s.index.name = "index"
s.index = s.index.as_unit(unit)
result = s.resample("5Min").last()
grouper = Grouper(freq=Minute(5), closed="left", label="left")
@@ -187,32 +174,28 @@ def test_resample_basic_grouper(series, unit):
@pytest.mark.filterwarnings(
"ignore:The 'convention' keyword in Series.resample:FutureWarning"
)
-@pytest.mark.parametrize(
- "_index_start,_index_end,_index_name",
- [("1/1/2000 00:00:00", "1/1/2000 00:13:00", "index")],
-)
@pytest.mark.parametrize(
"keyword,value",
[("label", "righttt"), ("closed", "righttt"), ("convention", "starttt")],
)
-def test_resample_string_kwargs(series, keyword, value, unit):
+def test_resample_string_kwargs(keyword, value, unit):
# see gh-19303
# Check that wrong keyword argument strings raise an error
+ index = date_range("1/1/2000 00:00:00", "1/1/2000 00:13:00", freq="Min")
+ series = Series(range(len(index)), index=index)
+ series.index.name = "index"
series.index = series.index.as_unit(unit)
msg = f"Unsupported value {value} for `{keyword}`"
with pytest.raises(ValueError, match=msg):
series.resample("5min", **({keyword: value}))
-@pytest.mark.parametrize(
- "_index_start,_index_end,_index_name",
- [("1/1/2000 00:00:00", "1/1/2000 00:13:00", "index")],
-)
-def test_resample_how(series, downsample_method, unit):
+def test_resample_how(downsample_method, unit):
if downsample_method == "ohlc":
pytest.skip("covered by test_resample_how_ohlc")
-
- s = series
+ index = date_range("1/1/2000 00:00:00", "1/1/2000 00:13:00", freq="Min")
+ s = Series(range(len(index)), index=index)
+ s.index.name = "index"
s.index = s.index.as_unit(unit)
grouplist = np.ones_like(s)
grouplist[0] = 0
@@ -230,12 +213,10 @@ def test_resample_how(series, downsample_method, unit):
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize(
- "_index_start,_index_end,_index_name",
- [("1/1/2000 00:00:00", "1/1/2000 00:13:00", "index")],
-)
-def test_resample_how_ohlc(series, unit):
- s = series
+def test_resample_how_ohlc(unit):
+ index = date_range("1/1/2000 00:00:00", "1/1/2000 00:13:00", freq="Min")
+ s = Series(range(len(index)), index=index)
+ s.index.name = "index"
s.index = s.index.as_unit(unit)
grouplist = np.ones_like(s)
grouplist[0] = 0
@@ -558,8 +539,10 @@ def test_nearest_upsample_with_limit(tz_aware_fixture, freq, rule, unit):
tm.assert_series_equal(result, expected)
-def test_resample_ohlc(series, unit):
- s = series
+def test_resample_ohlc(unit):
+ index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="Min")
+ s = Series(range(len(index)), index=index)
+ s.index.name = "index"
s.index = s.index.as_unit(unit)
grouper = Grouper(freq=Minute(5))
@@ -1854,8 +1837,12 @@ def test_resample_datetime_values(unit):
tm.assert_series_equal(res, exp)
-def test_resample_apply_with_additional_args(series, unit):
+def test_resample_apply_with_additional_args(unit):
# GH 14615
+ index = date_range("1/1/2000 00:00:00", "1/1/2000 00:13:00", freq="Min")
+ series = Series(range(len(index)), index=index)
+ series.index.name = "index"
+
def f(data, add_arg):
return np.mean(data) * add_arg
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index eb80f56dd7d4b..cf77238a553d0 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -35,16 +35,6 @@
)
-@pytest.fixture()
-def _index_factory():
- return period_range
-
-
-@pytest.fixture
-def _series_name():
- return "pi"
-
-
@pytest.fixture
def simple_period_range_series():
"""
@@ -69,11 +59,12 @@ def _simple_period_range_series(start, end, freq="D"):
class TestPeriodIndex:
@pytest.mark.parametrize("freq", ["2D", "1h", "2h"])
@pytest.mark.parametrize("kind", ["period", None, "timestamp"])
- def test_asfreq(self, series_and_frame, freq, kind):
+ @pytest.mark.parametrize("klass", [DataFrame, Series])
+ def test_asfreq(self, klass, freq, kind):
# GH 12884, 15944
# make sure .asfreq() returns PeriodIndex (except kind='timestamp')
- obj = series_and_frame
+ obj = klass(range(5), index=period_range("2020-01-01", periods=5))
if kind == "timestamp":
expected = obj.to_timestamp().resample(freq).asfreq()
else:
@@ -86,10 +77,11 @@ def test_asfreq(self, series_and_frame, freq, kind):
result = obj.resample(freq, kind=kind).asfreq()
tm.assert_almost_equal(result, expected)
- def test_asfreq_fill_value(self, series):
+ def test_asfreq_fill_value(self):
# test for fill value during resampling, issue 3715
- s = series
+ index = period_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D")
+ s = Series(range(len(index)), index=index)
new_index = date_range(
s.index[0].to_timestamp(how="start"),
(s.index[-1]).to_timestamp(how="start"),
@@ -116,9 +108,10 @@ def test_asfreq_fill_value(self, series):
@pytest.mark.parametrize("freq", ["h", "12h", "2D", "W"])
@pytest.mark.parametrize("kind", [None, "period", "timestamp"])
@pytest.mark.parametrize("kwargs", [{"on": "date"}, {"level": "d"}])
- def test_selection(self, index, freq, kind, kwargs):
+ def test_selection(self, freq, kind, kwargs):
# This is a bug, these should be implemented
# GH 14008
+ index = period_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq="D")
rng = np.arange(len(index), dtype=np.int64)
df = DataFrame(
{"date": index, "a": rng},
@@ -1014,13 +1007,14 @@ def test_resample_t_l_deprecated(self):
offsets.BusinessHour(2),
],
)
- def test_asfreq_invalid_period_freq(self, offset, series_and_frame):
+ @pytest.mark.parametrize("klass", [DataFrame, Series])
+ def test_asfreq_invalid_period_freq(self, offset, klass):
# GH#9586
msg = f"Invalid offset: '{offset.base}' for converting time series "
- df = series_and_frame
+ obj = klass(range(5), index=period_range("2020-01-01", periods=5))
with pytest.raises(ValueError, match=msg):
- df.asfreq(freq=offset)
+ obj.asfreq(freq=offset)
@pytest.mark.parametrize(
@@ -1033,11 +1027,12 @@ def test_asfreq_invalid_period_freq(self, offset, series_and_frame):
("2Y-MAR", "2YE-MAR"),
],
)
-def test_resample_frequency_ME_QE_YE_error_message(series_and_frame, freq, freq_depr):
+@pytest.mark.parametrize("klass", [DataFrame, Series])
+def test_resample_frequency_ME_QE_YE_error_message(klass, freq, freq_depr):
# GH#9586
msg = f"for Period, please use '{freq[1:]}' instead of '{freq_depr[1:]}'"
- obj = series_and_frame
+ obj = klass(range(5), index=period_range("2020-01-01", periods=5))
with pytest.raises(ValueError, match=msg):
obj.resample(freq_depr)
@@ -1062,10 +1057,11 @@ def test_corner_cases_period(simple_period_range_series):
"2BYE-MAR",
],
)
-def test_resample_frequency_invalid_freq(series_and_frame, freq_depr):
+@pytest.mark.parametrize("klass", [DataFrame, Series])
+def test_resample_frequency_invalid_freq(klass, freq_depr):
# GH#9586
msg = f"Invalid frequency: {freq_depr[1:]}"
- obj = series_and_frame
+ obj = klass(range(5), index=period_range("2020-01-01", periods=5))
with pytest.raises(ValueError, match=msg):
obj.resample(freq_depr)
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/56608 | 2023-12-23T03:44:04Z | 2023-12-28T19:05:57Z | 2023-12-28T19:05:57Z | 2023-12-28T19:06:00Z |
Start 2.3.0 | - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/56603 | 2023-12-22T19:13:57Z | 2023-12-22T19:14:56Z | 2023-12-22T19:14:56Z | 2023-12-22T19:14:57Z | |
CI: Move target for the deprecations bot | diff --git a/.github/workflows/deprecation-tracking-bot.yml b/.github/workflows/deprecation-tracking-bot.yml
index ec71daf6f84ab..3d4cab7be09c5 100644
--- a/.github/workflows/deprecation-tracking-bot.yml
+++ b/.github/workflows/deprecation-tracking-bot.yml
@@ -19,7 +19,7 @@ jobs:
issues: write
runs-on: ubuntu-22.04
env:
- DEPRECATION_TRACKER_ISSUE: 50578
+ DEPRECATION_TRACKER_ISSUE: 56596
steps:
- uses: actions/github-script@v7
id: update-deprecation-issue
| cc @lithomas1 for after the rc
Just making sure that we don't forget this | https://api.github.com/repos/pandas-dev/pandas/pulls/56597 | 2023-12-22T09:59:46Z | 2023-12-23T18:56:41Z | 2023-12-23T18:56:41Z | 2023-12-23T18:56:44Z |
TST/CLN: Inline seldom used fixture | diff --git a/pandas/tests/arrays/categorical/conftest.py b/pandas/tests/arrays/categorical/conftest.py
deleted file mode 100644
index 37249210f28f4..0000000000000
--- a/pandas/tests/arrays/categorical/conftest.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import pytest
-
-from pandas import Categorical
-
-
-@pytest.fixture
-def factor():
- """Fixture returning a Categorical object"""
- return Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
diff --git a/pandas/tests/arrays/categorical/test_api.py b/pandas/tests/arrays/categorical/test_api.py
index b4215b4a6fe21..a939ee5f6f53f 100644
--- a/pandas/tests/arrays/categorical/test_api.py
+++ b/pandas/tests/arrays/categorical/test_api.py
@@ -385,7 +385,8 @@ def test_remove_unused_categories(self):
class TestCategoricalAPIWithFactor:
- def test_describe(self, factor):
+ def test_describe(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
# string type
desc = factor.describe()
assert factor.ordered
diff --git a/pandas/tests/arrays/categorical/test_indexing.py b/pandas/tests/arrays/categorical/test_indexing.py
index 3377c411a7084..5e1c5c64fa660 100644
--- a/pandas/tests/arrays/categorical/test_indexing.py
+++ b/pandas/tests/arrays/categorical/test_indexing.py
@@ -21,7 +21,8 @@
class TestCategoricalIndexingWithFactor:
- def test_getitem(self, factor):
+ def test_getitem(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
assert factor[0] == "a"
assert factor[-1] == "c"
@@ -31,7 +32,8 @@ def test_getitem(self, factor):
subf = factor[np.asarray(factor) == "c"]
tm.assert_numpy_array_equal(subf._codes, np.array([2, 2, 2], dtype=np.int8))
- def test_setitem(self, factor):
+ def test_setitem(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
# int/positional
c = factor.copy()
c[0] = "b"
diff --git a/pandas/tests/arrays/categorical/test_operators.py b/pandas/tests/arrays/categorical/test_operators.py
index 16b941eab4830..4174d2adc810b 100644
--- a/pandas/tests/arrays/categorical/test_operators.py
+++ b/pandas/tests/arrays/categorical/test_operators.py
@@ -17,7 +17,8 @@ def test_categories_none_comparisons(self):
factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
tm.assert_categorical_equal(factor, factor)
- def test_comparisons(self, factor):
+ def test_comparisons(self):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
result = factor[factor == "a"]
expected = factor[np.asarray(factor) == "a"]
tm.assert_categorical_equal(result, expected)
diff --git a/pandas/tests/arrays/categorical/test_repr.py b/pandas/tests/arrays/categorical/test_repr.py
index d6f93fbbd912f..ef0315130215c 100644
--- a/pandas/tests/arrays/categorical/test_repr.py
+++ b/pandas/tests/arrays/categorical/test_repr.py
@@ -17,7 +17,8 @@
class TestCategoricalReprWithFactor:
- def test_print(self, factor, using_infer_string):
+ def test_print(self, using_infer_string):
+ factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"], ordered=True)
if using_infer_string:
expected = [
"['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c']",
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index 5db0aa5cf510f..bac9548b932c1 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -10,8 +10,6 @@
)
import pandas._testing as tm
-START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
-
class TestDatetimeIndexOps:
def test_infer_freq(self, freq_sample):
@@ -26,6 +24,7 @@ def test_infer_freq(self, freq_sample):
class TestBusinessDatetimeIndex:
@pytest.fixture
def rng(self, freq):
+ START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
return bdate_range(START, END, freq=freq)
def test_comparison(self, rng):
diff --git a/pandas/tests/tseries/offsets/conftest.py b/pandas/tests/tseries/offsets/conftest.py
deleted file mode 100644
index 2fc846353dcb5..0000000000000
--- a/pandas/tests/tseries/offsets/conftest.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import datetime
-
-import pytest
-
-from pandas._libs.tslibs import Timestamp
-
-
-@pytest.fixture
-def dt():
- """
- Fixture for common Timestamp.
- """
- return Timestamp(datetime.datetime(2008, 1, 2))
diff --git a/pandas/tests/tseries/offsets/test_common.py b/pandas/tests/tseries/offsets/test_common.py
index 5b80b8b1c4ab4..aa4e22f71ad66 100644
--- a/pandas/tests/tseries/offsets/test_common.py
+++ b/pandas/tests/tseries/offsets/test_common.py
@@ -250,7 +250,8 @@ def test_sub(date, offset_box, offset2):
[BusinessHour, BusinessHour()],
],
)
-def test_Mult1(offset_box, offset1, dt):
+def test_Mult1(offset_box, offset1):
+ dt = Timestamp(2008, 1, 2)
assert dt + 10 * offset1 == dt + offset_box(10)
assert dt + 5 * offset1 == dt + offset_box(5)
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/56595 | 2023-12-22T01:09:35Z | 2023-12-24T14:19:14Z | 2023-12-24T14:19:14Z | 2023-12-24T19:56:28Z |
DEPR: the method is_anchored() for offsets | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 5b955aa45219a..3ef1abff53d18 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -587,11 +587,13 @@ Other Deprecations
- Deprecated :func:`pd.core.internals.api.make_block`, use public APIs instead (:issue:`40226`)
- Deprecated :func:`read_gbq` and :meth:`DataFrame.to_gbq`. Use ``pandas_gbq.read_gbq`` and ``pandas_gbq.to_gbq`` instead https://pandas-gbq.readthedocs.io/en/latest/api.html (:issue:`55525`)
- Deprecated :meth:`.DataFrameGroupBy.fillna` and :meth:`.SeriesGroupBy.fillna`; use :meth:`.DataFrameGroupBy.ffill`, :meth:`.DataFrameGroupBy.bfill` for forward and backward filling or :meth:`.DataFrame.fillna` to fill with a single value (or the Series equivalents) (:issue:`55718`)
+- Deprecated :meth:`DateOffset.is_anchored`, use ``obj.n == 1`` for non-Tick subclasses (for Tick this was always False) (:issue:`55388`)
- Deprecated :meth:`DatetimeArray.__init__` and :meth:`TimedeltaArray.__init__`, use :func:`array` instead (:issue:`55623`)
- Deprecated :meth:`Index.format`, use ``index.astype(str)`` or ``index.map(formatter)`` instead (:issue:`55413`)
- Deprecated :meth:`Series.ravel`, the underlying array is already 1D, so ravel is not necessary (:issue:`52511`)
- Deprecated :meth:`Series.resample` and :meth:`DataFrame.resample` with a :class:`PeriodIndex` (and the 'convention' keyword), convert to :class:`DatetimeIndex` (with ``.to_timestamp()``) before resampling instead (:issue:`53481`)
- Deprecated :meth:`Series.view`, use :meth:`Series.astype` instead to change the dtype (:issue:`20251`)
+- Deprecated :meth:`offsets.Tick.is_anchored`, use ``False`` instead (:issue:`55388`)
- Deprecated ``core.internals`` members ``Block``, ``ExtensionBlock``, and ``DatetimeTZBlock``, use public APIs instead (:issue:`55139`)
- Deprecated ``year``, ``month``, ``quarter``, ``day``, ``hour``, ``minute``, and ``second`` keywords in the :class:`PeriodIndex` constructor, use :meth:`PeriodIndex.from_fields` instead (:issue:`55960`)
- Deprecated accepting a type as an argument in :meth:`Index.view`, call without any arguments instead (:issue:`55709`)
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index b3788b6003e67..3a339171d0da2 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -756,11 +756,14 @@ cdef class BaseOffset:
raise ValueError(f"{self} is a non-fixed frequency")
def is_anchored(self) -> bool:
- # TODO: Does this make sense for the general case? It would help
- # if there were a canonical docstring for what is_anchored means.
+ # GH#55388
"""
Return boolean whether the frequency is a unit frequency (n=1).
+ .. deprecated:: 2.2.0
+ is_anchored is deprecated and will be removed in a future version.
+ Use ``obj.n == 1`` instead.
+
Examples
--------
>>> pd.DateOffset().is_anchored()
@@ -768,6 +771,12 @@ cdef class BaseOffset:
>>> pd.DateOffset(2).is_anchored()
False
"""
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use \'obj.n == 1\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return self.n == 1
# ------------------------------------------------------------------
@@ -954,6 +963,27 @@ cdef class Tick(SingleConstructorOffset):
return True
def is_anchored(self) -> bool:
+ # GH#55388
+ """
+ Return False.
+
+ .. deprecated:: 2.2.0
+ is_anchored is deprecated and will be removed in a future version.
+ Use ``False`` instead.
+
+ Examples
+ --------
+ >>> pd.offsets.Hour().is_anchored()
+ False
+ >>> pd.offsets.Hour(2).is_anchored()
+ False
+ """
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use False instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return False
# This is identical to BaseOffset.__hash__, but has to be redefined here
@@ -2663,6 +2693,13 @@ cdef class QuarterOffset(SingleConstructorOffset):
return f"{self._prefix}-{month}"
def is_anchored(self) -> bool:
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use \'obj.n == 1 "
+ f"and obj.startingMonth is not None\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return self.n == 1 and self.startingMonth is not None
def is_on_offset(self, dt: datetime) -> bool:
@@ -3308,6 +3345,13 @@ cdef class Week(SingleConstructorOffset):
self._cache = state.pop("_cache", {})
def is_anchored(self) -> bool:
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use \'obj.n == 1 "
+ f"and obj.weekday is not None\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return self.n == 1 and self.weekday is not None
@apply_wraps
@@ -3597,6 +3641,12 @@ cdef class FY5253Mixin(SingleConstructorOffset):
self.variation = state.pop("variation")
def is_anchored(self) -> bool:
+ warnings.warn(
+ f"{type(self).__name__}.is_anchored is deprecated and will be removed "
+ f"in a future version, please use \'obj.n == 1\' instead.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
return (
self.n == 1 and self.startingMonth is not None and self.weekday is not None
)
diff --git a/pandas/tests/indexes/interval/test_interval_range.py b/pandas/tests/indexes/interval/test_interval_range.py
index d4d4a09c44d13..e8de59f84bcc6 100644
--- a/pandas/tests/indexes/interval/test_interval_range.py
+++ b/pandas/tests/indexes/interval/test_interval_range.py
@@ -84,9 +84,7 @@ def test_constructor_timestamp(self, closed, name, freq, periods, tz):
tm.assert_index_equal(result, expected)
# GH 20976: linspace behavior defined from start/end/periods
- if not breaks.freq.is_anchored() and tz is None:
- # matches expected only for non-anchored offsets and tz naive
- # (anchored/DST transitions cause unequal spacing in expected)
+ if not breaks.freq.n == 1 and tz is None:
result = interval_range(
start=start, end=end, periods=periods, name=name, closed=closed
)
diff --git a/pandas/tests/tseries/offsets/test_business_quarter.py b/pandas/tests/tseries/offsets/test_business_quarter.py
index 44a7f16ab039d..6d7a115054b7f 100644
--- a/pandas/tests/tseries/offsets/test_business_quarter.py
+++ b/pandas/tests/tseries/offsets/test_business_quarter.py
@@ -9,6 +9,7 @@
import pytest
+import pandas._testing as tm
from pandas.tests.tseries.offsets.common import (
assert_is_on_offset,
assert_offset_equal,
@@ -54,9 +55,12 @@ def test_repr(self):
assert repr(BQuarterBegin(startingMonth=1)) == expected
def test_is_anchored(self):
- assert BQuarterBegin(startingMonth=1).is_anchored()
- assert BQuarterBegin().is_anchored()
- assert not BQuarterBegin(2, startingMonth=1).is_anchored()
+ msg = "BQuarterBegin.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert BQuarterBegin(startingMonth=1).is_anchored()
+ assert BQuarterBegin().is_anchored()
+ assert not BQuarterBegin(2, startingMonth=1).is_anchored()
def test_offset_corner_case(self):
# corner
@@ -177,9 +181,12 @@ def test_repr(self):
assert repr(BQuarterEnd(startingMonth=1)) == expected
def test_is_anchored(self):
- assert BQuarterEnd(startingMonth=1).is_anchored()
- assert BQuarterEnd().is_anchored()
- assert not BQuarterEnd(2, startingMonth=1).is_anchored()
+ msg = "BQuarterEnd.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert BQuarterEnd(startingMonth=1).is_anchored()
+ assert BQuarterEnd().is_anchored()
+ assert not BQuarterEnd(2, startingMonth=1).is_anchored()
def test_offset_corner_case(self):
# corner
diff --git a/pandas/tests/tseries/offsets/test_fiscal.py b/pandas/tests/tseries/offsets/test_fiscal.py
index 7f8c34bc6832e..824e66a1ddef1 100644
--- a/pandas/tests/tseries/offsets/test_fiscal.py
+++ b/pandas/tests/tseries/offsets/test_fiscal.py
@@ -7,6 +7,7 @@
import pytest
from pandas import Timestamp
+import pandas._testing as tm
from pandas.tests.tseries.offsets.common import (
WeekDay,
assert_is_on_offset,
@@ -295,15 +296,18 @@ def test_apply(self):
class TestFY5253LastOfMonthQuarter:
def test_is_anchored(self):
- assert makeFY5253LastOfMonthQuarter(
- startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
- ).is_anchored()
- assert makeFY5253LastOfMonthQuarter(
- weekday=WeekDay.SAT, startingMonth=3, qtr_with_extra_week=4
- ).is_anchored()
- assert not makeFY5253LastOfMonthQuarter(
- 2, startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
- ).is_anchored()
+ msg = "FY5253Quarter.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert makeFY5253LastOfMonthQuarter(
+ startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+ ).is_anchored()
+ assert makeFY5253LastOfMonthQuarter(
+ weekday=WeekDay.SAT, startingMonth=3, qtr_with_extra_week=4
+ ).is_anchored()
+ assert not makeFY5253LastOfMonthQuarter(
+ 2, startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4
+ ).is_anchored()
def test_equality(self):
assert makeFY5253LastOfMonthQuarter(
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index ddf56e68b1611..62afb8b83d576 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -625,8 +625,11 @@ def test_default_constructor(self, dt):
assert (dt + DateOffset(2)) == datetime(2008, 1, 4)
def test_is_anchored(self):
- assert not DateOffset(2).is_anchored()
- assert DateOffset(1).is_anchored()
+ msg = "DateOffset.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert not DateOffset(2).is_anchored()
+ assert DateOffset(1).is_anchored()
def test_copy(self):
assert DateOffset(months=2).copy() == DateOffset(months=2)
diff --git a/pandas/tests/tseries/offsets/test_quarter.py b/pandas/tests/tseries/offsets/test_quarter.py
index d183645da507d..5fd3ba0a5fb87 100644
--- a/pandas/tests/tseries/offsets/test_quarter.py
+++ b/pandas/tests/tseries/offsets/test_quarter.py
@@ -9,6 +9,7 @@
import pytest
+import pandas._testing as tm
from pandas.tests.tseries.offsets.common import (
assert_is_on_offset,
assert_offset_equal,
@@ -53,9 +54,12 @@ def test_repr(self):
assert repr(QuarterBegin(startingMonth=1)) == expected
def test_is_anchored(self):
- assert QuarterBegin(startingMonth=1).is_anchored()
- assert QuarterBegin().is_anchored()
- assert not QuarterBegin(2, startingMonth=1).is_anchored()
+ msg = "QuarterBegin.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert QuarterBegin(startingMonth=1).is_anchored()
+ assert QuarterBegin().is_anchored()
+ assert not QuarterBegin(2, startingMonth=1).is_anchored()
def test_offset_corner_case(self):
# corner
@@ -161,9 +165,12 @@ def test_repr(self):
assert repr(QuarterEnd(startingMonth=1)) == expected
def test_is_anchored(self):
- assert QuarterEnd(startingMonth=1).is_anchored()
- assert QuarterEnd().is_anchored()
- assert not QuarterEnd(2, startingMonth=1).is_anchored()
+ msg = "QuarterEnd.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert QuarterEnd(startingMonth=1).is_anchored()
+ assert QuarterEnd().is_anchored()
+ assert not QuarterEnd(2, startingMonth=1).is_anchored()
def test_offset_corner_case(self):
# corner
diff --git a/pandas/tests/tseries/offsets/test_ticks.py b/pandas/tests/tseries/offsets/test_ticks.py
index b68b91826bc6f..399b7038d3426 100644
--- a/pandas/tests/tseries/offsets/test_ticks.py
+++ b/pandas/tests/tseries/offsets/test_ticks.py
@@ -339,7 +339,10 @@ def test_tick_equalities(cls):
@pytest.mark.parametrize("cls", tick_classes)
def test_tick_offset(cls):
- assert not cls().is_anchored()
+ msg = f"{cls.__name__}.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert not cls().is_anchored()
@pytest.mark.parametrize("cls", tick_classes)
diff --git a/pandas/tests/tseries/offsets/test_week.py b/pandas/tests/tseries/offsets/test_week.py
index f42ff091af277..0cd6f769769ae 100644
--- a/pandas/tests/tseries/offsets/test_week.py
+++ b/pandas/tests/tseries/offsets/test_week.py
@@ -21,6 +21,7 @@
WeekOfMonth,
)
+import pandas._testing as tm
from pandas.tests.tseries.offsets.common import (
WeekDay,
assert_is_on_offset,
@@ -42,10 +43,13 @@ def test_corner(self):
Week(weekday=-1)
def test_is_anchored(self):
- assert Week(weekday=0).is_anchored()
- assert not Week().is_anchored()
- assert not Week(2, weekday=2).is_anchored()
- assert not Week(2).is_anchored()
+ msg = "Week.is_anchored is deprecated "
+
+ with tm.assert_produces_warning(FutureWarning, match=msg):
+ assert Week(weekday=0).is_anchored()
+ assert not Week().is_anchored()
+ assert not Week(2, weekday=2).is_anchored()
+ assert not Week(2).is_anchored()
offset_cases = []
# not business week
| - [x] closes #55388
deprecated the method `is_anchored()` for offsets classes: `Tick, Week, QuarterOffset, FY5253Mixin, BaseOffset` | https://api.github.com/repos/pandas-dev/pandas/pulls/56594 | 2023-12-21T22:55:53Z | 2024-01-10T16:39:02Z | 2024-01-10T16:39:02Z | 2024-01-12T17:16:41Z |
DOC: Move deprecation note | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 535704a27169c..d1481639ca5a0 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -571,6 +571,9 @@ These methods are:
- :meth:`DataFrame.fillna`, :meth:`Series.fillna`
- :meth:`DataFrame.ffill`, :meth:`Series.ffill`
- :meth:`DataFrame.bfill`, :meth:`Series.bfill`
+- :meth:`DataFrame.mask`, :meth:`Series.mask`
+- :meth:`DataFrame.where`, :meth:`Series.where`
+- :meth:`DataFrame.clip`, :meth:`Series.clip`
Explicitly call :meth:`DataFrame.infer_objects` to replicate the current behavior in the future.
@@ -578,6 +581,8 @@ Explicitly call :meth:`DataFrame.infer_objects` to replicate the current behavio
result = result.infer_objects(copy=False)
+Or explicitly cast all-round floats to ints using ``astype``.
+
Set the following option to opt into the future behavior:
.. code-block:: ipython
@@ -618,7 +623,6 @@ Other Deprecations
- Deprecated allowing passing :class:`BlockManager` objects to :class:`DataFrame` or :class:`SingleBlockManager` objects to :class:`Series` (:issue:`52419`)
- Deprecated behavior of :meth:`Index.insert` with an object-dtype index silently performing type inference on the result, explicitly call ``result.infer_objects(copy=False)`` for the old behavior instead (:issue:`51363`)
- Deprecated casting non-datetimelike values (mainly strings) in :meth:`Series.isin` and :meth:`Index.isin` with ``datetime64``, ``timedelta64``, and :class:`PeriodDtype` dtypes (:issue:`53111`)
-- Deprecated downcasting behavior in :meth:`Series.where`, :meth:`DataFrame.where`, :meth:`Series.mask`, :meth:`DataFrame.mask`, :meth:`Series.clip`, :meth:`DataFrame.clip`; in a future version these will not infer object-dtype columns to non-object dtype, or all-round floats to integer dtype. Call ``result.infer_objects(copy=False)`` on the result for object inference, or explicitly cast floats to ints. To opt in to the future version, use ``pd.set_option("future.no_silent_downcasting", True)`` (:issue:`53656`)
- Deprecated dtype inference in :class:`Index`, :class:`Series` and :class:`DataFrame` constructors when giving a pandas input, call ``.infer_objects`` on the input to keep the current behavior (:issue:`56012`)
- Deprecated dtype inference when setting a :class:`Index` into a :class:`DataFrame`, cast explicitly instead (:issue:`56102`)
- Deprecated including the groups in computations when using :meth:`.DataFrameGroupBy.apply` and :meth:`.DataFrameGroupBy.resample`; pass ``include_groups=False`` to exclude the groups (:issue:`7155`)
| - [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
just a reordering, not critical for the rc | https://api.github.com/repos/pandas-dev/pandas/pulls/56593 | 2023-12-21T21:43:08Z | 2023-12-22T00:07:36Z | 2023-12-22T00:07:36Z | 2023-12-22T00:07:43Z |
BLD: Add wheel builds for musllinux on aarch64 | diff --git a/.circleci/config.yml b/.circleci/config.yml
index 1c70debca0caf..90afb1ce29684 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -18,6 +18,29 @@ jobs:
PATH=$HOME/miniconda3/envs/pandas-dev/bin:$HOME/miniconda3/condabin:$PATH
LD_PRELOAD=$HOME/miniconda3/envs/pandas-dev/lib/libgomp.so.1:$LD_PRELOAD
ci/run_tests.sh
+ linux-musl:
+ docker:
+ - image: quay.io/pypa/musllinux_1_1_aarch64
+ resource_class: arm.large
+ steps:
+ # Install pkgs first to have git in the image
+ # (needed for checkout)
+ - run: |
+ apk update
+ apk add git
+ apk add musl-locales
+ - checkout
+ - run: |
+ /opt/python/cp311-cp311/bin/python -m venv ~/virtualenvs/pandas-dev
+ . ~/virtualenvs/pandas-dev/bin/activate
+ python -m pip install --no-cache-dir -U pip wheel setuptools meson-python==0.13.1 meson[ninja]==1.2.1
+ python -m pip install --no-cache-dir versioneer[toml] cython numpy python-dateutil pytz pytest>=7.3.2 pytest-xdist>=2.2.0 hypothesis>=6.46.1
+ python -m pip install --no-cache-dir --no-build-isolation -e . --config-settings=setup-args="--werror"
+ python -m pip list --no-cache-dir
+ - run: |
+ . ~/virtualenvs/pandas-dev/bin/activate
+ export PANDAS_CI=1
+ python -m pytest -m 'not slow and not network and not clipboard and not single_cpu' pandas --junitxml=test-data.xml
build-aarch64:
parameters:
cibw-build:
@@ -89,6 +112,13 @@ workflows:
equal: [ scheduled_pipeline, << pipeline.trigger_source >> ]
jobs:
- test-arm
+ test-musl:
+ # Don't run trigger this one when scheduled pipeline runs
+ when:
+ not:
+ equal: [ scheduled_pipeline, << pipeline.trigger_source >> ]
+ jobs:
+ - linux-musl
build-wheels:
jobs:
- build-aarch64:
@@ -97,4 +127,11 @@ workflows:
only: /^v.*/
matrix:
parameters:
- cibw-build: ["cp39-manylinux_aarch64", "cp310-manylinux_aarch64", "cp311-manylinux_aarch64", "cp312-manylinux_aarch64"]
+ cibw-build: ["cp39-manylinux_aarch64",
+ "cp310-manylinux_aarch64",
+ "cp311-manylinux_aarch64",
+ "cp312-manylinux_aarch64",
+ "cp39-musllinux_aarch64",
+ "cp310-musllinux_aarch64",
+ "cp311-musllinux_aarch64",
+ "cp312-musllinux_aarch64",]
diff --git a/pyproject.toml b/pyproject.toml
index f6ba25f448540..94213b0d350c9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -152,7 +152,7 @@ parentdir_prefix = "pandas-"
setup = ['--vsenv'] # For Windows
[tool.cibuildwheel]
-skip = "cp36-* cp37-* cp38-* pp* *_i686 *_ppc64le *_s390x *-musllinux_aarch64"
+skip = "cp36-* cp37-* cp38-* pp* *_i686 *_ppc64le *_s390x"
build-verbosity = "3"
environment = {LDFLAGS="-Wl,--strip-all"}
test-requires = "hypothesis>=6.46.1 pytest>=7.3.2 pytest-xdist>=2.2.0"
| - [ ] closes #55645 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/56590 | 2023-12-21T19:53:36Z | 2023-12-22T15:24:08Z | 2023-12-22T15:24:08Z | 2023-12-22T15:24:10Z |
ENH: Update CFF with publication reference, Zenodo DOI, and other details | diff --git a/CITATION.cff b/CITATION.cff
index 741e7e7ac8c85..11f45b0d87ec7 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -3,12 +3,50 @@ title: 'pandas-dev/pandas: Pandas'
message: 'If you use this software, please cite it as below.'
authors:
- name: "The pandas development team"
+ website: "https://pandas.pydata.org/about/team.html"
abstract: "Pandas is a powerful data structures for data analysis, time series, and statistics."
+doi: 10.5281/zenodo.3509134
license: BSD-3-Clause
license-url: "https://github.com/pandas-dev/pandas/blob/main/LICENSE"
repository-code: "https://github.com/pandas-dev/pandas"
keywords:
- python
- data science
+ - flexible
+ - pandas
+ - alignment
+ - data analysis
type: software
-url: "https://github.com/pandas-dev/pandas"
+url: "https://pandas.pydata.org/"
+references:
+ - type: article
+ authors:
+ - given-names: Wes
+ family-names: McKinney
+ affiliation: AQR Capital Management, LLC
+ email: wesmckinn@gmail.com
+ title: Data Structures for Statistical Computing in Python
+ doi: 10.25080/Majora-92bf1922-00a
+ license: CC-BY-3.0
+ start: 56
+ end: 61
+ year: 2010
+ collection-title: Proceedings of the 9th Python in Science Conference
+ collection-doi: 10.25080/Majora-92bf1922-012
+ collection-type: proceedings
+ editors:
+ - given-names: Stéfan
+ name-particle: van der
+ family-names: Walt
+ - given-names: Jarrod
+ family-names: Millman
+ conference:
+ name: 9th Python in Science Conference (SciPy 2010)
+ city: Austin, TX
+ country: US
+ date-start: "2010-06-28"
+ date-end: "2010-07-03"
+ keywords:
+ - data structure
+ - statistics
+ - R
| Continuing in the spirit of #54241, this PR adds some further information to the CITATION.cff file, including a reference to [McKinney (2010)](https://doi.org/10.25080/Majora-92bf1922-00a), the DOI of the software itself ([10.5281/zenodo.3509134](https://doi.org/10.5281/zenodo.3509134)), a link to the [team page](https://pandas.pydata.org/about/team.html) on pandas' website, and a couple more keywords that bring this list into alignment with what the GitHub repository displays. | https://api.github.com/repos/pandas-dev/pandas/pulls/56589 | 2023-12-21T18:23:17Z | 2023-12-27T18:59:53Z | 2023-12-27T18:59:53Z | 2023-12-27T19:13:44Z |
ENH: support the Arrow PyCapsule Interface on pandas.DataFrame (export) | diff --git a/pandas/compat/_optional.py b/pandas/compat/_optional.py
index 3cdeae52a25ba..064ae473652d2 100644
--- a/pandas/compat/_optional.py
+++ b/pandas/compat/_optional.py
@@ -147,9 +147,8 @@ def import_optional_dependency(
The imported module, when found and the version is correct.
None is returned when the package is not found and `errors`
is False, or when the package's version is too old and `errors`
- is ``'warn'``.
+ is ``'warn'`` or ``'ignore'``.
"""
-
assert errors in {"warn", "raise", "ignore"}
package_name = INSTALL_MAPPING.get(name)
@@ -190,5 +189,7 @@ def import_optional_dependency(
return None
elif errors == "raise":
raise ImportError(msg)
+ else:
+ return None
return module
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index e6d86cba0a4c3..e093d551f3ead 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -988,6 +988,33 @@ def __dataframe_consortium_standard__(
)
return convert_to_standard_compliant_dataframe(self, api_version=api_version)
+ def __arrow_c_stream__(self, requested_schema=None):
+ """
+ Export the pandas DataFrame as an Arrow C stream PyCapsule.
+
+ This relies on pyarrow to convert the pandas DataFrame to the Arrow
+ format (and follows the default behaviour of ``pyarrow.Table.from_pandas``
+ in its handling of the index, i.e. store the index as a column except
+ for RangeIndex).
+ This conversion is not necessarily zero-copy.
+
+ Parameters
+ ----------
+ requested_schema : PyCapsule, default None
+ The schema to which the dataframe should be casted, passed as a
+ PyCapsule containing a C ArrowSchema representation of the
+ requested schema.
+
+ Returns
+ -------
+ PyCapsule
+ """
+ pa = import_optional_dependency("pyarrow", min_version="14.0.0")
+ if requested_schema is not None:
+ requested_schema = pa.Schema._import_from_c_capsule(requested_schema)
+ table = pa.Table.from_pandas(self, schema=requested_schema)
+ return table.__arrow_c_stream__()
+
# ----------------------------------------------------------------------
@property
diff --git a/pandas/tests/frame/test_arrow_interface.py b/pandas/tests/frame/test_arrow_interface.py
new file mode 100644
index 0000000000000..ac7b51cbdfa92
--- /dev/null
+++ b/pandas/tests/frame/test_arrow_interface.py
@@ -0,0 +1,45 @@
+import ctypes
+
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+
+pa = pytest.importorskip("pyarrow")
+
+
+@td.skip_if_no("pyarrow", min_version="14.0")
+def test_dataframe_arrow_interface():
+ df = pd.DataFrame({"a": [1, 2, 3], "b": ["a", "b", "c"]})
+
+ capsule = df.__arrow_c_stream__()
+ assert (
+ ctypes.pythonapi.PyCapsule_IsValid(
+ ctypes.py_object(capsule), b"arrow_array_stream"
+ )
+ == 1
+ )
+
+ table = pa.table(df)
+ expected = pa.table({"a": [1, 2, 3], "b": ["a", "b", "c"]})
+ assert table.equals(expected)
+
+ schema = pa.schema([("a", pa.int8()), ("b", pa.string())])
+ table = pa.table(df, schema=schema)
+ expected = expected.cast(schema)
+ assert table.equals(expected)
+
+
+@td.skip_if_no("pyarrow", min_version="15.0")
+def test_dataframe_to_arrow():
+ df = pd.DataFrame({"a": [1, 2, 3], "b": ["a", "b", "c"]})
+
+ table = pa.RecordBatchReader.from_stream(df)
+ expected = pa.table({"a": [1, 2, 3], "b": ["a", "b", "c"]})
+ assert table.equals(expected)
+
+ schema = pa.schema([("a", pa.int8()), ("b", pa.string())])
+ table = pa.RecordBatchReader.from_stream(df, schema=schema)
+ expected = expected.cast(schema)
+ assert table.equals(expected)
diff --git a/pandas/tests/test_optional_dependency.py b/pandas/tests/test_optional_dependency.py
index c1d1948d6c31a..52b5f636b1254 100644
--- a/pandas/tests/test_optional_dependency.py
+++ b/pandas/tests/test_optional_dependency.py
@@ -50,6 +50,20 @@ def test_bad_version(monkeypatch):
result = import_optional_dependency("fakemodule")
assert result is module
+ with pytest.raises(ImportError, match="Pandas requires version '1.1.0'"):
+ import_optional_dependency("fakemodule", min_version="1.1.0")
+
+ with tm.assert_produces_warning(UserWarning):
+ result = import_optional_dependency(
+ "fakemodule", errors="warn", min_version="1.1.0"
+ )
+ assert result is None
+
+ result = import_optional_dependency(
+ "fakemodule", errors="ignore", min_version="1.1.0"
+ )
+ assert result is None
+
def test_submodule(monkeypatch):
# Create a fake module with a submodule
| See https://github.com/apache/arrow/issues/39195 for some context, and https://arrow.apache.org/docs/dev/format/CDataInterface/PyCapsuleInterface.html for the new Arrow specification.
For now this PR just implements the stream support on DataFrame (using pyarrow under the hood to do the actual conversion). We should also consider adding the array and schema protocol methods.
We could add similar methods on Series, but that has less of an exact equivalent in Arrow terms (e.g. it would loose the index).
This PR also only implements exporting a pandas DataFrame through the protocol, not adding support to our constructors to consume (import) any object supporting the protocol. | https://api.github.com/repos/pandas-dev/pandas/pulls/56587 | 2023-12-21T16:38:04Z | 2024-01-18T19:23:06Z | 2024-01-18T19:23:06Z | 2024-01-18T22:10:13Z |
BUG: convert_dtypes raising when preserving object dtype | diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 1af2d9e739038..20eff9315bc80 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -746,7 +746,7 @@ def astype(
Block
"""
values = self.values
- if squeeze and values.ndim == 2:
+ if squeeze and values.ndim == 2 and is_1d_only_ea_dtype(dtype):
if values.shape[0] != 1:
raise ValueError("Can not squeeze with more than one column.")
values = values[0, :] # type: ignore[call-overload]
diff --git a/pandas/tests/frame/methods/test_convert_dtypes.py b/pandas/tests/frame/methods/test_convert_dtypes.py
index a181a271181ca..521d2cb14ac6a 100644
--- a/pandas/tests/frame/methods/test_convert_dtypes.py
+++ b/pandas/tests/frame/methods/test_convert_dtypes.py
@@ -193,3 +193,10 @@ def test_convert_dtypes_avoid_block_splitting(self):
)
tm.assert_frame_equal(result, expected)
assert result._mgr.nblocks == 2
+
+ def test_convert_dtypes_from_arrow(self):
+ # GH#56581
+ df = pd.DataFrame([["a", datetime.time(18, 12)]], columns=["a", "b"])
+ result = df.convert_dtypes()
+ expected = df.astype({"a": "string[python]"})
+ tm.assert_frame_equal(result, expected)
| - [ ] closes #56581 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
| https://api.github.com/repos/pandas-dev/pandas/pulls/56585 | 2023-12-21T00:27:13Z | 2023-12-21T01:30:49Z | 2023-12-21T01:30:49Z | 2023-12-21T01:34:31Z |
CI: Disable linkecheck | diff --git a/.github/workflows/broken-linkcheck.yml b/.github/workflows/broken-linkcheck.yml
index 10ab5b08a4437..191252cccf1c3 100644
--- a/.github/workflows/broken-linkcheck.yml
+++ b/.github/workflows/broken-linkcheck.yml
@@ -9,6 +9,7 @@ on:
- "doc/make.py"
jobs:
linkcheck:
+ if: false
runs-on: ubuntu-latest
defaults:
run:
| Since this job is not fully ready yet, going to disable as it can "fail" if the right files were modified | https://api.github.com/repos/pandas-dev/pandas/pulls/56584 | 2023-12-20T23:51:40Z | 2023-12-21T01:32:18Z | 2023-12-21T01:32:18Z | 2023-12-21T01:32:21Z |
TST/CLN: Reuse top level fixtures instead of parametrizations | diff --git a/pandas/conftest.py b/pandas/conftest.py
index 046cda259eefd..c325a268fe418 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -281,17 +281,6 @@ def axis(request):
return request.param
-axis_frame = axis
-
-
-@pytest.fixture(params=[1, "columns"], ids=lambda x: f"axis={repr(x)}")
-def axis_1(request):
- """
- Fixture for returning aliases of axis 1 of a DataFrame.
- """
- return request.param
-
-
@pytest.fixture(params=[True, False, None])
def observed(request):
"""
@@ -313,6 +302,22 @@ def ordered(request):
return request.param
+@pytest.fixture(params=[True, False])
+def dropna(request):
+ """
+ Boolean 'dropna' parameter.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def sort(request):
+ """
+ Boolean 'sort' parameter.
+ """
+ return request.param
+
+
@pytest.fixture(params=[True, False])
def skipna(request):
"""
@@ -414,6 +419,74 @@ def nselect_method(request):
return request.param
+@pytest.fixture(params=[None, "ignore"])
+def na_action(request):
+ """
+ Fixture for 'na_action' argument in map.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def ascending(request):
+ """
+ Fixture for 'na_action' argument in sort_values/sort_index/rank.
+ """
+ return request.param
+
+
+@pytest.fixture(params=["average", "min", "max", "first", "dense"])
+def rank_method(request):
+ """
+ Fixture for 'rank' argument in rank.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def as_index(request):
+ """
+ Fixture for 'as_index' argument in groupby.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def cache(request):
+ """
+ Fixture for 'cache' argument in to_datetime.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def parallel(request):
+ """
+ Fixture for parallel keyword argument for numba.jit.
+ """
+ return request.param
+
+
+# Can parameterize nogil & nopython over True | False, but limiting per
+# https://github.com/pandas-dev/pandas/pull/41971#issuecomment-860607472
+
+
+@pytest.fixture(params=[False])
+def nogil(request):
+ """
+ Fixture for nogil keyword argument for numba.jit.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[True])
+def nopython(request):
+ """
+ Fixture for nopython keyword argument for numba.jit.
+ """
+ return request.param
+
+
# ----------------------------------------------------------------
# Missing values & co.
# ----------------------------------------------------------------
@@ -478,10 +551,6 @@ def index_or_series(request):
return request.param
-# Generate cartesian product of index_or_series fixture:
-index_or_series2 = index_or_series
-
-
@pytest.fixture(params=[Index, Series, pd.array], ids=["index", "series", "array"])
def index_or_series_or_array(request):
"""
@@ -674,10 +743,6 @@ def index(request):
return indices_dict[request.param].copy()
-# Needed to generate cartesian product of indices
-index_fixture2 = index
-
-
@pytest.fixture(
params=[
key for key, value in indices_dict.items() if not isinstance(value, MultiIndex)
@@ -691,10 +756,6 @@ def index_flat(request):
return indices_dict[key].copy()
-# Alias so we can test with cartesian product of index_flat
-index_flat2 = index_flat
-
-
@pytest.fixture(
params=[
key
diff --git a/pandas/tests/apply/test_str.py b/pandas/tests/apply/test_str.py
index 17e8322dc40e1..e9967b75becce 100644
--- a/pandas/tests/apply/test_str.py
+++ b/pandas/tests/apply/test_str.py
@@ -43,10 +43,9 @@ def test_apply_with_string_funcs(request, float_frame, func, args, kwds, how):
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("arg", ["sum", "mean", "min", "max", "std"])
-def test_with_string_args(datetime_series, arg):
- result = datetime_series.apply(arg)
- expected = getattr(datetime_series, arg)()
+def test_with_string_args(datetime_series, all_numeric_reductions):
+ result = datetime_series.apply(all_numeric_reductions)
+ expected = getattr(datetime_series, all_numeric_reductions)()
assert result == expected
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index dbff88dc6f4f6..b4e8d09c18163 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -1221,7 +1221,6 @@ class TestDatetime64DateOffsetArithmetic:
# Tick DateOffsets
# TODO: parametrize over timezone?
- @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_dt64arr_series_add_tick_DateOffset(self, box_with_array, unit):
# GH#4532
# operate with pd.offsets
@@ -1311,7 +1310,6 @@ def test_dti_add_tick_tzaware(self, tz_aware_fixture, box_with_array):
# -------------------------------------------------------------
# RelativeDelta DateOffsets
- @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_dt64arr_add_sub_relativedelta_offsets(self, box_with_array, unit):
# GH#10699
vec = DatetimeIndex(
@@ -1422,7 +1420,6 @@ def test_dt64arr_add_sub_relativedelta_offsets(self, box_with_array, unit):
)
@pytest.mark.parametrize("normalize", [True, False])
@pytest.mark.parametrize("n", [0, 5])
- @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
@pytest.mark.parametrize("tz", [None, "US/Central"])
def test_dt64arr_add_sub_DateOffsets(
self, box_with_array, n, normalize, cls_and_kwargs, unit, tz
@@ -2356,7 +2353,6 @@ def test_dti_addsub_object_arraylike(
@pytest.mark.parametrize("years", [-1, 0, 1])
@pytest.mark.parametrize("months", [-2, 0, 2])
-@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_shift_months(years, months, unit):
dti = DatetimeIndex(
[
diff --git a/pandas/tests/arrays/boolean/test_reduction.py b/pandas/tests/arrays/boolean/test_reduction.py
index dd8c3eda9ed05..7071c6f8844e4 100644
--- a/pandas/tests/arrays/boolean/test_reduction.py
+++ b/pandas/tests/arrays/boolean/test_reduction.py
@@ -43,7 +43,6 @@ def test_any_all(values, exp_any, exp_all, exp_any_noskip, exp_all_noskip):
assert np.all(a.all()) is exp_all
-@pytest.mark.parametrize("dropna", [True, False])
def test_reductions_return_types(dropna, data, all_numeric_reductions):
op = all_numeric_reductions
s = pd.Series(data)
diff --git a/pandas/tests/arrays/categorical/test_algos.py b/pandas/tests/arrays/categorical/test_algos.py
index d4c19a4970135..69c3364c7e98e 100644
--- a/pandas/tests/arrays/categorical/test_algos.py
+++ b/pandas/tests/arrays/categorical/test_algos.py
@@ -5,7 +5,6 @@
import pandas._testing as tm
-@pytest.mark.parametrize("ordered", [True, False])
@pytest.mark.parametrize("categories", [["b", "a", "c"], ["a", "b", "c", "d"]])
def test_factorize(categories, ordered):
cat = pd.Categorical(
diff --git a/pandas/tests/arrays/categorical/test_analytics.py b/pandas/tests/arrays/categorical/test_analytics.py
index c2c53fbc4637e..1021b18f4ae71 100644
--- a/pandas/tests/arrays/categorical/test_analytics.py
+++ b/pandas/tests/arrays/categorical/test_analytics.py
@@ -97,7 +97,6 @@ def test_min_max_ordered_empty(self, categories, expected, aggregation):
"values, categories",
[(["a", "b", "c", np.nan], list("cba")), ([1, 2, 3, np.nan], [3, 2, 1])],
)
- @pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("function", ["min", "max"])
def test_min_max_with_nan(self, values, categories, function, skipna):
# GH 25303
@@ -111,7 +110,6 @@ def test_min_max_with_nan(self, values, categories, function, skipna):
assert result == expected
@pytest.mark.parametrize("function", ["min", "max"])
- @pytest.mark.parametrize("skipna", [True, False])
def test_min_max_only_nan(self, function, skipna):
# https://github.com/pandas-dev/pandas/issues/33450
cat = Categorical([np.nan], categories=[1, 2], ordered=True)
diff --git a/pandas/tests/arrays/categorical/test_api.py b/pandas/tests/arrays/categorical/test_api.py
index a939ee5f6f53f..41d9db7335957 100644
--- a/pandas/tests/arrays/categorical/test_api.py
+++ b/pandas/tests/arrays/categorical/test_api.py
@@ -301,7 +301,6 @@ def test_set_categories(self):
(["a", "b", "c"], ["a", "b"], ["d", "e"]),
],
)
- @pytest.mark.parametrize("ordered", [True, False])
def test_set_categories_many(self, values, categories, new_categories, ordered):
c = Categorical(values, categories)
expected = Categorical(values, new_categories, ordered)
diff --git a/pandas/tests/arrays/categorical/test_astype.py b/pandas/tests/arrays/categorical/test_astype.py
index a2a53af6ab1ad..7cfd8ec8dfadf 100644
--- a/pandas/tests/arrays/categorical/test_astype.py
+++ b/pandas/tests/arrays/categorical/test_astype.py
@@ -81,7 +81,6 @@ def test_astype_str_int_categories_to_nullable_float(self):
expected = array(codes, dtype="Float64") / 2
tm.assert_extension_array_equal(res, expected)
- @pytest.mark.parametrize("ordered", [True, False])
def test_astype(self, ordered):
# string
cat = Categorical(list("abbaaccc"), ordered=ordered)
@@ -108,11 +107,10 @@ def test_astype(self, ordered):
tm.assert_numpy_array_equal(result, expected)
@pytest.mark.parametrize("dtype_ordered", [True, False])
- @pytest.mark.parametrize("cat_ordered", [True, False])
- def test_astype_category(self, dtype_ordered, cat_ordered):
+ def test_astype_category(self, dtype_ordered, ordered):
# GH#10696/GH#18593
data = list("abcaacbab")
- cat = Categorical(data, categories=list("bac"), ordered=cat_ordered)
+ cat = Categorical(data, categories=list("bac"), ordered=ordered)
# standard categories
dtype = CategoricalDtype(ordered=dtype_ordered)
diff --git a/pandas/tests/arrays/categorical/test_constructors.py b/pandas/tests/arrays/categorical/test_constructors.py
index 373f1c95463fc..03678fb64d3e9 100644
--- a/pandas/tests/arrays/categorical/test_constructors.py
+++ b/pandas/tests/arrays/categorical/test_constructors.py
@@ -437,7 +437,6 @@ def test_constructor_dtype_and_others_raises(self):
Categorical(["a", "b"], ordered=False, dtype=dtype)
@pytest.mark.parametrize("categories", [None, ["a", "b"], ["a", "c"]])
- @pytest.mark.parametrize("ordered", [True, False])
def test_constructor_str_category(self, categories, ordered):
result = Categorical(
["a", "b"], categories=categories, ordered=ordered, dtype="category"
@@ -683,7 +682,6 @@ def test_from_inferred_categories_coerces(self):
expected = Categorical([1, 1, 2, np.nan])
tm.assert_categorical_equal(result, expected)
- @pytest.mark.parametrize("ordered", [None, True, False])
def test_construction_with_ordered(self, ordered):
# GH 9347, 9190
cat = Categorical([0, 1, 2], ordered=ordered)
diff --git a/pandas/tests/arrays/categorical/test_dtypes.py b/pandas/tests/arrays/categorical/test_dtypes.py
index 525663cad1745..f2f2851c22794 100644
--- a/pandas/tests/arrays/categorical/test_dtypes.py
+++ b/pandas/tests/arrays/categorical/test_dtypes.py
@@ -83,7 +83,6 @@ def test_set_dtype_new_categories(self):
(["a", "b", "c"], ["a", "b"], ["d", "e"]),
],
)
- @pytest.mark.parametrize("ordered", [True, False])
def test_set_dtype_many(self, values, categories, new_categories, ordered):
c = Categorical(values, categories)
expected = Categorical(values, new_categories, ordered)
diff --git a/pandas/tests/arrays/categorical/test_map.py b/pandas/tests/arrays/categorical/test_map.py
index 3d41b7cc7094d..763ca9180e53a 100644
--- a/pandas/tests/arrays/categorical/test_map.py
+++ b/pandas/tests/arrays/categorical/test_map.py
@@ -10,11 +10,6 @@
import pandas._testing as tm
-@pytest.fixture(params=[None, "ignore"])
-def na_action(request):
- return request.param
-
-
@pytest.mark.parametrize(
"data, categories",
[
diff --git a/pandas/tests/arrays/datetimes/test_constructors.py b/pandas/tests/arrays/datetimes/test_constructors.py
index daf4aa3b47f56..e14cd0c6f2b7d 100644
--- a/pandas/tests/arrays/datetimes/test_constructors.py
+++ b/pandas/tests/arrays/datetimes/test_constructors.py
@@ -165,7 +165,6 @@ def test_copy(self):
arr = DatetimeArray._from_sequence(data, copy=True)
assert arr._ndarray is not data
- @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_numpy_datetime_unit(self, unit):
data = np.array([1, 2, 3], dtype=f"M8[{unit}]")
arr = DatetimeArray._from_sequence(data)
diff --git a/pandas/tests/arrays/datetimes/test_reductions.py b/pandas/tests/arrays/datetimes/test_reductions.py
index a941546b13a56..a58b0f57bf0da 100644
--- a/pandas/tests/arrays/datetimes/test_reductions.py
+++ b/pandas/tests/arrays/datetimes/test_reductions.py
@@ -10,10 +10,6 @@
class TestReductions:
- @pytest.fixture(params=["s", "ms", "us", "ns"])
- def unit(self, request):
- return request.param
-
@pytest.fixture
def arr1d(self, tz_naive_fixture):
"""Fixture returning DatetimeArray with parametrized timezones"""
@@ -54,7 +50,6 @@ def test_min_max(self, arr1d, unit):
assert result is NaT
@pytest.mark.parametrize("tz", [None, "US/Central"])
- @pytest.mark.parametrize("skipna", [True, False])
def test_min_max_empty(self, skipna, tz):
dtype = DatetimeTZDtype(tz=tz) if tz is not None else np.dtype("M8[ns]")
arr = DatetimeArray._from_sequence([], dtype=dtype)
@@ -65,7 +60,6 @@ def test_min_max_empty(self, skipna, tz):
assert result is NaT
@pytest.mark.parametrize("tz", [None, "US/Central"])
- @pytest.mark.parametrize("skipna", [True, False])
def test_median_empty(self, skipna, tz):
dtype = DatetimeTZDtype(tz=tz) if tz is not None else np.dtype("M8[ns]")
arr = DatetimeArray._from_sequence([], dtype=dtype)
@@ -164,7 +158,6 @@ def test_mean_2d(self):
expected = dti.mean()
assert result == expected
- @pytest.mark.parametrize("skipna", [True, False])
def test_mean_empty(self, arr1d, skipna):
arr = arr1d[:0]
diff --git a/pandas/tests/arrays/floating/test_function.py b/pandas/tests/arrays/floating/test_function.py
index 40fd66fd049a6..9ea48bfb2413f 100644
--- a/pandas/tests/arrays/floating/test_function.py
+++ b/pandas/tests/arrays/floating/test_function.py
@@ -127,7 +127,6 @@ def test_value_counts_with_normalize():
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("min_count", [0, 4])
def test_floating_array_sum(skipna, min_count, dtype):
arr = pd.array([1, 2, 3, None], dtype=dtype)
@@ -171,7 +170,6 @@ def test_preserve_dtypes(op):
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("method", ["min", "max"])
def test_floating_array_min_max(skipna, method, dtype):
arr = pd.array([0.0, 1.0, None], dtype=dtype)
@@ -183,7 +181,6 @@ def test_floating_array_min_max(skipna, method, dtype):
assert result is pd.NA
-@pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("min_count", [0, 9])
def test_floating_array_prod(skipna, min_count, dtype):
arr = pd.array([1.0, 2.0, None], dtype=dtype)
diff --git a/pandas/tests/arrays/integer/test_dtypes.py b/pandas/tests/arrays/integer/test_dtypes.py
index e3848cdfe3aa9..99db05229a57d 100644
--- a/pandas/tests/arrays/integer/test_dtypes.py
+++ b/pandas/tests/arrays/integer/test_dtypes.py
@@ -59,7 +59,6 @@ def test_astype_nansafe():
arr.astype("uint32")
-@pytest.mark.parametrize("dropna", [True, False])
def test_construct_index(all_data, dropna):
# ensure that we do not coerce to different Index dtype or non-index
@@ -76,7 +75,6 @@ def test_construct_index(all_data, dropna):
tm.assert_index_equal(result, expected)
-@pytest.mark.parametrize("dropna", [True, False])
def test_astype_index(all_data, dropna):
# as an int/uint index to Index
diff --git a/pandas/tests/arrays/integer/test_function.py b/pandas/tests/arrays/integer/test_function.py
index d48b636a98feb..33300fff925f6 100644
--- a/pandas/tests/arrays/integer/test_function.py
+++ b/pandas/tests/arrays/integer/test_function.py
@@ -141,7 +141,6 @@ def test_value_counts_with_normalize():
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("min_count", [0, 4])
def test_integer_array_sum(skipna, min_count, any_int_ea_dtype):
dtype = any_int_ea_dtype
@@ -153,7 +152,6 @@ def test_integer_array_sum(skipna, min_count, any_int_ea_dtype):
assert result is pd.NA
-@pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("method", ["min", "max"])
def test_integer_array_min_max(skipna, method, any_int_ea_dtype):
dtype = any_int_ea_dtype
@@ -166,7 +164,6 @@ def test_integer_array_min_max(skipna, method, any_int_ea_dtype):
assert result is pd.NA
-@pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("min_count", [0, 9])
def test_integer_array_prod(skipna, min_count, any_int_ea_dtype):
dtype = any_int_ea_dtype
diff --git a/pandas/tests/arrays/interval/test_interval.py b/pandas/tests/arrays/interval/test_interval.py
index be4b2c3e7e74c..58ba340441d86 100644
--- a/pandas/tests/arrays/interval/test_interval.py
+++ b/pandas/tests/arrays/interval/test_interval.py
@@ -58,12 +58,11 @@ def test_is_empty(self, constructor, left, right, closed):
class TestMethods:
- @pytest.mark.parametrize("new_closed", ["left", "right", "both", "neither"])
- def test_set_closed(self, closed, new_closed):
+ def test_set_closed(self, closed, other_closed):
# GH 21670
array = IntervalArray.from_breaks(range(10), closed=closed)
- result = array.set_closed(new_closed)
- expected = IntervalArray.from_breaks(range(10), closed=new_closed)
+ result = array.set_closed(other_closed)
+ expected = IntervalArray.from_breaks(range(10), closed=other_closed)
tm.assert_extension_array_equal(result, expected)
@pytest.mark.parametrize(
diff --git a/pandas/tests/arrays/period/test_reductions.py b/pandas/tests/arrays/period/test_reductions.py
index 2889cc786dd71..5b859d86eb6d0 100644
--- a/pandas/tests/arrays/period/test_reductions.py
+++ b/pandas/tests/arrays/period/test_reductions.py
@@ -1,5 +1,3 @@
-import pytest
-
import pandas as pd
from pandas.core.arrays import period_array
@@ -32,7 +30,6 @@ def test_min_max(self):
result = arr.max(skipna=False)
assert result is pd.NaT
- @pytest.mark.parametrize("skipna", [True, False])
def test_min_max_empty(self, skipna):
arr = period_array([], freq="D")
result = arr.min(skipna=skipna)
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
index 320bdca60a932..f67268616a021 100644
--- a/pandas/tests/arrays/string_/test_string.py
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -415,7 +415,6 @@ def test_astype_float(dtype, any_float_dtype):
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.xfail(reason="Not implemented StringArray.sum")
def test_reduce(skipna, dtype):
arr = pd.Series(["a", "b", "c"], dtype=dtype)
@@ -423,7 +422,6 @@ def test_reduce(skipna, dtype):
assert result == "abc"
-@pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.xfail(reason="Not implemented StringArray.sum")
def test_reduce_missing(skipna, dtype):
arr = pd.Series([None, "a", None, "b", "c", None], dtype=dtype)
@@ -435,7 +433,6 @@ def test_reduce_missing(skipna, dtype):
@pytest.mark.parametrize("method", ["min", "max"])
-@pytest.mark.parametrize("skipna", [True, False])
def test_min_max(method, skipna, dtype):
arr = pd.Series(["a", "b", "c", None], dtype=dtype)
result = getattr(arr, method)(skipna=skipna)
diff --git a/pandas/tests/arrays/timedeltas/test_reductions.py b/pandas/tests/arrays/timedeltas/test_reductions.py
index 991dbf41c8087..3565f2e8690e2 100644
--- a/pandas/tests/arrays/timedeltas/test_reductions.py
+++ b/pandas/tests/arrays/timedeltas/test_reductions.py
@@ -10,7 +10,6 @@
class TestReductions:
@pytest.mark.parametrize("name", ["std", "min", "max", "median", "mean"])
- @pytest.mark.parametrize("skipna", [True, False])
def test_reductions_empty(self, name, skipna):
tdi = pd.TimedeltaIndex([])
arr = tdi.array
@@ -21,7 +20,6 @@ def test_reductions_empty(self, name, skipna):
result = getattr(arr, name)(skipna=skipna)
assert result is pd.NaT
- @pytest.mark.parametrize("skipna", [True, False])
def test_sum_empty(self, skipna):
tdi = pd.TimedeltaIndex([])
arr = tdi.array
diff --git a/pandas/tests/base/test_unique.py b/pandas/tests/base/test_unique.py
index d3fe144f70cfc..3a8ed471f9dc0 100644
--- a/pandas/tests/base/test_unique.py
+++ b/pandas/tests/base/test_unique.py
@@ -116,7 +116,6 @@ def test_unique_bad_unicode(index_or_series):
tm.assert_numpy_array_equal(result, expected)
-@pytest.mark.parametrize("dropna", [True, False])
def test_nunique_dropna(dropna):
# GH37566
ser = pd.Series(["yes", "yes", pd.NA, np.nan, None, pd.NaT])
diff --git a/pandas/tests/base/test_value_counts.py b/pandas/tests/base/test_value_counts.py
index 2729666398877..a0b0bdfdb46d8 100644
--- a/pandas/tests/base/test_value_counts.py
+++ b/pandas/tests/base/test_value_counts.py
@@ -329,7 +329,6 @@ def test_value_counts_timedelta64(index_or_series, unit):
tm.assert_series_equal(result2, expected_s)
-@pytest.mark.parametrize("dropna", [True, False])
def test_value_counts_with_nan(dropna, index_or_series):
# GH31944
klass = index_or_series
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index 0dad0b05303ad..c52d49034f74e 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -959,25 +959,24 @@ def test_same_categories_different_order(self):
c2 = CategoricalDtype(["b", "a"], ordered=True)
assert c1 is not c2
- @pytest.mark.parametrize("ordered1", [True, False, None])
@pytest.mark.parametrize("ordered2", [True, False, None])
- def test_categorical_equality(self, ordered1, ordered2):
+ def test_categorical_equality(self, ordered, ordered2):
# same categories, same order
# any combination of None/False are equal
# True/True is the only combination with True that are equal
- c1 = CategoricalDtype(list("abc"), ordered1)
+ c1 = CategoricalDtype(list("abc"), ordered)
c2 = CategoricalDtype(list("abc"), ordered2)
result = c1 == c2
- expected = bool(ordered1) is bool(ordered2)
+ expected = bool(ordered) is bool(ordered2)
assert result is expected
# same categories, different order
# any combination of None/False are equal (order doesn't matter)
# any combination with True are not equal (different order of cats)
- c1 = CategoricalDtype(list("abc"), ordered1)
+ c1 = CategoricalDtype(list("abc"), ordered)
c2 = CategoricalDtype(list("cab"), ordered2)
result = c1 == c2
- expected = (bool(ordered1) is False) and (bool(ordered2) is False)
+ expected = (bool(ordered) is False) and (bool(ordered2) is False)
assert result is expected
# different categories
@@ -985,9 +984,9 @@ def test_categorical_equality(self, ordered1, ordered2):
assert c1 != c2
# none categories
- c1 = CategoricalDtype(list("abc"), ordered1)
+ c1 = CategoricalDtype(list("abc"), ordered)
c2 = CategoricalDtype(None, ordered2)
- c3 = CategoricalDtype(None, ordered1)
+ c3 = CategoricalDtype(None, ordered)
assert c1 != c2
assert c2 != c1
assert c2 == c3
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 49eb06c299886..3ec6d70494902 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -1052,7 +1052,6 @@ def test_inferred_dtype_fixture(self, any_skipna_inferred_dtype):
# make sure the inferred dtype of the fixture is as requested
assert inferred_dtype == lib.infer_dtype(values, skipna=True)
- @pytest.mark.parametrize("skipna", [True, False])
def test_length_zero(self, skipna):
result = lib.infer_dtype(np.array([], dtype="i4"), skipna=skipna)
assert result == "integer"
@@ -1164,7 +1163,6 @@ def test_decimals(self):
assert result == "decimal"
# complex is compatible with nan, so skipna has no effect
- @pytest.mark.parametrize("skipna", [True, False])
def test_complex(self, skipna):
# gets cast to complex on array construction
arr = np.array([1.0, 2.0, 1 + 1j])
@@ -1343,9 +1341,8 @@ def test_infer_dtype_period(self):
arr = np.array([Period("2011-01", freq="D"), Period("2011-02", freq="M")])
assert lib.infer_dtype(arr, skipna=True) == "mixed"
- @pytest.mark.parametrize("klass", [pd.array, Series, Index])
- @pytest.mark.parametrize("skipna", [True, False])
- def test_infer_dtype_period_array(self, klass, skipna):
+ def test_infer_dtype_period_array(self, index_or_series_or_array, skipna):
+ klass = index_or_series_or_array
# https://github.com/pandas-dev/pandas/issues/23553
values = klass(
[
@@ -1534,7 +1531,6 @@ def test_date(self):
[pd.NaT, date(2020, 1, 1)],
],
)
- @pytest.mark.parametrize("skipna", [True, False])
def test_infer_dtype_date_order_invariant(self, values, skipna):
# https://github.com/pandas-dev/pandas/issues/33741
result = lib.infer_dtype(values, skipna=skipna)
@@ -1706,7 +1702,6 @@ def test_interval_mismatched_subtype(self):
assert lib.infer_dtype(arr, skipna=False) == "interval"
@pytest.mark.parametrize("klass", [pd.array, Series])
- @pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("data", [["a", "b", "c"], ["a", "b", pd.NA]])
def test_string_dtype(self, data, skipna, klass, nullable_string_dtype):
# StringArray
@@ -1715,7 +1710,6 @@ def test_string_dtype(self, data, skipna, klass, nullable_string_dtype):
assert inferred == "string"
@pytest.mark.parametrize("klass", [pd.array, Series])
- @pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("data", [[True, False, True], [True, False, pd.NA]])
def test_boolean_dtype(self, data, skipna, klass):
# BooleanArray
diff --git a/pandas/tests/extension/base/accumulate.py b/pandas/tests/extension/base/accumulate.py
index 9a41a3a582c4a..9189ef7ec9aa5 100644
--- a/pandas/tests/extension/base/accumulate.py
+++ b/pandas/tests/extension/base/accumulate.py
@@ -26,7 +26,6 @@ def check_accumulate(self, ser: pd.Series, op_name: str, skipna: bool):
expected = getattr(alt, op_name)(skipna=skipna)
tm.assert_series_equal(result, expected, check_dtype=False)
- @pytest.mark.parametrize("skipna", [True, False])
def test_accumulate_series(self, data, all_numeric_accumulations, skipna):
op_name = all_numeric_accumulations
ser = pd.Series(data)
diff --git a/pandas/tests/extension/base/dtype.py b/pandas/tests/extension/base/dtype.py
index c7b768f6e3c88..3fb116430861a 100644
--- a/pandas/tests/extension/base/dtype.py
+++ b/pandas/tests/extension/base/dtype.py
@@ -114,7 +114,6 @@ def test_get_common_dtype(self, dtype):
# only case we can test in general)
assert dtype._get_common_dtype([dtype]) == dtype
- @pytest.mark.parametrize("skipna", [True, False])
def test_infer_dtype(self, data, data_missing, skipna):
# only testing that this works without raising an error
res = infer_dtype(data, skipna=skipna)
diff --git a/pandas/tests/extension/base/groupby.py b/pandas/tests/extension/base/groupby.py
index 75628ea177fc2..9f38246d1a317 100644
--- a/pandas/tests/extension/base/groupby.py
+++ b/pandas/tests/extension/base/groupby.py
@@ -34,7 +34,6 @@ def test_grouping_grouper(self, data_for_grouping):
tm.assert_numpy_array_equal(gr1.grouping_vector, df.A.values)
tm.assert_extension_array_equal(gr2.grouping_vector, data_for_grouping)
- @pytest.mark.parametrize("as_index", [True, False])
def test_groupby_extension_agg(self, as_index, data_for_grouping):
df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index c803a8113b4a4..ba247f51e5f1b 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -37,7 +37,6 @@ def test_value_counts_default_dropna(self, data):
kwarg = sig.parameters["dropna"]
assert kwarg.default is True
- @pytest.mark.parametrize("dropna", [True, False])
def test_value_counts(self, all_data, dropna):
all_data = all_data[:10]
if dropna:
@@ -97,7 +96,6 @@ def test_apply_simple_series(self, data):
result = pd.Series(data).apply(id)
assert isinstance(result, pd.Series)
- @pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map(self, data_missing, na_action):
result = data_missing.map(lambda x: x, na_action=na_action)
expected = data_missing.to_numpy()
@@ -213,7 +211,6 @@ def test_nargsort(self, data_missing_for_sorting, na_position, expected):
result = nargsort(data_missing_for_sorting, na_position=na_position)
tm.assert_numpy_array_equal(result, expected)
- @pytest.mark.parametrize("ascending", [True, False])
def test_sort_values(self, data_for_sorting, ascending, sort_by_key):
ser = pd.Series(data_for_sorting)
result = ser.sort_values(ascending=ascending, key=sort_by_key)
@@ -227,7 +224,6 @@ def test_sort_values(self, data_for_sorting, ascending, sort_by_key):
tm.assert_series_equal(result, expected)
- @pytest.mark.parametrize("ascending", [True, False])
def test_sort_values_missing(
self, data_missing_for_sorting, ascending, sort_by_key
):
@@ -239,7 +235,6 @@ def test_sort_values_missing(
expected = ser.iloc[[0, 2, 1]]
tm.assert_series_equal(result, expected)
- @pytest.mark.parametrize("ascending", [True, False])
def test_sort_values_frame(self, data_for_sorting, ascending):
df = pd.DataFrame({"A": [1, 2, 1], "B": data_for_sorting})
result = df.sort_values(["A", "B"])
@@ -248,7 +243,6 @@ def test_sort_values_frame(self, data_for_sorting, ascending):
)
tm.assert_frame_equal(result, expected)
- @pytest.mark.parametrize("keep", ["first", "last", False])
def test_duplicated(self, data, keep):
arr = data.take([0, 1, 0, 1])
result = arr.duplicated(keep=keep)
diff --git a/pandas/tests/extension/base/reduce.py b/pandas/tests/extension/base/reduce.py
index 6ea1b3a6fbe9d..2a443901fa41a 100644
--- a/pandas/tests/extension/base/reduce.py
+++ b/pandas/tests/extension/base/reduce.py
@@ -77,7 +77,6 @@ def check_reduce_frame(self, ser: pd.Series, op_name: str, skipna: bool):
tm.assert_extension_array_equal(result1, expected)
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_series_boolean(self, data, all_boolean_reductions, skipna):
op_name = all_boolean_reductions
ser = pd.Series(data)
@@ -96,7 +95,6 @@ def test_reduce_series_boolean(self, data, all_boolean_reductions, skipna):
self.check_reduce(ser, op_name, skipna)
@pytest.mark.filterwarnings("ignore::RuntimeWarning")
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna):
op_name = all_numeric_reductions
ser = pd.Series(data)
@@ -115,7 +113,6 @@ def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna):
# min/max with empty produce numpy warnings
self.check_reduce(ser, op_name, skipna)
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_frame(self, data, all_numeric_reductions, skipna):
op_name = all_numeric_reductions
ser = pd.Series(data)
diff --git a/pandas/tests/extension/base/setitem.py b/pandas/tests/extension/base/setitem.py
index 9dd0a2eba6c0d..4a2942776b25e 100644
--- a/pandas/tests/extension/base/setitem.py
+++ b/pandas/tests/extension/base/setitem.py
@@ -105,10 +105,9 @@ def test_setitem_sequence_broadcasts(self, data, box_in_series):
assert data[0] == data[2]
assert data[1] == data[2]
- @pytest.mark.parametrize("setter", ["loc", "iloc"])
- def test_setitem_scalar(self, data, setter):
+ def test_setitem_scalar(self, data, indexer_li):
arr = pd.Series(data)
- setter = getattr(arr, setter)
+ setter = indexer_li(arr)
setter[0] = data[1]
assert arr[0] == data[1]
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index b3c57ee49a724..49f29b2194cae 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -227,8 +227,7 @@ def test_fillna_copy_series(self, data_missing, using_copy_on_write):
with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
super().test_fillna_copy_series(data_missing)
- @pytest.mark.parametrize("dropna", [True, False])
- def test_value_counts(self, all_data, dropna, request):
+ def test_value_counts(self, all_data, dropna):
all_data = all_data[:10]
if dropna:
other = np.array(all_data[~all_data.isna()])
diff --git a/pandas/tests/extension/json/test_json.py b/pandas/tests/extension/json/test_json.py
index 7686bc5abb44c..5319291f2ea01 100644
--- a/pandas/tests/extension/json/test_json.py
+++ b/pandas/tests/extension/json/test_json.py
@@ -162,18 +162,6 @@ def test_sort_values_frame(self):
# TODO (EA.factorize): see if _values_for_factorize allows this.
super().test_sort_values_frame()
- @pytest.mark.parametrize("ascending", [True, False])
- def test_sort_values(self, data_for_sorting, ascending, sort_by_key):
- super().test_sort_values(data_for_sorting, ascending, sort_by_key)
-
- @pytest.mark.parametrize("ascending", [True, False])
- def test_sort_values_missing(
- self, data_missing_for_sorting, ascending, sort_by_key
- ):
- super().test_sort_values_missing(
- data_missing_for_sorting, ascending, sort_by_key
- )
-
@pytest.mark.xfail(reason="combine for JSONArray not supported")
def test_combine_le(self, data_repeated):
super().test_combine_le(data_repeated)
diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
index ed1b7b199a16f..76982ee5c38f8 100644
--- a/pandas/tests/extension/test_arrow.py
+++ b/pandas/tests/extension/test_arrow.py
@@ -271,7 +271,6 @@ def test_compare_scalar(self, data, comparison_op):
ser = pd.Series(data)
self._compare_other(ser, data, comparison_op, data[0])
- @pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map(self, data_missing, na_action):
if data_missing.dtype.kind in "mM":
result = data_missing.map(lambda x: x, na_action=na_action)
@@ -424,7 +423,6 @@ def _supports_accumulation(self, ser: pd.Series, op_name: str) -> bool:
return False
return True
- @pytest.mark.parametrize("skipna", [True, False])
def test_accumulate_series(self, data, all_numeric_accumulations, skipna, request):
pa_type = data.dtype.pyarrow_dtype
op_name = all_numeric_accumulations
@@ -526,7 +524,6 @@ def check_reduce(self, ser: pd.Series, op_name: str, skipna: bool):
expected = getattr(alt, op_name)(skipna=skipna)
tm.assert_almost_equal(result, expected)
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna, request):
dtype = data.dtype
pa_dtype = dtype.pyarrow_dtype
@@ -552,7 +549,6 @@ def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna, reque
request.applymarker(xfail_mark)
super().test_reduce_series_numeric(data, all_numeric_reductions, skipna)
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_series_boolean(
self, data, all_boolean_reductions, skipna, na_value, request
):
@@ -589,7 +585,6 @@ def _get_expected_reduction_dtype(self, arr, op_name: str, skipna: bool):
}[arr.dtype.kind]
return cmp_dtype
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_frame(self, data, all_numeric_reductions, skipna, request):
op_name = all_numeric_reductions
if op_name == "skew":
@@ -2325,7 +2320,6 @@ def test_str_extract_expand():
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_duration_from_strings_with_nat(unit):
# GH51175
strings = ["1000", "NaT"]
@@ -2828,7 +2822,6 @@ def test_dt_components():
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("skipna", [True, False])
def test_boolean_reduce_series_all_null(all_boolean_reductions, skipna):
# GH51624
ser = pd.Series([None], dtype="float64[pyarrow]")
diff --git a/pandas/tests/extension/test_categorical.py b/pandas/tests/extension/test_categorical.py
index 1b322b1797144..edf560dda36e7 100644
--- a/pandas/tests/extension/test_categorical.py
+++ b/pandas/tests/extension/test_categorical.py
@@ -117,10 +117,6 @@ def test_getitem_scalar(self, data):
# to break things by changing.
super().test_getitem_scalar(data)
- @pytest.mark.xfail(reason="Unobserved categories included")
- def test_value_counts(self, all_data, dropna):
- return super().test_value_counts(all_data, dropna)
-
def test_combine_add(self, data_repeated):
# GH 20825
# When adding categoricals in combine, result is a string
@@ -138,7 +134,6 @@ def test_combine_add(self, data_repeated):
expected = pd.Series([a + val for a in list(orig_data1)])
tm.assert_series_equal(result, expected)
- @pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map(self, data, na_action):
result = data.map(lambda x: x, na_action=na_action)
tm.assert_extension_array_equal(result, data)
@@ -179,7 +174,6 @@ def test_array_repr(self, data, size):
super().test_array_repr(data, size)
@pytest.mark.xfail(reason="TBD")
- @pytest.mark.parametrize("as_index", [True, False])
def test_groupby_extension_agg(self, as_index, data_for_grouping):
super().test_groupby_extension_agg(as_index, data_for_grouping)
diff --git a/pandas/tests/extension/test_datetime.py b/pandas/tests/extension/test_datetime.py
index 7f70957007dad..4b25b2768849e 100644
--- a/pandas/tests/extension/test_datetime.py
+++ b/pandas/tests/extension/test_datetime.py
@@ -24,9 +24,9 @@
from pandas.tests.extension import base
-@pytest.fixture(params=["US/Central"])
-def dtype(request):
- return DatetimeTZDtype(unit="ns", tz=request.param)
+@pytest.fixture
+def dtype():
+ return DatetimeTZDtype(unit="ns", tz="US/Central")
@pytest.fixture
@@ -100,7 +100,6 @@ def _supports_accumulation(self, ser, op_name: str) -> bool:
def _supports_reduction(self, obj, op_name: str) -> bool:
return op_name in ["min", "max", "median", "mean", "std", "any", "all"]
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_series_boolean(self, data, all_boolean_reductions, skipna):
meth = all_boolean_reductions
msg = f"'{meth}' with datetime64 dtypes is deprecated and will raise in"
@@ -114,7 +113,6 @@ def test_series_constructor(self, data):
data = data._with_freq(None)
super().test_series_constructor(data)
- @pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map(self, data, na_action):
result = data.map(lambda x: x, na_action=na_action)
tm.assert_extension_array_equal(result, data)
diff --git a/pandas/tests/extension/test_masked.py b/pandas/tests/extension/test_masked.py
index 3efc561d6a125..0e19c4078b471 100644
--- a/pandas/tests/extension/test_masked.py
+++ b/pandas/tests/extension/test_masked.py
@@ -169,7 +169,6 @@ def data_for_grouping(dtype):
class TestMaskedArrays(base.ExtensionTests):
- @pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map(self, data_missing, na_action):
result = data_missing.map(lambda x: x, na_action=na_action)
if data_missing.dtype == Float32Dtype():
diff --git a/pandas/tests/extension/test_numpy.py b/pandas/tests/extension/test_numpy.py
index aaf49f53ba02b..8bf16272dd8c5 100644
--- a/pandas/tests/extension/test_numpy.py
+++ b/pandas/tests/extension/test_numpy.py
@@ -313,7 +313,6 @@ def check_reduce(self, ser: pd.Series, op_name: str, skipna: bool):
tm.assert_almost_equal(result, expected)
@pytest.mark.skip("TODO: tests not written yet")
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_frame(self, data, all_numeric_reductions, skipna):
pass
diff --git a/pandas/tests/extension/test_period.py b/pandas/tests/extension/test_period.py
index 2d1d213322bac..4fe9c160d66af 100644
--- a/pandas/tests/extension/test_period.py
+++ b/pandas/tests/extension/test_period.py
@@ -109,7 +109,6 @@ def test_diff(self, data, periods):
else:
super().test_diff(data, periods)
- @pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map(self, data, na_action):
result = data.map(lambda x: x, na_action=na_action)
tm.assert_extension_array_equal(result, data)
diff --git a/pandas/tests/extension/test_sparse.py b/pandas/tests/extension/test_sparse.py
index 4039a5d01f372..03f179fdd261e 100644
--- a/pandas/tests/extension/test_sparse.py
+++ b/pandas/tests/extension/test_sparse.py
@@ -102,7 +102,6 @@ class TestSparseArray(base.ExtensionTests):
def _supports_reduction(self, obj, op_name: str) -> bool:
return True
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna, request):
if all_numeric_reductions in [
"prod",
@@ -127,7 +126,6 @@ def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna, reque
super().test_reduce_series_numeric(data, all_numeric_reductions, skipna)
- @pytest.mark.parametrize("skipna", [True, False])
def test_reduce_frame(self, data, all_numeric_reductions, skipna, request):
if all_numeric_reductions in [
"prod",
@@ -368,7 +366,6 @@ def test_map(self, func, na_action, expected):
result = data.map(func, na_action=na_action)
tm.assert_extension_array_equal(result, expected)
- @pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map_raises(self, data, na_action):
# GH52096
msg = "fill value in the sparse values not supported"
@@ -489,7 +486,6 @@ def test_array_repr(self, data, size):
super().test_array_repr(data, size)
@pytest.mark.xfail(reason="result does not match expected")
- @pytest.mark.parametrize("as_index", [True, False])
def test_groupby_extension_agg(self, as_index, data_for_grouping):
super().test_groupby_extension_agg(as_index, data_for_grouping)
diff --git a/pandas/tests/frame/methods/test_align.py b/pandas/tests/frame/methods/test_align.py
index 5a9c47866dae8..1f5d960de40c1 100644
--- a/pandas/tests/frame/methods/test_align.py
+++ b/pandas/tests/frame/methods/test_align.py
@@ -395,7 +395,6 @@ def test_missing_axis_specification_exception(self):
@pytest.mark.parametrize("method", ["pad", "bfill"])
@pytest.mark.parametrize("axis", [0, 1, None])
@pytest.mark.parametrize("fill_axis", [0, 1])
- @pytest.mark.parametrize("how", ["inner", "outer", "left", "right"])
@pytest.mark.parametrize(
"left_slice",
[
@@ -412,8 +411,17 @@ def test_missing_axis_specification_exception(self):
)
@pytest.mark.parametrize("limit", [1, None])
def test_align_fill_method(
- self, how, method, axis, fill_axis, float_frame, left_slice, right_slice, limit
+ self,
+ join_type,
+ method,
+ axis,
+ fill_axis,
+ float_frame,
+ left_slice,
+ right_slice,
+ limit,
):
+ how = join_type
frame = float_frame
left = frame.iloc[left_slice[0], left_slice[1]]
right = frame.iloc[right_slice[0], right_slice[1]]
diff --git a/pandas/tests/frame/methods/test_asfreq.py b/pandas/tests/frame/methods/test_asfreq.py
index ef72ca1ac86b9..87d1745774487 100644
--- a/pandas/tests/frame/methods/test_asfreq.py
+++ b/pandas/tests/frame/methods/test_asfreq.py
@@ -19,10 +19,6 @@
class TestAsFreq:
- @pytest.fixture(params=["s", "ms", "us", "ns"])
- def unit(self, request):
- return request.param
-
def test_asfreq2(self, frame_or_series):
ts = frame_or_series(
[0.0, 1.0, 2.0],
diff --git a/pandas/tests/frame/methods/test_astype.py b/pandas/tests/frame/methods/test_astype.py
index 5a1e3cd786f84..b73c759518b0e 100644
--- a/pandas/tests/frame/methods/test_astype.py
+++ b/pandas/tests/frame/methods/test_astype.py
@@ -498,11 +498,10 @@ def test_astype_to_datetime_unit(self, unit):
assert exp_dta.dtype == dtype
tm.assert_extension_array_equal(res_dta, exp_dta)
- @pytest.mark.parametrize("unit", ["ns"])
- def test_astype_to_timedelta_unit_ns(self, unit):
+ def test_astype_to_timedelta_unit_ns(self):
# preserver the timedelta conversion
# GH#19223
- dtype = f"m8[{unit}]"
+ dtype = "m8[ns]"
arr = np.array([[1, 2, 3]], dtype=dtype)
df = DataFrame(arr)
result = df.astype(dtype)
diff --git a/pandas/tests/frame/methods/test_at_time.py b/pandas/tests/frame/methods/test_at_time.py
index 4c1434bd66aff..1ebe9920933d1 100644
--- a/pandas/tests/frame/methods/test_at_time.py
+++ b/pandas/tests/frame/methods/test_at_time.py
@@ -95,7 +95,6 @@ def test_at_time_raises(self, frame_or_series):
with pytest.raises(TypeError, match=msg): # index is not a DatetimeIndex
obj.at_time("00:00")
- @pytest.mark.parametrize("axis", ["index", "columns", 0, 1])
def test_at_time_axis(self, axis):
# issue 8839
rng = date_range("1/1/2000", "1/5/2000", freq="5min")
diff --git a/pandas/tests/frame/methods/test_join.py b/pandas/tests/frame/methods/test_join.py
index 735f6c50ab739..02f0b9e20871d 100644
--- a/pandas/tests/frame/methods/test_join.py
+++ b/pandas/tests/frame/methods/test_join.py
@@ -391,8 +391,8 @@ def test_join_list_series(float_frame):
tm.assert_frame_equal(result, float_frame)
-@pytest.mark.parametrize("sort_kw", [True, False])
-def test_suppress_future_warning_with_sort_kw(sort_kw):
+def test_suppress_future_warning_with_sort_kw(sort):
+ sort_kw = sort
a = DataFrame({"col1": [1, 2]}, index=["c", "a"])
b = DataFrame({"col2": [4, 5]}, index=["b", "a"])
diff --git a/pandas/tests/frame/methods/test_map.py b/pandas/tests/frame/methods/test_map.py
index 03681c3df844e..a60dcf9a02938 100644
--- a/pandas/tests/frame/methods/test_map.py
+++ b/pandas/tests/frame/methods/test_map.py
@@ -33,7 +33,6 @@ def test_map_float_object_conversion(val):
assert result == object
-@pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map_keeps_dtype(na_action):
# GH52219
arr = Series(["a", np.nan, "b"])
diff --git a/pandas/tests/frame/methods/test_rank.py b/pandas/tests/frame/methods/test_rank.py
index 8d7a0b373f5f8..1d0931f5982b7 100644
--- a/pandas/tests/frame/methods/test_rank.py
+++ b/pandas/tests/frame/methods/test_rank.py
@@ -31,13 +31,6 @@ class TestRank:
"dense": np.array([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3]),
}
- @pytest.fixture(params=["average", "min", "max", "first", "dense"])
- def method(self, request):
- """
- Fixture for trying all rank methods
- """
- return request.param
-
def test_rank(self, float_frame):
sp_stats = pytest.importorskip("scipy.stats")
@@ -225,8 +218,7 @@ def test_rank_axis(self):
tm.assert_frame_equal(df.rank(axis=1), df.rank(axis="columns"))
@pytest.mark.parametrize("ax", [0, 1])
- @pytest.mark.parametrize("m", ["average", "min", "max", "first", "dense"])
- def test_rank_methods_frame(self, ax, m):
+ def test_rank_methods_frame(self, ax, rank_method):
sp_stats = pytest.importorskip("scipy.stats")
xs = np.random.default_rng(2).integers(0, 21, (100, 26))
@@ -236,16 +228,19 @@ def test_rank_methods_frame(self, ax, m):
for vals in [xs, xs + 1e6, xs * 1e-6]:
df = DataFrame(vals, columns=cols)
- result = df.rank(axis=ax, method=m)
+ result = df.rank(axis=ax, method=rank_method)
sprank = np.apply_along_axis(
- sp_stats.rankdata, ax, vals, m if m != "first" else "ordinal"
+ sp_stats.rankdata,
+ ax,
+ vals,
+ rank_method if rank_method != "first" else "ordinal",
)
sprank = sprank.astype(np.float64)
expected = DataFrame(sprank, columns=cols).astype("float64")
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("dtype", ["O", "f8", "i8"])
- def test_rank_descending(self, method, dtype):
+ def test_rank_descending(self, rank_method, dtype):
if "i" in dtype:
df = self.df.dropna().astype(dtype)
else:
@@ -255,18 +250,18 @@ def test_rank_descending(self, method, dtype):
expected = (df.max() - df).rank()
tm.assert_frame_equal(res, expected)
- expected = (df.max() - df).rank(method=method)
+ expected = (df.max() - df).rank(method=rank_method)
if dtype != "O":
- res2 = df.rank(method=method, ascending=False, numeric_only=True)
+ res2 = df.rank(method=rank_method, ascending=False, numeric_only=True)
tm.assert_frame_equal(res2, expected)
- res3 = df.rank(method=method, ascending=False, numeric_only=False)
+ res3 = df.rank(method=rank_method, ascending=False, numeric_only=False)
tm.assert_frame_equal(res3, expected)
@pytest.mark.parametrize("axis", [0, 1])
@pytest.mark.parametrize("dtype", [None, object])
- def test_rank_2d_tie_methods(self, method, axis, dtype):
+ def test_rank_2d_tie_methods(self, rank_method, axis, dtype):
df = self.df
def _check2d(df, expected, method="average", axis=0):
@@ -276,14 +271,14 @@ def _check2d(df, expected, method="average", axis=0):
df = df.T
exp_df = exp_df.T
- result = df.rank(method=method, axis=axis)
+ result = df.rank(method=rank_method, axis=axis)
tm.assert_frame_equal(result, exp_df)
frame = df if dtype is None else df.astype(dtype)
- _check2d(frame, self.results[method], method=method, axis=axis)
+ _check2d(frame, self.results[rank_method], method=rank_method, axis=axis)
@pytest.mark.parametrize(
- "method,exp",
+ "rank_method,exp",
[
("dense", [[1.0, 1.0, 1.0], [1.0, 0.5, 2.0 / 3], [1.0, 0.5, 1.0 / 3]]),
(
@@ -312,11 +307,11 @@ def _check2d(df, expected, method="average", axis=0):
),
],
)
- def test_rank_pct_true(self, method, exp):
+ def test_rank_pct_true(self, rank_method, exp):
# see gh-15630.
df = DataFrame([[2012, 66, 3], [2012, 65, 2], [2012, 65, 1]])
- result = df.rank(method=method, pct=True)
+ result = df.rank(method=rank_method, pct=True)
expected = DataFrame(exp)
tm.assert_frame_equal(result, expected)
@@ -454,10 +449,10 @@ def test_rank_both_inf(self):
],
)
def test_rank_inf_nans_na_option(
- self, frame_or_series, method, na_option, ascending, expected
+ self, frame_or_series, rank_method, na_option, ascending, expected
):
obj = frame_or_series([np.inf, np.nan, -np.inf])
- result = obj.rank(method=method, na_option=na_option, ascending=ascending)
+ result = obj.rank(method=rank_method, na_option=na_option, ascending=ascending)
expected = frame_or_series(expected)
tm.assert_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_sort_index.py b/pandas/tests/frame/methods/test_sort_index.py
index 49e292057e4dc..821b2e0d7a6da 100644
--- a/pandas/tests/frame/methods/test_sort_index.py
+++ b/pandas/tests/frame/methods/test_sort_index.py
@@ -927,7 +927,6 @@ def test_sort_index_na_position(self):
result = df.sort_index(level=[0, 1], na_position="last")
tm.assert_frame_equal(result, expected)
- @pytest.mark.parametrize("ascending", [True, False])
def test_sort_index_multiindex_sort_remaining(self, ascending):
# GH #24247
df = DataFrame(
diff --git a/pandas/tests/frame/methods/test_sort_values.py b/pandas/tests/frame/methods/test_sort_values.py
index be75efcdfe9d3..b33ca95bd4180 100644
--- a/pandas/tests/frame/methods/test_sort_values.py
+++ b/pandas/tests/frame/methods/test_sort_values.py
@@ -848,11 +848,6 @@ def sort_names(request):
return request.param
-@pytest.fixture(params=[True, False])
-def ascending(request):
- return request.param
-
-
class TestSortValuesLevelAsStr:
def test_sort_index_level_and_column_label(
self, df_none, df_idx, sort_names, ascending, request
@@ -926,7 +921,6 @@ def test_sort_values_validate_ascending_for_value_error(self):
with pytest.raises(ValueError, match=msg):
df.sort_values(by="D", ascending="False")
- @pytest.mark.parametrize("ascending", [False, 0, 1, True])
def test_sort_values_validate_ascending_functional(self, ascending):
df = DataFrame({"D": [23, 7, 21]})
indexer = df["D"].argsort().values
diff --git a/pandas/tests/frame/test_cumulative.py b/pandas/tests/frame/test_cumulative.py
index 5bd9c42612315..d7aad680d389e 100644
--- a/pandas/tests/frame/test_cumulative.py
+++ b/pandas/tests/frame/test_cumulative.py
@@ -7,7 +7,6 @@
"""
import numpy as np
-import pytest
from pandas import (
DataFrame,
@@ -46,20 +45,23 @@ def test_cumprod_smoke(self, datetime_frame):
df.cumprod(0)
df.cumprod(1)
- @pytest.mark.parametrize("method", ["cumsum", "cumprod", "cummin", "cummax"])
- def test_cumulative_ops_match_series_apply(self, datetime_frame, method):
+ def test_cumulative_ops_match_series_apply(
+ self, datetime_frame, all_numeric_accumulations
+ ):
datetime_frame.iloc[5:10, 0] = np.nan
datetime_frame.iloc[10:15, 1] = np.nan
datetime_frame.iloc[15:, 2] = np.nan
# axis = 0
- result = getattr(datetime_frame, method)()
- expected = datetime_frame.apply(getattr(Series, method))
+ result = getattr(datetime_frame, all_numeric_accumulations)()
+ expected = datetime_frame.apply(getattr(Series, all_numeric_accumulations))
tm.assert_frame_equal(result, expected)
# axis = 1
- result = getattr(datetime_frame, method)(axis=1)
- expected = datetime_frame.apply(getattr(Series, method), axis=1)
+ result = getattr(datetime_frame, all_numeric_accumulations)(axis=1)
+ expected = datetime_frame.apply(
+ getattr(Series, all_numeric_accumulations), axis=1
+ )
tm.assert_frame_equal(result, expected)
# fix issue TODO: GH ref?
diff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py
index dd88e7401a03f..5aaa11b848be4 100644
--- a/pandas/tests/frame/test_reductions.py
+++ b/pandas/tests/frame/test_reductions.py
@@ -1059,7 +1059,6 @@ def test_sum_bools(self):
# ----------------------------------------------------------------------
# Index of max / min
- @pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("axis", [0, 1])
def test_idxmin(self, float_frame, int_frame, skipna, axis):
frame = float_frame
@@ -1108,7 +1107,6 @@ def test_idxmin_axis_2(self, float_frame):
with pytest.raises(ValueError, match=msg):
frame.idxmin(axis=2)
- @pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize("axis", [0, 1])
def test_idxmax(self, float_frame, int_frame, skipna, axis):
frame = float_frame
@@ -1257,29 +1255,30 @@ def test_idxmax_dt64_multicolumn_axis1(self):
# ----------------------------------------------------------------------
# Logical reductions
- @pytest.mark.parametrize("opname", ["any", "all"])
@pytest.mark.parametrize("axis", [0, 1])
@pytest.mark.parametrize("bool_only", [False, True])
- def test_any_all_mixed_float(self, opname, axis, bool_only, float_string_frame):
+ def test_any_all_mixed_float(
+ self, all_boolean_reductions, axis, bool_only, float_string_frame
+ ):
# make sure op works on mixed-type frame
mixed = float_string_frame
mixed["_bool_"] = np.random.default_rng(2).standard_normal(len(mixed)) > 0.5
- getattr(mixed, opname)(axis=axis, bool_only=bool_only)
+ getattr(mixed, all_boolean_reductions)(axis=axis, bool_only=bool_only)
- @pytest.mark.parametrize("opname", ["any", "all"])
@pytest.mark.parametrize("axis", [0, 1])
- def test_any_all_bool_with_na(self, opname, axis, bool_frame_with_na):
- getattr(bool_frame_with_na, opname)(axis=axis, bool_only=False)
+ def test_any_all_bool_with_na(
+ self, all_boolean_reductions, axis, bool_frame_with_na
+ ):
+ getattr(bool_frame_with_na, all_boolean_reductions)(axis=axis, bool_only=False)
@pytest.mark.filterwarnings("ignore:Downcasting object dtype arrays:FutureWarning")
- @pytest.mark.parametrize("opname", ["any", "all"])
- def test_any_all_bool_frame(self, opname, bool_frame_with_na):
+ def test_any_all_bool_frame(self, all_boolean_reductions, bool_frame_with_na):
# GH#12863: numpy gives back non-boolean data for object type
# so fill NaNs to compare with pandas behavior
frame = bool_frame_with_na.fillna(True)
- alternative = getattr(np, opname)
- f = getattr(frame, opname)
+ alternative = getattr(np, all_boolean_reductions)
+ f = getattr(frame, all_boolean_reductions)
def skipna_wrapper(x):
nona = x.dropna().values
@@ -1308,9 +1307,9 @@ def wrapper(x):
# all NA case
all_na = frame * np.nan
- r0 = getattr(all_na, opname)(axis=0)
- r1 = getattr(all_na, opname)(axis=1)
- if opname == "any":
+ r0 = getattr(all_na, all_boolean_reductions)(axis=0)
+ r1 = getattr(all_na, all_boolean_reductions)(axis=1)
+ if all_boolean_reductions == "any":
assert not r0.any()
assert not r1.any()
else:
@@ -1351,10 +1350,8 @@ def test_any_all_extra(self):
assert result is True
@pytest.mark.parametrize("axis", [0, 1])
- @pytest.mark.parametrize("bool_agg_func", ["any", "all"])
- @pytest.mark.parametrize("skipna", [True, False])
def test_any_all_object_dtype(
- self, axis, bool_agg_func, skipna, using_infer_string
+ self, axis, all_boolean_reductions, skipna, using_infer_string
):
# GH#35450
df = DataFrame(
@@ -1367,10 +1364,10 @@ def test_any_all_object_dtype(
)
if using_infer_string:
# na in object is True while in string pyarrow numpy it's false
- val = not axis == 0 and not skipna and bool_agg_func == "all"
+ val = not axis == 0 and not skipna and all_boolean_reductions == "all"
else:
val = True
- result = getattr(df, bool_agg_func)(axis=axis, skipna=skipna)
+ result = getattr(df, all_boolean_reductions)(axis=axis, skipna=skipna)
expected = Series([True, True, val, True])
tm.assert_series_equal(result, expected)
@@ -1737,27 +1734,26 @@ def test_reduction_timedelta_smallest_unit(self):
class TestNuisanceColumns:
- @pytest.mark.parametrize("method", ["any", "all"])
- def test_any_all_categorical_dtype_nuisance_column(self, method):
+ def test_any_all_categorical_dtype_nuisance_column(self, all_boolean_reductions):
# GH#36076 DataFrame should match Series behavior
ser = Series([0, 1], dtype="category", name="A")
df = ser.to_frame()
# Double-check the Series behavior is to raise
with pytest.raises(TypeError, match="does not support reduction"):
- getattr(ser, method)()
+ getattr(ser, all_boolean_reductions)()
with pytest.raises(TypeError, match="does not support reduction"):
- getattr(np, method)(ser)
+ getattr(np, all_boolean_reductions)(ser)
with pytest.raises(TypeError, match="does not support reduction"):
- getattr(df, method)(bool_only=False)
+ getattr(df, all_boolean_reductions)(bool_only=False)
with pytest.raises(TypeError, match="does not support reduction"):
- getattr(df, method)(bool_only=None)
+ getattr(df, all_boolean_reductions)(bool_only=None)
with pytest.raises(TypeError, match="does not support reduction"):
- getattr(np, method)(df, axis=0)
+ getattr(np, all_boolean_reductions)(df, axis=0)
def test_median_categorical_dtype_nuisance_column(self):
# GH#21020 DataFrame.median should match Series.median
diff --git a/pandas/tests/frame/test_stack_unstack.py b/pandas/tests/frame/test_stack_unstack.py
index ea66290ab0417..90524861ce311 100644
--- a/pandas/tests/frame/test_stack_unstack.py
+++ b/pandas/tests/frame/test_stack_unstack.py
@@ -2201,7 +2201,6 @@ def __init__(self, *args, **kwargs) -> None:
),
)
@pytest.mark.parametrize("stack_lev", range(2))
- @pytest.mark.parametrize("sort", [True, False])
def test_stack_order_with_unsorted_levels(
self, levels, stack_lev, sort, future_stack
):
diff --git a/pandas/tests/groupby/aggregate/test_numba.py b/pandas/tests/groupby/aggregate/test_numba.py
index ee694129f7118..89404a9bd09a3 100644
--- a/pandas/tests/groupby/aggregate/test_numba.py
+++ b/pandas/tests/groupby/aggregate/test_numba.py
@@ -53,7 +53,6 @@ def incorrect_function(values, index):
# Filter warnings when parallel=True and the function can't be parallelized by Numba
@pytest.mark.parametrize("jit", [True, False])
@pytest.mark.parametrize("pandas_obj", ["Series", "DataFrame"])
-@pytest.mark.parametrize("as_index", [True, False])
def test_numba_vs_cython(jit, pandas_obj, nogil, parallel, nopython, as_index):
pytest.importorskip("numba")
diff --git a/pandas/tests/groupby/conftest.py b/pandas/tests/groupby/conftest.py
index dce3f072ed903..331dbd85e0f36 100644
--- a/pandas/tests/groupby/conftest.py
+++ b/pandas/tests/groupby/conftest.py
@@ -13,26 +13,6 @@
)
-@pytest.fixture(params=[True, False])
-def sort(request):
- return request.param
-
-
-@pytest.fixture(params=[True, False])
-def as_index(request):
- return request.param
-
-
-@pytest.fixture(params=[True, False])
-def dropna(request):
- return request.param
-
-
-@pytest.fixture(params=[True, False])
-def observed(request):
- return request.param
-
-
@pytest.fixture
def df():
return DataFrame(
@@ -153,28 +133,6 @@ def groupby_func(request):
return request.param
-@pytest.fixture(params=[True, False])
-def parallel(request):
- """parallel keyword argument for numba.jit"""
- return request.param
-
-
-# Can parameterize nogil & nopython over True | False, but limiting per
-# https://github.com/pandas-dev/pandas/pull/41971#issuecomment-860607472
-
-
-@pytest.fixture(params=[False])
-def nogil(request):
- """nogil keyword argument for numba.jit"""
- return request.param
-
-
-@pytest.fixture(params=[True])
-def nopython(request):
- """nopython keyword argument for numba.jit"""
- return request.param
-
-
@pytest.fixture(
params=[
("mean", {}),
diff --git a/pandas/tests/groupby/methods/test_describe.py b/pandas/tests/groupby/methods/test_describe.py
index a2440e09dfc02..f27e99809176c 100644
--- a/pandas/tests/groupby/methods/test_describe.py
+++ b/pandas/tests/groupby/methods/test_describe.py
@@ -149,7 +149,6 @@ def test_frame_describe_unstacked_format():
"indexing past lexsort depth may impact performance:"
"pandas.errors.PerformanceWarning"
)
-@pytest.mark.parametrize("as_index", [True, False])
@pytest.mark.parametrize("keys", [["a1"], ["a1", "a2"]])
def test_describe_with_duplicate_output_column_names(as_index, keys):
# GH 35314
diff --git a/pandas/tests/groupby/methods/test_nlargest_nsmallest.py b/pandas/tests/groupby/methods/test_nlargest_nsmallest.py
index bf983f04a3f3f..1225c325c4c23 100644
--- a/pandas/tests/groupby/methods/test_nlargest_nsmallest.py
+++ b/pandas/tests/groupby/methods/test_nlargest_nsmallest.py
@@ -99,17 +99,16 @@ def test_nsmallest():
[([0, 1, 2, 3], [0, 0, 1, 1]), ([0], [0])],
)
@pytest.mark.parametrize("dtype", [None, *tm.ALL_INT_NUMPY_DTYPES])
-@pytest.mark.parametrize("method", ["nlargest", "nsmallest"])
-def test_nlargest_and_smallest_noop(data, groups, dtype, method):
+def test_nlargest_and_smallest_noop(data, groups, dtype, nselect_method):
# GH 15272, GH 16345, GH 29129
# Test nlargest/smallest when it results in a noop,
# i.e. input is sorted and group size <= n
if dtype is not None:
data = np.array(data, dtype=dtype)
- if method == "nlargest":
+ if nselect_method == "nlargest":
data = list(reversed(data))
ser = Series(data, name="a")
- result = getattr(ser.groupby(groups), method)(n=2)
+ result = getattr(ser.groupby(groups), nselect_method)(n=2)
expidx = np.array(groups, dtype=int) if isinstance(groups, list) else groups
expected = Series(data, index=MultiIndex.from_arrays([expidx, ser.index]), name="a")
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/groupby/methods/test_nth.py b/pandas/tests/groupby/methods/test_nth.py
index a8ed9e9d52021..52d63cb720485 100644
--- a/pandas/tests/groupby/methods/test_nth.py
+++ b/pandas/tests/groupby/methods/test_nth.py
@@ -529,7 +529,6 @@ def test_nth_multi_index_as_expected():
],
)
@pytest.mark.parametrize("columns", [None, [], ["A"], ["B"], ["A", "B"]])
-@pytest.mark.parametrize("as_index", [True, False])
def test_groupby_head_tail(op, n, expected_rows, columns, as_index):
df = DataFrame([[1, 2], [1, 4], [5, 6]], columns=["A", "B"])
g = df.groupby("A", as_index=as_index)
diff --git a/pandas/tests/groupby/methods/test_rank.py b/pandas/tests/groupby/methods/test_rank.py
index a3b7da3fa836c..18869033d05c6 100644
--- a/pandas/tests/groupby/methods/test_rank.py
+++ b/pandas/tests/groupby/methods/test_rank.py
@@ -480,19 +480,17 @@ def test_rank_avg_even_vals(dtype, upper):
tm.assert_frame_equal(result, exp_df)
-@pytest.mark.parametrize("ties_method", ["average", "min", "max", "first", "dense"])
-@pytest.mark.parametrize("ascending", [True, False])
@pytest.mark.parametrize("na_option", ["keep", "top", "bottom"])
@pytest.mark.parametrize("pct", [True, False])
@pytest.mark.parametrize(
"vals", [["bar", "bar", "foo", "bar", "baz"], ["bar", np.nan, "foo", np.nan, "baz"]]
)
-def test_rank_object_dtype(ties_method, ascending, na_option, pct, vals):
+def test_rank_object_dtype(rank_method, ascending, na_option, pct, vals):
df = DataFrame({"key": ["foo"] * 5, "val": vals})
mask = df["val"].isna()
gb = df.groupby("key")
- res = gb.rank(method=ties_method, ascending=ascending, na_option=na_option, pct=pct)
+ res = gb.rank(method=rank_method, ascending=ascending, na_option=na_option, pct=pct)
# construct our expected by using numeric values with the same ordering
if mask.any():
@@ -502,15 +500,13 @@ def test_rank_object_dtype(ties_method, ascending, na_option, pct, vals):
gb2 = df2.groupby("key")
alt = gb2.rank(
- method=ties_method, ascending=ascending, na_option=na_option, pct=pct
+ method=rank_method, ascending=ascending, na_option=na_option, pct=pct
)
tm.assert_frame_equal(res, alt)
@pytest.mark.parametrize("na_option", [True, "bad", 1])
-@pytest.mark.parametrize("ties_method", ["average", "min", "max", "first", "dense"])
-@pytest.mark.parametrize("ascending", [True, False])
@pytest.mark.parametrize("pct", [True, False])
@pytest.mark.parametrize(
"vals",
@@ -520,13 +516,13 @@ def test_rank_object_dtype(ties_method, ascending, na_option, pct, vals):
[1, np.nan, 2, np.nan, 3],
],
)
-def test_rank_naoption_raises(ties_method, ascending, na_option, pct, vals):
+def test_rank_naoption_raises(rank_method, ascending, na_option, pct, vals):
df = DataFrame({"key": ["foo"] * 5, "val": vals})
msg = "na_option must be one of 'keep', 'top', or 'bottom'"
with pytest.raises(ValueError, match=msg):
df.groupby("key").rank(
- method=ties_method, ascending=ascending, na_option=na_option, pct=pct
+ method=rank_method, ascending=ascending, na_option=na_option, pct=pct
)
diff --git a/pandas/tests/groupby/methods/test_size.py b/pandas/tests/groupby/methods/test_size.py
index 93a4e743d0d71..fd55ceedd1083 100644
--- a/pandas/tests/groupby/methods/test_size.py
+++ b/pandas/tests/groupby/methods/test_size.py
@@ -32,6 +32,7 @@ def test_size(df, by):
pytest.param([None, None, None, None], marks=pytest.mark.xfail),
],
)
+@pytest.mark.parametrize("axis_1", [1, "columns"])
def test_size_axis_1(df, axis_1, by, sort, dropna):
# GH#45715
counts = {key: sum(value == key for value in by) for key in dict.fromkeys(by)}
@@ -51,7 +52,6 @@ def test_size_axis_1(df, axis_1, by, sort, dropna):
@pytest.mark.parametrize("by", ["A", "B", ["A", "B"]])
-@pytest.mark.parametrize("sort", [True, False])
def test_size_sort(sort, by):
df = DataFrame(np.random.default_rng(2).choice(20, (1000, 3)), columns=list("ABC"))
left = df.groupby(by=by, sort=sort).size()
@@ -83,7 +83,6 @@ def test_size_period_index():
tm.assert_series_equal(result, ser)
-@pytest.mark.parametrize("as_index", [True, False])
def test_size_on_categorical(as_index):
df = DataFrame([[1, 1], [2, 2]], columns=["A", "B"])
df["A"] = df["A"].astype("category")
diff --git a/pandas/tests/groupby/methods/test_value_counts.py b/pandas/tests/groupby/methods/test_value_counts.py
index 2fa79c815d282..5c9f7febe32b3 100644
--- a/pandas/tests/groupby/methods/test_value_counts.py
+++ b/pandas/tests/groupby/methods/test_value_counts.py
@@ -76,9 +76,6 @@ def seed_df(seed_nans, n, m):
@pytest.mark.parametrize("bins", [None, [0, 5]], ids=repr)
@pytest.mark.parametrize("isort", [True, False])
@pytest.mark.parametrize("normalize, name", [(True, "proportion"), (False, "count")])
-@pytest.mark.parametrize("sort", [True, False])
-@pytest.mark.parametrize("ascending", [True, False])
-@pytest.mark.parametrize("dropna", [True, False])
def test_series_groupby_value_counts(
seed_nans,
num_rows,
@@ -295,7 +292,6 @@ def _frame_value_counts(df, keys, normalize, sort, ascending):
(True, False),
],
)
-@pytest.mark.parametrize("as_index", [True, False])
@pytest.mark.parametrize("frame", [True, False])
def test_against_frame_and_seriesgroupby(
education_df, groupby, normalize, name, sort, ascending, as_index, frame, request
@@ -583,7 +579,6 @@ def test_data_frame_value_counts_dropna(
tm.assert_series_equal(result_frame_groupby, expected)
-@pytest.mark.parametrize("as_index", [False, True])
@pytest.mark.parametrize("observed", [False, True])
@pytest.mark.parametrize(
"normalize, name, expected_data",
@@ -693,7 +688,6 @@ def assert_categorical_single_grouper(
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("as_index", [True, False])
@pytest.mark.parametrize(
"normalize, name, expected_data",
[
@@ -751,7 +745,6 @@ def test_categorical_single_grouper_observed_true(
)
-@pytest.mark.parametrize("as_index", [True, False])
@pytest.mark.parametrize(
"normalize, name, expected_data",
[
@@ -838,7 +831,6 @@ def test_categorical_single_grouper_observed_false(
)
-@pytest.mark.parametrize("as_index", [True, False])
@pytest.mark.parametrize(
"observed, expected_index",
[
@@ -924,7 +916,6 @@ def test_categorical_multiple_groupers(
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("as_index", [False, True])
@pytest.mark.parametrize("observed", [False, True])
@pytest.mark.parametrize(
"normalize, name, expected_data",
@@ -1033,7 +1024,6 @@ def test_mixed_groupings(normalize, expected_label, expected_values):
("level", list("abcd") + ["level_1"], ["a", None, "d", "b", "c", "level_1"]),
],
)
-@pytest.mark.parametrize("as_index", [False, True])
def test_column_label_duplicates(test, columns, expected_names, as_index):
# GH 44992
# Test for duplicate input column labels and generated duplicate labels
diff --git a/pandas/tests/groupby/test_apply.py b/pandas/tests/groupby/test_apply.py
index 34b6e7c4cde5f..f4b228eb5b326 100644
--- a/pandas/tests/groupby/test_apply.py
+++ b/pandas/tests/groupby/test_apply.py
@@ -1282,7 +1282,6 @@ def test_apply_by_cols_equals_apply_by_rows_transposed():
tm.assert_frame_equal(by_cols, df)
-@pytest.mark.parametrize("dropna", [True, False])
def test_apply_dropna_with_indexed_same(dropna):
# GH 38227
# GH#43205
@@ -1394,7 +1393,6 @@ def test_groupby_apply_to_series_name():
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("dropna", [True, False])
def test_apply_na(dropna):
# GH#28984
df = DataFrame(
diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py
index 7a91601bf688f..a2cc7fd782396 100644
--- a/pandas/tests/groupby/test_categorical.py
+++ b/pandas/tests/groupby/test_categorical.py
@@ -618,7 +618,6 @@ def test_dataframe_categorical_with_nan(observed):
@pytest.mark.parametrize("ordered", [True, False])
@pytest.mark.parametrize("observed", [True, False])
-@pytest.mark.parametrize("sort", [True, False])
def test_dataframe_categorical_ordered_observed_sort(ordered, observed, sort):
# GH 25871: Fix groupby sorting on ordered Categoricals
# GH 25167: Groupby with observed=True doesn't sort
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 3cc06ae4d2387..038f59f8ea80f 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -295,7 +295,6 @@ def f(x, q=None, axis=0):
tm.assert_frame_equal(apply_result, expected, check_names=False)
-@pytest.mark.parametrize("as_index", [True, False])
def test_pass_args_kwargs_duplicate_columns(tsframe, as_index):
# go through _aggregate_frame with self.axis == 0 and duplicate columns
tsframe.columns = ["A", "B", "A", "C"]
diff --git a/pandas/tests/groupby/test_groupby_dropna.py b/pandas/tests/groupby/test_groupby_dropna.py
index 73638eba0a3b3..ca097bc2be8bb 100644
--- a/pandas/tests/groupby/test_groupby_dropna.py
+++ b/pandas/tests/groupby/test_groupby_dropna.py
@@ -167,7 +167,6 @@ def test_groupby_dropna_series_by(dropna, expected):
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("dropna", (False, True))
def test_grouper_dropna_propagation(dropna):
# GH 36604
df = pd.DataFrame({"A": [0, 0, 1, None], "B": [1, 2, 3, None]})
diff --git a/pandas/tests/groupby/test_grouping.py b/pandas/tests/groupby/test_grouping.py
index 363ff883385db..782bb7eb7984e 100644
--- a/pandas/tests/groupby/test_grouping.py
+++ b/pandas/tests/groupby/test_grouping.py
@@ -649,7 +649,6 @@ def test_groupby_multiindex_partial_indexing_equivalence(self):
result_groups = df.groupby([("a", 1)])["b"].groups
tm.assert_dict_equal(expected_groups, result_groups)
- @pytest.mark.parametrize("sort", [True, False])
def test_groupby_level(self, sort, multiindex_dataframe_random_data, df):
# GH 17537
frame = multiindex_dataframe_random_data
@@ -708,7 +707,6 @@ def test_groupby_level_index_names(self, axis):
with tm.assert_produces_warning(FutureWarning, match=depr_msg):
df.groupby(level="foo", axis=axis)
- @pytest.mark.parametrize("sort", [True, False])
def test_groupby_level_with_nas(self, sort):
# GH 17537
index = MultiIndex(
diff --git a/pandas/tests/groupby/test_missing.py b/pandas/tests/groupby/test_missing.py
index 3180a92be1236..6c029c10817d9 100644
--- a/pandas/tests/groupby/test_missing.py
+++ b/pandas/tests/groupby/test_missing.py
@@ -109,7 +109,6 @@ def test_fill_consistency():
@pytest.mark.parametrize("method", ["ffill", "bfill"])
-@pytest.mark.parametrize("dropna", [True, False])
@pytest.mark.parametrize("has_nan_group", [True, False])
def test_ffill_handles_nan_groups(dropna, method, has_nan_group):
# GH 34725
diff --git a/pandas/tests/groupby/test_reductions.py b/pandas/tests/groupby/test_reductions.py
index 8333dba439be9..273734e84d9aa 100644
--- a/pandas/tests/groupby/test_reductions.py
+++ b/pandas/tests/groupby/test_reductions.py
@@ -20,7 +20,6 @@
from pandas.util import _test_decorators as td
-@pytest.mark.parametrize("agg_func", ["any", "all"])
@pytest.mark.parametrize(
"vals",
[
@@ -39,20 +38,20 @@
[np.nan, np.nan, np.nan],
],
)
-def test_groupby_bool_aggs(skipna, agg_func, vals):
+def test_groupby_bool_aggs(skipna, all_boolean_reductions, vals):
df = DataFrame({"key": ["a"] * 3 + ["b"] * 3, "val": vals * 2})
# Figure out expectation using Python builtin
- exp = getattr(builtins, agg_func)(vals)
+ exp = getattr(builtins, all_boolean_reductions)(vals)
# edge case for missing data with skipna and 'any'
- if skipna and all(isna(vals)) and agg_func == "any":
+ if skipna and all(isna(vals)) and all_boolean_reductions == "any":
exp = False
expected = DataFrame(
[exp] * 2, columns=["val"], index=pd.Index(["a", "b"], name="key")
)
- result = getattr(df.groupby("key"), agg_func)(skipna=skipna)
+ result = getattr(df.groupby("key"), all_boolean_reductions)(skipna=skipna)
tm.assert_frame_equal(result, expected)
@@ -69,18 +68,16 @@ def test_any():
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("bool_agg_func", ["any", "all"])
-def test_bool_aggs_dup_column_labels(bool_agg_func):
+def test_bool_aggs_dup_column_labels(all_boolean_reductions):
# GH#21668
df = DataFrame([[True, True]], columns=["a", "a"])
grp_by = df.groupby([0])
- result = getattr(grp_by, bool_agg_func)()
+ result = getattr(grp_by, all_boolean_reductions)()
expected = df.set_axis(np.array([0]))
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("bool_agg_func", ["any", "all"])
@pytest.mark.parametrize(
"data",
[
@@ -92,16 +89,16 @@ def test_bool_aggs_dup_column_labels(bool_agg_func):
[True, pd.NA, False],
],
)
-def test_masked_kleene_logic(bool_agg_func, skipna, data):
+def test_masked_kleene_logic(all_boolean_reductions, skipna, data):
# GH#37506
ser = Series(data, dtype="boolean")
# The result should match aggregating on the whole series. Correctness
# there is verified in test_reductions.py::test_any_all_boolean_kleene_logic
- expected_data = getattr(ser, bool_agg_func)(skipna=skipna)
+ expected_data = getattr(ser, all_boolean_reductions)(skipna=skipna)
expected = Series(expected_data, index=np.array([0]), dtype="boolean")
- result = ser.groupby([0, 0, 0]).agg(bool_agg_func, skipna=skipna)
+ result = ser.groupby([0, 0, 0]).agg(all_boolean_reductions, skipna=skipna)
tm.assert_series_equal(result, expected)
@@ -146,17 +143,18 @@ def test_masked_mixed_types(dtype1, dtype2, exp_col1, exp_col2):
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("bool_agg_func", ["any", "all"])
@pytest.mark.parametrize("dtype", ["Int64", "Float64", "boolean"])
-def test_masked_bool_aggs_skipna(bool_agg_func, dtype, skipna, frame_or_series):
+def test_masked_bool_aggs_skipna(
+ all_boolean_reductions, dtype, skipna, frame_or_series
+):
# GH#40585
obj = frame_or_series([pd.NA, 1], dtype=dtype)
expected_res = True
- if not skipna and bool_agg_func == "all":
+ if not skipna and all_boolean_reductions == "all":
expected_res = pd.NA
expected = frame_or_series([expected_res], index=np.array([1]), dtype="boolean")
- result = obj.groupby([1, 1]).agg(bool_agg_func, skipna=skipna)
+ result = obj.groupby([1, 1]).agg(all_boolean_reductions, skipna=skipna)
tm.assert_equal(result, expected)
@@ -177,20 +175,18 @@ def test_object_type_missing_vals(bool_agg_func, data, expected_res, frame_or_se
tm.assert_equal(result, expected)
-@pytest.mark.parametrize("bool_agg_func", ["any", "all"])
-def test_object_NA_raises_with_skipna_false(bool_agg_func):
+def test_object_NA_raises_with_skipna_false(all_boolean_reductions):
# GH#37501
ser = Series([pd.NA], dtype=object)
with pytest.raises(TypeError, match="boolean value of NA is ambiguous"):
- ser.groupby([1]).agg(bool_agg_func, skipna=False)
+ ser.groupby([1]).agg(all_boolean_reductions, skipna=False)
-@pytest.mark.parametrize("bool_agg_func", ["any", "all"])
-def test_empty(frame_or_series, bool_agg_func):
+def test_empty(frame_or_series, all_boolean_reductions):
# GH 45231
kwargs = {"columns": ["a"]} if frame_or_series is DataFrame else {"name": "a"}
obj = frame_or_series(**kwargs, dtype=object)
- result = getattr(obj.groupby(obj.index), bool_agg_func)()
+ result = getattr(obj.groupby(obj.index), all_boolean_reductions)()
expected = frame_or_series(**kwargs, dtype=bool)
tm.assert_equal(result, expected)
@@ -638,9 +634,6 @@ def test_max_nan_bug():
@pytest.mark.slow
-@pytest.mark.parametrize("sort", [False, True])
-@pytest.mark.parametrize("dropna", [False, True])
-@pytest.mark.parametrize("as_index", [True, False])
@pytest.mark.parametrize("with_nan", [True, False])
@pytest.mark.parametrize("keys", [["joe"], ["joe", "jim"]])
def test_series_groupby_nunique(sort, dropna, as_index, with_nan, keys):
@@ -1024,8 +1017,6 @@ def test_apply_to_nullable_integer_returns_float(values, function):
],
)
@pytest.mark.parametrize("axis", [0, 1])
-@pytest.mark.parametrize("skipna", [True, False])
-@pytest.mark.parametrize("sort", [True, False])
def test_regression_allowlist_methods(op, axis, skipna, sort):
# GH6944
# GH 17537
diff --git a/pandas/tests/groupby/transform/test_numba.py b/pandas/tests/groupby/transform/test_numba.py
index 61fcc930f116a..af11dae0aabfe 100644
--- a/pandas/tests/groupby/transform/test_numba.py
+++ b/pandas/tests/groupby/transform/test_numba.py
@@ -51,7 +51,6 @@ def incorrect_function(values, index):
# Filter warnings when parallel=True and the function can't be parallelized by Numba
@pytest.mark.parametrize("jit", [True, False])
@pytest.mark.parametrize("pandas_obj", ["Series", "DataFrame"])
-@pytest.mark.parametrize("as_index", [True, False])
def test_numba_vs_cython(jit, pandas_obj, nogil, parallel, nopython, as_index):
pytest.importorskip("numba")
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index a2ecd6c65db60..f7a4233b3ddc9 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -1239,15 +1239,14 @@ def test_groupby_transform_dtype():
tm.assert_series_equal(result, expected1)
-@pytest.mark.parametrize("func", ["cumsum", "cumprod", "cummin", "cummax"])
-def test_transform_absent_categories(func):
+def test_transform_absent_categories(all_numeric_accumulations):
# GH 16771
# cython transforms with more groups than rows
x_vals = [1]
x_cats = range(2)
y = [1]
df = DataFrame({"x": Categorical(x_vals, x_cats), "y": y})
- result = getattr(df.y.groupby(df.x, observed=False), func)()
+ result = getattr(df.y.groupby(df.x, observed=False), all_numeric_accumulations)()
expected = df.y
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexes/conftest.py b/pandas/tests/indexes/conftest.py
index bfb7acdcf4812..61f6be000cee8 100644
--- a/pandas/tests/indexes/conftest.py
+++ b/pandas/tests/indexes/conftest.py
@@ -15,8 +15,7 @@ def sort(request):
Caution:
Don't confuse this one with the "sort" fixture used
- for DataFrame.append or concat. That one has
- parameters [True, False].
+ for concat. That one has parameters [True, False].
We can't combine them as sort=True is not permitted
in the Index setops methods.
diff --git a/pandas/tests/indexes/datetimes/methods/test_snap.py b/pandas/tests/indexes/datetimes/methods/test_snap.py
index 7064e9e7993f8..651e4383a3fac 100644
--- a/pandas/tests/indexes/datetimes/methods/test_snap.py
+++ b/pandas/tests/indexes/datetimes/methods/test_snap.py
@@ -9,7 +9,6 @@
@pytest.mark.parametrize("tz", [None, "Asia/Shanghai", "Europe/Berlin"])
@pytest.mark.parametrize("name", [None, "my_dti"])
-@pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_dti_snap(name, tz, unit):
dti = DatetimeIndex(
[
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 44dd64e162413..019d434680661 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -1093,12 +1093,11 @@ def test_daterange_bug_456(self):
result = rng1.union(rng2)
assert isinstance(result, DatetimeIndex)
- @pytest.mark.parametrize("inclusive", ["left", "right", "neither", "both"])
- def test_bdays_and_open_boundaries(self, inclusive):
+ def test_bdays_and_open_boundaries(self, inclusive_endpoints_fixture):
# GH 6673
start = "2018-07-21" # Saturday
end = "2018-07-29" # Sunday
- result = date_range(start, end, freq="B", inclusive=inclusive)
+ result = date_range(start, end, freq="B", inclusive=inclusive_endpoints_fixture)
bday_start = "2018-07-23" # Monday
bday_end = "2018-07-27" # Friday
diff --git a/pandas/tests/indexes/datetimes/test_formats.py b/pandas/tests/indexes/datetimes/test_formats.py
index b52eed8c509c6..f8b01f7985535 100644
--- a/pandas/tests/indexes/datetimes/test_formats.py
+++ b/pandas/tests/indexes/datetimes/test_formats.py
@@ -14,11 +14,6 @@
import pandas._testing as tm
-@pytest.fixture(params=["s", "ms", "us", "ns"])
-def unit(request):
- return request.param
-
-
def test_get_values_for_csv():
index = pd.date_range(freq="1D", periods=3, start="2017-01-01")
diff --git a/pandas/tests/indexes/interval/test_indexing.py b/pandas/tests/indexes/interval/test_indexing.py
index fd03047b2c127..787461b944bd0 100644
--- a/pandas/tests/indexes/interval/test_indexing.py
+++ b/pandas/tests/indexes/interval/test_indexing.py
@@ -141,7 +141,6 @@ def test_get_loc_length_one_scalar(self, scalar, closed):
with pytest.raises(KeyError, match=str(scalar)):
index.get_loc(scalar)
- @pytest.mark.parametrize("other_closed", ["left", "right", "both", "neither"])
@pytest.mark.parametrize("left, right", [(0, 5), (-1, 4), (-1, 6), (6, 7)])
def test_get_loc_length_one_interval(self, left, right, closed, other_closed):
# GH 20921
diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index 63f9b2176dddd..89b991318be0d 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -865,12 +865,11 @@ def test_nbytes(self):
expected = 64 # 4 * 8 * 2
assert result == expected
- @pytest.mark.parametrize("new_closed", ["left", "right", "both", "neither"])
- def test_set_closed(self, name, closed, new_closed):
+ def test_set_closed(self, name, closed, other_closed):
# GH 21670
index = interval_range(0, 5, closed=closed, name=name)
- result = index.set_closed(new_closed)
- expected = interval_range(0, 5, closed=new_closed, name=name)
+ result = index.set_closed(other_closed)
+ expected = interval_range(0, 5, closed=other_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_pickle.py b/pandas/tests/indexes/interval/test_pickle.py
index 308a90e72eab5..c52106e5f0786 100644
--- a/pandas/tests/indexes/interval/test_pickle.py
+++ b/pandas/tests/indexes/interval/test_pickle.py
@@ -1,11 +1,8 @@
-import pytest
-
from pandas import IntervalIndex
import pandas._testing as tm
class TestPickle:
- @pytest.mark.parametrize("closed", ["left", "right", "both"])
def test_pickle_round_trip_closed(self, closed):
# https://github.com/pandas-dev/pandas/issues/35658
idx = IntervalIndex.from_tuples([(1, 2), (2, 3)], closed=closed)
diff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py
index 4fd807e1827dd..dc5a6719284a6 100644
--- a/pandas/tests/indexes/numeric/test_numeric.py
+++ b/pandas/tests/indexes/numeric/test_numeric.py
@@ -237,9 +237,9 @@ def test_logical_compat(self, simple_index):
class TestNumericInt:
- @pytest.fixture(params=[np.int64, np.int32, np.int16, np.int8, np.uint64])
- def dtype(self, request):
- return request.param
+ @pytest.fixture
+ def dtype(self, any_int_numpy_dtype):
+ return np.dtype(any_int_numpy_dtype)
@pytest.fixture
def simple_index(self, dtype):
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 666d92064c86c..158cba9dfdded 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -721,12 +721,11 @@ def test_format_missing(self, vals, nulls_fixture):
assert formatted == expected
assert index[3] is nulls_fixture
- @pytest.mark.parametrize("op", ["any", "all"])
- def test_logical_compat(self, op, simple_index):
+ def test_logical_compat(self, all_boolean_reductions, simple_index):
index = simple_index
- left = getattr(index, op)()
- assert left == getattr(index.values, op)()
- right = getattr(index.to_series(), op)()
+ left = getattr(index, all_boolean_reductions)()
+ assert left == getattr(index.values, all_boolean_reductions)()
+ right = getattr(index.to_series(), all_boolean_reductions)()
# left might not match right exactly in e.g. string cases where the
# because we use np.any/all instead of .any/all
assert bool(left) == bool(right)
diff --git a/pandas/tests/indexes/test_datetimelike.py b/pandas/tests/indexes/test_datetimelike.py
index 21a686e8bc05b..330ea50dc1373 100644
--- a/pandas/tests/indexes/test_datetimelike.py
+++ b/pandas/tests/indexes/test_datetimelike.py
@@ -162,7 +162,6 @@ def test_where_cast_str(self, simple_index):
result = index.where(mask, ["foo"])
tm.assert_index_equal(result, expected)
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_diff(self, unit):
# GH 55080
dti = pd.to_datetime([10, 20, 30], unit=unit).as_unit(unit)
diff --git a/pandas/tests/indexes/test_setops.py b/pandas/tests/indexes/test_setops.py
index 4a6982cf98670..8f4dd1c64236a 100644
--- a/pandas/tests/indexes/test_setops.py
+++ b/pandas/tests/indexes/test_setops.py
@@ -56,6 +56,11 @@ def any_dtype_for_small_pos_integer_indexes(request):
return request.param
+@pytest.fixture
+def index_flat2(index_flat):
+ return index_flat
+
+
def test_union_same_types(index):
# Union with a non-unique, non-monotonic index raises error
# Only needed for bool index factory
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index 1aa988cca0400..ada6f88679673 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -1681,10 +1681,10 @@ def test_loc_setitem_numpy_frame_categorical_value(self):
class TestLocWithEllipsis:
- @pytest.fixture(params=[tm.loc, tm.iloc])
- def indexer(self, request):
+ @pytest.fixture
+ def indexer(self, indexer_li):
# Test iloc while we're here
- return request.param
+ return indexer_li
@pytest.fixture
def obj(self, series_with_simple_index, frame_or_series):
diff --git a/pandas/tests/interchange/test_impl.py b/pandas/tests/interchange/test_impl.py
index 15c2b8d000b37..8bc6b48922a4f 100644
--- a/pandas/tests/interchange/test_impl.py
+++ b/pandas/tests/interchange/test_impl.py
@@ -304,7 +304,6 @@ def test_multi_chunk_pyarrow() -> None:
@pytest.mark.parametrize("tz", ["UTC", "US/Pacific"])
-@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_datetimetzdtype(tz, unit):
# GH 54239
tz_data = (
diff --git a/pandas/tests/io/excel/test_xlrd.py b/pandas/tests/io/excel/test_xlrd.py
index 6d5008ca9ee68..c49cbaf7fb26c 100644
--- a/pandas/tests/io/excel/test_xlrd.py
+++ b/pandas/tests/io/excel/test_xlrd.py
@@ -12,14 +12,14 @@
xlrd = pytest.importorskip("xlrd")
-@pytest.fixture(params=[".xls"])
-def read_ext_xlrd(request):
+@pytest.fixture
+def read_ext_xlrd():
"""
Valid extensions for reading Excel files with xlrd.
Similar to read_ext, but excludes .ods, .xlsb, and for xlrd>2 .xlsx, .xlsm
"""
- return request.param
+ return ".xls"
def test_read_xlrd_book(read_ext_xlrd, datapath):
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 0eefb0b52c483..9fa46222bce1a 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -957,7 +957,6 @@ def test_date_format_series_raises(self, datetime_series):
with pytest.raises(ValueError, match=msg):
ts.to_json(date_format="iso", date_unit="foo")
- @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_date_unit(self, unit, datetime_frame):
df = datetime_frame
df["date"] = Timestamp("20130101 20:43:42").as_unit("ns")
@@ -2026,9 +2025,6 @@ def test_json_uint64(self):
result = df.to_json(orient="split")
assert result == expected
- @pytest.mark.parametrize(
- "orient", ["split", "records", "values", "index", "columns"]
- )
def test_read_json_dtype_backend(
self, string_storage, dtype_backend, orient, using_infer_string
):
diff --git a/pandas/tests/io/parser/test_parse_dates.py b/pandas/tests/io/parser/test_parse_dates.py
index d8f362039ba13..700dcde336cd1 100644
--- a/pandas/tests/io/parser/test_parse_dates.py
+++ b/pandas/tests/io/parser/test_parse_dates.py
@@ -1326,9 +1326,8 @@ def test_read_with_parse_dates_invalid_type(all_parsers, parse_dates):
parser.read_csv(StringIO(data), parse_dates=(1,))
-@pytest.mark.parametrize("cache_dates", [True, False])
@pytest.mark.parametrize("value", ["nan", ""])
-def test_bad_date_parse(all_parsers, cache_dates, value):
+def test_bad_date_parse(all_parsers, cache, value):
# if we have an invalid date make sure that we handle this with
# and w/o the cache properly
parser = all_parsers
@@ -1339,13 +1338,12 @@ def test_bad_date_parse(all_parsers, cache_dates, value):
header=None,
names=["foo", "bar"],
parse_dates=["foo"],
- cache_dates=cache_dates,
+ cache_dates=cache,
)
-@pytest.mark.parametrize("cache_dates", [True, False])
@pytest.mark.parametrize("value", ["0"])
-def test_bad_date_parse_with_warning(all_parsers, cache_dates, value):
+def test_bad_date_parse_with_warning(all_parsers, cache, value):
# if we have an invalid date make sure that we handle this with
# and w/o the cache properly.
parser = all_parsers
@@ -1357,7 +1355,7 @@ def test_bad_date_parse_with_warning(all_parsers, cache_dates, value):
# TODO: parse dates directly in pyarrow, see
# https://github.com/pandas-dev/pandas/issues/48017
warn = None
- elif cache_dates:
+ elif cache:
# Note: warning is not raised if 'cache_dates', because here there is only a
# single unique date and hence no risk of inconsistent parsing.
warn = None
@@ -1370,7 +1368,7 @@ def test_bad_date_parse_with_warning(all_parsers, cache_dates, value):
header=None,
names=["foo", "bar"],
parse_dates=["foo"],
- cache_dates=cache_dates,
+ cache_dates=cache,
raise_on_extra_warnings=False,
)
diff --git a/pandas/tests/libs/test_join.py b/pandas/tests/libs/test_join.py
index ba2e6e7130929..bf8b4fabc54cb 100644
--- a/pandas/tests/libs/test_join.py
+++ b/pandas/tests/libs/test_join.py
@@ -138,14 +138,12 @@ def test_cython_inner_join(self):
tm.assert_numpy_array_equal(rs, exp_rs)
-@pytest.mark.parametrize("readonly", [True, False])
-def test_left_join_indexer_unique(readonly):
+def test_left_join_indexer_unique(writable):
a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
b = np.array([2, 2, 3, 4, 4], dtype=np.int64)
- if readonly:
- # GH#37312, GH#37264
- a.setflags(write=False)
- b.setflags(write=False)
+ # GH#37312, GH#37264
+ a.setflags(write=writable)
+ b.setflags(write=writable)
result = libjoin.left_join_indexer_unique(b, a)
expected = np.array([1, 1, 2, 3, 3], dtype=np.intp)
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index 30ec0d0affaa3..fcb5b65e59402 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -802,7 +802,6 @@ def test_var_masked_array(self, ddof, exp):
assert result == exp
@pytest.mark.parametrize("dtype", ("m8[ns]", "m8[ns]", "M8[ns]", "M8[ns, UTC]"))
- @pytest.mark.parametrize("skipna", [True, False])
def test_empty_timeseries_reductions_return_nat(self, dtype, skipna):
# covers GH#11245
assert Series([], dtype=dtype).min(skipna=skipna) is NaT
@@ -986,32 +985,27 @@ def test_all_any_bool_only(self):
assert s.any(bool_only=True)
assert not s.all(bool_only=True)
- @pytest.mark.parametrize("bool_agg_func", ["any", "all"])
- @pytest.mark.parametrize("skipna", [True, False])
- def test_any_all_object_dtype(self, bool_agg_func, skipna):
+ def test_any_all_object_dtype(self, all_boolean_reductions, skipna):
# GH#12863
ser = Series(["a", "b", "c", "d", "e"], dtype=object)
- result = getattr(ser, bool_agg_func)(skipna=skipna)
+ result = getattr(ser, all_boolean_reductions)(skipna=skipna)
expected = True
assert result == expected
- @pytest.mark.parametrize("bool_agg_func", ["any", "all"])
@pytest.mark.parametrize(
"data", [[False, None], [None, False], [False, np.nan], [np.nan, False]]
)
- def test_any_all_object_dtype_missing(self, data, bool_agg_func):
+ def test_any_all_object_dtype_missing(self, data, all_boolean_reductions):
# GH#27709
ser = Series(data)
- result = getattr(ser, bool_agg_func)(skipna=False)
+ result = getattr(ser, all_boolean_reductions)(skipna=False)
# None is treated is False, but np.nan is treated as True
- expected = bool_agg_func == "any" and None not in data
+ expected = all_boolean_reductions == "any" and None not in data
assert result == expected
@pytest.mark.parametrize("dtype", ["boolean", "Int64", "UInt64", "Float64"])
- @pytest.mark.parametrize("bool_agg_func", ["any", "all"])
- @pytest.mark.parametrize("skipna", [True, False])
@pytest.mark.parametrize(
# expected_data indexed as [[skipna=False/any, skipna=False/all],
# [skipna=True/any, skipna=True/all]]
@@ -1026,13 +1020,13 @@ def test_any_all_object_dtype_missing(self, data, bool_agg_func):
],
)
def test_any_all_nullable_kleene_logic(
- self, bool_agg_func, skipna, data, dtype, expected_data
+ self, all_boolean_reductions, skipna, data, dtype, expected_data
):
# GH-37506, GH-41967
ser = Series(data, dtype=dtype)
- expected = expected_data[skipna][bool_agg_func == "all"]
+ expected = expected_data[skipna][all_boolean_reductions == "all"]
- result = getattr(ser, bool_agg_func)(skipna=skipna)
+ result = getattr(ser, all_boolean_reductions)(skipna=skipna)
assert (result is pd.NA and expected is pd.NA) or result == expected
def test_any_axis1_bool_only(self):
@@ -1380,7 +1374,6 @@ def test_min_max_ordered(self, values, categories, function):
assert result == expected
@pytest.mark.parametrize("function", ["min", "max"])
- @pytest.mark.parametrize("skipna", [True, False])
def test_min_max_ordered_with_nan_only(self, function, skipna):
# https://github.com/pandas-dev/pandas/issues/33450
cat = Series(Categorical([np.nan], categories=[1, 2], ordered=True))
@@ -1388,7 +1381,6 @@ def test_min_max_ordered_with_nan_only(self, function, skipna):
assert result is np.nan
@pytest.mark.parametrize("function", ["min", "max"])
- @pytest.mark.parametrize("skipna", [True, False])
def test_min_max_skipna(self, function, skipna):
cat = Series(
Categorical(["a", "b", np.nan, "a"], categories=["b", "a"], ordered=True)
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 0dfe9877c4f86..f69649ab036d6 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -36,11 +36,6 @@
from pandas.tseries.offsets import Minute
-@pytest.fixture(params=["s", "ms", "us", "ns"])
-def unit(request):
- return request.param
-
-
@pytest.fixture
def simple_date_range_series():
"""
diff --git a/pandas/tests/resample/test_timedelta.py b/pandas/tests/resample/test_timedelta.py
index 7c70670d42908..309810b656ed3 100644
--- a/pandas/tests/resample/test_timedelta.py
+++ b/pandas/tests/resample/test_timedelta.py
@@ -176,7 +176,6 @@ def test_resample_with_timedelta_yields_no_empty_groups(duplicates):
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_resample_quantile_timedelta(unit):
# GH: 29485
dtype = np.dtype(f"m8[{unit}]")
diff --git a/pandas/tests/reshape/concat/conftest.py b/pandas/tests/reshape/concat/conftest.py
deleted file mode 100644
index 62b8c59ba8855..0000000000000
--- a/pandas/tests/reshape/concat/conftest.py
+++ /dev/null
@@ -1,7 +0,0 @@
-import pytest
-
-
-@pytest.fixture(params=[True, False])
-def sort(request):
- """Boolean sort keyword for concat and DataFrame.append."""
- return request.param
diff --git a/pandas/tests/reshape/concat/test_dataframe.py b/pandas/tests/reshape/concat/test_dataframe.py
index f288921c25753..8aefa9262dbc5 100644
--- a/pandas/tests/reshape/concat/test_dataframe.py
+++ b/pandas/tests/reshape/concat/test_dataframe.py
@@ -194,7 +194,6 @@ def test_concat_duplicates_in_index_with_keys(self):
@pytest.mark.parametrize("ignore_index", [True, False])
@pytest.mark.parametrize("order", ["C", "F"])
- @pytest.mark.parametrize("axis", [0, 1])
def test_concat_copies(self, axis, order, ignore_index, using_copy_on_write):
# based on asv ConcatDataFrames
df = DataFrame(np.zeros((10, 5), dtype=np.float32, order=order))
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 2505d9163a6d2..e6488bcc4568f 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -455,13 +455,12 @@ def test_left_merge_empty_dataframe(self):
result = merge(right, left, on="key", how="right")
tm.assert_frame_equal(result, left)
- @pytest.mark.parametrize("how", ["inner", "left", "right", "outer"])
- def test_merge_empty_dataframe(self, index, how):
+ def test_merge_empty_dataframe(self, index, join_type):
# GH52777
left = DataFrame([], index=index[:0])
right = left.copy()
- result = left.join(right, how=how)
+ result = left.join(right, how=join_type)
tm.assert_frame_equal(result, left)
@pytest.mark.parametrize(
@@ -2814,9 +2813,8 @@ def test_merge_arrow_and_numpy_dtypes(dtype):
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("how", ["inner", "left", "outer", "right"])
@pytest.mark.parametrize("tz", [None, "America/Chicago"])
-def test_merge_datetime_different_resolution(tz, how):
+def test_merge_datetime_different_resolution(tz, join_type):
# https://github.com/pandas-dev/pandas/issues/53200
vals = [
pd.Timestamp(2023, 5, 12, tz=tz),
@@ -2830,14 +2828,14 @@ def test_merge_datetime_different_resolution(tz, how):
expected = DataFrame({"t": vals, "a": [1.0, 2.0, np.nan], "b": [np.nan, 1.0, 2.0]})
expected["t"] = expected["t"].dt.as_unit("ns")
- if how == "inner":
+ if join_type == "inner":
expected = expected.iloc[[1]].reset_index(drop=True)
- elif how == "left":
+ elif join_type == "left":
expected = expected.iloc[[0, 1]]
- elif how == "right":
+ elif join_type == "right":
expected = expected.iloc[[1, 2]].reset_index(drop=True)
- result = df1.merge(df2, on="t", how=how)
+ result = df1.merge(df2, on="t", how=join_type)
tm.assert_frame_equal(result, expected)
@@ -2854,16 +2852,21 @@ def test_merge_multiindex_single_level():
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("how", ["left", "right", "inner", "outer"])
-@pytest.mark.parametrize("sort", [True, False])
@pytest.mark.parametrize("on_index", [True, False])
@pytest.mark.parametrize("left_unique", [True, False])
@pytest.mark.parametrize("left_monotonic", [True, False])
@pytest.mark.parametrize("right_unique", [True, False])
@pytest.mark.parametrize("right_monotonic", [True, False])
def test_merge_combinations(
- how, sort, on_index, left_unique, left_monotonic, right_unique, right_monotonic
+ join_type,
+ sort,
+ on_index,
+ left_unique,
+ left_monotonic,
+ right_unique,
+ right_monotonic,
):
+ how = join_type
# GH 54611
left = [2, 3]
if left_unique:
diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py
index b656191cc739d..33502f576dd2f 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -18,14 +18,6 @@
from pandas.core.reshape.merge import MergeError
-@pytest.fixture(params=["s", "ms", "us", "ns"])
-def unit(request):
- """
- Resolution for datetimelike dtypes.
- """
- return request.param
-
-
class TestAsOfMerge:
def prep_data(self, df, dedupe=False):
if dedupe:
diff --git a/pandas/tests/reshape/merge/test_multi.py b/pandas/tests/reshape/merge/test_multi.py
index 269d3a2b7078e..bc02da0d5b97b 100644
--- a/pandas/tests/reshape/merge/test_multi.py
+++ b/pandas/tests/reshape/merge/test_multi.py
@@ -88,7 +88,6 @@ def test_merge_on_multikey(self, left, right, join_type):
tm.assert_frame_equal(result, expected)
- @pytest.mark.parametrize("sort", [False, True])
def test_left_join_multi_index(self, sort):
icols = ["1st", "2nd", "3rd"]
@@ -150,7 +149,6 @@ def run_asserts(left, right, sort):
run_asserts(left, right, sort)
- @pytest.mark.parametrize("sort", [False, True])
def test_merge_right_vs_left(self, left, right, sort):
# compare left vs right merge with multikey
on_cols = ["key1", "key2"]
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index bf2717be4d7ae..6564ac0fd7e8a 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -30,11 +30,6 @@
from pandas.core.reshape.pivot import pivot_table
-@pytest.fixture(params=[True, False])
-def dropna(request):
- return request.param
-
-
@pytest.fixture(params=[([0] * 4, [1] * 4), (range(3), range(1, 4))])
def interval_values(request, closed):
left, right = request.param
@@ -2320,7 +2315,6 @@ def test_pivot_table_with_margins_and_numeric_columns(self):
tm.assert_frame_equal(result, expected)
- @pytest.mark.parametrize("dropna", [True, False])
def test_pivot_ea_dtype_dropna(self, dropna):
# GH#47477
df = DataFrame({"x": "a", "y": "b", "age": Series([20, 40], dtype="Int64")})
diff --git a/pandas/tests/scalar/timedelta/methods/test_round.py b/pandas/tests/scalar/timedelta/methods/test_round.py
index e54adb27d126b..676b44a4d54f4 100644
--- a/pandas/tests/scalar/timedelta/methods/test_round.py
+++ b/pandas/tests/scalar/timedelta/methods/test_round.py
@@ -170,7 +170,6 @@ def checker(ts, nanos, unit):
nanos = 24 * 60 * 60 * 1_000_000_000
checker(td, nanos, "D")
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_round_non_nano(self, unit):
td = Timedelta("1 days 02:34:57").as_unit(unit)
diff --git a/pandas/tests/scalar/timestamp/methods/test_normalize.py b/pandas/tests/scalar/timestamp/methods/test_normalize.py
index e097c9673e17a..60f249c602bd6 100644
--- a/pandas/tests/scalar/timestamp/methods/test_normalize.py
+++ b/pandas/tests/scalar/timestamp/methods/test_normalize.py
@@ -6,7 +6,6 @@
class TestTimestampNormalize:
@pytest.mark.parametrize("arg", ["2013-11-30", "2013-11-30 12:00:00"])
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_normalize(self, tz_naive_fixture, arg, unit):
tz = tz_naive_fixture
ts = Timestamp(arg, tz=tz).as_unit(unit)
diff --git a/pandas/tests/scalar/timestamp/methods/test_replace.py b/pandas/tests/scalar/timestamp/methods/test_replace.py
index 8a208455edc82..d67de79a8dd10 100644
--- a/pandas/tests/scalar/timestamp/methods/test_replace.py
+++ b/pandas/tests/scalar/timestamp/methods/test_replace.py
@@ -157,7 +157,6 @@ def test_replace_across_dst(self, tz, normalize):
ts2b = normalize(ts2)
assert ts2 == ts2b
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_replace_dst_border(self, unit):
# Gh 7825
t = Timestamp("2013-11-3", tz="America/Chicago").as_unit(unit)
@@ -168,7 +167,6 @@ def test_replace_dst_border(self, unit):
@pytest.mark.parametrize("fold", [0, 1])
@pytest.mark.parametrize("tz", ["dateutil/Europe/London", "Europe/London"])
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_replace_dst_fold(self, fold, tz, unit):
# GH 25017
d = datetime(2019, 10, 27, 2, 30)
diff --git a/pandas/tests/scalar/timestamp/methods/test_round.py b/pandas/tests/scalar/timestamp/methods/test_round.py
index d10ee18b47f19..59c0fe8bbebfb 100644
--- a/pandas/tests/scalar/timestamp/methods/test_round.py
+++ b/pandas/tests/scalar/timestamp/methods/test_round.py
@@ -147,7 +147,6 @@ def test_round_minute_freq(self, test_input, freq, expected, rounder):
result = func(freq)
assert result == expected
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_ceil(self, unit):
dt = Timestamp("20130101 09:10:11").as_unit(unit)
result = dt.ceil("D")
@@ -155,7 +154,6 @@ def test_ceil(self, unit):
assert result == expected
assert result._creso == dt._creso
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_floor(self, unit):
dt = Timestamp("20130101 09:10:11").as_unit(unit)
result = dt.floor("D")
diff --git a/pandas/tests/scalar/timestamp/methods/test_tz_localize.py b/pandas/tests/scalar/timestamp/methods/test_tz_localize.py
index af3dee1880d2e..0786cc58a4f95 100644
--- a/pandas/tests/scalar/timestamp/methods/test_tz_localize.py
+++ b/pandas/tests/scalar/timestamp/methods/test_tz_localize.py
@@ -50,7 +50,6 @@ def test_tz_localize_pushes_out_of_bounds(self):
with pytest.raises(OutOfBoundsDatetime, match=msg):
Timestamp.max.tz_localize("US/Pacific")
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_tz_localize_ambiguous_bool(self, unit):
# make sure that we are correctly accepting bool values as ambiguous
# GH#14402
@@ -295,7 +294,6 @@ def test_timestamp_tz_localize(self, tz):
],
)
@pytest.mark.parametrize("tz_type", ["", "dateutil/"])
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_timestamp_tz_localize_nonexistent_shift(
self, start_ts, tz, end_ts, shift, tz_type, unit
):
@@ -327,7 +325,6 @@ def test_timestamp_tz_localize_nonexistent_shift_invalid(self, offset, warsaw):
with pytest.raises(ValueError, match=msg):
ts.tz_localize(tz, nonexistent=timedelta(seconds=offset))
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_timestamp_tz_localize_nonexistent_NaT(self, warsaw, unit):
# GH 8917
tz = warsaw
@@ -335,7 +332,6 @@ def test_timestamp_tz_localize_nonexistent_NaT(self, warsaw, unit):
result = ts.tz_localize(tz, nonexistent="NaT")
assert result is NaT
- @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
def test_timestamp_tz_localize_nonexistent_raise(self, warsaw, unit):
# GH 8917
tz = warsaw
diff --git a/pandas/tests/series/methods/test_map.py b/pandas/tests/series/methods/test_map.py
index 251d4063008b9..f4f72854e50d3 100644
--- a/pandas/tests/series/methods/test_map.py
+++ b/pandas/tests/series/methods/test_map.py
@@ -326,7 +326,6 @@ def test_map_dict_na_key():
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map_defaultdict_na_key(na_action):
# GH 48813
s = Series([1, 2, np.nan])
@@ -336,7 +335,6 @@ def test_map_defaultdict_na_key(na_action):
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map_defaultdict_missing_key(na_action):
# GH 48813
s = Series([1, 2, np.nan])
@@ -346,7 +344,6 @@ def test_map_defaultdict_missing_key(na_action):
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map_defaultdict_unmutated(na_action):
# GH 48813
s = Series([1, 2, np.nan])
@@ -483,7 +480,6 @@ def test_map_box_period():
tm.assert_series_equal(res, exp)
-@pytest.mark.parametrize("na_action", [None, "ignore"])
def test_map_categorical(na_action, using_infer_string):
values = pd.Categorical(list("ABBABCD"), categories=list("DCBA"), ordered=True)
s = Series(values, name="XX", index=list("abcdefg"))
diff --git a/pandas/tests/series/methods/test_rank.py b/pandas/tests/series/methods/test_rank.py
index 24cf97c05c0a8..4d48f290e6a44 100644
--- a/pandas/tests/series/methods/test_rank.py
+++ b/pandas/tests/series/methods/test_rank.py
@@ -248,8 +248,6 @@ def test_rank_tie_methods(self, ser, results, dtype):
result = ser.rank(method=method)
tm.assert_series_equal(result, Series(exp))
- @pytest.mark.parametrize("ascending", [True, False])
- @pytest.mark.parametrize("method", ["average", "min", "max", "first", "dense"])
@pytest.mark.parametrize("na_option", ["top", "bottom", "keep"])
@pytest.mark.parametrize(
"dtype, na_value, pos_inf, neg_inf",
@@ -267,11 +265,11 @@ def test_rank_tie_methods(self, ser, results, dtype):
],
)
def test_rank_tie_methods_on_infs_nans(
- self, method, na_option, ascending, dtype, na_value, pos_inf, neg_inf
+ self, rank_method, na_option, ascending, dtype, na_value, pos_inf, neg_inf
):
pytest.importorskip("scipy")
if dtype == "float64[pyarrow]":
- if method == "average":
+ if rank_method == "average":
exp_dtype = "float64[pyarrow]"
else:
exp_dtype = "uint64[pyarrow]"
@@ -288,7 +286,7 @@ def test_rank_tie_methods_on_infs_nans(
"first": ([1, 2, 3], [4, 5, 6], [7, 8, 9]),
"dense": ([1, 1, 1], [2, 2, 2], [3, 3, 3]),
}
- ranks = exp_ranks[method]
+ ranks = exp_ranks[rank_method]
if na_option == "top":
order = [ranks[1], ranks[0], ranks[2]]
elif na_option == "bottom":
@@ -297,7 +295,9 @@ def test_rank_tie_methods_on_infs_nans(
order = [ranks[0], [np.nan] * chunk, ranks[1]]
expected = order if ascending else order[::-1]
expected = list(chain.from_iterable(expected))
- result = iseries.rank(method=method, na_option=na_option, ascending=ascending)
+ result = iseries.rank(
+ method=rank_method, na_option=na_option, ascending=ascending
+ )
tm.assert_series_equal(result, Series(expected, dtype=exp_dtype))
def test_rank_desc_mix_nans_infs(self):
@@ -308,7 +308,6 @@ def test_rank_desc_mix_nans_infs(self):
exp = Series([3, np.nan, 1, 4, 2], dtype="float64")
tm.assert_series_equal(result, exp)
- @pytest.mark.parametrize("method", ["average", "min", "max", "first", "dense"])
@pytest.mark.parametrize(
"op, value",
[
@@ -317,7 +316,7 @@ def test_rank_desc_mix_nans_infs(self):
[operator.mul, 1e-6],
],
)
- def test_rank_methods_series(self, method, op, value):
+ def test_rank_methods_series(self, rank_method, op, value):
sp_stats = pytest.importorskip("scipy.stats")
xs = np.random.default_rng(2).standard_normal(9)
@@ -327,8 +326,10 @@ def test_rank_methods_series(self, method, op, value):
index = [chr(ord("a") + i) for i in range(len(xs))]
vals = op(xs, value)
ts = Series(vals, index=index)
- result = ts.rank(method=method)
- sprank = sp_stats.rankdata(vals, method if method != "first" else "ordinal")
+ result = ts.rank(method=rank_method)
+ sprank = sp_stats.rankdata(
+ vals, rank_method if rank_method != "first" else "ordinal"
+ )
expected = Series(sprank, index=index).astype("float64")
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_sort_values.py b/pandas/tests/series/methods/test_sort_values.py
index 4808272879071..00142c4d82327 100644
--- a/pandas/tests/series/methods/test_sort_values.py
+++ b/pandas/tests/series/methods/test_sort_values.py
@@ -204,7 +204,6 @@ def test_sort_values_validate_ascending_for_value_error(self):
with pytest.raises(ValueError, match=msg):
ser.sort_values(ascending="False")
- @pytest.mark.parametrize("ascending", [False, 0, 1, True])
def test_sort_values_validate_ascending_functional(self, ascending):
# GH41634
ser = Series([23, 7, 21])
diff --git a/pandas/tests/series/test_reductions.py b/pandas/tests/series/test_reductions.py
index e200f7d9933aa..0bc3092d30b43 100644
--- a/pandas/tests/series/test_reductions.py
+++ b/pandas/tests/series/test_reductions.py
@@ -70,7 +70,6 @@ def test_reductions_td64_with_nat():
assert ser.max() == exp
-@pytest.mark.parametrize("skipna", [True, False])
def test_td64_sum_empty(skipna):
# GH#37151
ser = Series([], dtype="timedelta64[ns]")
diff --git a/pandas/tests/strings/test_cat.py b/pandas/tests/strings/test_cat.py
index c1e7ad6e02779..68ca807bde145 100644
--- a/pandas/tests/strings/test_cat.py
+++ b/pandas/tests/strings/test_cat.py
@@ -16,6 +16,11 @@
)
+@pytest.fixture
+def index_or_series2(index_or_series):
+ return index_or_series
+
+
@pytest.mark.parametrize("other", [None, Series, Index])
def test_str_cat_name(index_or_series, other):
# GH 21053
@@ -270,14 +275,13 @@ def test_str_cat_mixed_inputs(index_or_series):
s.str.cat(iter([t.values, list(s)]))
-@pytest.mark.parametrize("join", ["left", "outer", "inner", "right"])
-def test_str_cat_align_indexed(index_or_series, join):
+def test_str_cat_align_indexed(index_or_series, join_type):
# https://github.com/pandas-dev/pandas/issues/18657
box = index_or_series
s = Series(["a", "b", "c", "d"], index=["a", "b", "c", "d"])
t = Series(["D", "A", "E", "B"], index=["d", "a", "e", "b"])
- sa, ta = s.align(t, join=join)
+ sa, ta = s.align(t, join=join_type)
# result after manual alignment of inputs
expected = sa.str.cat(ta, na_rep="-")
@@ -286,25 +290,24 @@ def test_str_cat_align_indexed(index_or_series, join):
sa = Index(sa)
expected = Index(expected)
- result = s.str.cat(t, join=join, na_rep="-")
+ result = s.str.cat(t, join=join_type, na_rep="-")
tm.assert_equal(result, expected)
-@pytest.mark.parametrize("join", ["left", "outer", "inner", "right"])
-def test_str_cat_align_mixed_inputs(join):
+def test_str_cat_align_mixed_inputs(join_type):
s = Series(["a", "b", "c", "d"])
t = Series(["d", "a", "e", "b"], index=[3, 0, 4, 1])
d = concat([t, t], axis=1)
expected_outer = Series(["aaa", "bbb", "c--", "ddd", "-ee"])
- expected = expected_outer.loc[s.index.join(t.index, how=join)]
+ expected = expected_outer.loc[s.index.join(t.index, how=join_type)]
# list of Series
- result = s.str.cat([t, t], join=join, na_rep="-")
+ result = s.str.cat([t, t], join=join_type, na_rep="-")
tm.assert_series_equal(result, expected)
# DataFrame
- result = s.str.cat(d, join=join, na_rep="-")
+ result = s.str.cat(d, join=join_type, na_rep="-")
tm.assert_series_equal(result, expected)
# mixed list of indexed/unindexed
@@ -313,19 +316,19 @@ def test_str_cat_align_mixed_inputs(join):
# joint index of rhs [t, u]; u will be forced have index of s
rhs_idx = (
t.index.intersection(s.index)
- if join == "inner"
+ if join_type == "inner"
else t.index.union(s.index)
- if join == "outer"
+ if join_type == "outer"
else t.index.append(s.index.difference(t.index))
)
- expected = expected_outer.loc[s.index.join(rhs_idx, how=join)]
- result = s.str.cat([t, u], join=join, na_rep="-")
+ expected = expected_outer.loc[s.index.join(rhs_idx, how=join_type)]
+ result = s.str.cat([t, u], join=join_type, na_rep="-")
tm.assert_series_equal(result, expected)
with pytest.raises(TypeError, match="others must be Series,.*"):
# nested lists are forbidden
- s.str.cat([t, list(u)], join=join)
+ s.str.cat([t, list(u)], join=join_type)
# errors for incorrect lengths
rgx = r"If `others` contains arrays or lists \(or other list-likes.*"
@@ -333,11 +336,11 @@ def test_str_cat_align_mixed_inputs(join):
# unindexed object of wrong length
with pytest.raises(ValueError, match=rgx):
- s.str.cat(z, join=join)
+ s.str.cat(z, join=join_type)
# unindexed object of wrong length in list
with pytest.raises(ValueError, match=rgx):
- s.str.cat([t, z], join=join)
+ s.str.cat([t, z], join=join_type)
def test_str_cat_all_na(index_or_series, index_or_series2):
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index 718d1b3ee2e83..16d684b72e1e3 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -63,7 +63,6 @@ def test_factorize_complex(self):
expected_uniques = np.array([(1 + 0j), (2 + 0j), (2 + 1j)], dtype=object)
tm.assert_numpy_array_equal(uniques, expected_uniques)
- @pytest.mark.parametrize("sort", [True, False])
def test_factorize(self, index_or_series_obj, sort):
obj = index_or_series_obj
result_codes, result_uniques = obj.factorize(sort=sort)
@@ -354,7 +353,6 @@ def test_datetime64_factorize(self, writable):
tm.assert_numpy_array_equal(codes, expected_codes)
tm.assert_numpy_array_equal(uniques, expected_uniques)
- @pytest.mark.parametrize("sort", [True, False])
def test_factorize_rangeindex(self, sort):
# increasing -> sort doesn't matter
ri = pd.RangeIndex.from_range(range(10))
@@ -368,7 +366,6 @@ def test_factorize_rangeindex(self, sort):
tm.assert_numpy_array_equal(result[0], expected[0])
tm.assert_index_equal(result[1], expected[1], exact=True)
- @pytest.mark.parametrize("sort", [True, False])
def test_factorize_rangeindex_decreasing(self, sort):
# decreasing -> sort matters
ri = pd.RangeIndex.from_range(range(10))
@@ -431,7 +428,6 @@ def test_parametrized_factorize_na_value(self, data, na_value):
tm.assert_numpy_array_equal(codes, expected_codes)
tm.assert_numpy_array_equal(uniques, expected_uniques)
- @pytest.mark.parametrize("sort", [True, False])
@pytest.mark.parametrize(
"data, uniques",
[
diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py
index a50054f33f382..95d0953301a42 100644
--- a/pandas/tests/test_nanops.py
+++ b/pandas/tests/test_nanops.py
@@ -1102,10 +1102,6 @@ def prng(self):
class TestDatetime64NaNOps:
- @pytest.fixture(params=["s", "ms", "us", "ns"])
- def unit(self, request):
- return request.param
-
# Enabling mean changes the behavior of DataFrame.mean
# See https://github.com/pandas-dev/pandas/issues/24752
def test_nanmean(self, unit):
diff --git a/pandas/tests/test_sorting.py b/pandas/tests/test_sorting.py
index 285f240028152..329fbac925539 100644
--- a/pandas/tests/test_sorting.py
+++ b/pandas/tests/test_sorting.py
@@ -218,14 +218,13 @@ def test_int64_overflow_check_sum_col(self, left_right):
assert result.name is None
@pytest.mark.slow
- @pytest.mark.parametrize("how", ["left", "right", "outer", "inner"])
- def test_int64_overflow_how_merge(self, left_right, how):
+ def test_int64_overflow_how_merge(self, left_right, join_type):
left, right = left_right
out = merge(left, right, how="outer")
out.sort_values(out.columns.tolist(), inplace=True)
out.index = np.arange(len(out))
- tm.assert_frame_equal(out, merge(left, right, how=how, sort=True))
+ tm.assert_frame_equal(out, merge(left, right, how=join_type, sort=True))
@pytest.mark.slow
def test_int64_overflow_sort_false_order(self, left_right):
@@ -239,10 +238,9 @@ def test_int64_overflow_sort_false_order(self, left_right):
tm.assert_frame_equal(right, out[right.columns.tolist()])
@pytest.mark.slow
- @pytest.mark.parametrize("how", ["left", "right", "outer", "inner"])
- @pytest.mark.parametrize("sort", [True, False])
- def test_int64_overflow_one_to_many_none_match(self, how, sort):
+ def test_int64_overflow_one_to_many_none_match(self, join_type, sort):
# one-2-many/none match
+ how = join_type
low, high, n = -1 << 10, 1 << 10, 1 << 11
left = DataFrame(
np.random.default_rng(2).integers(low, high, (n, 7)).astype("int64"),
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 6791ac0340640..5b856bc632a1d 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -62,21 +62,11 @@
)
-@pytest.fixture(params=[True, False])
-def cache(request):
- """
- cache keyword to pass to to_datetime.
- """
- return request.param
-
-
class TestTimeConversionFormats:
- @pytest.mark.parametrize("readonly", [True, False])
- def test_to_datetime_readonly(self, readonly):
+ def test_to_datetime_readonly(self, writable):
# GH#34857
arr = np.array([], dtype=object)
- if readonly:
- arr.setflags(write=False)
+ arr.setflags(write=writable)
result = to_datetime(arr)
expected = to_datetime([])
tm.assert_index_equal(result, expected)
@@ -1588,7 +1578,6 @@ def test_convert_object_to_datetime_with_cache(
)
tm.assert_series_equal(result_series, expected_series)
- @pytest.mark.parametrize("cache", [True, False])
@pytest.mark.parametrize(
"input",
[
@@ -3600,7 +3589,6 @@ def test_empty_string_datetime_coerce__unit():
tm.assert_index_equal(expected, result)
-@pytest.mark.parametrize("cache", [True, False])
def test_to_datetime_monotonic_increasing_index(cache):
# GH28238
cstart = start_caching_at
diff --git a/pandas/tests/tools/test_to_timedelta.py b/pandas/tests/tools/test_to_timedelta.py
index b67694f1c58c7..036462674c270 100644
--- a/pandas/tests/tools/test_to_timedelta.py
+++ b/pandas/tests/tools/test_to_timedelta.py
@@ -32,12 +32,10 @@ def test_to_timedelta_dt64_raises(self):
with pytest.raises(TypeError, match=msg):
ser.to_frame().apply(to_timedelta)
- @pytest.mark.parametrize("readonly", [True, False])
- def test_to_timedelta_readonly(self, readonly):
+ def test_to_timedelta_readonly(self, writable):
# GH#34857
arr = np.array([], dtype=object)
- if readonly:
- arr.setflags(write=False)
+ arr.setflags(write=writable)
result = to_timedelta(arr)
expected = to_timedelta([])
tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py
index 99a504f4188c1..0d37273e89092 100644
--- a/pandas/tests/tseries/frequencies/test_inference.py
+++ b/pandas/tests/tseries/frequencies/test_inference.py
@@ -231,7 +231,6 @@ def test_infer_freq_index(freq, expected):
}.items()
),
)
-@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_infer_freq_tz(tz_naive_fixture, expected, dates, unit):
# see gh-7310, GH#55609
tz = tz_naive_fixture
diff --git a/pandas/tests/tseries/offsets/test_business_hour.py b/pandas/tests/tseries/offsets/test_business_hour.py
index 2779100f5355c..e675977c6fab4 100644
--- a/pandas/tests/tseries/offsets/test_business_hour.py
+++ b/pandas/tests/tseries/offsets/test_business_hour.py
@@ -947,7 +947,6 @@ def test_apply_nanoseconds(self):
assert_offset_equal(offset, base, expected)
@pytest.mark.parametrize("td_unit", ["s", "ms", "us", "ns"])
- @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
def test_bday_ignores_timedeltas(self, unit, td_unit):
# GH#55608
idx = date_range("2010/02/01", "2010/02/10", freq="12h", unit=unit)
diff --git a/pandas/tests/window/conftest.py b/pandas/tests/window/conftest.py
index 73ab470ab97a7..fe873b3b74254 100644
--- a/pandas/tests/window/conftest.py
+++ b/pandas/tests/window/conftest.py
@@ -50,28 +50,6 @@ def min_periods(request):
return request.param
-@pytest.fixture(params=[True, False])
-def parallel(request):
- """parallel keyword argument for numba.jit"""
- return request.param
-
-
-# Can parameterize nogil & nopython over True | False, but limiting per
-# https://github.com/pandas-dev/pandas/pull/41971#issuecomment-860607472
-
-
-@pytest.fixture(params=[False])
-def nogil(request):
- """nogil keyword argument for numba.jit"""
- return request.param
-
-
-@pytest.fixture(params=[True])
-def nopython(request):
- """nopython keyword argument for numba.jit"""
- return request.param
-
-
@pytest.fixture(params=[True, False])
def adjust(request):
"""adjust keyword argument for ewm"""
diff --git a/pandas/tests/window/test_expanding.py b/pandas/tests/window/test_expanding.py
index aebb9e86c763f..10d0afb5a2412 100644
--- a/pandas/tests/window/test_expanding.py
+++ b/pandas/tests/window/test_expanding.py
@@ -79,10 +79,10 @@ def test_missing_minp_zero():
tm.assert_series_equal(result, expected)
-def test_expanding_axis(axis_frame):
+def test_expanding_axis(axis):
# see gh-23372.
df = DataFrame(np.ones((10, 20)))
- axis = df._get_axis_number(axis_frame)
+ axis = df._get_axis_number(axis)
if axis == 0:
msg = "The 'axis' keyword in DataFrame.expanding is deprecated"
@@ -95,7 +95,7 @@ def test_expanding_axis(axis_frame):
expected = DataFrame([[np.nan] * 2 + [float(i) for i in range(3, 21)]] * 10)
with tm.assert_produces_warning(FutureWarning, match=msg):
- result = df.expanding(3, axis=axis_frame).sum()
+ result = df.expanding(3, axis=axis).sum()
tm.assert_frame_equal(result, expected)
@@ -241,7 +241,6 @@ def test_expanding_skew_kurt_numerical_stability(method):
@pytest.mark.parametrize("window", [1, 3, 10, 20])
@pytest.mark.parametrize("method", ["min", "max", "average"])
@pytest.mark.parametrize("pct", [True, False])
-@pytest.mark.parametrize("ascending", [True, False])
@pytest.mark.parametrize("test_data", ["default", "duplicates", "nans"])
def test_rank(window, method, pct, ascending, test_data):
length = 20
diff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py
index f353a7fa2f0fe..7ab6e7863ad81 100644
--- a/pandas/tests/window/test_rolling.py
+++ b/pandas/tests/window/test_rolling.py
@@ -594,10 +594,10 @@ def test_multi_index_names():
assert result.index.names == [None, "1", "2"]
-def test_rolling_axis_sum(axis_frame):
+def test_rolling_axis_sum(axis):
# see gh-23372.
df = DataFrame(np.ones((10, 20)))
- axis = df._get_axis_number(axis_frame)
+ axis = df._get_axis_number(axis)
if axis == 0:
msg = "The 'axis' keyword in DataFrame.rolling"
@@ -608,15 +608,15 @@ def test_rolling_axis_sum(axis_frame):
expected = DataFrame([[np.nan] * 2 + [3.0] * 18] * 10)
with tm.assert_produces_warning(FutureWarning, match=msg):
- result = df.rolling(3, axis=axis_frame).sum()
+ result = df.rolling(3, axis=axis).sum()
tm.assert_frame_equal(result, expected)
-def test_rolling_axis_count(axis_frame):
+def test_rolling_axis_count(axis):
# see gh-26055
df = DataFrame({"x": range(3), "y": range(3)})
- axis = df._get_axis_number(axis_frame)
+ axis = df._get_axis_number(axis)
if axis in [0, "index"]:
msg = "The 'axis' keyword in DataFrame.rolling"
@@ -626,7 +626,7 @@ def test_rolling_axis_count(axis_frame):
expected = DataFrame({"x": [1.0, 1.0, 1.0], "y": [2.0, 2.0, 2.0]})
with tm.assert_produces_warning(FutureWarning, match=msg):
- result = df.rolling(2, axis=axis_frame, min_periods=0).count()
+ result = df.rolling(2, axis=axis, min_periods=0).count()
tm.assert_frame_equal(result, expected)
@@ -639,21 +639,21 @@ def test_readonly_array():
tm.assert_series_equal(result, expected)
-def test_rolling_datetime(axis_frame, tz_naive_fixture):
+def test_rolling_datetime(axis, tz_naive_fixture):
# GH-28192
tz = tz_naive_fixture
df = DataFrame(
{i: [1] * 2 for i in date_range("2019-8-01", "2019-08-03", freq="D", tz=tz)}
)
- if axis_frame in [0, "index"]:
+ if axis in [0, "index"]:
msg = "The 'axis' keyword in DataFrame.rolling"
with tm.assert_produces_warning(FutureWarning, match=msg):
- result = df.T.rolling("2D", axis=axis_frame).sum().T
+ result = df.T.rolling("2D", axis=axis).sum().T
else:
msg = "Support for axis=1 in DataFrame.rolling"
with tm.assert_produces_warning(FutureWarning, match=msg):
- result = df.rolling("2D", axis=axis_frame).sum()
+ result = df.rolling("2D", axis=axis).sum()
expected = DataFrame(
{
**{
@@ -669,7 +669,6 @@ def test_rolling_datetime(axis_frame, tz_naive_fixture):
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("center", [True, False])
def test_rolling_window_as_string(center):
# see gh-22590
date_today = datetime.now()
@@ -1629,7 +1628,6 @@ def test_rolling_numeric_dtypes():
@pytest.mark.parametrize("window", [1, 3, 10, 20])
@pytest.mark.parametrize("method", ["min", "max", "average"])
@pytest.mark.parametrize("pct", [True, False])
-@pytest.mark.parametrize("ascending", [True, False])
@pytest.mark.parametrize("test_data", ["default", "duplicates", "nans"])
def test_rank(window, method, pct, ascending, test_data):
length = 20
@@ -1947,7 +1945,6 @@ def test_numeric_only_corr_cov_series(kernel, use_arg, numeric_only, dtype):
tm.assert_series_equal(result, expected)
-@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
@pytest.mark.parametrize("tz", [None, "UTC", "Europe/Prague"])
def test_rolling_timedelta_window_non_nanoseconds(unit, tz):
# Test Sum, GH#55106
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/56583 | 2023-12-20T23:34:59Z | 2024-01-02T19:17:08Z | 2024-01-02T19:17:08Z | 2024-01-03T21:56:29Z |
BUG: stack changes NA values in the index | diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst
index 8c475791df64d..5382e56544907 100644
--- a/doc/source/whatsnew/v2.2.0.rst
+++ b/doc/source/whatsnew/v2.2.0.rst
@@ -686,6 +686,7 @@ Reshaping
- Bug in :meth:`DataFrame.melt` where it would not preserve the datetime (:issue:`55254`)
- Bug in :meth:`DataFrame.pivot_table` where the row margin is incorrect when the columns have numeric names (:issue:`26568`)
- Bug in :meth:`DataFrame.pivot` with numeric columns and extension dtype for data (:issue:`56528`)
+- Bug in :meth:`DataFrame.stack` and :meth:`Series.stack` with ``future_stack=True`` would not preserve NA values in the index (:issue:`56573`)
Sparse
^^^^^^
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index 8c822ec58e011..7a49682d7c57c 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -953,8 +953,8 @@ def stack_v3(frame: DataFrame, level: list[int]) -> Series | DataFrame:
index_levels = frame.index.levels
index_codes = list(np.tile(frame.index.codes, (1, ratio)))
else:
- index_levels = [frame.index.unique()]
- codes = factorize(frame.index)[0]
+ codes, uniques = factorize(frame.index, use_na_sentinel=False)
+ index_levels = [uniques]
index_codes = list(np.tile(codes, (1, ratio)))
if isinstance(stack_cols, MultiIndex):
column_levels = ordered_stack_cols.levels
diff --git a/pandas/tests/frame/test_stack_unstack.py b/pandas/tests/frame/test_stack_unstack.py
index 554a9d4ce2d5d..6e1e743eb60de 100644
--- a/pandas/tests/frame/test_stack_unstack.py
+++ b/pandas/tests/frame/test_stack_unstack.py
@@ -2638,3 +2638,41 @@ def test_stack_tuple_columns(future_stack):
),
)
tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "dtype, na_value",
+ [
+ ("float64", np.nan),
+ ("Float64", np.nan),
+ ("Float64", pd.NA),
+ ("Int64", pd.NA),
+ ],
+)
+@pytest.mark.parametrize("test_multiindex", [True, False])
+def test_stack_preserves_na(dtype, na_value, test_multiindex):
+ # GH#56573
+ if test_multiindex:
+ index = MultiIndex.from_arrays(2 * [Index([na_value], dtype=dtype)])
+ else:
+ index = Index([na_value], dtype=dtype)
+ df = DataFrame({"a": [1]}, index=index)
+ result = df.stack(future_stack=True)
+
+ if test_multiindex:
+ expected_index = MultiIndex.from_arrays(
+ [
+ Index([na_value], dtype=dtype),
+ Index([na_value], dtype=dtype),
+ Index(["a"]),
+ ]
+ )
+ else:
+ expected_index = MultiIndex.from_arrays(
+ [
+ Index([na_value], dtype=dtype),
+ Index(["a"]),
+ ]
+ )
+ expected = Series(1, index=expected_index)
+ tm.assert_series_equal(result, expected)
| - [x] closes #56573 (Replace xxxx with the GitHub issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.
- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.
~Still needs a bit more testing (MultiIndex inputs).~ | https://api.github.com/repos/pandas-dev/pandas/pulls/56582 | 2023-12-20T22:54:02Z | 2023-12-21T20:59:20Z | 2023-12-21T20:59:20Z | 2024-02-14T01:30:52Z |
REF: Base class for all extension tests | diff --git a/ci/lint.sh b/ci/lint.sh
index fcd65fc5aba5e..545ac9c90c5c1 100755
--- a/ci/lint.sh
+++ b/ci/lint.sh
@@ -111,6 +111,15 @@ if [ "$LINT" ]; then
RET=1
fi
+ # Check for the following code in the extension array base tests
+ # tm.assert_frame_equal
+ # tm.assert_series_equal
+ grep -r -E --include '*.py' --exclude base.py 'tm.assert_(series|frame)_equal' pandas/tests/extension/base
+
+ if [ $? = "0" ]; then
+ RET=1
+ fi
+
echo "Check for invalid testing DONE"
# Check for imports from pandas.core.common instead
diff --git a/pandas/tests/extension/base/__init__.py b/pandas/tests/extension/base/__init__.py
index 2273ef1f3e110..27c106efd0524 100644
--- a/pandas/tests/extension/base/__init__.py
+++ b/pandas/tests/extension/base/__init__.py
@@ -31,6 +31,14 @@ class TestMyDtype(BaseDtypeTests):
Your class ``TestDtype`` will inherit all the tests defined on
``BaseDtypeTests``. pytest's fixture discover will supply your ``dtype``
wherever the test requires it. You're free to implement additional tests.
+
+All the tests in these modules use ``self.assert_frame_equal`` or
+``self.assert_series_equal`` for dataframe or series comparisons. By default,
+they use the usual ``pandas.testing.assert_frame_equal`` and
+``pandas.testing.assert_series_equal``. You can override the checks used
+by defining the staticmethods ``assert_frame_equal`` and
+``assert_series_equal`` on your base test class.
+
"""
from .casting import BaseCastingTests # noqa
from .constructors import BaseConstructorsTests # noqa
diff --git a/pandas/tests/extension/base/base.py b/pandas/tests/extension/base/base.py
new file mode 100644
index 0000000000000..d29587e635ebd
--- /dev/null
+++ b/pandas/tests/extension/base/base.py
@@ -0,0 +1,6 @@
+import pandas.util.testing as tm
+
+
+class BaseExtensionTests(object):
+ assert_series_equal = staticmethod(tm.assert_series_equal)
+ assert_frame_equal = staticmethod(tm.assert_frame_equal)
diff --git a/pandas/tests/extension/base/casting.py b/pandas/tests/extension/base/casting.py
index bcfbf0a247269..adc690939b36c 100644
--- a/pandas/tests/extension/base/casting.py
+++ b/pandas/tests/extension/base/casting.py
@@ -1,8 +1,10 @@
import pandas as pd
from pandas.core.internals import ObjectBlock
+from .base import BaseExtensionTests
-class BaseCastingTests(object):
+
+class BaseCastingTests(BaseExtensionTests):
"""Casting to and from ExtensionDtypes"""
def test_astype_object_series(self, all_data):
diff --git a/pandas/tests/extension/base/constructors.py b/pandas/tests/extension/base/constructors.py
index 7ad100e6289e9..2d5d747aec5a7 100644
--- a/pandas/tests/extension/base/constructors.py
+++ b/pandas/tests/extension/base/constructors.py
@@ -4,8 +4,10 @@
import pandas.util.testing as tm
from pandas.core.internals import ExtensionBlock
+from .base import BaseExtensionTests
-class BaseConstructorsTests(object):
+
+class BaseConstructorsTests(BaseExtensionTests):
def test_series_constructor(self, data):
result = pd.Series(data)
diff --git a/pandas/tests/extension/base/dtype.py b/pandas/tests/extension/base/dtype.py
index f5015bd469f13..63d3d807c270c 100644
--- a/pandas/tests/extension/base/dtype.py
+++ b/pandas/tests/extension/base/dtype.py
@@ -1,8 +1,10 @@
import numpy as np
import pandas as pd
+from .base import BaseExtensionTests
-class BaseDtypeTests(object):
+
+class BaseDtypeTests(BaseExtensionTests):
"""Base class for ExtensionDtype classes"""
def test_name(self, dtype):
diff --git a/pandas/tests/extension/base/getitem.py b/pandas/tests/extension/base/getitem.py
index f43971e928cac..31ed8b9e01225 100644
--- a/pandas/tests/extension/base/getitem.py
+++ b/pandas/tests/extension/base/getitem.py
@@ -1,20 +1,21 @@
import numpy as np
import pandas as pd
-import pandas.util.testing as tm
+from .base import BaseExtensionTests
-class BaseGetitemTests(object):
+
+class BaseGetitemTests(BaseExtensionTests):
"""Tests for ExtensionArray.__getitem__."""
def test_iloc_series(self, data):
ser = pd.Series(data)
result = ser.iloc[:4]
expected = pd.Series(data[:4])
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
result = ser.iloc[[0, 1, 2, 3]]
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
def test_iloc_frame(self, data):
df = pd.DataFrame({"A": data, 'B': np.arange(len(data))})
@@ -22,30 +23,30 @@ def test_iloc_frame(self, data):
# slice -> frame
result = df.iloc[:4, [0]]
- tm.assert_frame_equal(result, expected)
+ self.assert_frame_equal(result, expected)
# sequence -> frame
result = df.iloc[[0, 1, 2, 3], [0]]
- tm.assert_frame_equal(result, expected)
+ self.assert_frame_equal(result, expected)
expected = pd.Series(data[:4], name='A')
# slice -> series
result = df.iloc[:4, 0]
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
# sequence -> series
result = df.iloc[:4, 0]
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
def test_loc_series(self, data):
ser = pd.Series(data)
result = ser.loc[:3]
expected = pd.Series(data[:4])
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
result = ser.loc[[0, 1, 2, 3]]
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
def test_loc_frame(self, data):
df = pd.DataFrame({"A": data, 'B': np.arange(len(data))})
@@ -53,21 +54,21 @@ def test_loc_frame(self, data):
# slice -> frame
result = df.loc[:3, ['A']]
- tm.assert_frame_equal(result, expected)
+ self.assert_frame_equal(result, expected)
# sequence -> frame
result = df.loc[[0, 1, 2, 3], ['A']]
- tm.assert_frame_equal(result, expected)
+ self.assert_frame_equal(result, expected)
expected = pd.Series(data[:4], name='A')
# slice -> series
result = df.loc[:3, 'A']
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
# sequence -> series
result = df.loc[:3, 'A']
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
def test_getitem_scalar(self, data):
result = data[0]
diff --git a/pandas/tests/extension/base/interface.py b/pandas/tests/extension/base/interface.py
index 8f17131a9482b..e1596f0675f32 100644
--- a/pandas/tests/extension/base/interface.py
+++ b/pandas/tests/extension/base/interface.py
@@ -5,8 +5,10 @@
from pandas.core.dtypes.common import is_extension_array_dtype
from pandas.core.dtypes.dtypes import ExtensionDtype
+from .base import BaseExtensionTests
-class BaseInterfaceTests(object):
+
+class BaseInterfaceTests(BaseExtensionTests):
"""Tests that the basic interface is satisfied."""
# ------------------------------------------------------------------------
# Interface
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index c77811ca63926..74e5d180b1aa3 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -2,10 +2,11 @@
import numpy as np
import pandas as pd
-import pandas.util.testing as tm
+from .base import BaseExtensionTests
-class BaseMethodsTests(object):
+
+class BaseMethodsTests(BaseExtensionTests):
"""Various Series and DataFrame methods."""
@pytest.mark.parametrize('dropna', [True, False])
@@ -19,13 +20,13 @@ def test_value_counts(self, all_data, dropna):
result = pd.Series(all_data).value_counts(dropna=dropna).sort_index()
expected = pd.Series(other).value_counts(dropna=dropna).sort_index()
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
def test_count(self, data_missing):
df = pd.DataFrame({"A": data_missing})
result = df.count(axis='columns')
expected = pd.Series([0, 1])
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
def test_apply_simple_series(self, data):
result = pd.Series(data).apply(id)
diff --git a/pandas/tests/extension/base/missing.py b/pandas/tests/extension/base/missing.py
index 1d6f2eea1f1f9..3ae82fa1ca432 100644
--- a/pandas/tests/extension/base/missing.py
+++ b/pandas/tests/extension/base/missing.py
@@ -3,8 +3,10 @@
import pandas as pd
import pandas.util.testing as tm
+from .base import BaseExtensionTests
-class BaseMissingTests(object):
+
+class BaseMissingTests(BaseExtensionTests):
def test_isna(self, data_missing):
if data_missing._can_hold_na:
expected = np.array([True, False])
@@ -16,13 +18,13 @@ def test_isna(self, data_missing):
result = pd.Series(data_missing).isna()
expected = pd.Series(expected)
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
def test_dropna_series(self, data_missing):
ser = pd.Series(data_missing)
result = ser.dropna()
expected = ser.iloc[[1]]
- tm.assert_series_equal(result, expected)
+ self.assert_series_equal(result, expected)
def test_dropna_frame(self, data_missing):
df = pd.DataFrame({"A": data_missing})
@@ -30,16 +32,16 @@ def test_dropna_frame(self, data_missing):
# defaults
result = df.dropna()
expected = df.iloc[[1]]
- tm.assert_frame_equal(result, expected)
+ self.assert_frame_equal(result, expected)
# axis = 1
result = df.dropna(axis='columns')
expected = pd.DataFrame(index=[0, 1])
- tm.assert_frame_equal(result, expected)
+ self.assert_frame_equal(result, expected)
# multiple
df = pd.DataFrame({"A": data_missing,
"B": [1, np.nan]})
result = df.dropna()
expected = df.iloc[:0]
- tm.assert_frame_equal(result, expected)
+ self.assert_frame_equal(result, expected)
diff --git a/pandas/tests/extension/base/reshaping.py b/pandas/tests/extension/base/reshaping.py
index d8f577c6fa50d..cfb70f2291555 100644
--- a/pandas/tests/extension/base/reshaping.py
+++ b/pandas/tests/extension/base/reshaping.py
@@ -1,11 +1,12 @@
import pytest
import pandas as pd
-import pandas.util.testing as tm
from pandas.core.internals import ExtensionBlock
+from .base import BaseExtensionTests
-class BaseReshapingTests(object):
+
+class BaseReshapingTests(BaseExtensionTests):
"""Tests for reshaping and concatenation."""
@pytest.mark.parametrize('in_frame', [True, False])
def test_concat(self, data, in_frame):
@@ -32,8 +33,8 @@ def test_align(self, data, na_value):
# Assumes that the ctor can take a list of scalars of the type
e1 = pd.Series(type(data)(list(a) + [na_value]))
e2 = pd.Series(type(data)([na_value] + list(b)))
- tm.assert_series_equal(r1, e1)
- tm.assert_series_equal(r2, e2)
+ self.assert_series_equal(r1, e1)
+ self.assert_series_equal(r2, e2)
def test_align_frame(self, data, na_value):
a = data[:3]
@@ -45,17 +46,17 @@ def test_align_frame(self, data, na_value):
# Assumes that the ctor can take a list of scalars of the type
e1 = pd.DataFrame({'A': type(data)(list(a) + [na_value])})
e2 = pd.DataFrame({'A': type(data)([na_value] + list(b))})
- tm.assert_frame_equal(r1, e1)
- tm.assert_frame_equal(r2, e2)
+ self.assert_frame_equal(r1, e1)
+ self.assert_frame_equal(r2, e2)
def test_set_frame_expand_regular_with_extension(self, data):
df = pd.DataFrame({"A": [1] * len(data)})
df['B'] = data
expected = pd.DataFrame({"A": [1] * len(data), "B": data})
- tm.assert_frame_equal(df, expected)
+ self.assert_frame_equal(df, expected)
def test_set_frame_expand_extension_with_regular(self, data):
df = pd.DataFrame({'A': data})
df['B'] = [1] * len(data)
expected = pd.DataFrame({"A": data, "B": [1] * len(data)})
- tm.assert_frame_equal(df, expected)
+ self.assert_frame_equal(df, expected)
| Added the staticmethods
- assert_series_equal
- assert_frame_equal
to the base class. Useful for test cases like DecimalArray with NaNs,
since our assert_*_equal methods don't properly handle Decimal NaNs.
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
| https://api.github.com/repos/pandas-dev/pandas/pulls/19863 | 2018-02-23T12:09:25Z | 2018-02-24T15:19:19Z | 2018-02-24T15:19:19Z | 2018-05-02T13:10:24Z |
ENH: Let initialisation from dicts use insertion order for python >= 3.6 (part II) | diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 4cf7c8013aa2b..129ac6b06205c 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -99,9 +99,9 @@ def max_value(group):
applied = df.groupby('A').apply(max_value)
result = applied.get_dtype_counts().sort_values()
- expected = Series({'object': 2,
- 'float64': 2,
- 'int64': 1}).sort_values()
+ expected = Series({'float64': 2,
+ 'int64': 1,
+ 'object': 2}).sort_values()
assert_series_equal(result, expected)
def test_groupby_return_type(self):
@@ -244,7 +244,7 @@ def func_with_no_date(batch):
return pd.Series({'c': 2})
def func_with_date(batch):
- return pd.Series({'c': 2, 'b': datetime(2015, 1, 1)})
+ return pd.Series({'b': datetime(2015, 1, 1), 'c': 2})
dfg_no_conversion = df.groupby(by=['a']).apply(func_with_no_date)
dfg_no_conversion_expected = pd.DataFrame({'c': 2}, index=[1])
@@ -1628,8 +1628,8 @@ def f(g):
def test_apply_with_mixed_dtype(self):
# GH3480, apply with mixed dtype on axis=1 breaks in 0.11
- df = DataFrame({'foo1': ['one', 'two', 'two', 'three', 'one', 'two'],
- 'foo2': np.random.randn(6)})
+ df = DataFrame({'foo1': np.random.randn(6),
+ 'foo2': ['one', 'two', 'two', 'three', 'one', 'two']})
result = df.apply(lambda x: x, axis=1)
assert_series_equal(df.get_dtype_counts(), result.get_dtype_counts())
@@ -2113,10 +2113,10 @@ def test_multifunc_sum_bug(self):
def test_handle_dict_return_value(self):
def f(group):
- return {'min': group.min(), 'max': group.max()}
+ return {'max': group.max(), 'min': group.min()}
def g(group):
- return Series({'min': group.min(), 'max': group.max()})
+ return Series({'max': group.max(), 'min': group.min()})
result = self.df.groupby('A')['C'].apply(f)
expected = self.df.groupby('A')['C'].apply(g)
diff --git a/pandas/tests/groupby/test_transform.py b/pandas/tests/groupby/test_transform.py
index 4159d0f709a13..1be7dfdcc64e6 100644
--- a/pandas/tests/groupby/test_transform.py
+++ b/pandas/tests/groupby/test_transform.py
@@ -519,7 +519,9 @@ def test_cython_transform_frame(self, op, args, targop):
'timedelta': pd.timedelta_range(1, freq='s',
periods=1000),
'string': strings * 50,
- 'string_missing': strings_missing * 50})
+ 'string_missing': strings_missing * 50},
+ columns=['float', 'float_missing', 'int', 'datetime',
+ 'timedelta', 'string', 'string_missing'])
df['cat'] = df['string'].astype('category')
df2 = df.copy()
@@ -552,7 +554,9 @@ def test_cython_transform_frame(self, op, args, targop):
tm.assert_frame_equal(expected,
gb.transform(op, *args).sort_index(
axis=1))
- tm.assert_frame_equal(expected, getattr(gb, op)(*args))
+ tm.assert_frame_equal(
+ expected,
+ getattr(gb, op)(*args).sort_index(axis=1))
# individual columns
for c in df:
if c not in ['float', 'int', 'float_missing'
diff --git a/pandas/tests/indexing/test_ix.py b/pandas/tests/indexing/test_ix.py
index 3f71e673a4ffe..c84576c984525 100644
--- a/pandas/tests/indexing/test_ix.py
+++ b/pandas/tests/indexing/test_ix.py
@@ -53,13 +53,15 @@ def test_ix_loc_setitem_consistency(self):
# GH 8607
# ix setitem consistency
- df = DataFrame({'timestamp': [1413840976, 1413842580, 1413760580],
- 'delta': [1174, 904, 161],
- 'elapsed': [7673, 9277, 1470]})
- expected = DataFrame({'timestamp': pd.to_datetime(
- [1413840976, 1413842580, 1413760580], unit='s'),
- 'delta': [1174, 904, 161],
- 'elapsed': [7673, 9277, 1470]})
+ df = DataFrame({'delta': [1174, 904, 161],
+ 'elapsed': [7673, 9277, 1470],
+ 'timestamp': [1413840976, 1413842580, 1413760580]})
+ expected = DataFrame({'delta': [1174, 904, 161],
+ 'elapsed': [7673, 9277, 1470],
+ 'timestamp': pd.to_datetime(
+ [1413840976, 1413842580, 1413760580],
+ unit='s')
+ })
df2 = df.copy()
df2['timestamp'] = pd.to_datetime(df['timestamp'], unit='s')
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index dddba5b425c3b..03c071dbe4bc5 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -539,8 +539,8 @@ def test_east_asian_unicode_frame(self):
assert _rep(df) == expected
# column name
- df = DataFrame({u'あああああ': [1, 222, 33333, 4],
- 'b': [u'あ', u'いいい', u'う', u'ええええええ']},
+ df = DataFrame({'b': [u'あ', u'いいい', u'う', u'ええええええ'],
+ u'あああああ': [1, 222, 33333, 4]},
index=['a', 'bb', 'c', 'ddd'])
expected = (u" b あああああ\na あ 1\n"
u"bb いいい 222\nc う 33333\n"
@@ -647,8 +647,8 @@ def test_east_asian_unicode_frame(self):
assert _rep(df) == expected
# column name
- df = DataFrame({u'あああああ': [1, 222, 33333, 4],
- 'b': [u'あ', u'いいい', u'う', u'ええええええ']},
+ df = DataFrame({'b': [u'あ', u'いいい', u'う', u'ええええええ'],
+ u'あああああ': [1, 222, 33333, 4]},
index=['a', 'bb', 'c', 'ddd'])
expected = (u" b あああああ\n"
u"a あ 1\n"
@@ -733,8 +733,8 @@ def test_east_asian_unicode_frame(self):
assert _rep(df) == expected
# ambiguous unicode
- df = DataFrame({u'あああああ': [1, 222, 33333, 4],
- 'b': [u'あ', u'いいい', u'¡¡', u'ええええええ']},
+ df = DataFrame({'b': [u'あ', u'いいい', u'¡¡', u'ええええええ'],
+ u'あああああ': [1, 222, 33333, 4]},
index=['a', 'bb', 'c', '¡¡¡'])
expected = (u" b あああああ\n"
u"a あ 1\n"
diff --git a/pandas/tests/io/formats/test_to_latex.py b/pandas/tests/io/formats/test_to_latex.py
index f266a8b3a3268..5ebf196be094e 100644
--- a/pandas/tests/io/formats/test_to_latex.py
+++ b/pandas/tests/io/formats/test_to_latex.py
@@ -115,17 +115,18 @@ def test_to_latex_empty(self):
assert result == expected
def test_to_latex_with_formatters(self):
- df = DataFrame({'int': [1, 2, 3],
+ df = DataFrame({'datetime64': [datetime(2016, 1, 1),
+ datetime(2016, 2, 5),
+ datetime(2016, 3, 3)],
'float': [1.0, 2.0, 3.0],
+ 'int': [1, 2, 3],
'object': [(1, 2), True, False],
- 'datetime64': [datetime(2016, 1, 1),
- datetime(2016, 2, 5),
- datetime(2016, 3, 3)]})
+ })
- formatters = {'int': lambda x: '0x{x:x}'.format(x=x),
+ formatters = {'datetime64': lambda x: x.strftime('%Y-%m'),
'float': lambda x: '[{x: 4.1f}]'.format(x=x),
+ 'int': lambda x: '0x{x:x}'.format(x=x),
'object': lambda x: '-{x!s}-'.format(x=x),
- 'datetime64': lambda x: x.strftime('%Y-%m'),
'__index__': lambda x: 'index: {x}'.format(x=x)}
result = df.to_latex(formatters=dict(formatters))
@@ -347,10 +348,10 @@ def test_to_latex_escape(self):
a = 'a'
b = 'b'
- test_dict = {u('co^l1'): {a: "a",
- b: "b"},
- u('co$e^x$'): {a: "a",
- b: "b"}}
+ test_dict = {u('co$e^x$'): {a: "a",
+ b: "b"},
+ u('co^l1'): {a: "a",
+ b: "b"}}
unescaped_result = DataFrame(test_dict).to_latex(escape=False)
escaped_result = DataFrame(test_dict).to_latex(
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index a72744e08fa7c..7e497c395266f 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -553,7 +553,7 @@ def __str__(self):
def test_label_overflow(self):
# GH14256: buffer length not checked when writing label
- df = pd.DataFrame({'foo': [1337], 'bar' * 100000: [1]})
+ df = pd.DataFrame({'bar' * 100000: [1], 'foo': [1337]})
assert df.to_json() == \
'{{"{bar}":{{"0":1}},"foo":{{"0":1337}}}}'.format(
bar=('bar' * 100000))
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 101d34ebdb89f..5dca45c8dd8bb 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -588,18 +588,18 @@ def test_merge_on_datetime64tz(self):
result = pd.merge(left, right, on='key', how='outer')
assert_frame_equal(result, expected)
- left = pd.DataFrame({'value': pd.date_range('20151010', periods=2,
- tz='US/Eastern'),
- 'key': [1, 2]})
- right = pd.DataFrame({'value': pd.date_range('20151011', periods=2,
- tz='US/Eastern'),
- 'key': [2, 3]})
+ left = pd.DataFrame({'key': [1, 2],
+ 'value': pd.date_range('20151010', periods=2,
+ tz='US/Eastern')})
+ right = pd.DataFrame({'key': [2, 3],
+ 'value': pd.date_range('20151011', periods=2,
+ tz='US/Eastern')})
expected = DataFrame({
+ 'key': [1, 2, 3],
'value_x': list(pd.date_range('20151010', periods=2,
tz='US/Eastern')) + [pd.NaT],
'value_y': [pd.NaT] + list(pd.date_range('20151011', periods=2,
- tz='US/Eastern')),
- 'key': [1, 2, 3]})
+ tz='US/Eastern'))})
result = pd.merge(left, right, on='key', how='outer')
assert_frame_equal(result, expected)
assert result['value_x'].dtype == 'datetime64[ns, US/Eastern]'
@@ -632,18 +632,18 @@ def test_merge_on_periods(self):
result = pd.merge(left, right, on='key', how='outer')
assert_frame_equal(result, expected)
- left = pd.DataFrame({'value': pd.period_range('20151010', periods=2,
- freq='D'),
- 'key': [1, 2]})
- right = pd.DataFrame({'value': pd.period_range('20151011', periods=2,
- freq='D'),
- 'key': [2, 3]})
+ left = pd.DataFrame({'key': [1, 2],
+ 'value': pd.period_range('20151010', periods=2,
+ freq='D')})
+ right = pd.DataFrame({'key': [2, 3],
+ 'value': pd.period_range('20151011', periods=2,
+ freq='D')})
exp_x = pd.period_range('20151010', periods=2, freq='D')
exp_y = pd.period_range('20151011', periods=2, freq='D')
- expected = DataFrame({'value_x': list(exp_x) + [pd.NaT],
- 'value_y': [pd.NaT] + list(exp_y),
- 'key': [1, 2, 3]})
+ expected = DataFrame({'key': [1, 2, 3],
+ 'value_x': list(exp_x) + [pd.NaT],
+ 'value_y': [pd.NaT] + list(exp_y)})
result = pd.merge(left, right, on='key', how='outer')
assert_frame_equal(result, expected)
assert result['value_x'].dtype == 'object'
@@ -651,12 +651,13 @@ def test_merge_on_periods(self):
def test_indicator(self):
# PR #10054. xref #7412 and closes #8790.
- df1 = DataFrame({'col1': [0, 1], 'col_left': [
- 'a', 'b'], 'col_conflict': [1, 2]})
+ df1 = DataFrame({'col1': [0, 1], 'col_conflict': [1, 2],
+ 'col_left': ['a', 'b']})
df1_copy = df1.copy()
- df2 = DataFrame({'col1': [1, 2, 3, 4, 5], 'col_right': [2, 2, 2, 2, 2],
- 'col_conflict': [1, 2, 3, 4, 5]})
+ df2 = DataFrame({'col1': [1, 2, 3, 4, 5],
+ 'col_conflict': [1, 2, 3, 4, 5],
+ 'col_right': [2, 2, 2, 2, 2]})
df2_copy = df2.copy()
df_result = DataFrame({
diff --git a/pandas/tests/reshape/merge/test_merge_ordered.py b/pandas/tests/reshape/merge/test_merge_ordered.py
index 31c484a483d18..42d8eb7273ee1 100644
--- a/pandas/tests/reshape/merge/test_merge_ordered.py
+++ b/pandas/tests/reshape/merge/test_merge_ordered.py
@@ -83,9 +83,10 @@ def test_empty_sequence_concat(self):
pd.concat([pd.DataFrame(), None])
def test_doc_example(self):
- left = DataFrame({'key': ['a', 'c', 'e', 'a', 'c', 'e'],
+ left = DataFrame({'group': list('aaabbb'),
+ 'key': ['a', 'c', 'e', 'a', 'c', 'e'],
'lvalue': [1, 2, 3] * 2,
- 'group': list('aaabbb')})
+ })
right = DataFrame({'key': ['b', 'c', 'd'],
'rvalue': [1, 2, 3]})
diff --git a/pandas/tests/reshape/test_concat.py b/pandas/tests/reshape/test_concat.py
index 7e126dd56775b..11c3b733422cf 100644
--- a/pandas/tests/reshape/test_concat.py
+++ b/pandas/tests/reshape/test_concat.py
@@ -1542,10 +1542,10 @@ def test_concat_bug_2972(self):
def test_concat_bug_3602(self):
# GH 3602, duplicate columns
- df1 = DataFrame({'firmNo': [0, 0, 0, 0], 'stringvar': [
- 'rrr', 'rrr', 'rrr', 'rrr'], 'prc': [6, 6, 6, 6]})
- df2 = DataFrame({'misc': [1, 2, 3, 4], 'prc': [
- 6, 6, 6, 6], 'C': [9, 10, 11, 12]})
+ df1 = DataFrame({'firmNo': [0, 0, 0, 0], 'prc': [6, 6, 6, 6],
+ 'stringvar': ['rrr', 'rrr', 'rrr', 'rrr']})
+ df2 = DataFrame({'C': [9, 10, 11, 12], 'misc': [1, 2, 3, 4],
+ 'prc': [6, 6, 6, 6]})
expected = DataFrame([[0, 6, 'rrr', 9, 1, 6],
[0, 6, 'rrr', 10, 2, 6],
[0, 6, 'rrr', 11, 3, 6],
diff --git a/pandas/tests/reshape/test_melt.py b/pandas/tests/reshape/test_melt.py
index b7422dfd7e911..000b22d4fdd36 100644
--- a/pandas/tests/reshape/test_melt.py
+++ b/pandas/tests/reshape/test_melt.py
@@ -589,11 +589,11 @@ def test_nonnumeric_suffix(self):
def test_mixed_type_suffix(self):
df = pd.DataFrame({
- 'treatment_1': [1.0, 2.0],
- 'treatment_foo': [3.0, 4.0],
- 'result_foo': [5.0, 6.0],
+ 'A': ['X1', 'X2'],
'result_1': [0, 9],
- 'A': ['X1', 'X2']})
+ 'result_foo': [5.0, 6.0],
+ 'treatment_1': [1.0, 2.0],
+ 'treatment_foo': [3.0, 4.0]})
expected = pd.DataFrame({
'A': ['X1', 'X2', 'X1', 'X2'],
'colname': ['1', '1', 'foo', 'foo'],
diff --git a/pandas/tests/reshape/test_reshape.py b/pandas/tests/reshape/test_reshape.py
index a57c3c41b3637..c4d925b83585b 100644
--- a/pandas/tests/reshape/test_reshape.py
+++ b/pandas/tests/reshape/test_reshape.py
@@ -100,8 +100,8 @@ def test_basic_types(self, sparse, dtype):
expected_counts = {'int64': 1, 'object': 1}
expected_counts[dtype_name] = 3 + expected_counts.get(dtype_name, 0)
- expected = Series(expected_counts).sort_values()
- tm.assert_series_equal(result.get_dtype_counts().sort_values(),
+ expected = Series(expected_counts).sort_index()
+ tm.assert_series_equal(result.get_dtype_counts().sort_index(),
expected)
def test_just_na(self, sparse):
@@ -212,10 +212,10 @@ def test_dataframe_dummies_prefix_str(self, df, sparse):
def test_dataframe_dummies_subset(self, df, sparse):
result = get_dummies(df, prefix=['from_A'], columns=['A'],
sparse=sparse)
- expected = DataFrame({'from_A_a': [1, 0, 1],
- 'from_A_b': [0, 1, 0],
- 'B': ['b', 'b', 'c'],
- 'C': [1, 2, 3]}, dtype=np.uint8)
+ expected = DataFrame({'B': ['b', 'b', 'c'],
+ 'C': [1, 2, 3],
+ 'from_A_a': [1, 0, 1],
+ 'from_A_b': [0, 1, 0]}, dtype=np.uint8)
expected[['C']] = df[['C']]
assert_frame_equal(result, expected)
@@ -249,16 +249,16 @@ def test_dataframe_dummies_prefix_sep_bad_length(self, df, sparse):
def test_dataframe_dummies_prefix_dict(self, sparse):
prefixes = {'A': 'from_A', 'B': 'from_B'}
- df = DataFrame({'A': ['a', 'b', 'a'],
- 'B': ['b', 'b', 'c'],
- 'C': [1, 2, 3]})
+ df = DataFrame({'C': [1, 2, 3],
+ 'A': ['a', 'b', 'a'],
+ 'B': ['b', 'b', 'c']})
result = get_dummies(df, prefix=prefixes, sparse=sparse)
- expected = DataFrame({'from_A_a': [1, 0, 1],
+ expected = DataFrame({'C': [1, 2, 3],
+ 'from_A_a': [1, 0, 1],
'from_A_b': [0, 1, 0],
'from_B_b': [1, 1, 0],
- 'from_B_c': [0, 0, 1],
- 'C': [1, 2, 3]})
+ 'from_B_c': [0, 0, 1]})
columns = ['from_A_a', 'from_A_b', 'from_B_b', 'from_B_c']
expected[columns] = expected[columns].astype(np.uint8)
| - [x] xref #19018 and #19830
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
This PR is the second part of the preparation for allowing initialisation using insertion order for python>=3.6. See cross-referenced issues for details.
After this PR all tests will pass independent of dict initialisation rule, and then core/frame.py and core/series.py will be changed in the next PR to use insertion order for python>=3.6. | https://api.github.com/repos/pandas-dev/pandas/pulls/19859 | 2018-02-23T08:34:05Z | 2018-02-24T14:55:36Z | 2018-02-24T14:55:35Z | 2018-02-24T17:37:09Z |
DOC: Updated links to 2 tutorials in tutorials.rst | diff --git a/doc/source/tutorials.rst b/doc/source/tutorials.rst
index db9385519bff2..0398e2892cef5 100644
--- a/doc/source/tutorials.rst
+++ b/doc/source/tutorials.rst
@@ -26,32 +26,34 @@ repository <http://github.com/jvns/pandas-cookbook>`_. To run the examples in th
clone the GitHub repository and get IPython Notebook running.
See `How to use this cookbook <https://github.com/jvns/pandas-cookbook#how-to-use-this-cookbook>`_.
-- `A quick tour of the IPython Notebook: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/A%20quick%20tour%20of%20IPython%20Notebook.ipynb>`_
+- `A quick tour of the IPython Notebook: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/A%20quick%20tour%20of%20IPython%20Notebook.ipynb>`_
Shows off IPython's awesome tab completion and magic functions.
-- `Chapter 1: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%201%20-%20Reading%20from%20a%20CSV.ipynb>`_
+- `Chapter 1: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%201%20-%20Reading%20from%20a%20CSV.ipynb>`_
Reading your data into pandas is pretty much the easiest thing. Even
when the encoding is wrong!
-- `Chapter 2: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%202%20-%20Selecting%20data%20&%20finding%20the%20most%20common%20complaint%20type.ipynb>`_
+- `Chapter 2: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%202%20-%20Selecting%20data%20%26%20finding%20the%20most%20common%20complaint%20type.ipynb>`_
It's not totally obvious how to select data from a pandas dataframe.
Here we explain the basics (how to take slices and get columns)
-- `Chapter 3: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%203%20-%20Which%20borough%20has%20the%20most%20noise%20complaints%3F%20%28or%2C%20more%20selecting%20data%29.ipynb>`_
+- `Chapter 3: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%203%20-%20Which%20borough%20has%20the%20most%20noise%20complaints%20%28or%2C%20more%20selecting%20data%29.ipynb>`_
Here we get into serious slicing and dicing and learn how to filter
dataframes in complicated ways, really fast.
-- `Chapter 4: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%204%20-%20Find%20out%20on%20which%20weekday%20people%20bike%20the%20most%20with%20groupby%20and%20aggregate.ipynb>`_
+- `Chapter 4: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%204%20-%20Find%20out%20on%20which%20weekday%20people%20bike%20the%20most%20with%20groupby%20and%20aggregate.ipynb>`_
Groupby/aggregate is seriously my favorite thing about pandas
and I use it all the time. You should probably read this.
-- `Chapter 5: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%205%20-%20Combining%20dataframes%20and%20scraping%20Canadian%20weather%20data.ipynb>`_
+- `Chapter 5: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%205%20-%20Combining%20dataframes%20and%20scraping%20Canadian%20weather%20data.ipynb>`_
Here you get to find out if it's cold in Montreal in the winter
(spoiler: yes). Web scraping with pandas is fun! Here we combine dataframes.
-- `Chapter 6: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%206%20-%20String%20operations%21%20Which%20month%20was%20the%20snowiest%3F.ipynb>`_
+- `Chapter 6: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%206%20-%20String%20Operations-%20Which%20month%20was%20the%20snowiest.ipynb>`_
Strings with pandas are great. It has all these vectorized string
operations and they're the best. We will turn a bunch of strings
containing "Snow" into vectors of numbers in a trice.
-- `Chapter 7: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%207%20-%20Cleaning%20up%20messy%20data.ipynb>`_
+- `Chapter 7: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%207%20-%20Cleaning%20up%20messy%20data.ipynb>`_
Cleaning up messy data is never a joy, but with pandas it's easier.
-- `Chapter 8: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%208%20-%20How%20to%20deal%20with%20timestamps.ipynb>`_
+- `Chapter 8: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%208%20-%20How%20to%20deal%20with%20timestamps.ipynb>`_
Parsing Unix timestamps is confusing at first but it turns out
to be really easy.
+- `Chapter 9: <http://nbviewer.jupyter.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%209%20-%20Loading%20data%20from%20SQL%20databases.ipynb>`_
+ Reading data from SQL databases.
Lessons for new pandas users
| Two of the links to the [pandas-cookbook](https://github.com/jvns/pandas-cookbook) did not work for version `v0.2` of the documents. Now all links work. Where a version `v0.2` exists, it links to that version. In the remaining two cases, it now links to version `v0.1` instead of raising the `404: Page not found` error. | https://api.github.com/repos/pandas-dev/pandas/pulls/19857 | 2018-02-23T06:36:49Z | 2018-02-24T16:31:13Z | 2018-02-24T16:31:13Z | 2018-02-24T16:31:18Z |
ENH: Add option to disable MathJax (#19824). | diff --git a/doc/source/options.rst b/doc/source/options.rst
index cce16a5396377..a82be4d84bf3f 100644
--- a/doc/source/options.rst
+++ b/doc/source/options.rst
@@ -402,6 +402,10 @@ display.html.table_schema False Whether to publish a Table
display.html.border 1 A ``border=value`` attribute is
inserted in the ``<table>`` tag
for the DataFrame HTML repr.
+display.html.use_mathjax True When True, Jupyter notebook will process
+ table contents using MathJax, rendering
+ mathematical expressions enclosed by the
+ dollar symbol.
io.excel.xls.writer xlwt The default Excel writer engine for
'xls' files.
io.excel.xlsm.writer openpyxl The default Excel writer engine for
diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 08363cd54c606..f2c96ba3f53a8 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -337,6 +337,7 @@ Other Enhancements
- Added :func:`SeriesGroupBy.is_monotonic_increasing` and :func:`SeriesGroupBy.is_monotonic_decreasing` (:issue:`17015`)
- For subclassed ``DataFrames``, :func:`DataFrame.apply` will now preserve the ``Series`` subclass (if defined) when passing the data to the applied function (:issue:`19822`)
- :func:`DataFrame.from_dict` now accepts a ``columns`` argument that can be used to specify the column names when ``orient='index'`` is used (:issue:`18529`)
+- Added option ``display.html.use_mathjax`` so `MathJax <https://www.mathjax.org/>`_ can be disabled when rendering tables in ``Jupyter`` notebooks (:issue:`19856`, :issue:`19824`)
.. _whatsnew_0230.api_breaking:
diff --git a/pandas/core/config_init.py b/pandas/core/config_init.py
index da42cdbf10233..0edbf892172a9 100644
--- a/pandas/core/config_init.py
+++ b/pandas/core/config_init.py
@@ -207,6 +207,12 @@ def use_numexpr_cb(key):
(currently both are identical)
"""
+pc_html_use_mathjax_doc = """\
+: boolean
+ When True, Jupyter notebook will process table contents using MathJax,
+ rendering mathematical expressions enclosed by the dollar symbol.
+ (default: True)
+"""
pc_width_doc = """
: int
@@ -358,6 +364,8 @@ def table_schema_cb(key):
validator=is_bool, cb=table_schema_cb)
cf.register_option('html.border', 1, pc_html_border_doc,
validator=is_int)
+ cf.register_option('html.use_mathjax', True, pc_html_use_mathjax_doc,
+ validator=is_bool)
with cf.config_prefix('html'):
cf.register_option('border', 1, pc_html_border_doc,
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index 621641747f376..50b4f11634b78 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -1209,6 +1209,9 @@ def write_result(self, buf):
frame = self.frame
_classes = ['dataframe'] # Default class.
+ use_mathjax = get_option("display.html.use_mathjax")
+ if not use_mathjax:
+ _classes.append('tex2jax_ignore')
if self.classes is not None:
if isinstance(self.classes, str):
self.classes = self.classes.split()
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 525f487d8aa39..f876ceb8a26bf 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -325,9 +325,19 @@ def format_attr(pair):
.format(row=r, col=c)})
body.append(row_es)
+ table_attr = self.table_attributes
+ use_mathjax = get_option("display.html.use_mathjax")
+ if not use_mathjax:
+ table_attr = table_attr or ''
+ if 'class="' in table_attr:
+ table_attr = table_attr.replace('class="',
+ 'class="tex2jax_ignore ')
+ else:
+ table_attr += ' class="tex2jax_ignore"'
+
return dict(head=head, cellstyle=cellstyle, body=body, uuid=uuid,
precision=precision, table_styles=table_styles,
- caption=caption, table_attributes=self.table_attributes)
+ caption=caption, table_attributes=table_attr)
def format(self, formatter, subset=None):
"""
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 03c071dbe4bc5..6c3b75cdfa6df 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -1434,6 +1434,13 @@ def test_repr_html(self):
tm.reset_display_options()
+ def test_repr_html_mathjax(self):
+ df = DataFrame([[1, 2], [3, 4]])
+ assert 'tex2jax_ignore' not in df._repr_html_()
+
+ with pd.option_context('display.html.use_mathjax', False):
+ assert 'tex2jax_ignore' in df._repr_html_()
+
def test_repr_html_wide(self):
max_cols = get_option('display.max_columns')
df = DataFrame(tm.rands_array(25, size=(10, max_cols - 1)))
diff --git a/pandas/tests/io/formats/test_style.py b/pandas/tests/io/formats/test_style.py
index adf8e14b756c2..c1ab9cd184340 100644
--- a/pandas/tests/io/formats/test_style.py
+++ b/pandas/tests/io/formats/test_style.py
@@ -46,6 +46,13 @@ def test_init_series(self):
def test_repr_html_ok(self):
self.styler._repr_html_()
+ def test_repr_html_mathjax(self):
+ # gh-19824
+ assert 'tex2jax_ignore' not in self.styler._repr_html_()
+
+ with pd.option_context('display.html.use_mathjax', False):
+ assert 'tex2jax_ignore' in self.styler._repr_html_()
+
def test_update_ctx(self):
self.styler._update_ctx(self.attrs)
expected = {(0, 0): ['color: red'],
| This prevents MathJax from processing table contents:
<img width="599" alt="screen shot 2018-02-24 at 7 36 50 am" src="https://user-images.githubusercontent.com/1804856/36632244-0c07bdac-1939-11e8-85eb-0c22d42991d1.png">
I'm hoping for a code review, to find out if this might be accepted. If so, I'll add the tests/docs.
- [x] closes #19824
- [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/19856 | 2018-02-23T05:35:34Z | 2018-03-01T23:06:21Z | 2018-03-01T23:06:20Z | 2018-07-24T21:40:59Z |
BUG: names on union and intersection for Index were inconsistent (GH9943 GH9862) | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 6ace245a4bae1..f42cfc4d4c27f 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -1215,6 +1215,8 @@ Indexing
- Bug in `scalar in Index` if scalar is a float while the ``Index`` is of integer dtype (:issue:`22085`)
- Bug in `MultiIndex.set_levels` when levels value is not subscriptable (:issue:`23273`)
- Bug where setting a timedelta column by ``Index`` causes it to be casted to double, and therefore lose precision (:issue:`23511`)
+- Bug in :func:`Index.union` and :func:`Index.intersection` where name of the ``Index`` of the result was not computed correctly for certain cases (:issue:`9943`, :issue:`9862`)
+
Missing
^^^^^^^
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index ae64179b36485..7434a02043d65 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -61,7 +61,7 @@
import pandas.core.sorting as sorting
from pandas.io.formats.printing import (
pprint_thing, default_pprint, format_object_summary, format_object_attrs)
-from pandas.core.ops import make_invalid_op
+from pandas.core.ops import make_invalid_op, get_op_result_name
from pandas.core.strings import StringMethods
__all__ = ['Index']
@@ -1253,7 +1253,7 @@ def _convert_can_do_setop(self, other):
other = Index(other, name=self.name)
result_name = self.name
else:
- result_name = self.name if self.name == other.name else None
+ result_name = get_op_result_name(self, other)
return other, result_name
def _convert_for_op(self, value):
@@ -2745,19 +2745,15 @@ def __or__(self, other):
def __xor__(self, other):
return self.symmetric_difference(other)
- def _get_consensus_name(self, other):
+ def _get_reconciled_name_object(self, other):
"""
- Given 2 indexes, give a consensus name meaning
- we take the not None one, or None if the names differ.
- Return a new object if we are resetting the name
+ If the result of a set operation will be self,
+ return self, unless the name changes, in which
+ case make a shallow copy of self.
"""
- if self.name != other.name:
- if self.name is None or other.name is None:
- name = self.name or other.name
- else:
- name = None
- if self.name != name:
- return self._shallow_copy(name=name)
+ name = get_op_result_name(self, other)
+ if self.name != name:
+ return self._shallow_copy(name=name)
return self
def union(self, other):
@@ -2785,10 +2781,10 @@ def union(self, other):
other = ensure_index(other)
if len(other) == 0 or self.equals(other):
- return self._get_consensus_name(other)
+ return self._get_reconciled_name_object(other)
if len(self) == 0:
- return other._get_consensus_name(self)
+ return other._get_reconciled_name_object(self)
# TODO: is_dtype_union_equal is a hack around
# 1. buggy set ops with duplicates (GH #13432)
@@ -2851,11 +2847,10 @@ def union(self, other):
stacklevel=3)
# for subclasses
- return self._wrap_union_result(other, result)
+ return self._wrap_setop_result(other, result)
- def _wrap_union_result(self, other, result):
- name = self.name if self.name == other.name else None
- return self.__class__(result, name=name)
+ def _wrap_setop_result(self, other, result):
+ return self._constructor(result, name=get_op_result_name(self, other))
def intersection(self, other):
"""
@@ -2885,7 +2880,7 @@ def intersection(self, other):
other = ensure_index(other)
if self.equals(other):
- return self._get_consensus_name(other)
+ return self._get_reconciled_name_object(other)
if not is_dtype_equal(self.dtype, other.dtype):
this = self.astype('O')
@@ -2905,7 +2900,7 @@ def intersection(self, other):
if self.is_monotonic and other.is_monotonic:
try:
result = self._inner_indexer(lvals, rvals)[0]
- return self._wrap_union_result(other, result)
+ return self._wrap_setop_result(other, result)
except TypeError:
pass
@@ -4175,7 +4170,7 @@ def _join_monotonic(self, other, how='left', return_indexers=False):
return join_index
def _wrap_joined_index(self, joined, other):
- name = self.name if self.name == other.name else None
+ name = get_op_result_name(self, other)
return Index(joined, name=name)
def _get_string_slice(self, key, use_lhs=True, use_rhs=True):
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 278e395d65014..6e2f0b00fcd6e 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -25,6 +25,7 @@
import pandas.core.common as com
import pandas.core.missing as missing
import pandas.core.indexes.base as ibase
+from pandas.core.ops import get_op_result_name
from pandas.core.arrays.categorical import Categorical, contains
_index_doc_kwargs = dict(ibase._index_doc_kwargs)
@@ -324,6 +325,10 @@ def itemsize(self):
# Size of the items in categories, not codes.
return self.values.itemsize
+ def _wrap_setop_result(self, other, result):
+ name = get_op_result_name(self, other)
+ return self._shallow_copy(result, name=name)
+
def get_values(self):
""" return the underlying data as an ndarray """
return self._data.get_values()
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index bd6f0c68a9aa5..3a2f9986760d3 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -34,6 +34,7 @@
from pandas.core.indexes.base import Index, _index_shared_docs
from pandas.core.indexes.numeric import Int64Index
+from pandas.core.ops import get_op_result_name
import pandas.compat as compat
from pandas.tseries.frequencies import to_offset, Resolution
from pandas.core.indexes.datetimelike import (
@@ -592,6 +593,10 @@ def union(self, other):
y : Index or DatetimeIndex
"""
self._assert_can_do_setop(other)
+
+ if len(other) == 0 or self.equals(other) or len(self) == 0:
+ return super(DatetimeIndex, self).union(other)
+
if not isinstance(other, DatetimeIndex):
try:
other = DatetimeIndex(other)
@@ -674,7 +679,7 @@ def _maybe_utc_convert(self, other):
return this, other
def _wrap_joined_index(self, joined, other):
- name = self.name if self.name == other.name else None
+ name = get_op_result_name(self, other)
if (isinstance(other, DatetimeIndex) and
self.freq == other.freq and
self._can_fast_union(other)):
@@ -745,11 +750,11 @@ def _fast_union(self, other):
else:
return left
- def _wrap_union_result(self, other, result):
- name = self.name if self.name == other.name else None
+ def _wrap_setop_result(self, other, result):
+ name = get_op_result_name(self, other)
if not timezones.tz_compare(self.tz, other.tz):
raise ValueError('Passed item and index have different timezone')
- return self._simple_new(result, name=name, freq=None, tz=self.tz)
+ return self._shallow_copy(result, name=name, freq=None, tz=self.tz)
def intersection(self, other):
"""
@@ -765,6 +770,10 @@ def intersection(self, other):
y : Index or DatetimeIndex
"""
self._assert_can_do_setop(other)
+
+ if self.equals(other):
+ return self._get_reconciled_name_object(other)
+
if not isinstance(other, DatetimeIndex):
try:
other = DatetimeIndex(other)
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index b86921b5579ed..79239ec90ac80 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -25,6 +25,7 @@
from pandas.core.indexes.base import (
Index, ensure_index,
default_pprint, _index_shared_docs)
+from pandas.core.ops import get_op_result_name
from pandas._libs import Timestamp, Timedelta
from pandas._libs.interval import (
@@ -1048,7 +1049,7 @@ def func(self, other):
raise TypeError(msg.format(op=op_name))
result = getattr(self._multiindex, op_name)(other._multiindex)
- result_name = self.name if self.name == other.name else None
+ result_name = get_op_result_name(self, other)
# GH 19101: ensure empty results have correct dtype
if result.empty:
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index 420b862ae16a4..795ffeefa1794 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -21,7 +21,7 @@
from pandas.util._decorators import Appender, cache_readonly
import pandas.core.dtypes.concat as _concat
import pandas.core.indexes.base as ibase
-
+from pandas.core.ops import get_op_result_name
_num_index_shared_docs = dict()
@@ -215,7 +215,7 @@ def _convert_scalar_indexer(self, key, kind=None):
._convert_scalar_indexer(key, kind=kind))
def _wrap_joined_index(self, joined, other):
- name = self.name if self.name == other.name else None
+ name = get_op_result_name(self, other)
return Int64Index(joined, name=name)
@classmethod
@@ -288,7 +288,7 @@ def _convert_index_indexer(self, keyarr):
return keyarr
def _wrap_joined_index(self, joined, other):
- name = self.name if self.name == other.name else None
+ name = get_op_result_name(self, other)
return UInt64Index(joined, name=name)
@classmethod
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 7e11ca5dbfcef..92ffaea521d7f 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -12,9 +12,9 @@
is_integer_dtype,
is_datetime64_any_dtype,
is_bool_dtype,
- pandas_dtype,
+ pandas_dtype
)
-
+from pandas.core.ops import get_op_result_name
from pandas.core.accessor import PandasDelegate, delegate_names
from pandas.core.indexes.datetimes import DatetimeIndex, Int64Index, Index
from pandas.core.indexes.datetimelike import (
@@ -848,8 +848,8 @@ def _assert_can_do_setop(self, other):
msg = DIFFERENT_FREQ_INDEX.format(self.freqstr, other.freqstr)
raise IncompatibleFrequency(msg)
- def _wrap_union_result(self, other, result):
- name = self.name if self.name == other.name else None
+ def _wrap_setop_result(self, other, result):
+ name = get_op_result_name(self, other)
result = self._apply_meta(result)
result.name = name
return result
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 673ab9f2118a4..d1b5645928921 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -5,7 +5,7 @@
import numpy as np
-from pandas._libs import index as libindex
+from pandas._libs import index as libindex, lib
import pandas.compat as compat
from pandas.compat import get_range_parameters, lrange, range
from pandas.compat.numpy import function as nv
@@ -263,8 +263,9 @@ def tolist(self):
@Appender(_index_shared_docs['_shallow_copy'])
def _shallow_copy(self, values=None, **kwargs):
if values is None:
+ name = kwargs.get("name", self.name)
return RangeIndex._simple_new(
- name=self.name, **dict(self._get_data_as_items()))
+ name=name, **dict(self._get_data_as_items()))
else:
kwargs.setdefault('name', self.name)
return self._int64index._shallow_copy(values, **kwargs)
@@ -344,6 +345,10 @@ def intersection(self, other):
-------
intersection : Index
"""
+
+ if self.equals(other):
+ return self._get_reconciled_name_object(other)
+
if not isinstance(other, RangeIndex):
return super(RangeIndex, self).intersection(other)
@@ -424,10 +429,9 @@ def union(self, other):
union : Index
"""
self._assert_can_do_setop(other)
- if len(other) == 0 or self.equals(other):
- return self
- if len(self) == 0:
- return other
+ if len(other) == 0 or self.equals(other) or len(self) == 0:
+ return super(RangeIndex, self).union(other)
+
if isinstance(other, RangeIndex):
start_s, step_s = self._start, self._step
end_s = self._start + self._step * (len(self) - 1)
@@ -498,7 +502,12 @@ def __getitem__(self, key):
super_getitem = super(RangeIndex, self).__getitem__
if is_scalar(key):
- n = int(key)
+ if not lib.is_integer(key):
+ raise IndexError("only integers, slices (`:`), "
+ "ellipsis (`...`), numpy.newaxis (`None`) "
+ "and integer or boolean "
+ "arrays are valid indices")
+ n = com.cast_scalar_indexer(key)
if n != key:
return super_getitem(key)
if n < 0:
@@ -649,7 +658,8 @@ def _evaluate_numeric_binop(self, other):
return op(self._int64index, other)
# TODO: Do attrs get handled reliably?
- return _evaluate_numeric_binop
+ name = '__{name}__'.format(name=op.__name__)
+ return compat.set_function_name(_evaluate_numeric_binop, name, cls)
cls.__add__ = _make_evaluate_binop(operator.add)
cls.__radd__ = _make_evaluate_binop(ops.radd)
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 33361c851a4c5..5b077a6984114 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -26,6 +26,7 @@
from pandas.core.base import _shared_docs
from pandas.core.indexes.base import _index_shared_docs
import pandas.core.common as com
+from pandas.core.ops import get_op_result_name
import pandas.core.dtypes.concat as _concat
from pandas.util._decorators import Appender, Substitution
from pandas.core.indexes.datetimelike import (
@@ -281,6 +282,10 @@ def union(self, other):
y : Index or TimedeltaIndex
"""
self._assert_can_do_setop(other)
+
+ if len(other) == 0 or self.equals(other) or len(self) == 0:
+ return super(TimedeltaIndex, self).union(other)
+
if not isinstance(other, TimedeltaIndex):
try:
other = TimedeltaIndex(other)
@@ -313,7 +318,7 @@ def join(self, other, how='left', level=None, return_indexers=False,
sort=sort)
def _wrap_joined_index(self, joined, other):
- name = self.name if self.name == other.name else None
+ name = get_op_result_name(self, other)
if (isinstance(other, TimedeltaIndex) and self.freq == other.freq and
self._can_fast_union(other)):
joined = self._shallow_copy(joined, name=name)
@@ -373,10 +378,6 @@ def _fast_union(self, other):
else:
return left
- def _wrap_union_result(self, other, result):
- name = self.name if self.name == other.name else None
- return self._simple_new(result, name=name, freq=None)
-
def intersection(self, other):
"""
Specialized intersection for TimedeltaIndex objects. May be much faster
@@ -391,6 +392,10 @@ def intersection(self, other):
y : Index or TimedeltaIndex
"""
self._assert_can_do_setop(other)
+
+ if self.equals(other):
+ return self._get_reconciled_name_object(other)
+
if not isinstance(other, TimedeltaIndex):
try:
other = TimedeltaIndex(other)
diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py
index 468b1610a9142..c5cbaea23df76 100644
--- a/pandas/tests/indexes/common.py
+++ b/pandas/tests/indexes/common.py
@@ -360,10 +360,10 @@ def test_has_duplicates(self, indices):
def test_duplicated(self, indices, keep):
if type(indices) is not self._holder:
pytest.skip('Can only check if we know the index type')
- if not len(indices) or isinstance(indices, MultiIndex):
+ if not len(indices) or isinstance(indices, (MultiIndex, RangeIndex)):
# MultiIndex tested separately in:
# tests/indexes/multi/test_unique_and_duplicates
- pytest.skip('Skip check for empty Index and MultiIndex')
+ pytest.skip('Skip check for empty Index, MultiIndex, RangeIndex')
idx = self._holder(indices)
if idx.has_duplicates:
diff --git a/pandas/tests/indexes/conftest.py b/pandas/tests/indexes/conftest.py
index 8cfed33a96ac5..e82cce873e75c 100644
--- a/pandas/tests/indexes/conftest.py
+++ b/pandas/tests/indexes/conftest.py
@@ -15,6 +15,7 @@
tm.makeTimedeltaIndex(100),
tm.makeIntIndex(100),
tm.makeUIntIndex(100),
+ tm.makeRangeIndex(100),
tm.makeFloatIndex(100),
Index([True, False]),
tm.makeCategoricalIndex(100),
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index daebc6e95aac4..724dffc49dd3b 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -786,6 +786,67 @@ def test_intersect_str_dates(self):
assert len(result) == 0
+ @pytest.mark.parametrize(
+ 'fname, sname, expected_name',
+ [
+ ('A', 'A', 'A'),
+ ('A', 'B', None),
+ ('A', None, None),
+ (None, 'B', None),
+ (None, None, None),
+ ])
+ def test_corner_union(self, indices, fname, sname, expected_name):
+ # GH 9943 9862
+ # Test unions with various name combinations
+ # Do not test MultiIndex or repeats
+
+ if isinstance(indices, MultiIndex) or not indices.is_unique:
+ pytest.skip("Not for MultiIndex or repeated indices")
+
+ # Test copy.union(copy)
+ first = indices.copy().set_names(fname)
+ second = indices.copy().set_names(sname)
+ union = first.union(second)
+ expected = indices.copy().set_names(expected_name)
+ tm.assert_index_equal(union, expected)
+
+ # Test copy.union(empty)
+ first = indices.copy().set_names(fname)
+ second = indices.drop(indices).set_names(sname)
+ union = first.union(second)
+ expected = indices.copy().set_names(expected_name)
+ tm.assert_index_equal(union, expected)
+
+ # Test empty.union(copy)
+ first = indices.drop(indices).set_names(fname)
+ second = indices.copy().set_names(sname)
+ union = first.union(second)
+ expected = indices.copy().set_names(expected_name)
+ tm.assert_index_equal(union, expected)
+
+ # Test empty.union(empty)
+ first = indices.drop(indices).set_names(fname)
+ second = indices.drop(indices).set_names(sname)
+ union = first.union(second)
+ expected = indices.drop(indices).set_names(expected_name)
+ tm.assert_index_equal(union, expected)
+
+ def test_chained_union(self):
+ # Chained unions handles names correctly
+ i1 = Index([1, 2], name='i1')
+ i2 = Index([3, 4], name='i2')
+ i3 = Index([5, 6], name='i3')
+ union = i1.union(i2.union(i3))
+ expected = i1.union(i2).union(i3)
+ tm.assert_index_equal(union, expected)
+
+ j1 = Index([1, 2], name='j1')
+ j2 = Index([], name='j2')
+ j3 = Index([], name='j3')
+ union = j1.union(j2.union(j3))
+ expected = j1.union(j2).union(j3)
+ tm.assert_index_equal(union, expected)
+
def test_union(self):
# TODO: Replace with fixturesult
first = self.strIndex[5:20]
@@ -824,7 +885,7 @@ def test_union_identity(self):
@pytest.mark.parametrize("first_list", [list('ab'), list()])
@pytest.mark.parametrize("second_list", [list('ab'), list()])
@pytest.mark.parametrize("first_name, second_name, expected_name", [
- ('A', 'B', None), (None, 'B', 'B'), ('A', None, 'A')])
+ ('A', 'B', None), (None, 'B', None), ('A', None, None)])
def test_union_name_preservation(self, first_list, second_list, first_name,
second_name, expected_name):
first = Index(first_list, name=first_name)
diff --git a/pandas/tests/reshape/test_concat.py b/pandas/tests/reshape/test_concat.py
index 23bf8896409c9..c632a9fe31faa 100644
--- a/pandas/tests/reshape/test_concat.py
+++ b/pandas/tests/reshape/test_concat.py
@@ -2290,10 +2290,10 @@ def test_concat_categoricalindex(self):
result = pd.concat([a, b, c], axis=1)
- exp_idx = pd.CategoricalIndex([0, 1, 2, 9])
- exp = pd.DataFrame({0: [1, np.nan, np.nan, 1],
- 1: [2, 2, np.nan, np.nan],
- 2: [np.nan, 3, 3, np.nan]},
+ exp_idx = pd.CategoricalIndex([9, 0, 1, 2], categories=categories)
+ exp = pd.DataFrame({0: [1, 1, np.nan, np.nan],
+ 1: [np.nan, 2, 2, np.nan],
+ 2: [np.nan, np.nan, 3, 3]},
columns=[0, 1, 2],
index=exp_idx)
tm.assert_frame_equal(result, exp)
| xref #9943
closes #9862
- [x] tests added / passed
- Added tests to check names on unions when Index has different values
- Fixed test for ranges with unions
- Added tests for all index types for corner cases for union, difference
- Added tests so that `index.intersection(empty_index)==index.difference(index)`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Also fixes bug in `Index.difference` when computing `index.difference(index)`
| https://api.github.com/repos/pandas-dev/pandas/pulls/19849 | 2018-02-22T22:05:05Z | 2018-11-06T18:21:48Z | 2018-11-06T18:21:48Z | 2019-07-12T17:21:39Z |
Separate TimedeltaIndex mul/div tests | diff --git a/pandas/tests/indexes/datetimes/test_datetime.py b/pandas/tests/indexes/datetimes/test_datetime.py
index 2cf33644377ab..b685584a29fb9 100644
--- a/pandas/tests/indexes/datetimes/test_datetime.py
+++ b/pandas/tests/indexes/datetimes/test_datetime.py
@@ -2,7 +2,7 @@
import pytest
import numpy as np
-from datetime import date, timedelta, time
+from datetime import date
import dateutil
import pandas as pd
@@ -18,112 +18,6 @@
class TestDatetimeIndex(object):
- def test_get_loc(self):
- idx = pd.date_range('2000-01-01', periods=3)
-
- for method in [None, 'pad', 'backfill', 'nearest']:
- assert idx.get_loc(idx[1], method) == 1
- assert idx.get_loc(idx[1].to_pydatetime(), method) == 1
- assert idx.get_loc(str(idx[1]), method) == 1
-
- if method is not None:
- assert idx.get_loc(idx[1], method,
- tolerance=pd.Timedelta('0 days')) == 1
-
- assert idx.get_loc('2000-01-01', method='nearest') == 0
- assert idx.get_loc('2000-01-01T12', method='nearest') == 1
-
- assert idx.get_loc('2000-01-01T12', method='nearest',
- tolerance='1 day') == 1
- assert idx.get_loc('2000-01-01T12', method='nearest',
- tolerance=pd.Timedelta('1D')) == 1
- assert idx.get_loc('2000-01-01T12', method='nearest',
- tolerance=np.timedelta64(1, 'D')) == 1
- assert idx.get_loc('2000-01-01T12', method='nearest',
- tolerance=timedelta(1)) == 1
- with tm.assert_raises_regex(ValueError,
- 'unit abbreviation w/o a number'):
- idx.get_loc('2000-01-01T12', method='nearest', tolerance='foo')
- with pytest.raises(KeyError):
- idx.get_loc('2000-01-01T03', method='nearest', tolerance='2 hours')
- with pytest.raises(
- ValueError,
- match='tolerance size must match target index size'):
- idx.get_loc('2000-01-01', method='nearest',
- tolerance=[pd.Timedelta('1day').to_timedelta64(),
- pd.Timedelta('1day').to_timedelta64()])
-
- assert idx.get_loc('2000', method='nearest') == slice(0, 3)
- assert idx.get_loc('2000-01', method='nearest') == slice(0, 3)
-
- assert idx.get_loc('1999', method='nearest') == 0
- assert idx.get_loc('2001', method='nearest') == 2
-
- with pytest.raises(KeyError):
- idx.get_loc('1999', method='pad')
- with pytest.raises(KeyError):
- idx.get_loc('2001', method='backfill')
-
- with pytest.raises(KeyError):
- idx.get_loc('foobar')
- with pytest.raises(TypeError):
- idx.get_loc(slice(2))
-
- idx = pd.to_datetime(['2000-01-01', '2000-01-04'])
- assert idx.get_loc('2000-01-02', method='nearest') == 0
- assert idx.get_loc('2000-01-03', method='nearest') == 1
- assert idx.get_loc('2000-01', method='nearest') == slice(0, 2)
-
- # time indexing
- idx = pd.date_range('2000-01-01', periods=24, freq='H')
- tm.assert_numpy_array_equal(idx.get_loc(time(12)),
- np.array([12]), check_dtype=False)
- tm.assert_numpy_array_equal(idx.get_loc(time(12, 30)),
- np.array([]), check_dtype=False)
- with pytest.raises(NotImplementedError):
- idx.get_loc(time(12, 30), method='pad')
-
- def test_get_indexer(self):
- idx = pd.date_range('2000-01-01', periods=3)
- exp = np.array([0, 1, 2], dtype=np.intp)
- tm.assert_numpy_array_equal(idx.get_indexer(idx), exp)
-
- target = idx[0] + pd.to_timedelta(['-1 hour', '12 hours',
- '1 day 1 hour'])
- tm.assert_numpy_array_equal(idx.get_indexer(target, 'pad'),
- np.array([-1, 0, 1], dtype=np.intp))
- tm.assert_numpy_array_equal(idx.get_indexer(target, 'backfill'),
- np.array([0, 1, 2], dtype=np.intp))
- tm.assert_numpy_array_equal(idx.get_indexer(target, 'nearest'),
- np.array([0, 1, 1], dtype=np.intp))
- tm.assert_numpy_array_equal(
- idx.get_indexer(target, 'nearest',
- tolerance=pd.Timedelta('1 hour')),
- np.array([0, -1, 1], dtype=np.intp))
- tol_raw = [pd.Timedelta('1 hour'),
- pd.Timedelta('1 hour'),
- pd.Timedelta('1 hour').to_timedelta64(), ]
- tm.assert_numpy_array_equal(
- idx.get_indexer(target, 'nearest',
- tolerance=[np.timedelta64(x) for x in tol_raw]),
- np.array([0, -1, 1], dtype=np.intp))
- tol_bad = [pd.Timedelta('2 hour').to_timedelta64(),
- pd.Timedelta('1 hour').to_timedelta64(),
- 'foo', ]
- with pytest.raises(
- ValueError, match='abbreviation w/o a number'):
- idx.get_indexer(target, 'nearest', tolerance=tol_bad)
- with pytest.raises(ValueError):
- idx.get_indexer(idx[[0]], method='nearest', tolerance='foo')
-
- def test_reasonable_keyerror(self):
- # GH #1062
- index = DatetimeIndex(['1/3/2000'])
- try:
- index.get_loc('1/1/2000')
- except KeyError as e:
- assert '2000' in str(e)
-
def test_roundtrip_pickle_with_tz(self):
# GH 8367
diff --git a/pandas/tests/indexes/datetimes/test_indexing.py b/pandas/tests/indexes/datetimes/test_indexing.py
index a9f1a5e608ac7..af65a8618d30f 100644
--- a/pandas/tests/indexes/datetimes/test_indexing.py
+++ b/pandas/tests/indexes/datetimes/test_indexing.py
@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timedelta, time
import pytest
import pytz
@@ -12,10 +12,93 @@
START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
-class TestDatetimeIndex(object):
+class TestGetItem(object):
+ def test_getitem(self):
+ idx1 = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx')
+ idx2 = pd.date_range('2011-01-01', '2011-01-31', freq='D',
+ tz='Asia/Tokyo', name='idx')
- def test_where_other(self):
+ for idx in [idx1, idx2]:
+ result = idx[0]
+ assert result == Timestamp('2011-01-01', tz=idx.tz)
+
+ result = idx[0:5]
+ expected = pd.date_range('2011-01-01', '2011-01-05', freq='D',
+ tz=idx.tz, name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.freq == expected.freq
+
+ result = idx[0:10:2]
+ expected = pd.date_range('2011-01-01', '2011-01-09', freq='2D',
+ tz=idx.tz, name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.freq == expected.freq
+
+ result = idx[-20:-5:3]
+ expected = pd.date_range('2011-01-12', '2011-01-24', freq='3D',
+ tz=idx.tz, name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.freq == expected.freq
+
+ result = idx[4::-1]
+ expected = DatetimeIndex(['2011-01-05', '2011-01-04', '2011-01-03',
+ '2011-01-02', '2011-01-01'],
+ freq='-1D', tz=idx.tz, name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.freq == expected.freq
+
+ def test_dti_business_getitem(self):
+ rng = pd.bdate_range(START, END)
+ smaller = rng[:5]
+ exp = DatetimeIndex(rng.view(np.ndarray)[:5])
+ tm.assert_index_equal(smaller, exp)
+
+ assert smaller.offset == rng.offset
+
+ sliced = rng[::5]
+ assert sliced.offset == BDay() * 5
+ fancy_indexed = rng[[4, 3, 2, 1, 0]]
+ assert len(fancy_indexed) == 5
+ assert isinstance(fancy_indexed, DatetimeIndex)
+ assert fancy_indexed.freq is None
+
+ # 32-bit vs. 64-bit platforms
+ assert rng[4] == rng[np.int_(4)]
+
+ def test_dti_business_getitem_matplotlib_hackaround(self):
+ rng = pd.bdate_range(START, END)
+ values = rng[:, None]
+ expected = rng.values[:, None]
+ tm.assert_numpy_array_equal(values, expected)
+
+ def test_dti_custom_getitem(self):
+ rng = pd.bdate_range(START, END, freq='C')
+ smaller = rng[:5]
+ exp = DatetimeIndex(rng.view(np.ndarray)[:5])
+ tm.assert_index_equal(smaller, exp)
+ assert smaller.offset == rng.offset
+
+ sliced = rng[::5]
+ assert sliced.offset == CDay() * 5
+
+ fancy_indexed = rng[[4, 3, 2, 1, 0]]
+ assert len(fancy_indexed) == 5
+ assert isinstance(fancy_indexed, DatetimeIndex)
+ assert fancy_indexed.freq is None
+
+ # 32-bit vs. 64-bit platforms
+ assert rng[4] == rng[np.int_(4)]
+
+ def test_dti_custom_getitem_matplotlib_hackaround(self):
+ rng = pd.bdate_range(START, END, freq='C')
+ values = rng[:, None]
+ expected = rng.values[:, None]
+ tm.assert_numpy_array_equal(values, expected)
+
+
+class TestWhere(object):
+ def test_where_other(self):
# other is ndarray or Index
i = pd.date_range('20130101', periods=3, tz='US/Eastern')
@@ -46,6 +129,152 @@ def test_where_tz(self):
expected = i2
tm.assert_index_equal(result, expected)
+
+class TestTake(object):
+ def test_take(self):
+ # GH#10295
+ idx1 = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx')
+ idx2 = pd.date_range('2011-01-01', '2011-01-31', freq='D',
+ tz='Asia/Tokyo', name='idx')
+
+ for idx in [idx1, idx2]:
+ result = idx.take([0])
+ assert result == Timestamp('2011-01-01', tz=idx.tz)
+
+ result = idx.take([0, 1, 2])
+ expected = pd.date_range('2011-01-01', '2011-01-03', freq='D',
+ tz=idx.tz, name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.freq == expected.freq
+
+ result = idx.take([0, 2, 4])
+ expected = pd.date_range('2011-01-01', '2011-01-05', freq='2D',
+ tz=idx.tz, name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.freq == expected.freq
+
+ result = idx.take([7, 4, 1])
+ expected = pd.date_range('2011-01-08', '2011-01-02', freq='-3D',
+ tz=idx.tz, name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.freq == expected.freq
+
+ result = idx.take([3, 2, 5])
+ expected = DatetimeIndex(['2011-01-04', '2011-01-03',
+ '2011-01-06'],
+ freq=None, tz=idx.tz, name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.freq is None
+
+ result = idx.take([-3, 2, 5])
+ expected = DatetimeIndex(['2011-01-29', '2011-01-03',
+ '2011-01-06'],
+ freq=None, tz=idx.tz, name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.freq is None
+
+ def test_take_invalid_kwargs(self):
+ idx = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx')
+ indices = [1, 6, 5, 9, 10, 13, 15, 3]
+
+ msg = r"take\(\) got an unexpected keyword argument 'foo'"
+ tm.assert_raises_regex(TypeError, msg, idx.take,
+ indices, foo=2)
+
+ msg = "the 'out' parameter is not supported"
+ tm.assert_raises_regex(ValueError, msg, idx.take,
+ indices, out=indices)
+
+ msg = "the 'mode' parameter is not supported"
+ tm.assert_raises_regex(ValueError, msg, idx.take,
+ indices, mode='clip')
+
+ # TODO: This method came from test_datetime; de-dup with version above
+ @pytest.mark.parametrize('tz', [None, 'US/Eastern', 'Asia/Tokyo'])
+ def test_take2(self, tz):
+ dates = [datetime(2010, 1, 1, 14), datetime(2010, 1, 1, 15),
+ datetime(2010, 1, 1, 17), datetime(2010, 1, 1, 21)]
+
+ idx = DatetimeIndex(start='2010-01-01 09:00',
+ end='2010-02-01 09:00', freq='H', tz=tz,
+ name='idx')
+ expected = DatetimeIndex(dates, freq=None, name='idx', tz=tz)
+
+ taken1 = idx.take([5, 6, 8, 12])
+ taken2 = idx[[5, 6, 8, 12]]
+
+ for taken in [taken1, taken2]:
+ tm.assert_index_equal(taken, expected)
+ assert isinstance(taken, DatetimeIndex)
+ assert taken.freq is None
+ assert taken.tz == expected.tz
+ assert taken.name == expected.name
+
+ def test_take_fill_value(self):
+ # GH#12631
+ idx = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
+ name='xxx')
+ result = idx.take(np.array([1, 0, -1]))
+ expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
+ name='xxx')
+ tm.assert_index_equal(result, expected)
+
+ # fill_value
+ result = idx.take(np.array([1, 0, -1]), fill_value=True)
+ expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', 'NaT'],
+ name='xxx')
+ tm.assert_index_equal(result, expected)
+
+ # allow_fill=False
+ result = idx.take(np.array([1, 0, -1]), allow_fill=False,
+ fill_value=True)
+ expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
+ name='xxx')
+ tm.assert_index_equal(result, expected)
+
+ msg = ('When allow_fill=True and fill_value is not None, '
+ 'all indices must be >= -1')
+ with tm.assert_raises_regex(ValueError, msg):
+ idx.take(np.array([1, 0, -2]), fill_value=True)
+ with tm.assert_raises_regex(ValueError, msg):
+ idx.take(np.array([1, 0, -5]), fill_value=True)
+
+ with pytest.raises(IndexError):
+ idx.take(np.array([1, -5]))
+
+ def test_take_fill_value_with_timezone(self):
+ idx = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
+ name='xxx', tz='US/Eastern')
+ result = idx.take(np.array([1, 0, -1]))
+ expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
+ name='xxx', tz='US/Eastern')
+ tm.assert_index_equal(result, expected)
+
+ # fill_value
+ result = idx.take(np.array([1, 0, -1]), fill_value=True)
+ expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', 'NaT'],
+ name='xxx', tz='US/Eastern')
+ tm.assert_index_equal(result, expected)
+
+ # allow_fill=False
+ result = idx.take(np.array([1, 0, -1]), allow_fill=False,
+ fill_value=True)
+ expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
+ name='xxx', tz='US/Eastern')
+ tm.assert_index_equal(result, expected)
+
+ msg = ('When allow_fill=True and fill_value is not None, '
+ 'all indices must be >= -1')
+ with tm.assert_raises_regex(ValueError, msg):
+ idx.take(np.array([1, 0, -2]), fill_value=True)
+ with tm.assert_raises_regex(ValueError, msg):
+ idx.take(np.array([1, 0, -5]), fill_value=True)
+
+ with pytest.raises(IndexError):
+ idx.take(np.array([1, -5]))
+
+
+class TestDatetimeIndex(object):
@pytest.mark.parametrize('null', [None, np.nan, pd.NaT])
@pytest.mark.parametrize('tz', [None, 'UTC', 'US/Eastern'])
def test_insert_nat(self, tz, null):
@@ -253,233 +482,108 @@ def test_delete_slice(self):
assert result.freq == expected.freq
assert result.tz == expected.tz
- def test_getitem(self):
- idx1 = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx')
- idx2 = pd.date_range('2011-01-01', '2011-01-31', freq='D',
- tz='Asia/Tokyo', name='idx')
-
- for idx in [idx1, idx2]:
- result = idx[0]
- assert result == Timestamp('2011-01-01', tz=idx.tz)
-
- result = idx[0:5]
- expected = pd.date_range('2011-01-01', '2011-01-05', freq='D',
- tz=idx.tz, name='idx')
- tm.assert_index_equal(result, expected)
- assert result.freq == expected.freq
-
- result = idx[0:10:2]
- expected = pd.date_range('2011-01-01', '2011-01-09', freq='2D',
- tz=idx.tz, name='idx')
- tm.assert_index_equal(result, expected)
- assert result.freq == expected.freq
-
- result = idx[-20:-5:3]
- expected = pd.date_range('2011-01-12', '2011-01-24', freq='3D',
- tz=idx.tz, name='idx')
- tm.assert_index_equal(result, expected)
- assert result.freq == expected.freq
-
- result = idx[4::-1]
- expected = DatetimeIndex(['2011-01-05', '2011-01-04', '2011-01-03',
- '2011-01-02', '2011-01-01'],
- freq='-1D', tz=idx.tz, name='idx')
- tm.assert_index_equal(result, expected)
- assert result.freq == expected.freq
-
- def test_take(self):
- # GH 10295
- idx1 = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx')
- idx2 = pd.date_range('2011-01-01', '2011-01-31', freq='D',
- tz='Asia/Tokyo', name='idx')
-
- for idx in [idx1, idx2]:
- result = idx.take([0])
- assert result == Timestamp('2011-01-01', tz=idx.tz)
-
- result = idx.take([0, 1, 2])
- expected = pd.date_range('2011-01-01', '2011-01-03', freq='D',
- tz=idx.tz, name='idx')
- tm.assert_index_equal(result, expected)
- assert result.freq == expected.freq
-
- result = idx.take([0, 2, 4])
- expected = pd.date_range('2011-01-01', '2011-01-05', freq='2D',
- tz=idx.tz, name='idx')
- tm.assert_index_equal(result, expected)
- assert result.freq == expected.freq
-
- result = idx.take([7, 4, 1])
- expected = pd.date_range('2011-01-08', '2011-01-02', freq='-3D',
- tz=idx.tz, name='idx')
- tm.assert_index_equal(result, expected)
- assert result.freq == expected.freq
-
- result = idx.take([3, 2, 5])
- expected = DatetimeIndex(['2011-01-04', '2011-01-03',
- '2011-01-06'],
- freq=None, tz=idx.tz, name='idx')
- tm.assert_index_equal(result, expected)
- assert result.freq is None
-
- result = idx.take([-3, 2, 5])
- expected = DatetimeIndex(['2011-01-29', '2011-01-03',
- '2011-01-06'],
- freq=None, tz=idx.tz, name='idx')
- tm.assert_index_equal(result, expected)
- assert result.freq is None
-
- def test_take_invalid_kwargs(self):
- idx = pd.date_range('2011-01-01', '2011-01-31', freq='D', name='idx')
- indices = [1, 6, 5, 9, 10, 13, 15, 3]
-
- msg = r"take\(\) got an unexpected keyword argument 'foo'"
- tm.assert_raises_regex(TypeError, msg, idx.take,
- indices, foo=2)
-
- msg = "the 'out' parameter is not supported"
- tm.assert_raises_regex(ValueError, msg, idx.take,
- indices, out=indices)
-
- msg = "the 'mode' parameter is not supported"
- tm.assert_raises_regex(ValueError, msg, idx.take,
- indices, mode='clip')
-
- # TODO: This method came from test_datetime; de-dup with version above
- @pytest.mark.parametrize('tz', [None, 'US/Eastern', 'Asia/Tokyo'])
- def test_take2(self, tz):
- dates = [datetime(2010, 1, 1, 14), datetime(2010, 1, 1, 15),
- datetime(2010, 1, 1, 17), datetime(2010, 1, 1, 21)]
-
- idx = DatetimeIndex(start='2010-01-01 09:00',
- end='2010-02-01 09:00', freq='H', tz=tz,
- name='idx')
- expected = DatetimeIndex(dates, freq=None, name='idx', tz=tz)
-
- taken1 = idx.take([5, 6, 8, 12])
- taken2 = idx[[5, 6, 8, 12]]
-
- for taken in [taken1, taken2]:
- tm.assert_index_equal(taken, expected)
- assert isinstance(taken, DatetimeIndex)
- assert taken.freq is None
- assert taken.tz == expected.tz
- assert taken.name == expected.name
-
- def test_take_fill_value(self):
- # GH 12631
- idx = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
- name='xxx')
- result = idx.take(np.array([1, 0, -1]))
- expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
- name='xxx')
- tm.assert_index_equal(result, expected)
-
- # fill_value
- result = idx.take(np.array([1, 0, -1]), fill_value=True)
- expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', 'NaT'],
- name='xxx')
- tm.assert_index_equal(result, expected)
-
- # allow_fill=False
- result = idx.take(np.array([1, 0, -1]), allow_fill=False,
- fill_value=True)
- expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
- name='xxx')
- tm.assert_index_equal(result, expected)
-
- msg = ('When allow_fill=True and fill_value is not None, '
- 'all indices must be >= -1')
- with tm.assert_raises_regex(ValueError, msg):
- idx.take(np.array([1, 0, -2]), fill_value=True)
- with tm.assert_raises_regex(ValueError, msg):
- idx.take(np.array([1, 0, -5]), fill_value=True)
-
- with pytest.raises(IndexError):
- idx.take(np.array([1, -5]))
-
- def test_take_fill_value_with_timezone(self):
- idx = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
- name='xxx', tz='US/Eastern')
- result = idx.take(np.array([1, 0, -1]))
- expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
- name='xxx', tz='US/Eastern')
- tm.assert_index_equal(result, expected)
-
- # fill_value
- result = idx.take(np.array([1, 0, -1]), fill_value=True)
- expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', 'NaT'],
- name='xxx', tz='US/Eastern')
- tm.assert_index_equal(result, expected)
-
- # allow_fill=False
- result = idx.take(np.array([1, 0, -1]), allow_fill=False,
- fill_value=True)
- expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
- name='xxx', tz='US/Eastern')
- tm.assert_index_equal(result, expected)
-
- msg = ('When allow_fill=True and fill_value is not None, '
- 'all indices must be >= -1')
- with tm.assert_raises_regex(ValueError, msg):
- idx.take(np.array([1, 0, -2]), fill_value=True)
- with tm.assert_raises_regex(ValueError, msg):
- idx.take(np.array([1, 0, -5]), fill_value=True)
-
- with pytest.raises(IndexError):
- idx.take(np.array([1, -5]))
-
-
-class TestBusinessDatetimeIndexIndexing(object):
- def setup_method(self, method):
- self.rng = pd.bdate_range(START, END)
-
- def test_getitem(self):
- smaller = self.rng[:5]
- exp = DatetimeIndex(self.rng.view(np.ndarray)[:5])
- tm.assert_index_equal(smaller, exp)
-
- assert smaller.offset == self.rng.offset
-
- sliced = self.rng[::5]
- assert sliced.offset == BDay() * 5
-
- fancy_indexed = self.rng[[4, 3, 2, 1, 0]]
- assert len(fancy_indexed) == 5
- assert isinstance(fancy_indexed, DatetimeIndex)
- assert fancy_indexed.freq is None
-
- # 32-bit vs. 64-bit platforms
- assert self.rng[4] == self.rng[np.int_(4)]
-
- def test_getitem_matplotlib_hackaround(self):
- values = self.rng[:, None]
- expected = self.rng.values[:, None]
- tm.assert_numpy_array_equal(values, expected)
-
-
-class TestCustomDatetimeIndexIndexing(object):
- def setup_method(self, method):
- self.rng = pd.bdate_range(START, END, freq='C')
-
- def test_getitem(self):
- smaller = self.rng[:5]
- exp = DatetimeIndex(self.rng.view(np.ndarray)[:5])
- tm.assert_index_equal(smaller, exp)
- assert smaller.offset == self.rng.offset
-
- sliced = self.rng[::5]
- assert sliced.offset == CDay() * 5
-
- fancy_indexed = self.rng[[4, 3, 2, 1, 0]]
- assert len(fancy_indexed) == 5
- assert isinstance(fancy_indexed, DatetimeIndex)
- assert fancy_indexed.freq is None
-
- # 32-bit vs. 64-bit platforms
- assert self.rng[4] == self.rng[np.int_(4)]
-
- def test_getitem_matplotlib_hackaround(self):
- values = self.rng[:, None]
- expected = self.rng.values[:, None]
- tm.assert_numpy_array_equal(values, expected)
+ def test_get_loc(self):
+ idx = pd.date_range('2000-01-01', periods=3)
+
+ for method in [None, 'pad', 'backfill', 'nearest']:
+ assert idx.get_loc(idx[1], method) == 1
+ assert idx.get_loc(idx[1].to_pydatetime(), method) == 1
+ assert idx.get_loc(str(idx[1]), method) == 1
+
+ if method is not None:
+ assert idx.get_loc(idx[1], method,
+ tolerance=pd.Timedelta('0 days')) == 1
+
+ assert idx.get_loc('2000-01-01', method='nearest') == 0
+ assert idx.get_loc('2000-01-01T12', method='nearest') == 1
+
+ assert idx.get_loc('2000-01-01T12', method='nearest',
+ tolerance='1 day') == 1
+ assert idx.get_loc('2000-01-01T12', method='nearest',
+ tolerance=pd.Timedelta('1D')) == 1
+ assert idx.get_loc('2000-01-01T12', method='nearest',
+ tolerance=np.timedelta64(1, 'D')) == 1
+ assert idx.get_loc('2000-01-01T12', method='nearest',
+ tolerance=timedelta(1)) == 1
+ with tm.assert_raises_regex(ValueError,
+ 'unit abbreviation w/o a number'):
+ idx.get_loc('2000-01-01T12', method='nearest', tolerance='foo')
+ with pytest.raises(KeyError):
+ idx.get_loc('2000-01-01T03', method='nearest', tolerance='2 hours')
+ with pytest.raises(
+ ValueError,
+ match='tolerance size must match target index size'):
+ idx.get_loc('2000-01-01', method='nearest',
+ tolerance=[pd.Timedelta('1day').to_timedelta64(),
+ pd.Timedelta('1day').to_timedelta64()])
+
+ assert idx.get_loc('2000', method='nearest') == slice(0, 3)
+ assert idx.get_loc('2000-01', method='nearest') == slice(0, 3)
+
+ assert idx.get_loc('1999', method='nearest') == 0
+ assert idx.get_loc('2001', method='nearest') == 2
+
+ with pytest.raises(KeyError):
+ idx.get_loc('1999', method='pad')
+ with pytest.raises(KeyError):
+ idx.get_loc('2001', method='backfill')
+
+ with pytest.raises(KeyError):
+ idx.get_loc('foobar')
+ with pytest.raises(TypeError):
+ idx.get_loc(slice(2))
+
+ idx = pd.to_datetime(['2000-01-01', '2000-01-04'])
+ assert idx.get_loc('2000-01-02', method='nearest') == 0
+ assert idx.get_loc('2000-01-03', method='nearest') == 1
+ assert idx.get_loc('2000-01', method='nearest') == slice(0, 2)
+
+ # time indexing
+ idx = pd.date_range('2000-01-01', periods=24, freq='H')
+ tm.assert_numpy_array_equal(idx.get_loc(time(12)),
+ np.array([12]), check_dtype=False)
+ tm.assert_numpy_array_equal(idx.get_loc(time(12, 30)),
+ np.array([]), check_dtype=False)
+ with pytest.raises(NotImplementedError):
+ idx.get_loc(time(12, 30), method='pad')
+
+ def test_get_indexer(self):
+ idx = pd.date_range('2000-01-01', periods=3)
+ exp = np.array([0, 1, 2], dtype=np.intp)
+ tm.assert_numpy_array_equal(idx.get_indexer(idx), exp)
+
+ target = idx[0] + pd.to_timedelta(['-1 hour', '12 hours',
+ '1 day 1 hour'])
+ tm.assert_numpy_array_equal(idx.get_indexer(target, 'pad'),
+ np.array([-1, 0, 1], dtype=np.intp))
+ tm.assert_numpy_array_equal(idx.get_indexer(target, 'backfill'),
+ np.array([0, 1, 2], dtype=np.intp))
+ tm.assert_numpy_array_equal(idx.get_indexer(target, 'nearest'),
+ np.array([0, 1, 1], dtype=np.intp))
+ tm.assert_numpy_array_equal(
+ idx.get_indexer(target, 'nearest',
+ tolerance=pd.Timedelta('1 hour')),
+ np.array([0, -1, 1], dtype=np.intp))
+ tol_raw = [pd.Timedelta('1 hour'),
+ pd.Timedelta('1 hour'),
+ pd.Timedelta('1 hour').to_timedelta64(), ]
+ tm.assert_numpy_array_equal(
+ idx.get_indexer(target, 'nearest',
+ tolerance=[np.timedelta64(x) for x in tol_raw]),
+ np.array([0, -1, 1], dtype=np.intp))
+ tol_bad = [pd.Timedelta('2 hour').to_timedelta64(),
+ pd.Timedelta('1 hour').to_timedelta64(),
+ 'foo', ]
+ with pytest.raises(
+ ValueError, match='abbreviation w/o a number'):
+ idx.get_indexer(target, 'nearest', tolerance=tol_bad)
+ with pytest.raises(ValueError):
+ idx.get_indexer(idx[[0]], method='nearest', tolerance='foo')
+
+ def test_reasonable_keyerror(self):
+ # GH#1062
+ index = DatetimeIndex(['1/3/2000'])
+ try:
+ index.get_loc('1/1/2000')
+ except KeyError as e:
+ assert '2000' in str(e)
diff --git a/pandas/tests/indexes/period/test_indexing.py b/pandas/tests/indexes/period/test_indexing.py
index b913934195260..6b8e2203e83fd 100644
--- a/pandas/tests/indexes/period/test_indexing.py
+++ b/pandas/tests/indexes/period/test_indexing.py
@@ -6,9 +6,9 @@
import pandas as pd
from pandas.util import testing as tm
from pandas.compat import lrange
-from pandas._libs import tslib, tslibs
+from pandas._libs import tslibs
from pandas import (PeriodIndex, Series, DatetimeIndex,
- period_range, Period)
+ period_range, Period, notna)
from pandas._libs.tslibs import period as libperiod
@@ -119,7 +119,7 @@ def test_getitem_datetime(self):
def test_getitem_nat(self):
idx = pd.PeriodIndex(['2011-01', 'NaT', '2011-02'], freq='M')
assert idx[0] == pd.Period('2011-01', freq='M')
- assert idx[1] is tslib.NaT
+ assert idx[1] is pd.NaT
s = pd.Series([0, 1, 2], index=idx)
assert s[pd.NaT] == 1
@@ -127,7 +127,7 @@ def test_getitem_nat(self):
s = pd.Series(idx, index=idx)
assert (s[pd.Period('2011-01', freq='M')] ==
pd.Period('2011-01', freq='M'))
- assert s[pd.NaT] is tslib.NaT
+ assert s[pd.NaT] is pd.NaT
def test_getitem_list_periods(self):
# GH 7710
@@ -190,31 +190,43 @@ def test_getitem_day(self):
s[v]
-class TestIndexing(object):
+class TestWhere(object):
+ @pytest.mark.parametrize('klass', [list, tuple, np.array, Series])
+ def test_where(self, klass):
+ i = period_range('20130101', periods=5, freq='D')
+ cond = [True] * len(i)
+ expected = i
+ result = i.where(klass(cond))
+ tm.assert_index_equal(result, expected)
- def test_get_loc_msg(self):
- idx = period_range('2000-1-1', freq='A', periods=10)
- bad_period = Period('2012', 'A')
- pytest.raises(KeyError, idx.get_loc, bad_period)
+ cond = [False] + [True] * (len(i) - 1)
+ expected = PeriodIndex([pd.NaT] + i[1:].tolist(), freq='D')
+ result = i.where(klass(cond))
+ tm.assert_index_equal(result, expected)
- try:
- idx.get_loc(bad_period)
- except KeyError as inst:
- assert inst.args[0] == bad_period
+ def test_where_other(self):
+ i = period_range('20130101', periods=5, freq='D')
+ for arr in [np.nan, pd.NaT]:
+ result = i.where(notna(i), other=np.nan)
+ expected = i
+ tm.assert_index_equal(result, expected)
- def test_get_loc_nat(self):
- didx = DatetimeIndex(['2011-01-01', 'NaT', '2011-01-03'])
- pidx = PeriodIndex(['2011-01-01', 'NaT', '2011-01-03'], freq='M')
+ i2 = i.copy()
+ i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(),
+ freq='D')
+ result = i.where(notna(i2), i2)
+ tm.assert_index_equal(result, i2)
- # check DatetimeIndex compat
- for idx in [didx, pidx]:
- assert idx.get_loc(pd.NaT) == 1
- assert idx.get_loc(None) == 1
- assert idx.get_loc(float('nan')) == 1
- assert idx.get_loc(np.nan) == 1
+ i2 = i.copy()
+ i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(),
+ freq='D')
+ result = i.where(notna(i2), i2.values)
+ tm.assert_index_equal(result, i2)
+
+class TestTake(object):
def test_take(self):
- # GH 10295
+ # GH#10295
idx1 = pd.period_range('2011-01-01', '2011-01-31', freq='D',
name='idx')
@@ -278,7 +290,7 @@ def test_take_misc(self):
assert taken.name == expected.name
def test_take_fill_value(self):
- # GH 12631
+ # GH#12631
idx = pd.PeriodIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
name='xxx', freq='D')
result = idx.take(np.array([1, 0, -1]))
@@ -309,6 +321,30 @@ def test_take_fill_value(self):
with pytest.raises(IndexError):
idx.take(np.array([1, -5]))
+
+class TestIndexing(object):
+
+ def test_get_loc_msg(self):
+ idx = period_range('2000-1-1', freq='A', periods=10)
+ bad_period = Period('2012', 'A')
+ pytest.raises(KeyError, idx.get_loc, bad_period)
+
+ try:
+ idx.get_loc(bad_period)
+ except KeyError as inst:
+ assert inst.args[0] == bad_period
+
+ def test_get_loc_nat(self):
+ didx = DatetimeIndex(['2011-01-01', 'NaT', '2011-01-03'])
+ pidx = PeriodIndex(['2011-01-01', 'NaT', '2011-01-03'], freq='M')
+
+ # check DatetimeIndex compat
+ for idx in [didx, pidx]:
+ assert idx.get_loc(pd.NaT) == 1
+ assert idx.get_loc(None) == 1
+ assert idx.get_loc(float('nan')) == 1
+ assert idx.get_loc(np.nan) == 1
+
def test_get_loc(self):
# GH 17717
p0 = pd.Period('2017-09-01')
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index dd437363cfc1d..4548d7fa1a468 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -5,7 +5,7 @@
import pandas as pd
import pandas.util._test_decorators as td
from pandas.util import testing as tm
-from pandas import (PeriodIndex, period_range, notna, DatetimeIndex, NaT,
+from pandas import (PeriodIndex, period_range, DatetimeIndex, NaT,
Index, Period, Series, DataFrame, date_range,
offsets)
@@ -33,38 +33,9 @@ def test_pickle_round_trip(self, freq):
result = tm.round_trip_pickle(idx)
tm.assert_index_equal(result, idx)
- @pytest.mark.parametrize('klass', [list, tuple, np.array, Series])
- def test_where(self, klass):
- i = self.create_index()
- cond = [True] * len(i)
- expected = i
- result = i.where(klass(cond))
- tm.assert_index_equal(result, expected)
-
- cond = [False] + [True] * (len(i) - 1)
- expected = PeriodIndex([NaT] + i[1:].tolist(), freq='D')
- result = i.where(klass(cond))
- tm.assert_index_equal(result, expected)
-
- def test_where_other(self):
-
- i = self.create_index()
- for arr in [np.nan, pd.NaT]:
- result = i.where(notna(i), other=np.nan)
- expected = i
- tm.assert_index_equal(result, expected)
-
- i2 = i.copy()
- i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(),
- freq='D')
- result = i.where(notna(i2), i2)
- tm.assert_index_equal(result, i2)
-
- i2 = i.copy()
- i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(),
- freq='D')
- result = i.where(notna(i2), i2.values)
- tm.assert_index_equal(result, i2)
+ def test_where(self):
+ # This is handled in test_indexing
+ pass
def test_repeat(self):
# GH10183
diff --git a/pandas/tests/indexes/timedeltas/test_arithmetic.py b/pandas/tests/indexes/timedeltas/test_arithmetic.py
index 24341b3419859..282501860f7e5 100644
--- a/pandas/tests/indexes/timedeltas/test_arithmetic.py
+++ b/pandas/tests/indexes/timedeltas/test_arithmetic.py
@@ -123,8 +123,149 @@ def test_comparisons_nat(self):
tm.assert_numpy_array_equal(result, expected)
+class TestTimedeltaIndexMultiplicationDivision(object):
+ # __mul__, __rmul__,
+ # __div__, __rdiv__, __floordiv__, __rfloordiv__,
+ # __mod__, __rmod__, __divmod__, __rdivmod__
+
+ # -------------------------------------------------------------
+ # Multiplication
+ # organized with scalar others first, then array-like
+
+ def test_tdi_mul_int(self):
+ idx = TimedeltaIndex(np.arange(5, dtype='int64'))
+ result = idx * 1
+ tm.assert_index_equal(result, idx)
+
+ def test_tdi_rmul_int(self):
+ idx = TimedeltaIndex(np.arange(5, dtype='int64'))
+ result = 1 * idx
+ tm.assert_index_equal(result, idx)
+
+ def test_tdi_mul_tdlike_scalar_raises(self, delta):
+ rng = timedelta_range('1 days', '10 days', name='foo')
+ with pytest.raises(TypeError):
+ rng * delta
+
+ def test_tdi_mul_int_array_zerodim(self):
+ rng5 = np.arange(5, dtype='int64')
+ idx = TimedeltaIndex(rng5)
+ expected = TimedeltaIndex(rng5 * 5)
+ result = idx * np.array(5, dtype='int64')
+ tm.assert_index_equal(result, expected)
+
+ def test_tdi_mul_int_array(self):
+ rng5 = np.arange(5, dtype='int64')
+ idx = TimedeltaIndex(rng5)
+ didx = TimedeltaIndex(rng5 ** 2)
+
+ result = idx * rng5
+ tm.assert_index_equal(result, didx)
+
+ def test_tdi_mul_dti_raises(self):
+ idx = TimedeltaIndex(np.arange(5, dtype='int64'))
+ with pytest.raises(TypeError):
+ idx * idx
+
+ def test_tdi_mul_too_short_raises(self):
+ idx = TimedeltaIndex(np.arange(5, dtype='int64'))
+ with pytest.raises(TypeError):
+ idx * TimedeltaIndex(np.arange(3))
+ with pytest.raises(ValueError):
+ idx * np.array([1, 2])
+
+ def test_tdi_mul_int_series(self):
+ idx = TimedeltaIndex(np.arange(5, dtype='int64'))
+ didx = TimedeltaIndex(np.arange(5, dtype='int64') ** 2)
+
+ result = idx * Series(np.arange(5, dtype='int64'))
+
+ tm.assert_series_equal(result, Series(didx))
+
+ def test_tdi_mul_float_series(self):
+ idx = TimedeltaIndex(np.arange(5, dtype='int64'))
+
+ rng5f = np.arange(5, dtype='float64')
+ result = idx * Series(rng5f + 0.1)
+ expected = Series(TimedeltaIndex(rng5f * (rng5f + 0.1)))
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('other', [np.arange(1, 11),
+ pd.Int64Index(range(1, 11)),
+ pd.UInt64Index(range(1, 11)),
+ pd.Float64Index(range(1, 11)),
+ pd.RangeIndex(1, 11)])
+ def test_tdi_rmul_arraylike(self, other):
+ tdi = TimedeltaIndex(['1 Day'] * 10)
+ expected = timedelta_range('1 days', '10 days')
+
+ result = other * tdi
+ tm.assert_index_equal(result, expected)
+ commute = tdi * other
+ tm.assert_index_equal(commute, expected)
+
+ # -------------------------------------------------------------
+ # TimedeltaIndex.__div__
+
+ def test_tdi_div_int(self):
+ idx = TimedeltaIndex(np.arange(5, dtype='int64'))
+ result = idx / 1
+ tm.assert_index_equal(result, idx)
+
+ def test_tdi_div_tdlike_scalar(self, delta):
+ rng = timedelta_range('1 days', '10 days', name='foo')
+ expected = Int64Index((np.arange(10) + 1) * 12, name='foo')
+
+ result = rng / delta
+ tm.assert_index_equal(result, expected, exact=False)
+
+ def test_tdi_div_tdlike_scalar_with_nat(self, delta):
+ rng = TimedeltaIndex(['1 days', pd.NaT, '2 days'], name='foo')
+ expected = Float64Index([12, np.nan, 24], name='foo')
+ result = rng / delta
+ tm.assert_index_equal(result, expected)
+
+ def test_tdi_div_nat_raises(self):
+ # don't allow division by NaT (make could in the future)
+ rng = timedelta_range('1 days', '10 days', name='foo')
+ with pytest.raises(TypeError):
+ rng / pd.NaT
+
+ # -------------------------------------------------------------
+ # TimedeltaIndex.__floordiv__
+
+ def test_tdi_floordiv_int(self):
+ idx = TimedeltaIndex(np.arange(5, dtype='int64'))
+ result = idx // 1
+ tm.assert_index_equal(result, idx)
+
+ def test_tdi_floordiv_tdlike_scalar(self, delta):
+ tdi = timedelta_range('1 days', '10 days', name='foo')
+ expected = Int64Index((np.arange(10) + 1) * 12, name='foo')
+
+ result = tdi // delta
+ tm.assert_index_equal(result, expected, exact=False)
+
+ @pytest.mark.parametrize('scalar_td', [
+ timedelta(minutes=10, seconds=7),
+ Timedelta('10m7s'),
+ Timedelta('10m7s').to_timedelta64()])
+ def test_tdi_floordiv_timedelta_scalar(self, scalar_td):
+ # GH#19125
+ tdi = TimedeltaIndex(['00:05:03', '00:05:03', pd.NaT], freq=None)
+ expected = pd.Index([2.0, 2.0, np.nan])
+
+ res = tdi.__rfloordiv__(scalar_td)
+ tm.assert_index_equal(res, expected)
+
+ expected = pd.Index([0.0, 0.0, np.nan])
+
+ res = tdi // (scalar_td)
+ tm.assert_index_equal(res, expected)
+
+
class TestTimedeltaIndexArithmetic(object):
- _holder = TimedeltaIndex
+ # Addition and Subtraction Operations
# -------------------------------------------------------------
# Invalid Operations
@@ -138,6 +279,20 @@ def test_tdi_add_str_invalid(self):
with pytest.raises(TypeError):
'a' + tdi
+ @pytest.mark.parametrize('freq', [None, 'H'])
+ def test_tdi_sub_period(self, freq):
+ # GH#13078
+ # not supported, check TypeError
+ p = pd.Period('2011-01-01', freq='D')
+
+ idx = pd.TimedeltaIndex(['1 hours', '2 hours'], freq=freq)
+
+ with pytest.raises(TypeError):
+ idx - p
+
+ with pytest.raises(TypeError):
+ p - idx
+
# -------------------------------------------------------------
# TimedeltaIndex.shift is used by __add__/__sub__
@@ -310,69 +465,6 @@ def test_tdi_add_sub_anchored_offset_arraylike(self, box):
with tm.assert_produces_warning(PerformanceWarning):
anchored - tdi
- def test_mul_int(self):
- idx = self._holder(np.arange(5, dtype='int64'))
- result = idx * 1
- tm.assert_index_equal(result, idx)
-
- def test_rmul_int(self):
- idx = self._holder(np.arange(5, dtype='int64'))
- result = 1 * idx
- tm.assert_index_equal(result, idx)
-
- def test_div_int(self):
- idx = self._holder(np.arange(5, dtype='int64'))
- result = idx / 1
- tm.assert_index_equal(result, idx)
-
- def test_floordiv_int(self):
- idx = self._holder(np.arange(5, dtype='int64'))
- result = idx // 1
- tm.assert_index_equal(result, idx)
-
- def test_mul_int_array_zerodim(self):
- rng5 = np.arange(5, dtype='int64')
- idx = self._holder(rng5)
- expected = self._holder(rng5 * 5)
- result = idx * np.array(5, dtype='int64')
- tm.assert_index_equal(result, expected)
-
- def test_mul_int_array(self):
- rng5 = np.arange(5, dtype='int64')
- idx = self._holder(rng5)
- didx = self._holder(rng5 ** 2)
-
- result = idx * rng5
- tm.assert_index_equal(result, didx)
-
- def test_mul_int_series(self):
- idx = self._holder(np.arange(5, dtype='int64'))
- didx = self._holder(np.arange(5, dtype='int64') ** 2)
-
- result = idx * Series(np.arange(5, dtype='int64'))
-
- tm.assert_series_equal(result, Series(didx))
-
- def test_mul_float_series(self):
- idx = self._holder(np.arange(5, dtype='int64'))
-
- rng5f = np.arange(5, dtype='float64')
- result = idx * Series(rng5f + 0.1)
- expected = Series(self._holder(rng5f * (rng5f + 0.1)))
- tm.assert_series_equal(result, expected)
-
- def test_dti_mul_dti_raises(self):
- idx = self._holder(np.arange(5, dtype='int64'))
- with pytest.raises(TypeError):
- idx * idx
-
- def test_dti_mul_too_short_raises(self):
- idx = self._holder(np.arange(5, dtype='int64'))
- with pytest.raises(TypeError):
- idx * self._holder(np.arange(3))
- with pytest.raises(ValueError):
- idx * np.array([1, 2])
-
def test_ufunc_coercions(self):
# normal ops are also tested in tseries/test_timedeltas.py
idx = TimedeltaIndex(['2H', '4H', '6H', '8H', '10H'],
@@ -496,68 +588,6 @@ def test_tdi_radd_timestamp(self):
# -------------------------------------------------------------
- @pytest.mark.parametrize('scalar_td', [
- timedelta(minutes=10, seconds=7),
- Timedelta('10m7s'),
- Timedelta('10m7s').to_timedelta64()])
- def test_tdi_floordiv_timedelta_scalar(self, scalar_td):
- # GH#19125
- tdi = TimedeltaIndex(['00:05:03', '00:05:03', pd.NaT], freq=None)
- expected = pd.Index([2.0, 2.0, np.nan])
-
- res = tdi.__rfloordiv__(scalar_td)
- tm.assert_index_equal(res, expected)
-
- expected = pd.Index([0.0, 0.0, np.nan])
-
- res = tdi // (scalar_td)
- tm.assert_index_equal(res, expected)
-
- def test_tdi_floordiv_tdlike_scalar(self, delta):
- tdi = timedelta_range('1 days', '10 days', name='foo')
- expected = Int64Index((np.arange(10) + 1) * 12, name='foo')
-
- result = tdi // delta
- tm.assert_index_equal(result, expected, exact=False)
-
- def test_tdi_mul_tdlike_scalar_raises(self, delta):
- rng = timedelta_range('1 days', '10 days', name='foo')
- with pytest.raises(TypeError):
- rng * delta
-
- def test_tdi_div_nat_raises(self):
- # don't allow division by NaT (make could in the future)
- rng = timedelta_range('1 days', '10 days', name='foo')
- with pytest.raises(TypeError):
- rng / pd.NaT
-
- def test_tdi_div_tdlike_scalar(self, delta):
- rng = timedelta_range('1 days', '10 days', name='foo')
- expected = Int64Index((np.arange(10) + 1) * 12, name='foo')
-
- result = rng / delta
- tm.assert_index_equal(result, expected, exact=False)
-
- def test_tdi_div_tdlike_scalar_with_nat(self, delta):
- rng = TimedeltaIndex(['1 days', pd.NaT, '2 days'], name='foo')
- expected = Float64Index([12, np.nan, 24], name='foo')
- result = rng / delta
- tm.assert_index_equal(result, expected)
-
- @pytest.mark.parametrize('other', [np.arange(1, 11),
- pd.Int64Index(range(1, 11)),
- pd.UInt64Index(range(1, 11)),
- pd.Float64Index(range(1, 11)),
- pd.RangeIndex(1, 11)])
- def test_tdi_rmul_arraylike(self, other):
- tdi = TimedeltaIndex(['1 Day'] * 10)
- expected = timedelta_range('1 days', '10 days')
-
- result = other * tdi
- tm.assert_index_equal(result, expected)
- commute = tdi * other
- tm.assert_index_equal(commute, expected)
-
def test_subtraction_ops(self):
# with datetimes/timedelta and tdi/dti
tdi = TimedeltaIndex(['1 days', pd.NaT, '2 days'], name='foo')
@@ -685,20 +715,6 @@ def test_dti_tdi_numeric_ops(self):
expected = DatetimeIndex(['20121231', pd.NaT, '20130101'])
tm.assert_index_equal(result, expected)
- @pytest.mark.parametrize('freq', [None, 'H'])
- def test_sub_period(self, freq):
- # GH 13078
- # not supported, check TypeError
- p = pd.Period('2011-01-01', freq='D')
-
- idx = pd.TimedeltaIndex(['1 hours', '2 hours'], freq=freq)
-
- with pytest.raises(TypeError):
- idx - p
-
- with pytest.raises(TypeError):
- p - idx
-
def test_addition_ops(self):
# with datetimes/timedelta and tdi/dti
tdi = TimedeltaIndex(['1 days', pd.NaT, '2 days'], name='foo')
diff --git a/pandas/tests/indexes/timedeltas/test_indexing.py b/pandas/tests/indexes/timedeltas/test_indexing.py
index 59e38c2e738b0..08992188265bd 100644
--- a/pandas/tests/indexes/timedeltas/test_indexing.py
+++ b/pandas/tests/indexes/timedeltas/test_indexing.py
@@ -8,116 +8,7 @@
from pandas import TimedeltaIndex, timedelta_range, compat, Index, Timedelta
-class TestTimedeltaIndex(object):
-
- def test_insert(self):
-
- idx = TimedeltaIndex(['4day', '1day', '2day'], name='idx')
-
- result = idx.insert(2, timedelta(days=5))
- exp = TimedeltaIndex(['4day', '1day', '5day', '2day'], name='idx')
- tm.assert_index_equal(result, exp)
-
- # insertion of non-datetime should coerce to object index
- result = idx.insert(1, 'inserted')
- expected = Index([Timedelta('4day'), 'inserted', Timedelta('1day'),
- Timedelta('2day')], name='idx')
- assert not isinstance(result, TimedeltaIndex)
- tm.assert_index_equal(result, expected)
- assert result.name == expected.name
-
- idx = timedelta_range('1day 00:00:01', periods=3, freq='s', name='idx')
-
- # preserve freq
- expected_0 = TimedeltaIndex(['1day', '1day 00:00:01', '1day 00:00:02',
- '1day 00:00:03'],
- name='idx', freq='s')
- expected_3 = TimedeltaIndex(['1day 00:00:01', '1day 00:00:02',
- '1day 00:00:03', '1day 00:00:04'],
- name='idx', freq='s')
-
- # reset freq to None
- expected_1_nofreq = TimedeltaIndex(['1day 00:00:01', '1day 00:00:01',
- '1day 00:00:02', '1day 00:00:03'],
- name='idx', freq=None)
- expected_3_nofreq = TimedeltaIndex(['1day 00:00:01', '1day 00:00:02',
- '1day 00:00:03', '1day 00:00:05'],
- name='idx', freq=None)
-
- cases = [(0, Timedelta('1day'), expected_0),
- (-3, Timedelta('1day'), expected_0),
- (3, Timedelta('1day 00:00:04'), expected_3),
- (1, Timedelta('1day 00:00:01'), expected_1_nofreq),
- (3, Timedelta('1day 00:00:05'), expected_3_nofreq)]
-
- for n, d, expected in cases:
- result = idx.insert(n, d)
- tm.assert_index_equal(result, expected)
- assert result.name == expected.name
- assert result.freq == expected.freq
-
- # GH 18295 (test missing)
- expected = TimedeltaIndex(['1day', pd.NaT, '2day', '3day'])
- for na in (np.nan, pd.NaT, None):
- result = timedelta_range('1day', '3day').insert(1, na)
- tm.assert_index_equal(result, expected)
-
- def test_delete(self):
- idx = timedelta_range(start='1 Days', periods=5, freq='D', name='idx')
-
- # prserve freq
- expected_0 = timedelta_range(start='2 Days', periods=4, freq='D',
- name='idx')
- expected_4 = timedelta_range(start='1 Days', periods=4, freq='D',
- name='idx')
-
- # reset freq to None
- expected_1 = TimedeltaIndex(
- ['1 day', '3 day', '4 day', '5 day'], freq=None, name='idx')
-
- cases = {0: expected_0,
- -5: expected_0,
- -1: expected_4,
- 4: expected_4,
- 1: expected_1}
- for n, expected in compat.iteritems(cases):
- result = idx.delete(n)
- tm.assert_index_equal(result, expected)
- assert result.name == expected.name
- assert result.freq == expected.freq
-
- with pytest.raises((IndexError, ValueError)):
- # either depeidnig on numpy version
- result = idx.delete(5)
-
- def test_delete_slice(self):
- idx = timedelta_range(start='1 days', periods=10, freq='D', name='idx')
-
- # prserve freq
- expected_0_2 = timedelta_range(start='4 days', periods=7, freq='D',
- name='idx')
- expected_7_9 = timedelta_range(start='1 days', periods=7, freq='D',
- name='idx')
-
- # reset freq to None
- expected_3_5 = TimedeltaIndex(['1 d', '2 d', '3 d',
- '7 d', '8 d', '9 d', '10d'],
- freq=None, name='idx')
-
- cases = {(0, 1, 2): expected_0_2,
- (7, 8, 9): expected_7_9,
- (3, 4, 5): expected_3_5}
- for n, expected in compat.iteritems(cases):
- result = idx.delete(n)
- tm.assert_index_equal(result, expected)
- assert result.name == expected.name
- assert result.freq == expected.freq
-
- result = idx.delete(slice(n[0], n[-1] + 1))
- tm.assert_index_equal(result, expected)
- assert result.name == expected.name
- assert result.freq == expected.freq
-
+class TestGetItem(object):
def test_getitem(self):
idx1 = timedelta_range('1 day', '31 day', freq='D', name='idx')
@@ -150,6 +41,13 @@ def test_getitem(self):
tm.assert_index_equal(result, expected)
assert result.freq == expected.freq
+
+class TestWhere(object):
+ # placeholder for symmetry with DatetimeIndex and PeriodIndex tests
+ pass
+
+
+class TestTake(object):
def test_take(self):
# GH 10295
idx1 = timedelta_range('1 day', '31 day', freq='D', name='idx')
@@ -252,6 +150,117 @@ def test_take_fill_value(self):
with pytest.raises(IndexError):
idx.take(np.array([1, -5]))
+
+class TestTimedeltaIndex(object):
+
+ def test_insert(self):
+
+ idx = TimedeltaIndex(['4day', '1day', '2day'], name='idx')
+
+ result = idx.insert(2, timedelta(days=5))
+ exp = TimedeltaIndex(['4day', '1day', '5day', '2day'], name='idx')
+ tm.assert_index_equal(result, exp)
+
+ # insertion of non-datetime should coerce to object index
+ result = idx.insert(1, 'inserted')
+ expected = Index([Timedelta('4day'), 'inserted', Timedelta('1day'),
+ Timedelta('2day')], name='idx')
+ assert not isinstance(result, TimedeltaIndex)
+ tm.assert_index_equal(result, expected)
+ assert result.name == expected.name
+
+ idx = timedelta_range('1day 00:00:01', periods=3, freq='s', name='idx')
+
+ # preserve freq
+ expected_0 = TimedeltaIndex(['1day', '1day 00:00:01', '1day 00:00:02',
+ '1day 00:00:03'],
+ name='idx', freq='s')
+ expected_3 = TimedeltaIndex(['1day 00:00:01', '1day 00:00:02',
+ '1day 00:00:03', '1day 00:00:04'],
+ name='idx', freq='s')
+
+ # reset freq to None
+ expected_1_nofreq = TimedeltaIndex(['1day 00:00:01', '1day 00:00:01',
+ '1day 00:00:02', '1day 00:00:03'],
+ name='idx', freq=None)
+ expected_3_nofreq = TimedeltaIndex(['1day 00:00:01', '1day 00:00:02',
+ '1day 00:00:03', '1day 00:00:05'],
+ name='idx', freq=None)
+
+ cases = [(0, Timedelta('1day'), expected_0),
+ (-3, Timedelta('1day'), expected_0),
+ (3, Timedelta('1day 00:00:04'), expected_3),
+ (1, Timedelta('1day 00:00:01'), expected_1_nofreq),
+ (3, Timedelta('1day 00:00:05'), expected_3_nofreq)]
+
+ for n, d, expected in cases:
+ result = idx.insert(n, d)
+ tm.assert_index_equal(result, expected)
+ assert result.name == expected.name
+ assert result.freq == expected.freq
+
+ # GH 18295 (test missing)
+ expected = TimedeltaIndex(['1day', pd.NaT, '2day', '3day'])
+ for na in (np.nan, pd.NaT, None):
+ result = timedelta_range('1day', '3day').insert(1, na)
+ tm.assert_index_equal(result, expected)
+
+ def test_delete(self):
+ idx = timedelta_range(start='1 Days', periods=5, freq='D', name='idx')
+
+ # prserve freq
+ expected_0 = timedelta_range(start='2 Days', periods=4, freq='D',
+ name='idx')
+ expected_4 = timedelta_range(start='1 Days', periods=4, freq='D',
+ name='idx')
+
+ # reset freq to None
+ expected_1 = TimedeltaIndex(
+ ['1 day', '3 day', '4 day', '5 day'], freq=None, name='idx')
+
+ cases = {0: expected_0,
+ -5: expected_0,
+ -1: expected_4,
+ 4: expected_4,
+ 1: expected_1}
+ for n, expected in compat.iteritems(cases):
+ result = idx.delete(n)
+ tm.assert_index_equal(result, expected)
+ assert result.name == expected.name
+ assert result.freq == expected.freq
+
+ with pytest.raises((IndexError, ValueError)):
+ # either depeidnig on numpy version
+ result = idx.delete(5)
+
+ def test_delete_slice(self):
+ idx = timedelta_range(start='1 days', periods=10, freq='D', name='idx')
+
+ # prserve freq
+ expected_0_2 = timedelta_range(start='4 days', periods=7, freq='D',
+ name='idx')
+ expected_7_9 = timedelta_range(start='1 days', periods=7, freq='D',
+ name='idx')
+
+ # reset freq to None
+ expected_3_5 = TimedeltaIndex(['1 d', '2 d', '3 d',
+ '7 d', '8 d', '9 d', '10d'],
+ freq=None, name='idx')
+
+ cases = {(0, 1, 2): expected_0_2,
+ (7, 8, 9): expected_7_9,
+ (3, 4, 5): expected_3_5}
+ for n, expected in compat.iteritems(cases):
+ result = idx.delete(n)
+ tm.assert_index_equal(result, expected)
+ assert result.name == expected.name
+ assert result.freq == expected.freq
+
+ result = idx.delete(slice(n[0], n[-1] + 1))
+ tm.assert_index_equal(result, expected)
+ assert result.name == expected.name
+ assert result.freq == expected.freq
+
def test_get_loc(self):
idx = pd.to_timedelta(['0 days', '1 days', '2 days'])
| Collect DTI/TDI/PI indexing tests ~symmetrically. | https://api.github.com/repos/pandas-dev/pandas/pulls/19848 | 2018-02-22T20:44:09Z | 2018-02-23T12:35:07Z | 2018-02-23T12:35:07Z | 2018-02-23T15:23:28Z |
Fix+test DTI/TDI/PI add/sub with ndarray[datetime64/timedelta64] | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index fd3c3a5a7a301..b0e4ae02ff8ee 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -755,6 +755,7 @@ Datetimelike
- Bug in :func:`Timestamp.floor` :func:`DatetimeIndex.floor` where time stamps far in the future and past were not rounded correctly (:issue:`19206`)
- Bug in :func:`to_datetime` where passing an out-of-bounds datetime with ``errors='coerce'`` and ``utc=True`` would raise ``OutOfBoundsDatetime`` instead of parsing to ``NaT`` (:issue:`19612`)
- Bug in :class:`DatetimeIndex` and :class:`TimedeltaIndex` addition and subtraction where name of the returned object was not always set consistently. (:issue:`19744`)
+- Bug in :class:`DatetimeIndex` and :class:`TimedeltaIndex` addition and subtraction where operations with numpy arrays raised ``TypeError`` (:issue:`19847`)
-
Timedelta
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index a68d883f04380..9411428b2e68d 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -31,6 +31,7 @@
is_integer_dtype,
is_object_dtype,
is_string_dtype,
+ is_datetime64_dtype,
is_period_dtype,
is_timedelta64_dtype)
from pandas.core.dtypes.generic import (
@@ -676,9 +677,7 @@ def _add_datetimelike_methods(cls):
"""
def __add__(self, other):
- from pandas.core.index import Index
- from pandas.core.indexes.timedeltas import TimedeltaIndex
- from pandas.tseries.offsets import DateOffset
+ from pandas import Index, DatetimeIndex, TimedeltaIndex, DateOffset
other = lib.item_from_zerodim(other)
if isinstance(other, ABCSeries):
@@ -710,6 +709,9 @@ def __add__(self, other):
.format(typ=type(other)))
elif isinstance(other, Index):
result = self._add_datelike(other)
+ elif is_datetime64_dtype(other):
+ # ndarray[datetime64]; note DatetimeIndex is caught above
+ return self + DatetimeIndex(other)
elif is_integer_dtype(other) and self.freq is None:
# GH#19123
raise NullFrequencyError("Cannot shift with no freq")
@@ -729,10 +731,7 @@ def __radd__(self, other):
cls.__radd__ = __radd__
def __sub__(self, other):
- from pandas.core.index import Index
- from pandas.core.indexes.datetimes import DatetimeIndex
- from pandas.core.indexes.timedeltas import TimedeltaIndex
- from pandas.tseries.offsets import DateOffset
+ from pandas import Index, DatetimeIndex, TimedeltaIndex, DateOffset
other = lib.item_from_zerodim(other)
if isinstance(other, ABCSeries):
@@ -764,6 +763,9 @@ def __sub__(self, other):
.format(typ=type(other).__name__))
elif isinstance(other, DatetimeIndex):
result = self._sub_datelike(other)
+ elif is_datetime64_dtype(other):
+ # ndarray[datetime64]; note we caught DatetimeIndex earlier
+ return self - DatetimeIndex(other)
elif isinstance(other, Index):
raise TypeError("cannot subtract {typ1} and {typ2}"
.format(typ1=type(self).__name__,
@@ -782,6 +784,11 @@ def __sub__(self, other):
cls.__sub__ = __sub__
def __rsub__(self, other):
+ if is_datetime64_dtype(other) and is_timedelta64_dtype(self):
+ # ndarray[datetime64] cannot be subtracted from self, so
+ # we need to wrap in DatetimeIndex and flip the operation
+ from pandas import DatetimeIndex
+ return DatetimeIndex(other) - self
return -(self - other)
cls.__rsub__ = __rsub__
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 219adfdb66c82..6f80962eab079 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -377,6 +377,10 @@ def _add_delta(self, delta):
new_values = self._add_delta_td(delta)
elif isinstance(delta, TimedeltaIndex):
new_values = self._add_delta_tdi(delta)
+ elif is_timedelta64_dtype(delta):
+ # ndarray[timedelta64] --> wrap in TimedeltaIndex
+ delta = TimedeltaIndex(delta)
+ new_values = self._add_delta_tdi(delta)
else:
raise TypeError("cannot add the type {0} to a TimedeltaIndex"
.format(type(delta)))
diff --git a/pandas/tests/indexes/datetimes/test_arithmetic.py b/pandas/tests/indexes/datetimes/test_arithmetic.py
index 7900c983b6c77..5a7ea44f3698c 100644
--- a/pandas/tests/indexes/datetimes/test_arithmetic.py
+++ b/pandas/tests/indexes/datetimes/test_arithmetic.py
@@ -571,6 +571,62 @@ def test_add_datetimelike_and_dti_tz(self, addend):
with tm.assert_raises_regex(TypeError, msg):
addend + dti_tz
+ # -------------------------------------------------------------
+ # __add__/__sub__ with ndarray[datetime64] and ndarray[timedelta64]
+
+ def test_dti_add_dt64_array_raises(self, tz):
+ dti = pd.date_range('2016-01-01', periods=3, tz=tz)
+ dtarr = dti.values
+
+ with pytest.raises(TypeError):
+ dti + dtarr
+ with pytest.raises(TypeError):
+ dtarr + dti
+
+ def test_dti_sub_dt64_array_naive(self):
+ dti = pd.date_range('2016-01-01', periods=3, tz=None)
+ dtarr = dti.values
+
+ expected = dti - dti
+ result = dti - dtarr
+ tm.assert_index_equal(result, expected)
+ result = dtarr - dti
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_sub_dt64_array_aware_raises(self, tz):
+ if tz is None:
+ return
+ dti = pd.date_range('2016-01-01', periods=3, tz=tz)
+ dtarr = dti.values
+
+ with pytest.raises(TypeError):
+ dti - dtarr
+ with pytest.raises(TypeError):
+ dtarr - dti
+
+ def test_dti_add_td64_array(self, tz):
+ dti = pd.date_range('2016-01-01', periods=3, tz=tz)
+ tdi = dti - dti.shift(1)
+ tdarr = tdi.values
+
+ expected = dti + tdi
+ result = dti + tdarr
+ tm.assert_index_equal(result, expected)
+ result = tdarr + dti
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_sub_td64_array(self, tz):
+ dti = pd.date_range('2016-01-01', periods=3, tz=tz)
+ tdi = dti - dti.shift(1)
+ tdarr = tdi.values
+
+ expected = dti - tdi
+ result = dti - tdarr
+ tm.assert_index_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ tdarr - dti
+
# -------------------------------------------------------------
def test_sub_dti_dti(self):
diff --git a/pandas/tests/indexes/period/test_arithmetic.py b/pandas/tests/indexes/period/test_arithmetic.py
index 0c06e6a4963b4..d7bf1e0210f62 100644
--- a/pandas/tests/indexes/period/test_arithmetic.py
+++ b/pandas/tests/indexes/period/test_arithmetic.py
@@ -255,6 +255,64 @@ def test_comp_nat(self, dtype):
class TestPeriodIndexArithmetic(object):
+
+ # -----------------------------------------------------------------
+ # __add__/__sub__ with ndarray[datetime64] and ndarray[timedelta64]
+
+ def test_pi_add_sub_dt64_array_raises(self):
+ rng = pd.period_range('1/1/2000', freq='D', periods=3)
+ dti = pd.date_range('2016-01-01', periods=3)
+ dtarr = dti.values
+
+ with pytest.raises(TypeError):
+ rng + dtarr
+ with pytest.raises(TypeError):
+ dtarr + rng
+
+ with pytest.raises(TypeError):
+ rng - dtarr
+ with pytest.raises(TypeError):
+ dtarr - rng
+
+ def test_pi_add_sub_td64_array_non_tick_raises(self):
+ rng = pd.period_range('1/1/2000', freq='Q', periods=3)
+ dti = pd.date_range('2016-01-01', periods=3)
+ tdi = dti - dti.shift(1)
+ tdarr = tdi.values
+
+ with pytest.raises(period.IncompatibleFrequency):
+ rng + tdarr
+ with pytest.raises(period.IncompatibleFrequency):
+ tdarr + rng
+
+ with pytest.raises(period.IncompatibleFrequency):
+ rng - tdarr
+ with pytest.raises(period.IncompatibleFrequency):
+ tdarr - rng
+
+ @pytest.mark.xfail(reason='op with TimedeltaIndex raises, with ndarray OK')
+ def test_pi_add_sub_td64_array_tick(self):
+ rng = pd.period_range('1/1/2000', freq='Q', periods=3)
+ dti = pd.date_range('2016-01-01', periods=3)
+ tdi = dti - dti.shift(1)
+ tdarr = tdi.values
+
+ expected = rng + tdi
+ result = rng + tdarr
+ tm.assert_index_equal(result, expected)
+ result = tdarr + rng
+ tm.assert_index_equal(result, expected)
+
+ expected = rng - tdi
+ result = rng - tdarr
+ tm.assert_index_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ tdarr - rng
+
+ # -----------------------------------------------------------------
+ # operations with array/Index of DateOffset objects
+
@pytest.mark.parametrize('box', [np.array, pd.Index])
def test_pi_add_offset_array(self, box):
# GH#18849
diff --git a/pandas/tests/indexes/timedeltas/test_arithmetic.py b/pandas/tests/indexes/timedeltas/test_arithmetic.py
index 282501860f7e5..6a80b995b6ee9 100644
--- a/pandas/tests/indexes/timedeltas/test_arithmetic.py
+++ b/pandas/tests/indexes/timedeltas/test_arithmetic.py
@@ -586,6 +586,55 @@ def test_tdi_radd_timestamp(self):
expected = DatetimeIndex(['2011-01-02', '2011-01-03'])
tm.assert_index_equal(result, expected)
+ # -------------------------------------------------------------
+ # __add__/__sub__ with ndarray[datetime64] and ndarray[timedelta64]
+
+ def test_tdi_sub_dt64_array(self):
+ dti = pd.date_range('2016-01-01', periods=3)
+ tdi = dti - dti.shift(1)
+ dtarr = dti.values
+
+ with pytest.raises(TypeError):
+ tdi - dtarr
+
+ # TimedeltaIndex.__rsub__
+ expected = pd.DatetimeIndex(dtarr) - tdi
+ result = dtarr - tdi
+ tm.assert_index_equal(result, expected)
+
+ def test_tdi_add_dt64_array(self):
+ dti = pd.date_range('2016-01-01', periods=3)
+ tdi = dti - dti.shift(1)
+ dtarr = dti.values
+
+ expected = pd.DatetimeIndex(dtarr) + tdi
+ result = tdi + dtarr
+ tm.assert_index_equal(result, expected)
+ result = dtarr + tdi
+ tm.assert_index_equal(result, expected)
+
+ def test_tdi_add_td64_array(self):
+ dti = pd.date_range('2016-01-01', periods=3)
+ tdi = dti - dti.shift(1)
+ tdarr = tdi.values
+
+ expected = 2 * tdi
+ result = tdi + tdarr
+ tm.assert_index_equal(result, expected)
+ result = tdarr + tdi
+ tm.assert_index_equal(result, expected)
+
+ def test_tdi_sub_td64_array(self):
+ dti = pd.date_range('2016-01-01', periods=3)
+ tdi = dti - dti.shift(1)
+ tdarr = tdi.values
+
+ expected = 0 * tdi
+ result = tdi - tdarr
+ tm.assert_index_equal(result, expected)
+ result = tdarr - tdi
+ tm.assert_index_equal(result, expected)
+
# -------------------------------------------------------------
def test_subtraction_ops(self):
| Two notes for upcoming passes:
- the tests are pretty redundant, can be parametrized more tightly once they are all OK.
- catching ndarray[datetime64] separately from DatetimeIndex is kind of weird, but for the moment necesarry. Once #19835 goes through and re-orders the catching, we'll be able to fix this. | https://api.github.com/repos/pandas-dev/pandas/pulls/19847 | 2018-02-22T20:08:11Z | 2018-02-25T16:11:42Z | 2018-02-25T16:11:42Z | 2018-06-22T03:28:41Z |
DOC: Make API reference intro section concise | diff --git a/doc/source/api.rst b/doc/source/api.rst
index b8aad67e147ba..0e47499a03f3a 100644
--- a/doc/source/api.rst
+++ b/doc/source/api.rst
@@ -6,19 +6,18 @@ API Reference
*************
This page gives an overview of all public pandas objects, functions and
-methods. In general, all classes and functions exposed in the top-level
-``pandas.*`` namespace are regarded as public.
+methods. All classes and functions exposed in ``pandas.*`` namespace are public.
-Further some of the subpackages are public, including ``pandas.errors``,
-``pandas.plotting``, and ``pandas.testing``. Certain functions in the
-``pandas.io`` and ``pandas.tseries`` submodules are public as well (those
-mentioned in the documentation). Further, the ``pandas.api.types`` subpackage
-holds some public functions related to data types in pandas.
+Some subpackages are public which include ``pandas.errors``,
+``pandas.plotting``, and ``pandas.testing``. Public functions in
+``pandas.io`` and ``pandas.tseries`` submodules are mentioned in
+the documentation. ``pandas.api.types`` subpackage holds some
+public functions related to data types in pandas.
.. warning::
- The ``pandas.core``, ``pandas.compat``, and ``pandas.util`` top-level modules are considered to be PRIVATE. Stability of functionality in those modules in not guaranteed.
+ The ``pandas.core``, ``pandas.compat``, and ``pandas.util`` top-level modules are PRIVATE. Stable functionality in such modules is not guaranteed.
.. _api.functions:
| Also revise the typo "in not guaranteed" to "is not guaranteed"
| https://api.github.com/repos/pandas-dev/pandas/pulls/19846 | 2018-02-22T20:06:18Z | 2018-02-26T08:43:00Z | 2018-02-26T08:43:00Z | 2018-02-26T08:43:06Z |
CI: Align pep8speaks config with setup.cfg | diff --git a/.pep8speaks.yml b/.pep8speaks.yml
index 299b76c8922cc..fda26d87bf7f6 100644
--- a/.pep8speaks.yml
+++ b/.pep8speaks.yml
@@ -6,5 +6,7 @@ scanner:
pycodestyle:
max-line-length: 79
ignore: # Errors and warnings to ignore
- - E731
- - E402
+ - E402, # module level import not at top of file
+ - E731, # do not assign a lambda expression, use a def
+ - E741, # do not use variables named 'l', 'O', or 'I'
+ - W503 # line break before binary operator
| I copy pasted the ignored flake8 codes from setup.cfg, so that the online pep8speaks does the same as our linting on CI | https://api.github.com/repos/pandas-dev/pandas/pulls/19841 | 2018-02-22T12:49:13Z | 2018-02-22T13:55:03Z | 2018-02-22T13:55:03Z | 2018-02-22T13:55:03Z |
DOC: script to build single docstring page | diff --git a/doc/make.py b/doc/make.py
index e3cb29aa3e086..2819a62347627 100755
--- a/doc/make.py
+++ b/doc/make.py
@@ -14,11 +14,14 @@
import sys
import os
import shutil
-import subprocess
+# import subprocess
import argparse
from contextlib import contextmanager
+import webbrowser
import jinja2
+import pandas
+
DOC_PATH = os.path.dirname(os.path.abspath(__file__))
SOURCE_PATH = os.path.join(DOC_PATH, 'source')
@@ -26,28 +29,6 @@
BUILD_DIRS = ['doctrees', 'html', 'latex', 'plots', '_static', '_templates']
-def _generate_index(include_api, single_doc=None):
- """Create index.rst file with the specified sections.
-
- Parameters
- ----------
- include_api : bool
- Whether API documentation will be built.
- single_doc : str or None
- If provided, this single documentation page will be generated.
- """
- if single_doc is not None:
- single_doc = os.path.splitext(os.path.basename(single_doc))[0]
- include_api = False
-
- with open(os.path.join(SOURCE_PATH, 'index.rst.template')) as f:
- t = jinja2.Template(f.read())
-
- with open(os.path.join(SOURCE_PATH, 'index.rst'), 'w') as f:
- f.write(t.render(include_api=include_api,
- single_doc=single_doc))
-
-
@contextmanager
def _maybe_exclude_notebooks():
"""Skip building the notebooks if pandoc is not installed.
@@ -58,6 +39,7 @@ def _maybe_exclude_notebooks():
1. nbconvert isn't installed, or
2. nbconvert is installed, but pandoc isn't
"""
+ # TODO move to exclude_pattern
base = os.path.dirname(__file__)
notebooks = [os.path.join(base, 'source', nb)
for nb in ['style.ipynb']]
@@ -96,8 +78,110 @@ class DocBuilder:
All public methods of this class can be called as parameters of the
script.
"""
- def __init__(self, num_jobs=1):
+ def __init__(self, num_jobs=1, include_api=True, single_doc=None):
self.num_jobs = num_jobs
+ self.include_api = include_api
+ self.single_doc = None
+ self.single_doc_type = None
+ if single_doc is not None:
+ self._process_single_doc(single_doc)
+ self.exclude_patterns = self._exclude_patterns
+
+ self._generate_index()
+ if self.single_doc_type == 'docstring':
+ self._run_os('sphinx-autogen', '-o',
+ 'source/generated_single', 'source/index.rst')
+
+ @property
+ def _exclude_patterns(self):
+ """Docs source files that will be excluded from building."""
+ # TODO move maybe_exclude_notebooks here
+ if self.single_doc is not None:
+ rst_files = [f for f in os.listdir(SOURCE_PATH)
+ if ((f.endswith('.rst') or f.endswith('.ipynb'))
+ and (f != 'index.rst')
+ and (f != '{0}.rst'.format(self.single_doc)))]
+ if self.single_doc_type != 'api':
+ rst_files += ['generated/*.rst']
+ elif not self.include_api:
+ rst_files = ['api.rst', 'generated/*.rst']
+ else:
+ rst_files = ['generated_single/*.rst']
+
+ exclude_patterns = ','.join(
+ '{!r}'.format(i) for i in ['**.ipynb_checkpoints'] + rst_files)
+
+ return exclude_patterns
+
+ def _process_single_doc(self, single_doc):
+ """Extract self.single_doc (base name) and self.single_doc_type from
+ passed single_doc kwarg.
+
+ """
+ self.include_api = False
+
+ if single_doc == 'api.rst':
+ self.single_doc_type = 'api'
+ self.single_doc = 'api'
+ elif os.path.exists(os.path.join(SOURCE_PATH, single_doc)):
+ self.single_doc_type = 'rst'
+ self.single_doc = os.path.splitext(os.path.basename(single_doc))[0]
+ elif os.path.exists(
+ os.path.join(SOURCE_PATH, '{}.rst'.format(single_doc))):
+ self.single_doc_type = 'rst'
+ self.single_doc = single_doc
+ elif single_doc is not None:
+ try:
+ obj = pandas
+ for name in single_doc.split('.'):
+ obj = getattr(obj, name)
+ except AttributeError:
+ raise ValueError('Single document not understood, it should '
+ 'be a file in doc/source/*.rst (e.g. '
+ '"contributing.rst" or a pandas function or '
+ 'method (e.g. "pandas.DataFrame.head")')
+ else:
+ self.single_doc_type = 'docstring'
+ if single_doc.startswith('pandas.'):
+ self.single_doc = single_doc[len('pandas.'):]
+ else:
+ self.single_doc = single_doc
+
+ def _copy_generated_docstring(self):
+ """Copy existing generated (from api.rst) docstring page because
+ this is more correct in certain cases (where a custom autodoc
+ template is used).
+
+ """
+ fname = os.path.join(SOURCE_PATH, 'generated',
+ 'pandas.{}.rst'.format(self.single_doc))
+ temp_dir = os.path.join(SOURCE_PATH, 'generated_single')
+
+ try:
+ os.makedirs(temp_dir)
+ except OSError:
+ pass
+
+ if os.path.exists(fname):
+ try:
+ # copying to make sure sphinx always thinks it is new
+ # and needs to be re-generated (to pick source code changes)
+ shutil.copy(fname, temp_dir)
+ except: # noqa
+ pass
+
+ def _generate_index(self):
+ """Create index.rst file with the specified sections."""
+ if self.single_doc_type == 'docstring':
+ self._copy_generated_docstring()
+
+ with open(os.path.join(SOURCE_PATH, 'index.rst.template')) as f:
+ t = jinja2.Template(f.read())
+
+ with open(os.path.join(SOURCE_PATH, 'index.rst'), 'w') as f:
+ f.write(t.render(include_api=self.include_api,
+ single_doc=self.single_doc,
+ single_doc_type=self.single_doc_type))
@staticmethod
def _create_build_structure():
@@ -121,7 +205,10 @@ def _run_os(*args):
--------
>>> DocBuilder()._run_os('python', '--version')
"""
- subprocess.check_call(args, stderr=subprocess.STDOUT)
+ # TODO check_call should be more safe, but it fails with
+ # exclude patterns, needs investigation
+ # subprocess.check_call(args, stderr=subprocess.STDOUT)
+ os.system(' '.join(args))
def _sphinx_build(self, kind):
"""Call sphinx to build documentation.
@@ -142,11 +229,21 @@ def _sphinx_build(self, kind):
self._run_os('sphinx-build',
'-j{}'.format(self.num_jobs),
'-b{}'.format(kind),
- '-d{}'.format(os.path.join(BUILD_PATH,
- 'doctrees')),
+ '-d{}'.format(os.path.join(BUILD_PATH, 'doctrees')),
+ '-Dexclude_patterns={}'.format(self.exclude_patterns),
SOURCE_PATH,
os.path.join(BUILD_PATH, kind))
+ def _open_browser(self):
+ base_url = os.path.join('file://', DOC_PATH, 'build', 'html')
+ if self.single_doc_type == 'docstring':
+ url = os.path.join(
+ base_url,
+ 'generated_single', 'pandas.{}.html'.format(self.single_doc))
+ else:
+ url = os.path.join(base_url, '{}.html'.format(self.single_doc))
+ webbrowser.open(url, new=2)
+
def html(self):
"""Build HTML documentation."""
self._create_build_structure()
@@ -156,6 +253,11 @@ def html(self):
if os.path.exists(zip_fname):
os.remove(zip_fname)
+ if self.single_doc is not None:
+ self._open_browser()
+ shutil.rmtree(os.path.join(SOURCE_PATH, 'generated_single'),
+ ignore_errors=True)
+
def latex(self, force=False):
"""Build PDF documentation."""
self._create_build_structure()
@@ -222,8 +324,8 @@ def main():
metavar='FILENAME',
type=str,
default=None,
- help=('filename of section to compile, '
- 'e.g. "indexing"'))
+ help=('filename of section or method name to '
+ 'compile, e.g. "indexing", "DataFrame.join"'))
argparser.add_argument('--python-path',
type=str,
default=os.path.join(DOC_PATH, '..'),
@@ -235,8 +337,10 @@ def main():
args.command, ', '.join(cmds)))
os.environ['PYTHONPATH'] = args.python_path
- _generate_index(not args.no_api, args.single)
- getattr(DocBuilder(args.num_jobs), args.command)()
+
+ getattr(DocBuilder(args.num_jobs,
+ not args.no_api,
+ args.single), args.command)()
if __name__ == '__main__':
diff --git a/doc/source/conf.py b/doc/source/conf.py
index b5fbf096f2626..835127e5094e4 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -18,7 +18,6 @@
import importlib
import warnings
-from pandas.compat import u, PY3
try:
raw_input # Python 2
@@ -86,38 +85,6 @@
if any(re.match("\s*api\s*", l) for l in index_rst_lines):
autosummary_generate = True
-files_to_delete = []
-for f in os.listdir(os.path.dirname(__file__)):
- if (not f.endswith(('.ipynb', '.rst')) or
- f.startswith('.') or os.path.basename(f) == 'index.rst'):
- continue
-
- _file_basename = os.path.splitext(f)[0]
- _regex_to_match = "\s*{}\s*$".format(_file_basename)
- if not any(re.match(_regex_to_match, line) for line in index_rst_lines):
- files_to_delete.append(f)
-
-if files_to_delete:
- print("I'm about to DELETE the following:\n{}\n".format(
- list(sorted(files_to_delete))))
- sys.stdout.write("WARNING: I'd like to delete those "
- "to speed up processing (yes/no)? ")
- if PY3:
- answer = input()
- else:
- answer = raw_input()
-
- if answer.lower().strip() in ('y', 'yes'):
- for f in files_to_delete:
- f = os.path.join(os.path.join(os.path.dirname(__file__), f))
- f = os.path.abspath(f)
- try:
- print("Deleting {}".format(f))
- os.unlink(f)
- except:
- print("Error deleting {}".format(f))
- pass
-
# Add any paths that contain templates here, relative to this directory.
templates_path = ['../_templates']
@@ -131,8 +98,8 @@
master_doc = 'index'
# General information about the project.
-project = u('pandas')
-copyright = u('2008-2014, the pandas development team')
+project = u'pandas'
+copyright = u'2008-2014, the pandas development team'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
@@ -343,8 +310,8 @@
# file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'pandas.tex',
- u('pandas: powerful Python data analysis toolkit'),
- u('Wes McKinney\n\& PyData Development Team'), 'manual'),
+ u'pandas: powerful Python data analysis toolkit',
+ u'Wes McKinney\n\& PyData Development Team', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
diff --git a/doc/source/contributing.rst b/doc/source/contributing.rst
index 258ab874cafcf..e159af9958fde 100644
--- a/doc/source/contributing.rst
+++ b/doc/source/contributing.rst
@@ -171,7 +171,7 @@ We'll now kick off a three-step process:
# Create and activate the build environment
conda env create -f ci/environment-dev.yaml
conda activate pandas-dev
-
+
# or with older versions of Anaconda:
source activate pandas-dev
@@ -388,14 +388,11 @@ If you want to do a full clean build, do::
python make.py html
You can tell ``make.py`` to compile only a single section of the docs, greatly
-reducing the turn-around time for checking your changes. You will be prompted to
-delete ``.rst`` files that aren't required. This is okay because the prior
-versions of these files can be checked out from git. However, you must make sure
-not to commit the file deletions to your Git repository!
+reducing the turn-around time for checking your changes.
::
- #omit autosummary and API section
+ # omit autosummary and API section
python make.py clean
python make.py --no-api
@@ -404,10 +401,20 @@ not to commit the file deletions to your Git repository!
python make.py clean
python make.py --single indexing
-For comparison, a full documentation build may take 10 minutes, a ``-no-api`` build
-may take 3 minutes and a single section may take 15 seconds. Subsequent builds, which
-only process portions you have changed, will be faster. Open the following file in a web
-browser to see the full documentation you just built::
+ # compile the reference docs for a single function
+ python make.py clean
+ python make.py --single DataFrame.join
+
+For comparison, a full documentation build may take 15 minutes, but a single
+section may take 15 seconds. Subsequent builds, which only process portions
+you have changed, will be faster.
+
+You can also specify to use multiple cores to speed up the documentation build::
+
+ python make.py html --num-jobs 4
+
+Open the following file in a web browser to see the full documentation you
+just built::
pandas/docs/build/html/index.html
diff --git a/doc/source/index.rst.template b/doc/source/index.rst.template
index eff1227e98994..cb6cce5edaf79 100644
--- a/doc/source/index.rst.template
+++ b/doc/source/index.rst.template
@@ -106,8 +106,13 @@ Some other notes
See the package overview for more detail about what's in the library.
+{% if single_doc_type == 'docstring' -%}
+.. autosummary::
+ :toctree: generated_single/
+{% else -%}
.. toctree::
:maxdepth: 4
+{% endif %}
{% if single_doc -%}
{{ single_doc }}
| Add a way to build a single docstring page, without the need to build the full docs.
| https://api.github.com/repos/pandas-dev/pandas/pulls/19840 | 2018-02-22T12:43:33Z | 2018-03-01T09:35:05Z | 2018-03-01T09:35:05Z | 2018-03-01T09:35:09Z |
DOC: Making doc/source/conf.py pass PEP-8, and added to lint | diff --git a/ci/lint.sh b/ci/lint.sh
index b862a3bfcf29e..e3a39668885f0 100755
--- a/ci/lint.sh
+++ b/ci/lint.sh
@@ -37,12 +37,12 @@ if [ "$LINT" ]; then
fi
echo "Linting scripts/*.py DONE"
- echo "Linting doc script"
- flake8 doc/make.py
+ echo "Linting doc scripts"
+ flake8 doc/make.py doc/source/conf.py
if [ $? -ne "0" ]; then
RET=1
fi
- echo "Linting doc script DONE"
+ echo "Linting doc scripts DONE"
echo "Linting *.pyx"
flake8 pandas --filename=*.pyx --select=E501,E302,E203,E111,E114,E221,E303,E128,E231,E126,E265,E305,E301,E127,E261,E271,E129,W291,E222,E241,E123,F403
diff --git a/doc/source/conf.py b/doc/source/conf.py
index 7c4edd0486636..b5fbf096f2626 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -2,7 +2,8 @@
#
# pandas documentation build configuration file, created by
#
-# This file is execfile()d with the current directory set to its containing dir.
+# This file is execfile()d with the current directory set to its containing
+# dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
@@ -49,8 +50,9 @@
# -- General configuration -----------------------------------------------
-# Add any Sphinx extension module names here, as strings. They can be extensions
-# coming with Sphinx (named 'sphinx.ext.*') or your custom ones. sphinxext.
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+# sphinxext.
extensions = ['sphinx.ext.autodoc',
'sphinx.ext.autosummary',
@@ -60,7 +62,8 @@
'numpydoc',
'ipython_sphinxext.ipython_directive',
'ipython_sphinxext.ipython_console_highlighting',
- 'IPython.sphinxext.ipython_console_highlighting', # lowercase didn't work
+ # lowercase didn't work
+ 'IPython.sphinxext.ipython_console_highlighting',
'sphinx.ext.intersphinx',
'sphinx.ext.coverage',
'sphinx.ext.mathjax',
@@ -95,22 +98,24 @@
files_to_delete.append(f)
if files_to_delete:
- print("I'm about to DELETE the following:\n%s\n" % list(sorted(files_to_delete)))
- sys.stdout.write("WARNING: I'd like to delete those to speed up processing (yes/no)? ")
+ print("I'm about to DELETE the following:\n{}\n".format(
+ list(sorted(files_to_delete))))
+ sys.stdout.write("WARNING: I'd like to delete those "
+ "to speed up processing (yes/no)? ")
if PY3:
answer = input()
else:
answer = raw_input()
- if answer.lower().strip() in ('y','yes'):
+ if answer.lower().strip() in ('y', 'yes'):
for f in files_to_delete:
- f = os.path.join(os.path.join(os.path.dirname(__file__),f))
- f= os.path.abspath(f)
+ f = os.path.join(os.path.join(os.path.dirname(__file__), f))
+ f = os.path.abspath(f)
try:
- print("Deleting %s" % f)
+ print("Deleting {}".format(f))
os.unlink(f)
except:
- print("Error deleting %s" % f)
+ print("Error deleting {}".format(f))
pass
# Add any paths that contain templates here, relative to this directory.
@@ -137,7 +142,7 @@
import pandas
# version = '%s r%s' % (pandas.__version__, svn_version())
-version = '%s' % (pandas.__version__)
+version = str(pandas.__version__)
# The full version, including alpha/beta/rc tags.
release = version
@@ -159,8 +164,8 @@
# for source files.
exclude_trees = []
-# The reST default role (used for this markup: `text`) to use for all documents.
-# default_role = None
+# The reST default role (used for this markup: `text`) to use for all
+# documents. default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
# add_function_parentheses = True
@@ -334,8 +339,8 @@
# The font size ('10pt', '11pt' or '12pt').
# latex_font_size = '10pt'
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title, author, documentclass [howto/manual]).
+# Grouping the document tree into LaTeX files. List of tuples (source start
+# file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'pandas.tex',
u('pandas: powerful Python data analysis toolkit'),
@@ -392,7 +397,7 @@
# wherever the docs are built. The docs' target is the browser, not
# the console, so this is fine.
'pd.options.display.encoding="utf8"'
- ]
+]
# Add custom Documenter to handle attributes/methods of an AccessorProperty
@@ -400,7 +405,8 @@
import sphinx
from sphinx.util import rpartition
-from sphinx.ext.autodoc import Documenter, MethodDocumenter, AttributeDocumenter
+from sphinx.ext.autodoc import (
+ Documenter, MethodDocumenter, AttributeDocumenter)
from sphinx.ext.autosummary import Autosummary
@@ -408,7 +414,6 @@ class AccessorDocumenter(MethodDocumenter):
"""
Specialized Documenter subclass for accessors.
"""
-
objtype = 'accessor'
directivetype = 'method'
@@ -426,7 +431,6 @@ class AccessorLevelDocumenter(Documenter):
Specialized Documenter subclass for objects on accessor level (methods,
attributes).
"""
-
# This is the simple straightforward version
# modname is None, base the last elements (eg 'hour')
# and path the part before (eg 'Series.dt')
@@ -436,7 +440,6 @@ class AccessorLevelDocumenter(Documenter):
# mod_cls = mod_cls.split('.')
#
# return modname, mod_cls + [base]
-
def resolve_name(self, modname, parents, path, base):
if modname is None:
if path:
@@ -471,16 +474,17 @@ def resolve_name(self, modname, parents, path, base):
return modname, parents + [base]
-class AccessorAttributeDocumenter(AccessorLevelDocumenter, AttributeDocumenter):
-
+class AccessorAttributeDocumenter(AccessorLevelDocumenter,
+ AttributeDocumenter):
objtype = 'accessorattribute'
directivetype = 'attribute'
- # lower than AttributeDocumenter so this is not chosen for normal attributes
+ # lower than AttributeDocumenter so this is not chosen for normal
+ # attributes
priority = 0.6
-class AccessorMethodDocumenter(AccessorLevelDocumenter, MethodDocumenter):
+class AccessorMethodDocumenter(AccessorLevelDocumenter, MethodDocumenter):
objtype = 'accessormethod'
directivetype = 'method'
@@ -508,7 +512,6 @@ class PandasAutosummary(Autosummary):
This alternative autosummary class lets us override the table summary for
Series.plot and DataFrame.plot in the API docs.
"""
-
def _replace_pandas_items(self, display_name, sig, summary, real_name):
# this a hack: ideally we should extract the signature from the
# .__call__ method instead of hard coding this
@@ -561,18 +564,18 @@ def linkcode_resolve(domain, info):
lineno = None
if lineno:
- linespec = "#L%d-L%d" % (lineno, lineno + len(source) - 1)
+ linespec = "#L{:d}-L{:d}".format(lineno, lineno + len(source) - 1)
else:
linespec = ""
fn = os.path.relpath(fn, start=os.path.dirname(pandas.__file__))
if '+' in pandas.__version__:
- return "http://github.com/pandas-dev/pandas/blob/master/pandas/%s%s" % (
- fn, linespec)
+ return ("http://github.com/pandas-dev/pandas/blob/master/pandas/"
+ "{}{}".format(fn, linespec))
else:
- return "http://github.com/pandas-dev/pandas/blob/v%s/pandas/%s%s" % (
- pandas.__version__, fn, linespec)
+ return ("http://github.com/pandas-dev/pandas/blob/"
+ "v{}/pandas/{}{}".format(pandas.__version__, fn, linespec))
# remove the docstring of the flags attribute (inherited from numpy ndarray)
| - [X] closes https://github.com/pandas-dev/pandas/issues/19838
- [ ] tests added / passed
- [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/19839 | 2018-02-22T11:48:28Z | 2018-02-22T14:06:09Z | 2018-02-22T14:06:08Z | 2018-02-22T14:06:18Z |
DOC: remove deprecated from_items from dsintro docs | diff --git a/doc/source/dsintro.rst b/doc/source/dsintro.rst
index e8f73a9ec2e8a..1ba00b8fb6f23 100644
--- a/doc/source/dsintro.rst
+++ b/doc/source/dsintro.rst
@@ -364,6 +364,19 @@ and returns a DataFrame. It operates like the ``DataFrame`` constructor except
for the ``orient`` parameter which is ``'columns'`` by default, but which can be
set to ``'index'`` in order to use the dict keys as row labels.
+
+.. ipython:: python
+
+ pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])]))
+
+If you pass ``orient='index'``, the keys will be the row labels. In this
+case, you can also pass the desired column names:
+
+.. ipython:: python
+
+ pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])]),
+ orient='index', columns=['one', 'two', 'three'])
+
.. _basics.dataframe.from_records:
**DataFrame.from_records**
@@ -378,28 +391,6 @@ dtype. For example:
data
pd.DataFrame.from_records(data, index='C')
-.. _basics.dataframe.from_items:
-
-**DataFrame.from_items**
-
-``DataFrame.from_items`` works analogously to the form of the ``dict``
-constructor that takes a sequence of ``(key, value)`` pairs, where the keys are
-column (or row, in the case of ``orient='index'``) names, and the value are the
-column values (or row values). This can be useful for constructing a DataFrame
-with the columns in a particular order without having to pass an explicit list
-of columns:
-
-.. ipython:: python
-
- pd.DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])])
-
-If you pass ``orient='index'``, the keys will be the row labels. But in this
-case you must also pass the desired column names:
-
-.. ipython:: python
-
- pd.DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])],
- orient='index', columns=['one', 'two', 'three'])
Column selection, addition, deletion
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 1c5cf87d6b39b..061b69f25e7ac 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1255,12 +1255,14 @@ def to_records(self, index=True, convert_datetime64=True):
@classmethod
def from_items(cls, items, columns=None, orient='columns'):
- """
+ """Construct a dataframe from a list of tuples
+
.. deprecated:: 0.23.0
- from_items is deprecated and will be removed in a
- future version. Use :meth:`DataFrame.from_dict(dict())`
- instead. :meth:`DataFrame.from_dict(OrderedDict(...))` may be used
- to preserve the key order.
+ `from_items` is deprecated and will be removed in a future version.
+ Use :meth:`DataFrame.from_dict(dict(items)) <DataFrame.from_dict>`
+ instead.
+ :meth:`DataFrame.from_dict(OrderedDict(items)) <DataFrame.from_dict>`
+ may be used to preserve the key order.
Convert (key, value) pairs to DataFrame. The keys will be the axis
index (usually the columns, but depends on the specified
@@ -1284,8 +1286,8 @@ def from_items(cls, items, columns=None, orient='columns'):
"""
warnings.warn("from_items is deprecated. Please use "
- "DataFrame.from_dict(dict()) instead. "
- "DataFrame.from_dict(OrderedDict()) may be used to "
+ "DataFrame.from_dict(dict(items), ...) instead. "
+ "DataFrame.from_dict(OrderedDict(items)) may be used to "
"preserve the key order.",
FutureWarning, stacklevel=2)
| Follow-up on https://github.com/pandas-dev/pandas/pull/19802 and https://github.com/pandas-dev/pandas/pull/18529 | https://api.github.com/repos/pandas-dev/pandas/pulls/19837 | 2018-02-22T10:40:54Z | 2018-02-24T14:39:08Z | 2018-02-24T14:39:08Z | 2018-02-24T14:39:11Z |
DOC: correct min_count param docstring | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 8034cf89cf8b7..85e2ce475ffa2 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -7855,7 +7855,7 @@ def _doc_parms(cls):
>>> pd.Series([np.nan]).prod()
1.0
->>> pd.Series([np.nan]).sum(min_count=1)
+>>> pd.Series([np.nan]).prod(min_count=1)
nan
"""
@@ -7867,8 +7867,9 @@ def _doc_parms(cls):
.. versionadded :: 0.22.0
- Added with the default being 1. This means the sum or product
- of an all-NA or empty series is ``NaN``.
+ Added with the default being 0. This means the sum of an all-NA
+ or empty Series is 0, and the product of an all-NA or empty
+ Series is 1.
"""
| correct min_count param docstring for function ’Series.prod‘， ’Series.sum', 'DataFrame.prod', 'DataFrame.sum'
- [ ] 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/19836 | 2018-02-22T06:28:32Z | 2018-02-23T11:24:24Z | 2018-02-23T11:24:24Z | 2018-02-23T11:44:20Z |
De-duplicate add_offset_array methods | diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index ac75e5ae5e2a0..a68d883f04380 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -2,7 +2,7 @@
Base and utility classes for tseries type pandas objects.
"""
import warnings
-
+import operator
from datetime import datetime, timedelta
from pandas import compat
@@ -10,6 +10,12 @@
from pandas.core.tools.timedeltas import to_timedelta
import numpy as np
+
+from pandas._libs import lib, iNaT, NaT
+from pandas._libs.tslibs.period import Period
+from pandas._libs.tslibs.timedeltas import delta_to_nanoseconds
+from pandas._libs.tslibs.timestamps import round_ns
+
from pandas.core.dtypes.common import (
_ensure_int64,
is_dtype_equal,
@@ -25,18 +31,15 @@
is_integer_dtype,
is_object_dtype,
is_string_dtype,
+ is_period_dtype,
is_timedelta64_dtype)
from pandas.core.dtypes.generic import (
ABCIndex, ABCSeries, ABCPeriodIndex, ABCIndexClass)
from pandas.core.dtypes.missing import isna
from pandas.core import common as com, algorithms, ops
from pandas.core.algorithms import checked_add_with_arr
-from pandas.errors import NullFrequencyError
+from pandas.errors import NullFrequencyError, PerformanceWarning
import pandas.io.formats.printing as printing
-from pandas._libs import lib, iNaT, NaT
-from pandas._libs.tslibs.period import Period
-from pandas._libs.tslibs.timedeltas import delta_to_nanoseconds
-from pandas._libs.tslibs.timestamps import round_ns
from pandas.core.indexes.base import Index, _index_shared_docs
from pandas.util._decorators import Appender, cache_readonly
@@ -637,13 +640,33 @@ def _sub_datelike(self, other):
def _sub_period(self, other):
return NotImplemented
- def _add_offset_array(self, other):
- # Array/Index of DateOffset objects
- return NotImplemented
+ def _addsub_offset_array(self, other, op):
+ """
+ Add or subtract array-like of DateOffset objects
- def _sub_offset_array(self, other):
- # Array/Index of DateOffset objects
- return NotImplemented
+ Parameters
+ ----------
+ other : Index, np.ndarray
+ object-dtype containing pd.DateOffset objects
+ op : {operator.add, operator.sub}
+
+ Returns
+ -------
+ result : same class as self
+ """
+ assert op in [operator.add, operator.sub]
+ if len(other) == 1:
+ return op(self, other[0])
+
+ warnings.warn("Adding/subtracting array of DateOffsets to "
+ "{cls} not vectorized"
+ .format(cls=type(self).__name__), PerformanceWarning)
+
+ res_values = op(self.astype('O').values, np.array(other))
+ kwargs = {}
+ if not is_period_dtype(self):
+ kwargs['freq'] = 'infer'
+ return self._constructor(res_values, **kwargs)
@classmethod
def _add_datetimelike_methods(cls):
@@ -660,13 +683,24 @@ def __add__(self, other):
other = lib.item_from_zerodim(other)
if isinstance(other, ABCSeries):
return NotImplemented
- elif is_timedelta64_dtype(other):
+
+ # scalar others
+ elif isinstance(other, (DateOffset, timedelta, np.timedelta64)):
result = self._add_delta(other)
- elif isinstance(other, (DateOffset, timedelta)):
+ elif isinstance(other, (datetime, np.datetime64)):
+ result = self._add_datelike(other)
+ elif is_integer(other):
+ # This check must come after the check for np.timedelta64
+ # as is_integer returns True for these
+ result = self.shift(other)
+
+ # array-like others
+ elif is_timedelta64_dtype(other):
+ # TimedeltaIndex, ndarray[timedelta64]
result = self._add_delta(other)
elif is_offsetlike(other):
# Array/Index of DateOffset objects
- result = self._add_offset_array(other)
+ result = self._addsub_offset_array(other, operator.add)
elif isinstance(self, TimedeltaIndex) and isinstance(other, Index):
if hasattr(other, '_add_delta'):
# i.e. DatetimeIndex, TimedeltaIndex, or PeriodIndex
@@ -674,12 +708,6 @@ def __add__(self, other):
else:
raise TypeError("cannot add TimedeltaIndex and {typ}"
.format(typ=type(other)))
- elif is_integer(other):
- # This check must come after the check for timedelta64_dtype
- # or else it will incorrectly catch np.timedelta64 objects
- result = self.shift(other)
- elif isinstance(other, (datetime, np.datetime64)):
- result = self._add_datelike(other)
elif isinstance(other, Index):
result = self._add_datelike(other)
elif is_integer_dtype(other) and self.freq is None:
@@ -709,13 +737,26 @@ def __sub__(self, other):
other = lib.item_from_zerodim(other)
if isinstance(other, ABCSeries):
return NotImplemented
- elif is_timedelta64_dtype(other):
+
+ # scalar others
+ elif isinstance(other, (DateOffset, timedelta, np.timedelta64)):
result = self._add_delta(-other)
- elif isinstance(other, (DateOffset, timedelta)):
+ elif isinstance(other, (datetime, np.datetime64)):
+ result = self._sub_datelike(other)
+ elif is_integer(other):
+ # This check must come after the check for np.timedelta64
+ # as is_integer returns True for these
+ result = self.shift(-other)
+ elif isinstance(other, Period):
+ result = self._sub_period(other)
+
+ # array-like others
+ elif is_timedelta64_dtype(other):
+ # TimedeltaIndex, ndarray[timedelta64]
result = self._add_delta(-other)
elif is_offsetlike(other):
# Array/Index of DateOffset objects
- result = self._sub_offset_array(other)
+ result = self._addsub_offset_array(other, operator.sub)
elif isinstance(self, TimedeltaIndex) and isinstance(other, Index):
# We checked above for timedelta64_dtype(other) so this
# must be invalid.
@@ -723,14 +764,6 @@ def __sub__(self, other):
.format(typ=type(other).__name__))
elif isinstance(other, DatetimeIndex):
result = self._sub_datelike(other)
- elif is_integer(other):
- # This check must come after the check for timedelta64_dtype
- # or else it will incorrectly catch np.timedelta64 objects
- result = self.shift(-other)
- elif isinstance(other, (datetime, np.datetime64)):
- result = self._sub_datelike(other)
- elif isinstance(other, Period):
- result = self._sub_period(other)
elif isinstance(other, Index):
raise TypeError("cannot subtract {typ1} and {typ2}"
.format(typ1=type(self).__name__,
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 17f92339e4205..36ea2bffb9531 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -964,29 +964,6 @@ def _add_offset(self, offset):
"or DatetimeIndex", PerformanceWarning)
return self.astype('O') + offset
- def _add_offset_array(self, other):
- # Array/Index of DateOffset objects
- if len(other) == 1:
- return self + other[0]
- else:
- warnings.warn("Adding/subtracting array of DateOffsets to "
- "{} not vectorized".format(type(self)),
- PerformanceWarning)
- return self.astype('O') + np.array(other)
- # TODO: pass freq='infer' like we do in _sub_offset_array?
- # TODO: This works for __add__ but loses dtype in __sub__
-
- def _sub_offset_array(self, other):
- # Array/Index of DateOffset objects
- if len(other) == 1:
- return self - other[0]
- else:
- warnings.warn("Adding/subtracting array of DateOffsets to "
- "{} not vectorized".format(type(self)),
- PerformanceWarning)
- res_values = self.astype('O').values - np.array(other)
- return self.__class__(res_values, freq='infer')
-
def _format_native_types(self, na_rep='NaT', date_format=None, **kwargs):
from pandas.io.formats.format import _get_format_datetime64_from_values
format = _get_format_datetime64_from_values(self, date_format)
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 4c14cbffcd813..f0567c9c963af 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -44,7 +44,6 @@
from pandas.util._decorators import (Appender, Substitution, cache_readonly,
deprecate_kwarg)
from pandas.compat import zip, u
-from pandas.errors import PerformanceWarning
import pandas.core.indexes.base as ibase
_index_doc_kwargs = dict(ibase._index_doc_kwargs)
@@ -745,28 +744,6 @@ def _sub_period(self, other):
# result must be Int64Index or Float64Index
return Index(new_data)
- def _add_offset_array(self, other):
- # Array/Index of DateOffset objects
- if len(other) == 1:
- return self + other[0]
- else:
- warnings.warn("Adding/subtracting array of DateOffsets to "
- "{cls} not vectorized"
- .format(cls=type(self).__name__), PerformanceWarning)
- res_values = self.astype('O').values + np.array(other)
- return self.__class__(res_values)
-
- def _sub_offset_array(self, other):
- # Array/Index of DateOffset objects
- if len(other) == 1:
- return self - other[0]
- else:
- warnings.warn("Adding/subtracting array of DateOffsets to "
- "{cls} not vectorized"
- .format(cls=type(self).__name__), PerformanceWarning)
- res_values = self.astype('O').values - np.array(other)
- return self.__class__(res_values)
-
def shift(self, n):
"""
Specialized shift which produces an PeriodIndex
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 3542a24290f89..219adfdb66c82 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -1,7 +1,6 @@
""" implement the TimedeltaIndex """
from datetime import timedelta
-import warnings
import numpy as np
from pandas.core.dtypes.common import (
@@ -433,43 +432,16 @@ def _sub_datelike(self, other):
else:
raise TypeError("cannot subtract a datelike from a TimedeltaIndex")
- def _add_offset_array(self, other):
- # Array/Index of DateOffset objects
+ def _addsub_offset_array(self, other, op):
+ # Add or subtract Array-like of DateOffset objects
try:
# TimedeltaIndex can only operate with a subset of DateOffset
# subclasses. Incompatible classes will raise AttributeError,
# which we re-raise as TypeError
- if len(other) == 1:
- return self + other[0]
- else:
- from pandas.errors import PerformanceWarning
- warnings.warn("Adding/subtracting array of DateOffsets to "
- "{} not vectorized".format(type(self)),
- PerformanceWarning)
- return self.astype('O') + np.array(other)
- # TODO: pass freq='infer' like we do in _sub_offset_array?
- # TODO: This works for __add__ but loses dtype in __sub__
- except AttributeError:
- raise TypeError("Cannot add non-tick DateOffset to TimedeltaIndex")
-
- def _sub_offset_array(self, other):
- # Array/Index of DateOffset objects
- try:
- # TimedeltaIndex can only operate with a subset of DateOffset
- # subclasses. Incompatible classes will raise AttributeError,
- # which we re-raise as TypeError
- if len(other) == 1:
- return self - other[0]
- else:
- from pandas.errors import PerformanceWarning
- warnings.warn("Adding/subtracting array of DateOffsets to "
- "{} not vectorized".format(type(self)),
- PerformanceWarning)
- res_values = self.astype('O').values - np.array(other)
- return self.__class__(res_values, freq='infer')
+ return DatetimeIndexOpsMixin._addsub_offset_array(self, other, op)
except AttributeError:
- raise TypeError("Cannot subtrack non-tick DateOffset from"
- " TimedeltaIndex")
+ raise TypeError("Cannot add/subtract non-tick DateOffset to {cls}"
+ .format(cls=type(self).__name__))
def _format_native_types(self, na_rep=u('NaT'),
date_format=None, **kwargs):
| Combine DTI/TDI/PI add_offset_array and sub_offset_array methods.
Re-order `__add__` and `__sub__` if/else branches to put scalars up front.
This was going to include fixes for DTI/TDI with ndarray[timedelta64]/ndarray[datetime64], but the diff got big enough to split that off to the next one. | https://api.github.com/repos/pandas-dev/pandas/pulls/19835 | 2018-02-22T05:15:07Z | 2018-02-24T14:43:35Z | 2018-02-24T14:43:35Z | 2018-06-22T03:28:35Z |
Continue porting period_helper; fix leftover asfreq bug | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 4c1e98b236db7..c1ba35dff90ed 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -763,7 +763,7 @@ Timedelta
- Bug in :class:`TimedeltaIndex` where division by a ``Series`` would return a ``TimedeltaIndex`` instead of a ``Series`` (:issue:`19042`)
- Bug in :func:`Timedelta.__add__`, :func:`Timedelta.__sub__` where adding or subtracting a ``np.timedelta64`` object would return another ``np.timedelta64`` instead of a ``Timedelta`` (:issue:`19738`)
- Bug in :func:`Timedelta.__floordiv__`, :func:`Timedelta.__rfloordiv__` where operating with a ``Tick`` object would raise a ``TypeError`` instead of returning a numeric value (:issue:`19738`)
-- Bug in :func:`Period.asfreq` where periods near ``datetime(1, 1, 1)`` could be converted incorrectly (:issue:`19643`)
+- Bug in :func:`Period.asfreq` where periods near ``datetime(1, 1, 1)`` could be converted incorrectly (:issue:`19643`, :issue:`19834`)
- Bug in :func:`Timedelta.total_seconds()` causing precision errors i.e. ``Timedelta('30S').total_seconds()==30.000000000000004`` (:issue:`19458`)
-
diff --git a/pandas/_libs/src/period_helper.c b/pandas/_libs/src/period_helper.c
index a812ed2e7e2b3..e3d250aa44f17 100644
--- a/pandas/_libs/src/period_helper.c
+++ b/pandas/_libs/src/period_helper.c
@@ -42,10 +42,10 @@ static int floordiv(int x, int divisor) {
static int monthToQuarter(int month) { return ((month - 1) / 3) + 1; }
-/* Find the absdate (days elapsed since datetime(1, 1, 1)
+/* Find the unix_date (days elapsed since datetime(1970, 1, 1)
* for the given year/month/day.
* Assumes GREGORIAN_CALENDAR */
-npy_int64 absdate_from_ymd(int year, int month, int day) {
+npy_int64 unix_date_from_ymd(int year, int month, int day) {
/* Calculate the absolute date */
pandas_datetimestruct dts;
npy_int64 unix_date;
@@ -55,16 +55,16 @@ npy_int64 absdate_from_ymd(int year, int month, int day) {
dts.month = month;
dts.day = day;
unix_date = pandas_datetimestruct_to_datetime(PANDAS_FR_D, &dts);
- return ORD_OFFSET + unix_date;
+ return unix_date;
}
/* Sets the date part of the date_info struct
Assumes GREGORIAN_CALENDAR */
static int dInfoCalc_SetFromAbsDate(register struct date_info *dinfo,
- npy_int64 absdate) {
+ npy_int64 unix_date) {
pandas_datetimestruct dts;
- pandas_datetime_to_datetimestruct(absdate - ORD_OFFSET, PANDAS_FR_D, &dts);
+ pandas_datetime_to_datetimestruct(unix_date, PANDAS_FR_D, &dts);
dinfo->year = dts.year;
dinfo->month = dts.month;
dinfo->day = dts.day;
@@ -137,26 +137,26 @@ PANDAS_INLINE npy_int64 transform_via_day(npy_int64 ordinal,
return result;
}
-static npy_int64 DtoB_weekday(npy_int64 absdate) {
- return floordiv(absdate, 7) * 5 + mod_compat(absdate, 7) - BDAY_OFFSET;
+static npy_int64 DtoB_weekday(npy_int64 unix_date) {
+ return floordiv(unix_date + 4, 7) * 5 + mod_compat(unix_date + 4, 7) - 4;
}
static npy_int64 DtoB(struct date_info *dinfo,
- int roll_back, npy_int64 absdate) {
+ int roll_back, npy_int64 unix_date) {
int day_of_week = dayofweek(dinfo->year, dinfo->month, dinfo->day);
if (roll_back == 1) {
if (day_of_week > 4) {
// change to friday before weekend
- absdate -= (day_of_week - 4);
+ unix_date -= (day_of_week - 4);
}
} else {
if (day_of_week > 4) {
// change to Monday after weekend
- absdate += (7 - day_of_week);
+ unix_date += (7 - day_of_week);
}
}
- return DtoB_weekday(absdate);
+ return DtoB_weekday(unix_date);
}
@@ -165,18 +165,19 @@ static npy_int64 DtoB(struct date_info *dinfo,
static npy_int64 asfreq_DTtoA(npy_int64 ordinal, asfreq_info *af_info) {
struct date_info dinfo;
ordinal = downsample_daytime(ordinal, af_info);
- dInfoCalc_SetFromAbsDate(&dinfo, ordinal + ORD_OFFSET);
+ dInfoCalc_SetFromAbsDate(&dinfo, ordinal);
if (dinfo.month > af_info->to_a_year_end) {
- return (npy_int64)(dinfo.year + 1 - BASE_YEAR);
+ return (npy_int64)(dinfo.year + 1 - 1970);
} else {
- return (npy_int64)(dinfo.year - BASE_YEAR);
+ return (npy_int64)(dinfo.year - 1970);
}
}
-static npy_int64 DtoQ_yq(npy_int64 ordinal, asfreq_info *af_info, int *year,
- int *quarter) {
+static int DtoQ_yq(npy_int64 ordinal, asfreq_info *af_info, int *year) {
struct date_info dinfo;
- dInfoCalc_SetFromAbsDate(&dinfo, ordinal + ORD_OFFSET);
+ int quarter;
+
+ dInfoCalc_SetFromAbsDate(&dinfo, ordinal);
if (af_info->to_q_year_end != 12) {
dinfo.month -= af_info->to_q_year_end;
if (dinfo.month <= 0) {
@@ -187,9 +188,8 @@ static npy_int64 DtoQ_yq(npy_int64 ordinal, asfreq_info *af_info, int *year,
}
*year = dinfo.year;
- *quarter = monthToQuarter(dinfo.month);
-
- return 0;
+ quarter = monthToQuarter(dinfo.month);
+ return quarter;
}
static npy_int64 asfreq_DTtoQ(npy_int64 ordinal, asfreq_info *af_info) {
@@ -197,8 +197,8 @@ static npy_int64 asfreq_DTtoQ(npy_int64 ordinal, asfreq_info *af_info) {
ordinal = downsample_daytime(ordinal, af_info);
- DtoQ_yq(ordinal, af_info, &year, &quarter);
- return (npy_int64)((year - BASE_YEAR) * 4 + quarter - 1);
+ quarter = DtoQ_yq(ordinal, af_info, &year);
+ return (npy_int64)((year - 1970) * 4 + quarter - 1);
}
static npy_int64 asfreq_DTtoM(npy_int64 ordinal, asfreq_info *af_info) {
@@ -206,28 +206,25 @@ static npy_int64 asfreq_DTtoM(npy_int64 ordinal, asfreq_info *af_info) {
ordinal = downsample_daytime(ordinal, af_info);
- dInfoCalc_SetFromAbsDate(&dinfo, ordinal + ORD_OFFSET);
- return (npy_int64)((dinfo.year - BASE_YEAR) * 12 + dinfo.month - 1);
+ dInfoCalc_SetFromAbsDate(&dinfo, ordinal);
+ return (npy_int64)((dinfo.year - 1970) * 12 + dinfo.month - 1);
}
static npy_int64 asfreq_DTtoW(npy_int64 ordinal, asfreq_info *af_info) {
ordinal = downsample_daytime(ordinal, af_info);
- return (ordinal + ORD_OFFSET - (1 + af_info->to_week_end)) / 7 + 1 -
- WEEK_OFFSET;
+ return floordiv(ordinal + 3 - af_info->to_week_end, 7) + 1;
}
static npy_int64 asfreq_DTtoB(npy_int64 ordinal, asfreq_info *af_info) {
struct date_info dinfo;
- npy_int64 absdate;
int roll_back;
ordinal = downsample_daytime(ordinal, af_info);
- absdate = ordinal + ORD_OFFSET;
- dInfoCalc_SetFromAbsDate(&dinfo, absdate);
+ dInfoCalc_SetFromAbsDate(&dinfo, ordinal);
// This usage defines roll_back the opposite way from the others
roll_back = 1 - af_info->is_end;
- return DtoB(&dinfo, roll_back, absdate);
+ return DtoB(&dinfo, roll_back, ordinal);
}
// all intra day calculations are now done within one function
@@ -243,10 +240,7 @@ static npy_int64 asfreq_UpsampleWithinDay(npy_int64 ordinal,
//************ FROM BUSINESS ***************
static npy_int64 asfreq_BtoDT(npy_int64 ordinal, asfreq_info *af_info) {
- ordinal += BDAY_OFFSET;
- ordinal =
- (floordiv(ordinal - 1, 5) * 7 + mod_compat(ordinal - 1, 5) + 1 -
- ORD_OFFSET);
+ ordinal = floordiv(ordinal + 3, 5) * 7 + mod_compat(ordinal + 3, 5) - 3;
return upsample_daytime(ordinal, af_info);
}
@@ -270,8 +264,7 @@ static npy_int64 asfreq_BtoW(npy_int64 ordinal, asfreq_info *af_info) {
//************ FROM WEEKLY ***************
static npy_int64 asfreq_WtoDT(npy_int64 ordinal, asfreq_info *af_info) {
- ordinal = (ordinal + WEEK_OFFSET) * 7 +
- af_info->from_week_end - ORD_OFFSET +
+ ordinal = ordinal * 7 + af_info->from_week_end - 4 +
(7 - 1) * (af_info->is_end - 1);
return upsample_daytime(ordinal, af_info);
}
@@ -294,30 +287,29 @@ static npy_int64 asfreq_WtoW(npy_int64 ordinal, asfreq_info *af_info) {
static npy_int64 asfreq_WtoB(npy_int64 ordinal, asfreq_info *af_info) {
struct date_info dinfo;
- npy_int64 absdate = asfreq_WtoDT(ordinal, af_info) + ORD_OFFSET;
+ npy_int64 unix_date = asfreq_WtoDT(ordinal, af_info);
int roll_back = af_info->is_end;
- dInfoCalc_SetFromAbsDate(&dinfo, absdate);
+ dInfoCalc_SetFromAbsDate(&dinfo, unix_date);
- return DtoB(&dinfo, roll_back, absdate);
+ return DtoB(&dinfo, roll_back, unix_date);
}
//************ FROM MONTHLY ***************
static void MtoD_ym(npy_int64 ordinal, int *y, int *m) {
- *y = floordiv(ordinal, 12) + BASE_YEAR;
+ *y = floordiv(ordinal, 12) + 1970;
*m = mod_compat(ordinal, 12) + 1;
}
static npy_int64 asfreq_MtoDT(npy_int64 ordinal, asfreq_info *af_info) {
- npy_int64 absdate;
+ npy_int64 unix_date;
int y, m;
ordinal += af_info->is_end;
MtoD_ym(ordinal, &y, &m);
- absdate = absdate_from_ymd(y, m, 1);
- ordinal = absdate - ORD_OFFSET;
+ unix_date = unix_date_from_ymd(y, m, 1);
- ordinal -= af_info->is_end;
- return upsample_daytime(ordinal, af_info);
+ unix_date -= af_info->is_end;
+ return upsample_daytime(unix_date, af_info);
}
static npy_int64 asfreq_MtoA(npy_int64 ordinal, asfreq_info *af_info) {
@@ -334,18 +326,18 @@ static npy_int64 asfreq_MtoW(npy_int64 ordinal, asfreq_info *af_info) {
static npy_int64 asfreq_MtoB(npy_int64 ordinal, asfreq_info *af_info) {
struct date_info dinfo;
- npy_int64 absdate = asfreq_MtoDT(ordinal, af_info) + ORD_OFFSET;
+ npy_int64 unix_date = asfreq_MtoDT(ordinal, af_info);
int roll_back = af_info->is_end;
- dInfoCalc_SetFromAbsDate(&dinfo, absdate);
+ dInfoCalc_SetFromAbsDate(&dinfo, unix_date);
- return DtoB(&dinfo, roll_back, absdate);
+ return DtoB(&dinfo, roll_back, unix_date);
}
//************ FROM QUARTERLY ***************
static void QtoD_ym(npy_int64 ordinal, int *y, int *m, asfreq_info *af_info) {
- *y = floordiv(ordinal, 4) + BASE_YEAR;
+ *y = floordiv(ordinal, 4) + 1970;
*m = mod_compat(ordinal, 4) * 3 + 1;
if (af_info->from_q_year_end != 12) {
@@ -359,16 +351,16 @@ static void QtoD_ym(npy_int64 ordinal, int *y, int *m, asfreq_info *af_info) {
}
static npy_int64 asfreq_QtoDT(npy_int64 ordinal, asfreq_info *af_info) {
- npy_int64 absdate;
+ npy_int64 unix_date;
int y, m;
ordinal += af_info->is_end;
QtoD_ym(ordinal, &y, &m, af_info);
- absdate = absdate_from_ymd(y, m, 1);
+ unix_date = unix_date_from_ymd(y, m, 1);
- absdate -= af_info->is_end;
- return upsample_daytime(absdate - ORD_OFFSET, af_info);
+ unix_date -= af_info->is_end;
+ return upsample_daytime(unix_date, af_info);
}
static npy_int64 asfreq_QtoQ(npy_int64 ordinal, asfreq_info *af_info) {
@@ -389,21 +381,21 @@ static npy_int64 asfreq_QtoW(npy_int64 ordinal, asfreq_info *af_info) {
static npy_int64 asfreq_QtoB(npy_int64 ordinal, asfreq_info *af_info) {
struct date_info dinfo;
- npy_int64 absdate = asfreq_QtoDT(ordinal, af_info) + ORD_OFFSET;
+ npy_int64 unix_date = asfreq_QtoDT(ordinal, af_info);
int roll_back = af_info->is_end;
- dInfoCalc_SetFromAbsDate(&dinfo, absdate);
+ dInfoCalc_SetFromAbsDate(&dinfo, unix_date);
- return DtoB(&dinfo, roll_back, absdate);
+ return DtoB(&dinfo, roll_back, unix_date);
}
//************ FROM ANNUAL ***************
static npy_int64 asfreq_AtoDT(npy_int64 ordinal, asfreq_info *af_info) {
- npy_int64 absdate;
+ npy_int64 unix_date;
// start from 1970
- npy_int64 year = ordinal + BASE_YEAR;
+ npy_int64 year = ordinal + 1970;
int month = (af_info->from_a_year_end % 12) + 1;
if (af_info->from_a_year_end != 12) {
@@ -411,10 +403,10 @@ static npy_int64 asfreq_AtoDT(npy_int64 ordinal, asfreq_info *af_info) {
}
year += af_info->is_end;
- absdate = absdate_from_ymd(year, month, 1);
+ unix_date = unix_date_from_ymd(year, month, 1);
- absdate -= af_info->is_end;
- return upsample_daytime(absdate - ORD_OFFSET, af_info);
+ unix_date -= af_info->is_end;
+ return upsample_daytime(unix_date, af_info);
}
static npy_int64 asfreq_AtoA(npy_int64 ordinal, asfreq_info *af_info) {
@@ -435,11 +427,11 @@ static npy_int64 asfreq_AtoW(npy_int64 ordinal, asfreq_info *af_info) {
static npy_int64 asfreq_AtoB(npy_int64 ordinal, asfreq_info *af_info) {
struct date_info dinfo;
- npy_int64 absdate = asfreq_AtoDT(ordinal, af_info) + ORD_OFFSET;
+ npy_int64 unix_date = asfreq_AtoDT(ordinal, af_info);
int roll_back = af_info->is_end;
- dInfoCalc_SetFromAbsDate(&dinfo, absdate);
+ dInfoCalc_SetFromAbsDate(&dinfo, unix_date);
- return DtoB(&dinfo, roll_back, absdate);
+ return DtoB(&dinfo, roll_back, unix_date);
}
static npy_int64 nofunc(npy_int64 ordinal, asfreq_info *af_info) {
diff --git a/pandas/_libs/src/period_helper.h b/pandas/_libs/src/period_helper.h
index 1573b1eeec74b..7163dc960d152 100644
--- a/pandas/_libs/src/period_helper.h
+++ b/pandas/_libs/src/period_helper.h
@@ -20,32 +20,8 @@ frequency conversion routines.
#include "limits.h"
#include "numpy/ndarraytypes.h"
-/*
- * declarations from period here
- */
-
-#define Py_Error(errortype, errorstr) \
- { \
- PyErr_SetString(errortype, errorstr); \
- goto onError; \
- }
-
/*** FREQUENCY CONSTANTS ***/
-// HIGHFREQ_ORIG is the datetime ordinal from which to begin the second
-// frequency ordinal sequence
-
-// #define HIGHFREQ_ORIG 62135683200LL
-#define BASE_YEAR 1970
-#define ORD_OFFSET 719163LL // days until 1970-01-01
-#define BDAY_OFFSET 513689LL // days until 1970-01-01
-#define WEEK_OFFSET 102737LL
-#define BASE_WEEK_TO_DAY_OFFSET \
- 1 // difference between day 0 and end of week in days
-#define DAYS_PER_WEEK 7
-#define BUSINESS_DAYS_PER_WEEK 5
-#define HIGHFREQ_ORIG 0 // ORD_OFFSET * 86400LL // days until 1970-01-01
-
#define FR_ANN 1000 /* Annual */
#define FR_ANNDEC FR_ANN /* Annual - December year end*/
#define FR_ANNJAN 1001 /* Annual - January year end*/
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index e1c783ac9fa54..f1a193706144f 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -75,10 +75,6 @@ cdef extern from "period_helper.h":
int FR_BUS
int FR_UND
- int ORD_OFFSET
- int WEEK_OFFSET
- int BDAY_OFFSET
-
ctypedef struct date_info:
double second
int minute
@@ -181,7 +177,7 @@ cdef int64_t get_period_ordinal(int year, int month, int day,
period_ordinal : int64_t
"""
cdef:
- int64_t absdays, unix_date, seconds, delta
+ int64_t unix_date, seconds, delta
int64_t weeks
int64_t day_adj
int freq_group, fmonth, mdiff
@@ -215,8 +211,7 @@ cdef int64_t get_period_ordinal(int year, int month, int day,
elif freq == FR_MTH:
return (year - 1970) * 12 + month - 1
- absdays = absdate_from_ymd(year, month, day)
- unix_date = absdays - ORD_OFFSET
+ unix_date = unix_date_from_ymd(year, month, day)
if freq >= FR_SEC:
seconds = unix_date * 86400 + hour * 3600 + minute * 60 + second
@@ -247,48 +242,48 @@ cdef int64_t get_period_ordinal(int year, int month, int day,
return unix_date
elif freq == FR_BUS:
- # calculate the current week assuming sunday as last day of a week
- # Jan 1 0001 is a Monday, so subtract 1 to get to end-of-week
- weeks = (unix_date + ORD_OFFSET - 1) // 7
+ # calculate the current week (counting from 1970-01-01) treating
+ # sunday as last day of a week
+ weeks = (unix_date + 3) // 7
# calculate the current weekday (in range 1 .. 7)
- delta = (unix_date + ORD_OFFSET - 1) % 7 + 1
+ delta = (unix_date + 3) % 7 + 1
# return the number of business days in full weeks plus the business
# days in the last - possible partial - week
if delta <= 5:
- return (weeks * 5) + delta - BDAY_OFFSET
+ return (5 * weeks) + delta - 4
else:
- return (weeks * 5) + (5 + 1) - BDAY_OFFSET
+ return (5 * weeks) + (5 + 1) - 4
elif freq_group == FR_WK:
day_adj = freq - FR_WK
- return (unix_date + ORD_OFFSET - (1 + day_adj)) // 7 + 1 - WEEK_OFFSET
+ return (unix_date + 3 - day_adj) // 7 + 1
# raise ValueError
cdef void get_date_info(int64_t ordinal, int freq, date_info *dinfo) nogil:
cdef:
- int64_t absdate
+ int64_t unix_date
double abstime
- absdate = get_python_ordinal(ordinal, freq);
- abstime = get_abs_time(freq, absdate - ORD_OFFSET, ordinal)
+ unix_date = get_unix_date(ordinal, freq)
+ abstime = get_abs_time(freq, unix_date, ordinal)
while abstime < 0:
abstime += 86400
- absdate -= 1
+ unix_date -= 1
while abstime >= 86400:
abstime -= 86400
- absdate += 1
+ unix_date += 1
- dInfoCalc_SetFromAbsDateTime(dinfo, absdate, abstime)
+ date_info_from_days_and_time(dinfo, unix_date, abstime)
-cdef int64_t get_python_ordinal(int64_t period_ordinal, int freq) nogil:
+cdef int64_t get_unix_date(int64_t period_ordinal, int freq) nogil:
"""
Returns the proleptic Gregorian ordinal of the date, as an integer.
- This corresponds to the number of days since Jan., 1st, 1AD.
+ This corresponds to the number of days since Jan., 1st, 1970 AD.
When the instance has a frequency less than daily, the proleptic date
is calculated for the last day of the period.
@@ -299,92 +294,56 @@ cdef int64_t get_python_ordinal(int64_t period_ordinal, int freq) nogil:
Returns
-------
- absdate : int64_t number of days since datetime(1, 1, 1)
+ unix_date : int64_t number of days since datetime(1970, 1, 1)
"""
cdef:
asfreq_info af_info
freq_conv_func toDaily = NULL
if freq == FR_DAY:
- return period_ordinal + ORD_OFFSET
+ return period_ordinal
toDaily = get_asfreq_func(freq, FR_DAY)
get_asfreq_info(freq, FR_DAY, 'E', &af_info)
- return toDaily(period_ordinal, &af_info) + ORD_OFFSET
+ return toDaily(period_ordinal, &af_info)
-cdef void dInfoCalc_SetFromAbsDateTime(date_info *dinfo,
- int64_t absdate, double abstime) nogil:
+@cython.cdivision
+cdef void date_info_from_days_and_time(date_info *dinfo,
+ int64_t unix_date,
+ double abstime) nogil:
"""
Set the instance's value using the given date and time.
- Assumes GREGORIAN_CALENDAR.
Parameters
----------
dinfo : date_info*
- absdate : int64_t
- days elapsed since datetime(1, 1, 1)
+ unix_date : int64_t
+ days elapsed since datetime(1970, 1, 1)
abstime : double
- seconds elapsed since beginning of day described by absdate
+ seconds elapsed since beginning of day described by unix_date
Notes
-----
Updates dinfo inplace
"""
+ cdef:
+ pandas_datetimestruct dts
+ int inttime
+ int hour, minute
+ double second
+
# Bounds check
# The calling function is responsible for ensuring that
# abstime >= 0.0 and abstime <= 86400
# Calculate the date
- dInfoCalc_SetFromAbsDate(dinfo, absdate)
-
- # Calculate the time
- dInfoCalc_SetFromAbsTime(dinfo, abstime)
-
-
-cdef void dInfoCalc_SetFromAbsDate(date_info *dinfo, int64_t absdate) nogil:
- """
- Sets the date part of the date_info struct
- Assumes GREGORIAN_CALENDAR
-
- Parameters
- ----------
- dinfo : date_info*
- unix_date : int64_t
-
- Notes
- -----
- Updates dinfo inplace
- """
- cdef:
- pandas_datetimestruct dts
-
- pandas_datetime_to_datetimestruct(absdate - ORD_OFFSET, PANDAS_FR_D, &dts)
+ pandas_datetime_to_datetimestruct(unix_date, PANDAS_FR_D, &dts)
dinfo.year = dts.year
dinfo.month = dts.month
dinfo.day = dts.day
-
-@cython.cdivision
-cdef void dInfoCalc_SetFromAbsTime(date_info *dinfo, double abstime) nogil:
- """
- Sets the time part of the DateTime object.
-
- Parameters
- ----------
- dinfo : date_info*
- abstime : double
- seconds elapsed since beginning of day described by absdate
-
- Notes
- -----
- Updates dinfo inplace
- """
- cdef:
- int inttime
- int hour, minute
- double second
-
+ # Calculate the time
inttime = <int>abstime
hour = inttime / 3600
minute = (inttime % 3600) / 60
@@ -396,8 +355,7 @@ cdef void dInfoCalc_SetFromAbsTime(date_info *dinfo, double abstime) nogil:
@cython.cdivision
-cdef double get_abs_time(int freq, int64_t date_ordinal,
- int64_t ordinal) nogil:
+cdef double get_abs_time(int freq, int64_t unix_date, int64_t ordinal) nogil:
cdef:
int freq_index, day_index, base_index
int64_t per_day, start_ord
@@ -416,16 +374,15 @@ cdef double get_abs_time(int freq, int64_t date_ordinal,
if base_index < freq_index:
unit = 1 / unit
- start_ord = date_ordinal * per_day
+ start_ord = unix_date * per_day
result = <double>(unit * (ordinal - start_ord))
return result
-cdef int64_t absdate_from_ymd(int year, int month, int day) nogil:
+cdef int64_t unix_date_from_ymd(int year, int month, int day) nogil:
"""
- Find the absdate (days elapsed since datetime(1, 1, 1)
+ Find the unix_date (days elapsed since datetime(1970, 1, 1)
for the given year/month/day.
- Assumes GREGORIAN_CALENDAR
Parameters
----------
@@ -435,11 +392,9 @@ cdef int64_t absdate_from_ymd(int year, int month, int day) nogil:
Returns
-------
- absdate : int
- days elapsed since datetime(1, 1, 1)
+ unix_date : int
+ days elapsed since datetime(1970, 1, 1)
"""
-
- # /* Calculate the absolute date
cdef:
pandas_datetimestruct dts
int64_t unix_date
@@ -449,7 +404,7 @@ cdef int64_t absdate_from_ymd(int year, int month, int day) nogil:
dts.month = month
dts.day = day
unix_date = pandas_datetimestruct_to_datetime(PANDAS_FR_D, &dts)
- return ORD_OFFSET + unix_date
+ return unix_date
cdef int get_yq(int64_t ordinal, int freq, int *quarter, int *year):
@@ -475,9 +430,9 @@ cdef int get_yq(int64_t ordinal, int freq, int *quarter, int *year):
cdef:
asfreq_info af_info
int qtr_freq
- int64_t daily_ord
+ int64_t unix_date
- daily_ord = get_python_ordinal(ordinal, freq) - ORD_OFFSET
+ unix_date = get_unix_date(ordinal, freq)
if get_freq_group(freq) == FR_QTR:
qtr_freq = freq
@@ -486,16 +441,16 @@ cdef int get_yq(int64_t ordinal, int freq, int *quarter, int *year):
get_asfreq_info(FR_DAY, qtr_freq, 'E', &af_info)
- DtoQ_yq(daily_ord, &af_info, year, quarter)
+ quarter[0] = DtoQ_yq(unix_date, &af_info, year)
return qtr_freq
-cdef void DtoQ_yq(int64_t ordinal, asfreq_info *af_info,
- int *year, int *quarter):
+cdef int DtoQ_yq(int64_t unix_date, asfreq_info *af_info, int *year):
cdef:
date_info dinfo
+ int quarter
- dInfoCalc_SetFromAbsDate(&dinfo, ordinal + ORD_OFFSET)
+ date_info_from_days_and_time(&dinfo, unix_date, 0)
if af_info.to_q_year_end != 12:
dinfo.month -= af_info.to_q_year_end
@@ -505,10 +460,11 @@ cdef void DtoQ_yq(int64_t ordinal, asfreq_info *af_info,
dinfo.year += 1
year[0] = dinfo.year
- quarter[0] = monthToQuarter(dinfo.month)
+ quarter = month_to_quarter(dinfo.month)
+ return quarter
-cdef inline int monthToQuarter(int month):
+cdef inline int month_to_quarter(int month):
return (month - 1) // 3 + 1
@@ -678,7 +634,7 @@ def period_format(int64_t value, int freq, object fmt=None):
return repr(NaT)
if fmt is None:
- freq_group = (freq // 1000) * 1000
+ freq_group = get_freq_group(freq)
if freq_group == 1000: # FR_ANN
fmt = b'%Y'
elif freq_group == 2000: # FR_QTR
@@ -1620,8 +1576,8 @@ class Period(_Period):
return cls._from_ordinal(ordinal, freq)
-def _ordinal_from_fields(year, month, quarter, day,
- hour, minute, second, freq):
+cdef int64_t _ordinal_from_fields(year, month, quarter, day,
+ hour, minute, second, freq):
base, mult = get_freq_code(freq)
if quarter is not None:
year, month = _quarter_to_myear(year, quarter, freq)
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index dff5433adcf79..f43ab0704f0f4 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -1440,3 +1440,10 @@ def test_period_immutable():
freq = per.freq
with pytest.raises(AttributeError):
per.freq = 2 * freq
+
+
+@pytest.mark.xfail(reason='GH#19834 Period parsing error')
+def test_small_year_parsing():
+ per1 = Period('0001-01-07', 'D')
+ assert per1.year == 1
+ assert per1.day == 7
diff --git a/pandas/tests/scalar/period/test_period_asfreq.py b/pandas/tests/scalar/period/test_period_asfreq.py
index 9f8b2562e9e20..474d19809b03c 100644
--- a/pandas/tests/scalar/period/test_period_asfreq.py
+++ b/pandas/tests/scalar/period/test_period_asfreq.py
@@ -21,6 +21,16 @@ def test_asfreq_near_zero(self, freq):
tup2 = (prev.year, prev.month, prev.day)
assert tup2 < tup1
+ def test_asfreq_near_zero_weekly(self):
+ # GH#19834
+ per1 = Period('0001-01-01', 'D') + 6
+ per2 = Period('0001-01-01', 'D') - 6
+ week1 = per1.asfreq('W')
+ week2 = per2.asfreq('W')
+ assert week1 != week2
+ assert week1.asfreq('D', 'E') >= per1
+ assert week2.asfreq('D', 'S') <= per2
+
@pytest.mark.xfail(reason='GH#19643 period_helper asfreq functions fail '
'to check for overflows')
def test_to_timestamp_out_of_bounds(self):
| In #19650 we fixed a bug with asfreq but missed a weekly-frequency case. This fixes and tests that. I'll see if I can cook up a more thorough set of tests to make sure nothing else slips through the cracks.
Other than that, the main thing this does is substitute in `ORD_OFFSET = WEEK_OFFSET * 7 + 4` and `BDAY_OFFSET = 5 * WEEK_OFFSET + 4` and then cleans up some algebra (which is now OK because we are using non-cdivision floordiv and mod). As a result we get rid of a bunch of calls that add ORD_OFFSET just to subtract it a few lines later.
Gets rid of CamelCase in tslibs.period, moves towards using pandas_datetimestruct directly and getting rid of the redundant `date_info`.
Catches a RuntimeWarning in the tests; closes #19767.
| https://api.github.com/repos/pandas-dev/pandas/pulls/19834 | 2018-02-22T02:27:13Z | 2018-02-23T11:35:01Z | 2018-02-23T11:35:01Z | 2018-02-23T15:27:43Z |
BUG: Fix qcut with NaT present | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 4c1e98b236db7..86661eb5e4414 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -896,6 +896,7 @@ Reshaping
- Bug in :func:`DataFrame.join` which does an ``outer`` instead of a ``left`` join when being called with multiple DataFrames and some have non-unique indices (:issue:`19624`)
- :func:`Series.rename` now accepts ``axis`` as a kwarg (:issue:`18589`)
- Comparisons between :class:`Series` and :class:`Index` would return a ``Series`` with an incorrect name, ignoring the ``Index``'s name attribute (:issue:`19582`)
+- Bug in :func:`qcut` where datetime and timedelta data with ``NaT`` present raised a ``ValueError`` (:issue:`19768`)
Other
^^^^^
diff --git a/pandas/core/reshape/tile.py b/pandas/core/reshape/tile.py
index 777f08bd9db2b..359c030157bd3 100644
--- a/pandas/core/reshape/tile.py
+++ b/pandas/core/reshape/tile.py
@@ -279,18 +279,22 @@ def _trim_zeros(x):
def _coerce_to_type(x):
"""
if the passed data is of datetime/timedelta type,
- this method converts it to integer so that cut method can
+ this method converts it to numeric so that cut method can
handle it
"""
dtype = None
if is_timedelta64_dtype(x):
- x = to_timedelta(x).view(np.int64)
+ x = to_timedelta(x)
dtype = np.timedelta64
elif is_datetime64_dtype(x):
- x = to_datetime(x).view(np.int64)
+ x = to_datetime(x)
dtype = np.datetime64
+ if dtype is not None:
+ # GH 19768: force NaT to NaN during integer conversion
+ x = np.where(x.notna(), x.view(np.int64), np.nan)
+
return x, dtype
diff --git a/pandas/tests/reshape/test_tile.py b/pandas/tests/reshape/test_tile.py
index f7262a2f0da63..ff914273d47b1 100644
--- a/pandas/tests/reshape/test_tile.py
+++ b/pandas/tests/reshape/test_tile.py
@@ -6,7 +6,8 @@
from pandas import (Series, isna, to_datetime, DatetimeIndex,
Timestamp, Interval, IntervalIndex, Categorical,
- cut, qcut, date_range)
+ cut, qcut, date_range, NaT, TimedeltaIndex)
+from pandas.tseries.offsets import Nano, Day
import pandas.util.testing as tm
from pandas.api.types import CategoricalDtype as CDT
@@ -250,6 +251,18 @@ def test_qcut_nas(self):
result = qcut(arr, 4)
assert isna(result[:20]).all()
+ @pytest.mark.parametrize('s', [
+ Series(DatetimeIndex(['20180101', NaT, '20180103'])),
+ Series(TimedeltaIndex(['0 days', NaT, '2 days']))],
+ ids=lambda x: str(x.dtype))
+ def test_qcut_nat(self, s):
+ # GH 19768
+ intervals = IntervalIndex.from_tuples(
+ [(s[0] - Nano(), s[2] - Day()), np.nan, (s[2] - Day(), s[2])])
+ expected = Series(Categorical(intervals, ordered=True))
+ result = qcut(s, 2)
+ tm.assert_series_equal(result, expected)
+
def test_qcut_index(self):
result = qcut([0, 2], 2)
intervals = [Interval(-0.001, 1), Interval(1, 2)]
| - [X] closes #19768
- [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/19833 | 2018-02-22T01:05:37Z | 2018-02-22T11:39:39Z | 2018-02-22T11:39:39Z | 2018-02-22T17:58:05Z |
DOC: correct Series.reset_index example | diff --git a/pandas/core/series.py b/pandas/core/series.py
index 90dc14836ab55..b682d88ec2ce7 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1015,7 +1015,7 @@ def reset_index(self, level=None, drop=False, name=None, inplace=False):
>>> s = pd.Series([1, 2, 3, 4], index=pd.Index(['a', 'b', 'c', 'd'],
... name = 'idx'))
>>> s.reset_index()
- index 0
+ idx 0
0 0 1
1 1 2
2 2 3
| - [ ] 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/19832 | 2018-02-21T23:52:45Z | 2018-02-22T02:23:12Z | 2018-02-22T02:23:12Z | 2018-02-22T02:23:14Z |
Fix to_csv of DataFrame with single level multiindex. | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index de111072bef02..7a5d455ff853f 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -188,7 +188,7 @@ Renaming names in a MultiIndex
:func:`DataFrame.rename_axis` now supports ``index`` and ``columns`` arguments
and :func:`Series.rename_axis` supports ``index`` argument (:issue:`19978`)
-This change allows a dictionary to be passed so that some of the names
+This change allows a dictionary to be passed so that some of the names
of a ``MultiIndex`` can be changed.
Example:
@@ -1216,6 +1216,7 @@ Notice how we now instead output ``np.nan`` itself instead of a stringified form
- :func:`read_sas()` will correctly parse sas7bdat files with data page types having also bit 7 set (so page type is 128 + 256 = 384) (:issue:`16615`)
- Bug in :meth:`detect_client_encoding` where potential ``IOError`` goes unhandled when importing in a mod_wsgi process due to restricted access to stdout. (:issue:`21552`)
- Bug in :func:`to_string()` that broke column alignment when ``index=False`` and width of first column's values is greater than the width of first column's header (:issue:`16839`, :issue:`13032`)
+- Bug in :func:`DataFrame.to_csv` where a single level MultiIndex incorrectly wrote a tuple. Now just the value of the index is written (:issue:`19589`).
Plotting
^^^^^^^^
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 24e7d9bebae3e..c694289efc493 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -732,11 +732,14 @@ def _format_native_types(self, na_rep='nan', **kwargs):
new_levels.append(level)
new_labels.append(label)
- # reconstruct the multi-index
- mi = MultiIndex(levels=new_levels, labels=new_labels, names=self.names,
- sortorder=self.sortorder, verify_integrity=False)
-
- return mi.values
+ if len(new_levels) == 1:
+ return Index(new_levels[0])._format_native_types()
+ else:
+ # reconstruct the multi-index
+ mi = MultiIndex(levels=new_levels, labels=new_labels,
+ names=self.names, sortorder=self.sortorder,
+ verify_integrity=False)
+ return mi.values
@Appender(_index_shared_docs['_get_grouper_for_level'])
def _get_grouper_for_level(self, mapper, level):
diff --git a/pandas/tests/io/formats/test_to_csv.py b/pandas/tests/io/formats/test_to_csv.py
index 7042cae526207..228373a7bf545 100644
--- a/pandas/tests/io/formats/test_to_csv.py
+++ b/pandas/tests/io/formats/test_to_csv.py
@@ -325,6 +325,25 @@ def test_to_csv_multi_index(self):
exp = tm.convert_rows_list_to_csv_str(exp_rows)
assert df.to_csv(index=False) == exp
+ @pytest.mark.parametrize("ind,expected", [
+ (pd.MultiIndex(levels=[[1.0]],
+ labels=[[0]],
+ names=["x"]),
+ "x,data\n1.0,1\n"),
+ (pd.MultiIndex(levels=[[1.], [2.]],
+ labels=[[0], [0]],
+ names=["x", "y"]),
+ "x,y,data\n1.0,2.0,1\n")
+ ])
+ @pytest.mark.parametrize("klass", [
+ pd.DataFrame, pd.Series
+ ])
+ def test_to_csv_single_level_multi_index(self, ind, expected, klass):
+ # see gh-19589
+ result = klass(pd.Series([1], ind, name="data")).to_csv(
+ line_terminator="\n", header=True)
+ assert result == expected
+
def test_to_csv_string_array_ascii(self):
# GH 10813
str_array = [{'names': ['foo', 'bar']}, {'names': ['baz', 'qux']}]
| ### What's this PR do?
Fixes the output of to_csv to show the value instead of the tuple when a ``DataFrame`` or ``Series`` is constructed using a ``MultiIndex`` with one level. Although, I'm not sure if it's more desirable to require a MultiIndex to be instantiated with more than one level in the future.
- [X] closes #19589
- [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/19831 | 2018-02-21T22:38:08Z | 2018-11-01T00:38:03Z | 2018-11-01T00:38:03Z | 2018-11-01T00:38:26Z |
ENH: Let initialisation from dicts use insertion order for python >= 3.6 (part I) | diff --git a/pandas/tests/frame/test_apply.py b/pandas/tests/frame/test_apply.py
index d1ad9f71e6350..a057ca0879cac 100644
--- a/pandas/tests/frame/test_apply.py
+++ b/pandas/tests/frame/test_apply.py
@@ -646,7 +646,7 @@ def test_infer_output_shape_columns(self):
'datetime': [pd.Timestamp('2017-11-29 03:30:00'),
pd.Timestamp('2017-11-29 03:45:00')]})
result = df.apply(lambda row: (row.number, row.string), axis=1)
- expected = Series([t[2:] for t in df.itertuples()])
+ expected = Series([(t.number, t.string) for t in df.itertuples()])
assert_series_equal(result, expected)
def test_infer_output_shape_listlike_columns(self):
diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py
index 8b1fd7d50cb4d..8e012922d25f1 100644
--- a/pandas/tests/frame/test_block_internals.py
+++ b/pandas/tests/frame/test_block_internals.py
@@ -405,8 +405,8 @@ def test_get_numeric_data(self):
result = df.get_dtype_counts()
expected = Series({'int64': 1, 'float64': 1,
datetime64name: 1, objectname: 1})
- result.sort_index()
- expected.sort_index()
+ result = result.sort_index()
+ expected = expected.sort_index()
assert_series_equal(result, expected)
df = DataFrame({'a': 1., 'b': 2, 'c': 'foo',
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 8abd88d8a379c..511b7d17ce79a 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -1362,9 +1362,8 @@ def test_constructor_with_datetimes(self):
expected['float64'] = 1
expected[floatname] = 1
- result.sort_index()
- expected = Series(expected)
- expected.sort_index()
+ result = result.sort_index()
+ expected = Series(expected).sort_index()
tm.assert_series_equal(result, expected)
# check with ndarray construction ndim>0
@@ -1373,7 +1372,7 @@ def test_constructor_with_datetimes(self):
intname: np.array([1] * 10, dtype=intname)},
index=np.arange(10))
result = df.get_dtype_counts()
- result.sort_index()
+ result = result.sort_index()
tm.assert_series_equal(result, expected)
# GH 2809
@@ -1384,8 +1383,8 @@ def test_constructor_with_datetimes(self):
df = DataFrame({'datetime_s': datetime_s})
result = df.get_dtype_counts()
expected = Series({datetime64name: 1})
- result.sort_index()
- expected.sort_index()
+ result = result.sort_index()
+ expected = expected.sort_index()
tm.assert_series_equal(result, expected)
# GH 2810
@@ -1395,8 +1394,8 @@ def test_constructor_with_datetimes(self):
df = DataFrame({'datetimes': datetimes, 'dates': dates})
result = df.get_dtype_counts()
expected = Series({datetime64name: 1, objectname: 1})
- result.sort_index()
- expected.sort_index()
+ result = result.sort_index()
+ expected = expected.sort_index()
tm.assert_series_equal(result, expected)
# GH 7594
@@ -1519,8 +1518,8 @@ def test_constructor_for_list_with_dtypes(self):
result = df.get_dtype_counts()
expected = Series(
{'int64': 1, 'float64': 2, datetime64name: 1, objectname: 1})
- result.sort_index()
- expected.sort_index()
+ result = result.sort_index()
+ expected = expected.sort_index()
tm.assert_series_equal(result, expected)
def test_constructor_frame_copy(self):
@@ -1832,7 +1831,7 @@ def test_from_records_misc_brokenness(self):
rows.append([datetime(2010, 1, 1), 1])
rows.append([datetime(2010, 1, 2), 1])
df2_obj = DataFrame.from_records(rows, columns=['date', 'test'])
- results = df2_obj.get_dtype_counts()
+ results = df2_obj.get_dtype_counts().sort_index()
expected = Series({'datetime64[ns]': 1, 'int64': 1})
tm.assert_series_equal(results, expected)
diff --git a/pandas/tests/frame/test_dtypes.py b/pandas/tests/frame/test_dtypes.py
index 38bdecc9eb88f..e9e5b2a447a4a 100644
--- a/pandas/tests/frame/test_dtypes.py
+++ b/pandas/tests/frame/test_dtypes.py
@@ -725,9 +725,9 @@ def test_timedeltas(self):
df = DataFrame(dict(A=Series(date_range('2012-1-1', periods=3,
freq='D')),
B=Series([timedelta(days=i) for i in range(3)])))
- result = df.get_dtype_counts().sort_values()
+ result = df.get_dtype_counts().sort_index()
expected = Series(
- {'datetime64[ns]': 1, 'timedelta64[ns]': 1}).sort_values()
+ {'datetime64[ns]': 1, 'timedelta64[ns]': 1}).sort_index()
assert_series_equal(result, expected)
df['C'] = df['A'] + df['B']
diff --git a/pandas/tests/frame/test_indexing.py b/pandas/tests/frame/test_indexing.py
index 882fa634d167d..a8b81b1b03552 100644
--- a/pandas/tests/frame/test_indexing.py
+++ b/pandas/tests/frame/test_indexing.py
@@ -2430,8 +2430,8 @@ def _check_get(df, cond, check_dtypes=True):
# upcasting case (GH # 2794)
df = DataFrame(dict((c, Series([1] * 3, dtype=c))
- for c in ['int64', 'int32',
- 'float32', 'float64']))
+ for c in ['float32', 'float64',
+ 'int32', 'int64']))
df.iloc[1, :] = 0
result = df.where(df >= 0).get_dtype_counts()
diff --git a/pandas/tests/frame/test_mutate_columns.py b/pandas/tests/frame/test_mutate_columns.py
index 8236a41d00243..4c560129bfa45 100644
--- a/pandas/tests/frame/test_mutate_columns.py
+++ b/pandas/tests/frame/test_mutate_columns.py
@@ -166,17 +166,17 @@ def test_insert(self):
# new item
df['x'] = df['a'].astype('float32')
- result = Series(dict(float64=5, float32=1))
- assert (df.get_dtype_counts() == result).all()
+ result = Series(dict(float32=1, float64=5))
+ assert (df.get_dtype_counts().sort_index() == result).all()
# replacing current (in different block)
df['a'] = df['a'].astype('float32')
- result = Series(dict(float64=4, float32=2))
- assert (df.get_dtype_counts() == result).all()
+ result = Series(dict(float32=2, float64=4))
+ assert (df.get_dtype_counts().sort_index() == result).all()
df['y'] = df['a'].astype('int32')
- result = Series(dict(float64=4, float32=2, int32=1))
- assert (df.get_dtype_counts() == result).all()
+ result = Series(dict(float32=2, float64=4, int32=1))
+ assert (df.get_dtype_counts().sort_index() == result).all()
with tm.assert_raises_regex(ValueError, 'already exists'):
df.insert(1, 'a', df['b'])
diff --git a/pandas/tests/frame/test_nonunique_indexes.py b/pandas/tests/frame/test_nonunique_indexes.py
index 36465db78361f..0b32ec89d3909 100644
--- a/pandas/tests/frame/test_nonunique_indexes.py
+++ b/pandas/tests/frame/test_nonunique_indexes.py
@@ -155,14 +155,14 @@ def check(result, expected=None):
# rename, GH 4403
df4 = DataFrame(
- {'TClose': [22.02],
- 'RT': [0.0454],
+ {'RT': [0.0454],
+ 'TClose': [22.02],
'TExg': [0.0422]},
index=MultiIndex.from_tuples([(600809, 20130331)],
names=['STK_ID', 'RPT_Date']))
- df5 = DataFrame({'STK_ID': [600809] * 3,
- 'RPT_Date': [20120930, 20121231, 20130331],
+ df5 = DataFrame({'RPT_Date': [20120930, 20121231, 20130331],
+ 'STK_ID': [600809] * 3,
'STK_Name': [u('饡驦'), u('饡驦'), u('饡驦')],
'TClose': [38.05, 41.66, 30.01]},
index=MultiIndex.from_tuples(
diff --git a/pandas/tests/frame/test_reshape.py b/pandas/tests/frame/test_reshape.py
index 7907486c7c98d..68df0982a1e3e 100644
--- a/pandas/tests/frame/test_reshape.py
+++ b/pandas/tests/frame/test_reshape.py
@@ -719,9 +719,10 @@ def verify(df):
assert_frame_equal(left, right)
# GH7401
- df = pd.DataFrame({'A': list('aaaaabbbbb'), 'C': np.arange(10),
+ df = pd.DataFrame({'A': list('aaaaabbbbb'),
'B': (date_range('2012-01-01', periods=5)
- .tolist() * 2)})
+ .tolist() * 2),
+ 'C': np.arange(10)})
df.iloc[3, 1] = np.NaN
left = df.set_index(['A', 'B']).unstack()
diff --git a/pandas/tests/frame/test_to_csv.py b/pandas/tests/frame/test_to_csv.py
index a3ba34ae92283..dda5cdea52cac 100644
--- a/pandas/tests/frame/test_to_csv.py
+++ b/pandas/tests/frame/test_to_csv.py
@@ -1054,10 +1054,10 @@ def test_to_csv_with_dst_transitions(self):
def test_to_csv_quoting(self):
df = DataFrame({
- 'c_string': ['a', 'b,c'],
- 'c_int': [42, np.nan],
- 'c_float': [1.0, 3.2],
'c_bool': [True, False],
+ 'c_float': [1.0, 3.2],
+ 'c_int': [42, np.nan],
+ 'c_string': ['a', 'b,c'],
})
expected = """\
| - [x] xref #19018
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
This PR prepares pandas to allow initialisation using insertion order for python>=3.6. E.g. ``Series({'B': 1, 'A': 2})`` will then retain order and not convert to ``Series({'A': 2, 'B': 1})``.
Letting dataframe/series initialisation from dicts preserve order for python >=3.6 is a relative simple change, just change a line each in core/frame.py and core/series.py. However, this makes some 36 tests fail, as the tests have been set up to depend on conversion to alphabetical order.
This PR makes all tests in ``pandas/tests/frame`` pass both if dict initialisation uses insertion order and alphabetical order. No test functionality is changed in this PR.
After this PR I will do 1 or 2 more similar PRs, so all tests pass independent of dict initialisation rule, and then core/frame.py and core/series.py will be changed to use insertion order for python>=3.6. | https://api.github.com/repos/pandas-dev/pandas/pulls/19830 | 2018-02-21T22:04:58Z | 2018-02-23T01:22:35Z | 2018-02-23T01:22:35Z | 2018-02-23T07:26:46Z |
Test Decorators and Better Pytest Integration in 'test_excel' | diff --git a/pandas/compat/__init__.py b/pandas/compat/__init__.py
index 80a2c05d86971..78aaf4596c8b7 100644
--- a/pandas/compat/__init__.py
+++ b/pandas/compat/__init__.py
@@ -365,6 +365,20 @@ def callable(obj):
return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+if sys.version_info[0] < 3:
+ # In PY2 functools.wraps doesn't provide metadata pytest needs to generate
+ # decorated tests using parametrization. See pytest GH issue #2782
+ def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+ updated=functools.WRAPPER_UPDATES):
+ def wrapper(f):
+ f = functools.wraps(wrapped, assigned, updated)(f)
+ f.__wrapped__ = wrapped
+ return f
+ return wrapper
+else:
+ wraps = functools.wraps
+
+
def add_metaclass(metaclass):
"""Class decorator for creating a class with a metaclass."""
def wrapper(cls):
diff --git a/pandas/tests/io/test_excel.py b/pandas/tests/io/test_excel.py
index 86cee54665781..fdf9954285db8 100644
--- a/pandas/tests/io/test_excel.py
+++ b/pandas/tests/io/test_excel.py
@@ -28,43 +28,6 @@
from pandas.util.testing import ensure_clean, makeCustomDataframe as mkdf
-def _skip_if_no_xlrd():
- try:
- import xlrd
- ver = tuple(map(int, xlrd.__VERSION__.split(".")[:2]))
- if ver < (0, 9):
- pytest.skip('xlrd < 0.9, skipping')
- except ImportError:
- pytest.skip('xlrd not installed, skipping')
-
-
-def _skip_if_no_xlwt():
- try:
- import xlwt # NOQA
- except ImportError:
- pytest.skip('xlwt not installed, skipping')
-
-
-def _skip_if_no_openpyxl():
- try:
- import openpyxl # NOQA
- except ImportError:
- pytest.skip('openpyxl not installed, skipping')
-
-
-def _skip_if_no_xlsxwriter():
- try:
- import xlsxwriter # NOQA
- except ImportError:
- pytest.skip('xlsxwriter not installed, skipping')
-
-
-def _skip_if_no_excelsuite():
- _skip_if_no_xlrd()
- _skip_if_no_xlwt()
- _skip_if_no_openpyxl()
-
-
_seriesd = tm.getSeriesData()
_tsd = tm.getTimeSeriesData()
_frame = DataFrame(_seriesd)[:10]
@@ -74,6 +37,7 @@ def _skip_if_no_excelsuite():
_mixed_frame['foo'] = 'bar'
+@td.skip_if_no('xlrd', '0.9')
class SharedItems(object):
def setup_method(self, method):
@@ -103,7 +67,7 @@ def get_csv_refdf(self, basename):
dfref = read_csv(pref, index_col=0, parse_dates=True, engine='python')
return dfref
- def get_excelfile(self, basename):
+ def get_excelfile(self, basename, ext):
"""
Return test data ExcelFile instance. Test data path is defined by
pandas.util.testing.get_data_path()
@@ -119,9 +83,9 @@ def get_excelfile(self, basename):
excel : io.excel.ExcelFile
"""
- return ExcelFile(os.path.join(self.dirpath, basename + self.ext))
+ return ExcelFile(os.path.join(self.dirpath, basename + ext))
- def get_exceldf(self, basename, *args, **kwds):
+ def get_exceldf(self, basename, ext, *args, **kwds):
"""
Return test data DataFrame. Test data path is defined by
pandas.util.testing.get_data_path()
@@ -137,36 +101,23 @@ def get_exceldf(self, basename, *args, **kwds):
df : DataFrame
"""
- pth = os.path.join(self.dirpath, basename + self.ext)
+ pth = os.path.join(self.dirpath, basename + ext)
return read_excel(pth, *args, **kwds)
class ReadingTestsBase(SharedItems):
# This is based on ExcelWriterBase
- #
- # Base class for test cases to run with different Excel readers.
- # To add a reader test, define the following:
- # 1. A check_skip function that skips your tests if your reader isn't
- # installed.
- # 2. Add a property ext, which is the file extension that your reader
- # reades from. (needs to start with '.' so it's a valid path)
- # 3. Add a property engine_name, which is the name of the reader class.
- # For the reader this is not used for anything at the moment.
- def setup_method(self, method):
- self.check_skip()
- super(ReadingTestsBase, self).setup_method(method)
-
- def test_usecols_int(self):
+ def test_usecols_int(self, ext):
dfref = self.get_csv_refdf('test1')
dfref = dfref.reindex(columns=['A', 'B', 'C'])
- df1 = self.get_exceldf('test1', 'Sheet1', index_col=0, usecols=3)
- df2 = self.get_exceldf('test1', 'Sheet2', skiprows=[1], index_col=0,
- usecols=3)
+ df1 = self.get_exceldf('test1', ext, 'Sheet1', index_col=0, usecols=3)
+ df2 = self.get_exceldf('test1', ext, 'Sheet2', skiprows=[1],
+ index_col=0, usecols=3)
with tm.assert_produces_warning(FutureWarning):
- df3 = self.get_exceldf('test1', 'Sheet2', skiprows=[1],
+ df3 = self.get_exceldf('test1', ext, 'Sheet2', skiprows=[1],
index_col=0, parse_cols=3)
# TODO add index to xls file)
@@ -174,17 +125,17 @@ def test_usecols_int(self):
tm.assert_frame_equal(df2, dfref, check_names=False)
tm.assert_frame_equal(df3, dfref, check_names=False)
- def test_usecols_list(self):
+ def test_usecols_list(self, ext):
dfref = self.get_csv_refdf('test1')
dfref = dfref.reindex(columns=['B', 'C'])
- df1 = self.get_exceldf('test1', 'Sheet1', index_col=0,
- usecols=[0, 2, 3])
- df2 = self.get_exceldf('test1', 'Sheet2', skiprows=[1], index_col=0,
+ df1 = self.get_exceldf('test1', ext, 'Sheet1', index_col=0,
usecols=[0, 2, 3])
+ df2 = self.get_exceldf('test1', ext, 'Sheet2', skiprows=[1],
+ index_col=0, usecols=[0, 2, 3])
with tm.assert_produces_warning(FutureWarning):
- df3 = self.get_exceldf('test1', 'Sheet2', skiprows=[1],
+ df3 = self.get_exceldf('test1', ext, 'Sheet2', skiprows=[1],
index_col=0, parse_cols=[0, 2, 3])
# TODO add index to xls file)
@@ -192,18 +143,18 @@ def test_usecols_list(self):
tm.assert_frame_equal(df2, dfref, check_names=False)
tm.assert_frame_equal(df3, dfref, check_names=False)
- def test_usecols_str(self):
+ def test_usecols_str(self, ext):
dfref = self.get_csv_refdf('test1')
df1 = dfref.reindex(columns=['A', 'B', 'C'])
- df2 = self.get_exceldf('test1', 'Sheet1', index_col=0,
- usecols='A:D')
- df3 = self.get_exceldf('test1', 'Sheet2', skiprows=[1], index_col=0,
+ df2 = self.get_exceldf('test1', ext, 'Sheet1', index_col=0,
usecols='A:D')
+ df3 = self.get_exceldf('test1', ext, 'Sheet2', skiprows=[1],
+ index_col=0, usecols='A:D')
with tm.assert_produces_warning(FutureWarning):
- df4 = self.get_exceldf('test1', 'Sheet2', skiprows=[1],
+ df4 = self.get_exceldf('test1', ext, 'Sheet2', skiprows=[1],
index_col=0, parse_cols='A:D')
# TODO add index to xls, read xls ignores index name ?
@@ -212,37 +163,37 @@ def test_usecols_str(self):
tm.assert_frame_equal(df4, df1, check_names=False)
df1 = dfref.reindex(columns=['B', 'C'])
- df2 = self.get_exceldf('test1', 'Sheet1', index_col=0,
- usecols='A,C,D')
- df3 = self.get_exceldf('test1', 'Sheet2', skiprows=[1], index_col=0,
+ df2 = self.get_exceldf('test1', ext, 'Sheet1', index_col=0,
usecols='A,C,D')
+ df3 = self.get_exceldf('test1', ext, 'Sheet2', skiprows=[1],
+ index_col=0, usecols='A,C,D')
# TODO add index to xls file
tm.assert_frame_equal(df2, df1, check_names=False)
tm.assert_frame_equal(df3, df1, check_names=False)
df1 = dfref.reindex(columns=['B', 'C'])
- df2 = self.get_exceldf('test1', 'Sheet1', index_col=0,
- usecols='A,C:D')
- df3 = self.get_exceldf('test1', 'Sheet2', skiprows=[1], index_col=0,
+ df2 = self.get_exceldf('test1', ext, 'Sheet1', index_col=0,
usecols='A,C:D')
+ df3 = self.get_exceldf('test1', ext, 'Sheet2', skiprows=[1],
+ index_col=0, usecols='A,C:D')
tm.assert_frame_equal(df2, df1, check_names=False)
tm.assert_frame_equal(df3, df1, check_names=False)
- def test_excel_stop_iterator(self):
+ def test_excel_stop_iterator(self, ext):
- parsed = self.get_exceldf('test2', 'Sheet1')
+ parsed = self.get_exceldf('test2', ext, 'Sheet1')
expected = DataFrame([['aaaa', 'bbbbb']], columns=['Test', 'Test1'])
tm.assert_frame_equal(parsed, expected)
- def test_excel_cell_error_na(self):
+ def test_excel_cell_error_na(self, ext):
- parsed = self.get_exceldf('test3', 'Sheet1')
+ parsed = self.get_exceldf('test3', ext, 'Sheet1')
expected = DataFrame([[np.nan]], columns=['Test'])
tm.assert_frame_equal(parsed, expected)
- def test_excel_passes_na(self):
+ def test_excel_passes_na(self, ext):
- excel = self.get_excelfile('test4')
+ excel = self.get_excelfile('test4', ext)
parsed = read_excel(excel, 'Sheet1', keep_default_na=False,
na_values=['apple'])
@@ -257,7 +208,7 @@ def test_excel_passes_na(self):
tm.assert_frame_equal(parsed, expected)
# 13967
- excel = self.get_excelfile('test5')
+ excel = self.get_excelfile('test5', ext)
parsed = read_excel(excel, 'Sheet1', keep_default_na=False,
na_values=['apple'])
@@ -271,9 +222,9 @@ def test_excel_passes_na(self):
columns=['Test'])
tm.assert_frame_equal(parsed, expected)
- def test_excel_table_sheet_by_index(self):
+ def test_excel_table_sheet_by_index(self, ext):
- excel = self.get_excelfile('test1')
+ excel = self.get_excelfile('test1', ext)
dfref = self.get_csv_refdf('test1')
df1 = read_excel(excel, 0, index_col=0)
@@ -300,21 +251,22 @@ def test_excel_table_sheet_by_index(self):
with pytest.raises(xlrd.XLRDError):
read_excel(excel, 'asdf')
- def test_excel_table(self):
+ def test_excel_table(self, ext):
dfref = self.get_csv_refdf('test1')
- df1 = self.get_exceldf('test1', 'Sheet1', index_col=0)
- df2 = self.get_exceldf('test1', 'Sheet2', skiprows=[1], index_col=0)
+ df1 = self.get_exceldf('test1', ext, 'Sheet1', index_col=0)
+ df2 = self.get_exceldf('test1', ext, 'Sheet2', skiprows=[1],
+ index_col=0)
# TODO add index to file
tm.assert_frame_equal(df1, dfref, check_names=False)
tm.assert_frame_equal(df2, dfref, check_names=False)
- df3 = self.get_exceldf('test1', 'Sheet1', index_col=0,
+ df3 = self.get_exceldf('test1', ext, 'Sheet1', index_col=0,
skipfooter=1)
tm.assert_frame_equal(df3, df1.iloc[:-1])
- def test_reader_special_dtypes(self):
+ def test_reader_special_dtypes(self, ext):
expected = DataFrame.from_dict(OrderedDict([
("IntCol", [1, 2, -3, 4, 0]),
@@ -330,36 +282,36 @@ def test_reader_special_dtypes(self):
basename = 'test_types'
# should read in correctly and infer types
- actual = self.get_exceldf(basename, 'Sheet1')
+ actual = self.get_exceldf(basename, ext, 'Sheet1')
tm.assert_frame_equal(actual, expected)
# if not coercing number, then int comes in as float
float_expected = expected.copy()
float_expected["IntCol"] = float_expected["IntCol"].astype(float)
float_expected.loc[float_expected.index[1], "Str2Col"] = 3.0
- actual = self.get_exceldf(basename, 'Sheet1', convert_float=False)
+ actual = self.get_exceldf(basename, ext, 'Sheet1', convert_float=False)
tm.assert_frame_equal(actual, float_expected)
# check setting Index (assuming xls and xlsx are the same here)
for icol, name in enumerate(expected.columns):
- actual = self.get_exceldf(basename, 'Sheet1', index_col=icol)
+ actual = self.get_exceldf(basename, ext, 'Sheet1', index_col=icol)
exp = expected.set_index(name)
tm.assert_frame_equal(actual, exp)
# convert_float and converters should be different but both accepted
expected["StrCol"] = expected["StrCol"].apply(str)
actual = self.get_exceldf(
- basename, 'Sheet1', converters={"StrCol": str})
+ basename, ext, 'Sheet1', converters={"StrCol": str})
tm.assert_frame_equal(actual, expected)
no_convert_float = float_expected.copy()
no_convert_float["StrCol"] = no_convert_float["StrCol"].apply(str)
- actual = self.get_exceldf(basename, 'Sheet1', convert_float=False,
+ actual = self.get_exceldf(basename, ext, 'Sheet1', convert_float=False,
converters={"StrCol": str})
tm.assert_frame_equal(actual, no_convert_float)
# GH8212 - support for converters and missing values
- def test_reader_converters(self):
+ def test_reader_converters(self, ext):
basename = 'test_converters'
@@ -378,13 +330,14 @@ def test_reader_converters(self):
# should read in correctly and set types of single cells (not array
# dtypes)
- actual = self.get_exceldf(basename, 'Sheet1', converters=converters)
+ actual = self.get_exceldf(basename, ext, 'Sheet1',
+ converters=converters)
tm.assert_frame_equal(actual, expected)
- def test_reader_dtype(self):
+ def test_reader_dtype(self, ext):
# GH 8212
basename = 'testdtype'
- actual = self.get_exceldf(basename)
+ actual = self.get_exceldf(basename, ext)
expected = DataFrame({
'a': [1, 2, 3, 4],
@@ -395,7 +348,7 @@ def test_reader_dtype(self):
tm.assert_frame_equal(actual, expected)
- actual = self.get_exceldf(basename,
+ actual = self.get_exceldf(basename, ext,
dtype={'a': 'float64',
'b': 'float32',
'c': str})
@@ -406,14 +359,14 @@ def test_reader_dtype(self):
tm.assert_frame_equal(actual, expected)
with pytest.raises(ValueError):
- actual = self.get_exceldf(basename, dtype={'d': 'int64'})
+ actual = self.get_exceldf(basename, ext, dtype={'d': 'int64'})
- def test_reading_all_sheets(self):
+ def test_reading_all_sheets(self, ext):
# Test reading all sheetnames by setting sheetname to None,
# Ensure a dict is returned.
# See PR #9450
basename = 'test_multisheet'
- dfs = self.get_exceldf(basename, sheet_name=None)
+ dfs = self.get_exceldf(basename, ext, sheet_name=None)
# ensure this is not alphabetical to test order preservation
expected_keys = ['Charlie', 'Alpha', 'Beta']
tm.assert_contains_all(expected_keys, dfs.keys())
@@ -421,7 +374,7 @@ def test_reading_all_sheets(self):
# Ensure sheet order is preserved
assert expected_keys == list(dfs.keys())
- def test_reading_multiple_specific_sheets(self):
+ def test_reading_multiple_specific_sheets(self, ext):
# Test reading specific sheetnames by specifying a mixed list
# of integers and strings, and confirm that duplicated sheet
# references (positions/names) are removed properly.
@@ -430,42 +383,41 @@ def test_reading_multiple_specific_sheets(self):
basename = 'test_multisheet'
# Explicitly request duplicates. Only the set should be returned.
expected_keys = [2, 'Charlie', 'Charlie']
- dfs = self.get_exceldf(basename, sheet_name=expected_keys)
+ dfs = self.get_exceldf(basename, ext, sheet_name=expected_keys)
expected_keys = list(set(expected_keys))
tm.assert_contains_all(expected_keys, dfs.keys())
assert len(expected_keys) == len(dfs.keys())
- def test_reading_all_sheets_with_blank(self):
+ def test_reading_all_sheets_with_blank(self, ext):
# Test reading all sheetnames by setting sheetname to None,
# In the case where some sheets are blank.
# Issue #11711
basename = 'blank_with_header'
- dfs = self.get_exceldf(basename, sheet_name=None)
+ dfs = self.get_exceldf(basename, ext, sheet_name=None)
expected_keys = ['Sheet1', 'Sheet2', 'Sheet3']
tm.assert_contains_all(expected_keys, dfs.keys())
# GH6403
- def test_read_excel_blank(self):
- actual = self.get_exceldf('blank', 'Sheet1')
+ def test_read_excel_blank(self, ext):
+ actual = self.get_exceldf('blank', ext, 'Sheet1')
tm.assert_frame_equal(actual, DataFrame())
- def test_read_excel_blank_with_header(self):
+ def test_read_excel_blank_with_header(self, ext):
expected = DataFrame(columns=['col_1', 'col_2'])
- actual = self.get_exceldf('blank_with_header', 'Sheet1')
+ actual = self.get_exceldf('blank_with_header', ext, 'Sheet1')
tm.assert_frame_equal(actual, expected)
+ @td.skip_if_no('openpyxl')
+ @td.skip_if_no('xlwt')
# GH 12292 : error when read one empty column from excel file
- def test_read_one_empty_col_no_header(self):
- _skip_if_no_xlwt()
- _skip_if_no_openpyxl()
-
+ def test_read_one_empty_col_no_header(self, ext):
df = pd.DataFrame(
[["", 1, 100],
["", 2, 200],
["", 3, 300],
["", 4, 400]]
)
- with ensure_clean(self.ext) as path:
+ with ensure_clean(ext) as path:
df.to_excel(path, 'no_header', index=False, header=False)
actual_header_none = read_excel(
path,
@@ -484,17 +436,16 @@ def test_read_one_empty_col_no_header(self):
tm.assert_frame_equal(actual_header_none, expected)
tm.assert_frame_equal(actual_header_zero, expected)
- def test_read_one_empty_col_with_header(self):
- _skip_if_no_xlwt()
- _skip_if_no_openpyxl()
-
+ @td.skip_if_no('openpyxl')
+ @td.skip_if_no('xlwt')
+ def test_read_one_empty_col_with_header(self, ext):
df = pd.DataFrame(
[["", 1, 100],
["", 2, 200],
["", 3, 300],
["", 4, 400]]
)
- with ensure_clean(self.ext) as path:
+ with ensure_clean(ext) as path:
df.to_excel(path, 'with_header', index=False, header=True)
actual_header_none = read_excel(
path,
@@ -514,16 +465,15 @@ def test_read_one_empty_col_with_header(self):
expected_header_zero = DataFrame(columns=[0], dtype='int64')
tm.assert_frame_equal(actual_header_zero, expected_header_zero)
- def test_set_column_names_in_parameter(self):
- _skip_if_no_xlwt()
- _skip_if_no_openpyxl()
-
+ @td.skip_if_no('openpyxl')
+ @td.skip_if_no('xlwt')
+ def test_set_column_names_in_parameter(self, ext):
# GH 12870 : pass down column names associated with
# keyword argument names
refdf = pd.DataFrame([[1, 'foo'], [2, 'bar'],
[3, 'baz']], columns=['a', 'b'])
- with ensure_clean(self.ext) as pth:
+ with ensure_clean(ext) as pth:
with ExcelWriter(pth) as writer:
refdf.to_excel(writer, 'Data_no_head',
header=False, index=False)
@@ -540,42 +490,45 @@ def test_set_column_names_in_parameter(self):
tm.assert_frame_equal(xlsdf_no_head, refdf)
tm.assert_frame_equal(xlsdf_with_head, refdf)
- def test_date_conversion_overflow(self):
+ def test_date_conversion_overflow(self, ext):
# GH 10001 : pandas.ExcelFile ignore parse_dates=False
expected = pd.DataFrame([[pd.Timestamp('2016-03-12'), 'Marc Johnson'],
[pd.Timestamp('2016-03-16'), 'Jack Black'],
[1e+20, 'Timothy Brown']],
columns=['DateColWithBigInt', 'StringCol'])
- result = self.get_exceldf('testdateoverflow')
+ result = self.get_exceldf('testdateoverflow', ext)
tm.assert_frame_equal(result, expected)
- def test_sheet_name_and_sheetname(self):
+ def test_sheet_name_and_sheetname(self, ext):
# GH10559: Minor improvement: Change "sheet_name" to "sheetname"
# GH10969: DOC: Consistent var names (sheetname vs sheet_name)
# GH12604: CLN GH10559 Rename sheetname variable to sheet_name
dfref = self.get_csv_refdf('test1')
- df1 = self.get_exceldf('test1', sheet_name='Sheet1') # doc
+ df1 = self.get_exceldf('test1', ext, sheet_name='Sheet1') # doc
with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
- df2 = self.get_exceldf('test1', sheetname='Sheet1') # bkwrd compat
+ df2 = self.get_exceldf('test1', ext,
+ sheetname='Sheet1') # bkwrd compat
tm.assert_frame_equal(df1, dfref, check_names=False)
tm.assert_frame_equal(df2, dfref, check_names=False)
- def test_sheet_name_both_raises(self):
+ def test_sheet_name_both_raises(self, ext):
with tm.assert_raises_regex(TypeError, "Cannot specify both"):
- self.get_exceldf('test1', sheetname='Sheet1', sheet_name='Sheet1')
+ self.get_exceldf('test1', ext, sheetname='Sheet1',
+ sheet_name='Sheet1')
-class XlrdTests(ReadingTestsBase):
+@pytest.mark.parametrize("ext", ['.xls', '.xlsx', '.xlsm'])
+class TestXlrdReader(ReadingTestsBase):
"""
This is the base class for the xlrd tests, and 3 different file formats
are supported: xls, xlsx, xlsm
"""
- def test_excel_read_buffer(self):
+ def test_excel_read_buffer(self, ext):
- pth = os.path.join(self.dirpath, 'test1' + self.ext)
+ pth = os.path.join(self.dirpath, 'test1' + ext)
expected = read_excel(pth, 'Sheet1', index_col=0)
with open(pth, 'rb') as f:
actual = read_excel(f, 'Sheet1', index_col=0)
@@ -586,10 +539,10 @@ def test_excel_read_buffer(self):
actual = read_excel(xls, 'Sheet1', index_col=0)
tm.assert_frame_equal(expected, actual)
- def test_read_xlrd_Book(self):
- _skip_if_no_xlwt()
-
+ @td.skip_if_no('xlwt')
+ def test_read_xlrd_Book(self, ext):
import xlrd
+
df = self.frame
with ensure_clean('.xls') as pth:
df.to_excel(pth, "SheetA")
@@ -603,39 +556,39 @@ def test_read_xlrd_Book(self):
tm.assert_frame_equal(df, result)
@tm.network
- def test_read_from_http_url(self):
+ def test_read_from_http_url(self, ext):
url = ('https://raw.github.com/pandas-dev/pandas/master/'
- 'pandas/tests/io/data/test1' + self.ext)
+ 'pandas/tests/io/data/test1' + ext)
url_table = read_excel(url)
- local_table = self.get_exceldf('test1')
+ local_table = self.get_exceldf('test1', ext)
tm.assert_frame_equal(url_table, local_table)
- def test_read_from_s3_url(self):
+ @td.skip_if_no('s3fs')
+ def test_read_from_s3_url(self, ext):
boto3 = pytest.importorskip('boto3')
- pytest.importorskip('s3fs')
moto = pytest.importorskip('moto')
with moto.mock_s3():
conn = boto3.resource("s3", region_name="us-east-1")
conn.create_bucket(Bucket="pandas-test")
- file_name = os.path.join(self.dirpath, 'test1' + self.ext)
+ file_name = os.path.join(self.dirpath, 'test1' + ext)
with open(file_name, 'rb') as f:
- conn.Bucket("pandas-test").put_object(Key="test1" + self.ext,
+ conn.Bucket("pandas-test").put_object(Key="test1" + ext,
Body=f)
- url = ('s3://pandas-test/test1' + self.ext)
+ url = ('s3://pandas-test/test1' + ext)
url_table = read_excel(url)
- local_table = self.get_exceldf('test1')
+ local_table = self.get_exceldf('test1', ext)
tm.assert_frame_equal(url_table, local_table)
@pytest.mark.slow
- def test_read_from_file_url(self):
+ def test_read_from_file_url(self, ext):
# FILE
if sys.version_info[:2] < (2, 6):
pytest.skip("file:// not supported with Python < 2.6")
- localtable = os.path.join(self.dirpath, 'test1' + self.ext)
+ localtable = os.path.join(self.dirpath, 'test1' + ext)
local_table = read_excel(localtable)
try:
@@ -649,37 +602,37 @@ def test_read_from_file_url(self):
tm.assert_frame_equal(url_table, local_table)
@td.skip_if_no('pathlib')
- def test_read_from_pathlib_path(self):
+ def test_read_from_pathlib_path(self, ext):
# GH12655
from pathlib import Path
- str_path = os.path.join(self.dirpath, 'test1' + self.ext)
+ str_path = os.path.join(self.dirpath, 'test1' + ext)
expected = read_excel(str_path, 'Sheet1', index_col=0)
- path_obj = Path(self.dirpath, 'test1' + self.ext)
+ path_obj = Path(self.dirpath, 'test1' + ext)
actual = read_excel(path_obj, 'Sheet1', index_col=0)
tm.assert_frame_equal(expected, actual)
@td.skip_if_no('py.path')
- def test_read_from_py_localpath(self):
+ def test_read_from_py_localpath(self, ext):
# GH12655
from py.path import local as LocalPath
- str_path = os.path.join(self.dirpath, 'test1' + self.ext)
+ str_path = os.path.join(self.dirpath, 'test1' + ext)
expected = read_excel(str_path, 'Sheet1', index_col=0)
abs_dir = os.path.abspath(self.dirpath)
- path_obj = LocalPath(abs_dir).join('test1' + self.ext)
+ path_obj = LocalPath(abs_dir).join('test1' + ext)
actual = read_excel(path_obj, 'Sheet1', index_col=0)
tm.assert_frame_equal(expected, actual)
- def test_reader_closes_file(self):
+ def test_reader_closes_file(self, ext):
- pth = os.path.join(self.dirpath, 'test1' + self.ext)
+ pth = os.path.join(self.dirpath, 'test1' + ext)
f = open(pth, 'rb')
with ExcelFile(f) as xlsx:
# parses okay
@@ -687,14 +640,12 @@ def test_reader_closes_file(self):
assert f.closed
- def test_creating_and_reading_multiple_sheets(self):
+ @td.skip_if_no('openpyxl')
+ @td.skip_if_no('xlwt')
+ def test_creating_and_reading_multiple_sheets(self, ext):
# Test reading multiple sheets, from a runtime created excel file
# with multiple sheets.
# See PR #9450
-
- _skip_if_no_xlwt()
- _skip_if_no_openpyxl()
-
def tdf(sheetname):
d, i = [11, 22, 33], [1, 2, 3]
return DataFrame(d, i, columns=[sheetname])
@@ -704,7 +655,7 @@ def tdf(sheetname):
dfs = [tdf(s) for s in sheets]
dfs = dict(zip(sheets, dfs))
- with ensure_clean(self.ext) as pth:
+ with ensure_clean(ext) as pth:
with ExcelWriter(pth) as ew:
for sheetname, df in iteritems(dfs):
df.to_excel(ew, sheetname)
@@ -712,10 +663,10 @@ def tdf(sheetname):
for s in sheets:
tm.assert_frame_equal(dfs[s], dfs_returned[s])
- def test_reader_seconds(self):
- # Test reading times with and without milliseconds. GH5945.
+ def test_reader_seconds(self, ext):
import xlrd
+ # Test reading times with and without milliseconds. GH5945.
if LooseVersion(xlrd.__VERSION__) >= LooseVersion("0.9.3"):
# Xlrd >= 0.9.3 can handle Excel milliseconds.
expected = DataFrame.from_dict({"Time": [time(1, 2, 3),
@@ -743,16 +694,16 @@ def test_reader_seconds(self):
time(16, 37, 1),
time(18, 20, 54)]})
- actual = self.get_exceldf('times_1900', 'Sheet1')
+ actual = self.get_exceldf('times_1900', ext, 'Sheet1')
tm.assert_frame_equal(actual, expected)
- actual = self.get_exceldf('times_1904', 'Sheet1')
+ actual = self.get_exceldf('times_1904', ext, 'Sheet1')
tm.assert_frame_equal(actual, expected)
- def test_read_excel_multiindex(self):
+ def test_read_excel_multiindex(self, ext):
# GH 4679
mi = MultiIndex.from_product([['foo', 'bar'], ['a', 'b']])
- mi_file = os.path.join(self.dirpath, 'testmultiindex' + self.ext)
+ mi_file = os.path.join(self.dirpath, 'testmultiindex' + ext)
expected = DataFrame([[1, 2.5, pd.Timestamp('2015-01-01'), True],
[2, 3.5, pd.Timestamp('2015-01-02'), False],
@@ -806,9 +757,9 @@ def test_read_excel_multiindex(self):
header=[0, 1], skiprows=2)
tm.assert_frame_equal(actual, expected)
- def test_read_excel_multiindex_empty_level(self):
+ @td.skip_if_no('xlsxwriter')
+ def test_read_excel_multiindex_empty_level(self, ext):
# GH 12453
- _skip_if_no_xlsxwriter()
with ensure_clean('.xlsx') as path:
df = DataFrame({
('Zero', ''): {0: 0},
@@ -846,9 +797,9 @@ def test_read_excel_multiindex_empty_level(self):
actual = pd.read_excel(path, header=[0, 1])
tm.assert_frame_equal(actual, expected)
- def test_excel_multindex_roundtrip(self):
+ @td.skip_if_no('xlsxwriter')
+ def test_excel_multindex_roundtrip(self, ext):
# GH 4679
- _skip_if_no_xlsxwriter()
with ensure_clean('.xlsx') as pth:
for c_idx_names in [True, False]:
for r_idx_names in [True, False]:
@@ -891,9 +842,9 @@ def test_excel_multindex_roundtrip(self):
tm.assert_frame_equal(
df, act, check_names=check_names)
- def test_excel_old_index_format(self):
+ def test_excel_old_index_format(self, ext):
# see gh-4679
- filename = 'test_index_name_pre17' + self.ext
+ filename = 'test_index_name_pre17' + ext
in_file = os.path.join(self.dirpath, filename)
# We detect headers to determine if index names exist, so
@@ -952,31 +903,30 @@ def test_excel_old_index_format(self):
actual = pd.read_excel(in_file, 'multi_no_names', index_col=[0, 1])
tm.assert_frame_equal(actual, expected, check_names=False)
- def test_read_excel_bool_header_arg(self):
+ def test_read_excel_bool_header_arg(self, ext):
# GH 6114
for arg in [True, False]:
with pytest.raises(TypeError):
- pd.read_excel(os.path.join(self.dirpath, 'test1' + self.ext),
+ pd.read_excel(os.path.join(self.dirpath, 'test1' + ext),
header=arg)
- def test_read_excel_chunksize(self):
+ def test_read_excel_chunksize(self, ext):
# GH 8011
with pytest.raises(NotImplementedError):
- pd.read_excel(os.path.join(self.dirpath, 'test1' + self.ext),
+ pd.read_excel(os.path.join(self.dirpath, 'test1' + ext),
chunksize=100)
- def test_read_excel_parse_dates(self):
+ @td.skip_if_no('openpyxl')
+ @td.skip_if_no('xlwt')
+ def test_read_excel_parse_dates(self, ext):
# GH 11544, 12051
- _skip_if_no_openpyxl()
- _skip_if_no_xlwt() # for df2.to_excel
-
df = DataFrame(
{'col': [1, 2, 3],
'date_strings': pd.date_range('2012-01-01', periods=3)})
df2 = df.copy()
df2['date_strings'] = df2['date_strings'].dt.strftime('%m/%d/%Y')
- with ensure_clean(self.ext) as pth:
+ with ensure_clean(ext) as pth:
df2.to_excel(pth)
res = read_excel(pth)
@@ -995,10 +945,10 @@ def test_read_excel_parse_dates(self):
date_parser=dateparser, index_col=0)
tm.assert_frame_equal(df, res)
- def test_read_excel_skiprows_list(self):
+ def test_read_excel_skiprows_list(self, ext):
# GH 4903
actual = pd.read_excel(os.path.join(self.dirpath,
- 'testskiprows' + self.ext),
+ 'testskiprows' + ext),
'skiprows_list', skiprows=[0, 2])
expected = DataFrame([[1, 2.5, pd.Timestamp('2015-01-01'), True],
[2, 3.5, pd.Timestamp('2015-01-02'), False],
@@ -1008,40 +958,40 @@ def test_read_excel_skiprows_list(self):
tm.assert_frame_equal(actual, expected)
actual = pd.read_excel(os.path.join(self.dirpath,
- 'testskiprows' + self.ext),
+ 'testskiprows' + ext),
'skiprows_list', skiprows=np.array([0, 2]))
tm.assert_frame_equal(actual, expected)
- def test_read_excel_nrows(self):
+ def test_read_excel_nrows(self, ext):
# GH 16645
num_rows_to_pull = 5
- actual = pd.read_excel(os.path.join(self.dirpath, 'test1' + self.ext),
+ actual = pd.read_excel(os.path.join(self.dirpath, 'test1' + ext),
nrows=num_rows_to_pull)
expected = pd.read_excel(os.path.join(self.dirpath,
- 'test1' + self.ext))
+ 'test1' + ext))
expected = expected[:num_rows_to_pull]
tm.assert_frame_equal(actual, expected)
- def test_read_excel_nrows_greater_than_nrows_in_file(self):
+ def test_read_excel_nrows_greater_than_nrows_in_file(self, ext):
# GH 16645
expected = pd.read_excel(os.path.join(self.dirpath,
- 'test1' + self.ext))
+ 'test1' + ext))
num_records_in_file = len(expected)
num_rows_to_pull = num_records_in_file + 10
- actual = pd.read_excel(os.path.join(self.dirpath, 'test1' + self.ext),
+ actual = pd.read_excel(os.path.join(self.dirpath, 'test1' + ext),
nrows=num_rows_to_pull)
tm.assert_frame_equal(actual, expected)
- def test_read_excel_nrows_non_integer_parameter(self):
+ def test_read_excel_nrows_non_integer_parameter(self, ext):
# GH 16645
msg = "'nrows' must be an integer >=0"
with tm.assert_raises_regex(ValueError, msg):
- pd.read_excel(os.path.join(self.dirpath, 'test1' + self.ext),
+ pd.read_excel(os.path.join(self.dirpath, 'test1' + ext),
nrows='5')
- def test_read_excel_squeeze(self):
+ def test_read_excel_squeeze(self, ext):
# GH 12157
- f = os.path.join(self.dirpath, 'test_squeeze' + self.ext)
+ f = os.path.join(self.dirpath, 'test_squeeze' + ext)
actual = pd.read_excel(f, 'two_columns', index_col=0, squeeze=True)
expected = pd.Series([2, 3, 4], [4, 5, 6], name='b')
@@ -1058,351 +1008,308 @@ def test_read_excel_squeeze(self):
tm.assert_series_equal(actual, expected)
-class TestXlsReaderTests(XlrdTests):
- ext = '.xls'
- engine_name = 'xlrd'
- check_skip = staticmethod(_skip_if_no_xlrd)
-
-
-class TestXlsxReaderTests(XlrdTests):
- ext = '.xlsx'
- engine_name = 'xlrd'
- check_skip = staticmethod(_skip_if_no_xlrd)
+class _WriterBase(SharedItems):
+ @pytest.fixture(autouse=True)
+ def set_engine_and_path(self, request, merge_cells, engine, ext):
+ """Fixture to set engine and open file for use in each test case
-class TestXlsmReaderTests(XlrdTests):
- ext = '.xlsm'
- engine_name = 'xlrd'
- check_skip = staticmethod(_skip_if_no_xlrd)
+ Rather than requiring `engine=...` to be provided explictly as an
+ argument in each test, this fixture sets a global option to dictate
+ which engine should be used to write Excel files. After executing
+ the test it rolls back said change to the global option.
+ It also uses a context manager to open a temporary excel file for
+ the function to write to, accessible via `self.path`
-class ExcelWriterBase(SharedItems):
+ Notes
+ -----
+ This fixture will run as part of each test method defined in the
+ class and any subclasses, on account of the `autouse=True`
+ argument
+ """
+ option_name = 'io.excel.{ext}.writer'.format(ext=ext.strip('.'))
+ prev_engine = get_option(option_name)
+ set_option(option_name, engine)
+ with ensure_clean(ext) as path:
+ self.path = path
+ yield
+ set_option(option_name, prev_engine) # Roll back option change
+
+
+@pytest.mark.parametrize("merge_cells", [True, False])
+@pytest.mark.parametrize("engine,ext", [
+ pytest.param('openpyxl', '.xlsx', marks=pytest.mark.skipif(
+ not td.safe_import('openpyxl'), reason='No openpyxl')),
+ pytest.param('openpyxl', '.xlsm', marks=pytest.mark.skipif(
+ not td.safe_import('openpyxl'), reason='No openpyxl')),
+ pytest.param('xlwt', '.xls', marks=pytest.mark.skipif(
+ not td.safe_import('xlwt'), reason='No xlwt')),
+ pytest.param('xlsxwriter', '.xlsx', marks=pytest.mark.skipif(
+ not td.safe_import('xlsxwriter'), reason='No xlsxwriter'))
+])
+class TestExcelWriter(_WriterBase):
# Base class for test cases to run with different Excel writers.
- # To add a writer test, define the following:
- # 1. A check_skip function that skips your tests if your writer isn't
- # installed.
- # 2. Add a property ext, which is the file extension that your writer
- # writes to. (needs to start with '.' so it's a valid path)
- # 3. Add a property engine_name, which is the name of the writer class.
-
- # Test with MultiIndex and Hierarchical Rows as merged cells.
- merge_cells = True
-
- def setup_method(self, method):
- self.check_skip()
- super(ExcelWriterBase, self).setup_method(method)
- self.option_name = 'io.excel.%s.writer' % self.ext.strip('.')
- self.prev_engine = get_option(self.option_name)
- set_option(self.option_name, self.engine_name)
-
- def teardown_method(self, method):
- set_option(self.option_name, self.prev_engine)
- def test_excel_sheet_by_name_raise(self):
- _skip_if_no_xlrd()
+ def test_excel_sheet_by_name_raise(self, merge_cells, engine, ext):
import xlrd
- with ensure_clean(self.ext) as pth:
- gt = DataFrame(np.random.randn(10, 2))
- gt.to_excel(pth)
- xl = ExcelFile(pth)
- df = read_excel(xl, 0)
- tm.assert_frame_equal(gt, df)
-
- with pytest.raises(xlrd.XLRDError):
- read_excel(xl, '0')
-
- def test_excelwriter_contextmanager(self):
- _skip_if_no_xlrd()
-
- with ensure_clean(self.ext) as pth:
- with ExcelWriter(pth) as writer:
- self.frame.to_excel(writer, 'Data1')
- self.frame2.to_excel(writer, 'Data2')
-
- with ExcelFile(pth) as reader:
- found_df = read_excel(reader, 'Data1')
- found_df2 = read_excel(reader, 'Data2')
- tm.assert_frame_equal(found_df, self.frame)
- tm.assert_frame_equal(found_df2, self.frame2)
-
- def test_roundtrip(self):
- _skip_if_no_xlrd()
-
- with ensure_clean(self.ext) as path:
- self.frame['A'][:5] = nan
-
- self.frame.to_excel(path, 'test1')
- self.frame.to_excel(path, 'test1', columns=['A', 'B'])
- self.frame.to_excel(path, 'test1', header=False)
- self.frame.to_excel(path, 'test1', index=False)
-
- # test roundtrip
- self.frame.to_excel(path, 'test1')
- recons = read_excel(path, 'test1', index_col=0)
- tm.assert_frame_equal(self.frame, recons)
-
- self.frame.to_excel(path, 'test1', index=False)
- recons = read_excel(path, 'test1', index_col=None)
- recons.index = self.frame.index
- tm.assert_frame_equal(self.frame, recons)
-
- self.frame.to_excel(path, 'test1', na_rep='NA')
- recons = read_excel(path, 'test1', index_col=0, na_values=['NA'])
- tm.assert_frame_equal(self.frame, recons)
-
- # GH 3611
- self.frame.to_excel(path, 'test1', na_rep='88')
- recons = read_excel(path, 'test1', index_col=0, na_values=['88'])
- tm.assert_frame_equal(self.frame, recons)
-
- self.frame.to_excel(path, 'test1', na_rep='88')
- recons = read_excel(path, 'test1', index_col=0,
- na_values=[88, 88.0])
- tm.assert_frame_equal(self.frame, recons)
-
- # GH 6573
- self.frame.to_excel(path, 'Sheet1')
- recons = read_excel(path, index_col=0)
- tm.assert_frame_equal(self.frame, recons)
-
- self.frame.to_excel(path, '0')
- recons = read_excel(path, index_col=0)
- tm.assert_frame_equal(self.frame, recons)
-
- # GH 8825 Pandas Series should provide to_excel method
- s = self.frame["A"]
- s.to_excel(path)
- recons = read_excel(path, index_col=0)
- tm.assert_frame_equal(s.to_frame(), recons)
-
- def test_mixed(self):
- _skip_if_no_xlrd()
-
- with ensure_clean(self.ext) as path:
- self.mixed_frame.to_excel(path, 'test1')
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1', index_col=0)
- tm.assert_frame_equal(self.mixed_frame, recons)
-
- def test_tsframe(self):
- _skip_if_no_xlrd()
+ gt = DataFrame(np.random.randn(10, 2))
+ gt.to_excel(self.path)
+ xl = ExcelFile(self.path)
+ df = read_excel(xl, 0)
+ tm.assert_frame_equal(gt, df)
+ with pytest.raises(xlrd.XLRDError):
+ read_excel(xl, '0')
+
+ def test_excelwriter_contextmanager(self, merge_cells, engine, ext):
+ with ExcelWriter(self.path) as writer:
+ self.frame.to_excel(writer, 'Data1')
+ self.frame2.to_excel(writer, 'Data2')
+
+ with ExcelFile(self.path) as reader:
+ found_df = read_excel(reader, 'Data1')
+ found_df2 = read_excel(reader, 'Data2')
+ tm.assert_frame_equal(found_df, self.frame)
+ tm.assert_frame_equal(found_df2, self.frame2)
+
+ def test_roundtrip(self, merge_cells, engine, ext):
+ self.frame['A'][:5] = nan
+
+ self.frame.to_excel(self.path, 'test1')
+ self.frame.to_excel(self.path, 'test1', columns=['A', 'B'])
+ self.frame.to_excel(self.path, 'test1', header=False)
+ self.frame.to_excel(self.path, 'test1', index=False)
+
+ # test roundtrip
+ self.frame.to_excel(self.path, 'test1')
+ recons = read_excel(self.path, 'test1', index_col=0)
+ tm.assert_frame_equal(self.frame, recons)
+
+ self.frame.to_excel(self.path, 'test1', index=False)
+ recons = read_excel(self.path, 'test1', index_col=None)
+ recons.index = self.frame.index
+ tm.assert_frame_equal(self.frame, recons)
+
+ self.frame.to_excel(self.path, 'test1', na_rep='NA')
+ recons = read_excel(self.path, 'test1', index_col=0, na_values=['NA'])
+ tm.assert_frame_equal(self.frame, recons)
+
+ # GH 3611
+ self.frame.to_excel(self.path, 'test1', na_rep='88')
+ recons = read_excel(self.path, 'test1', index_col=0, na_values=['88'])
+ tm.assert_frame_equal(self.frame, recons)
+
+ self.frame.to_excel(self.path, 'test1', na_rep='88')
+ recons = read_excel(self.path, 'test1', index_col=0,
+ na_values=[88, 88.0])
+ tm.assert_frame_equal(self.frame, recons)
+
+ # GH 6573
+ self.frame.to_excel(self.path, 'Sheet1')
+ recons = read_excel(self.path, index_col=0)
+ tm.assert_frame_equal(self.frame, recons)
+
+ self.frame.to_excel(self.path, '0')
+ recons = read_excel(self.path, index_col=0)
+ tm.assert_frame_equal(self.frame, recons)
+
+ # GH 8825 Pandas Series should provide to_excel method
+ s = self.frame["A"]
+ s.to_excel(self.path)
+ recons = read_excel(self.path, index_col=0)
+ tm.assert_frame_equal(s.to_frame(), recons)
+
+ def test_mixed(self, merge_cells, engine, ext):
+ self.mixed_frame.to_excel(self.path, 'test1')
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1', index_col=0)
+ tm.assert_frame_equal(self.mixed_frame, recons)
+
+ def test_tsframe(self, merge_cells, engine, ext):
df = tm.makeTimeDataFrame()[:5]
- with ensure_clean(self.ext) as path:
- df.to_excel(path, 'test1')
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1')
- tm.assert_frame_equal(df, recons)
-
- def test_basics_with_nan(self):
- _skip_if_no_xlrd()
- with ensure_clean(self.ext) as path:
- self.frame['A'][:5] = nan
- self.frame.to_excel(path, 'test1')
- self.frame.to_excel(path, 'test1', columns=['A', 'B'])
- self.frame.to_excel(path, 'test1', header=False)
- self.frame.to_excel(path, 'test1', index=False)
-
- def test_int_types(self):
- _skip_if_no_xlrd()
-
- for np_type in (np.int8, np.int16, np.int32, np.int64):
-
- with ensure_clean(self.ext) as path:
- # Test np.int values read come back as int (rather than float
- # which is Excel's format).
- frame = DataFrame(np.random.randint(-10, 10, size=(10, 2)),
- dtype=np_type)
- frame.to_excel(path, 'test1')
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1')
- int_frame = frame.astype(np.int64)
- tm.assert_frame_equal(int_frame, recons)
- recons2 = read_excel(path, 'test1')
- tm.assert_frame_equal(int_frame, recons2)
-
- # test with convert_float=False comes back as float
- float_frame = frame.astype(float)
- recons = read_excel(path, 'test1', convert_float=False)
- tm.assert_frame_equal(recons, float_frame,
- check_index_type=False,
- check_column_type=False)
-
- def test_float_types(self):
- _skip_if_no_xlrd()
-
- for np_type in (np.float16, np.float32, np.float64):
- with ensure_clean(self.ext) as path:
- # Test np.float values read come back as float.
- frame = DataFrame(np.random.random_sample(10), dtype=np_type)
- frame.to_excel(path, 'test1')
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1').astype(np_type)
- tm.assert_frame_equal(frame, recons, check_dtype=False)
-
- def test_bool_types(self):
- _skip_if_no_xlrd()
-
- for np_type in (np.bool8, np.bool_):
- with ensure_clean(self.ext) as path:
- # Test np.bool values read come back as float.
- frame = (DataFrame([1, 0, True, False], dtype=np_type))
- frame.to_excel(path, 'test1')
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1').astype(np_type)
- tm.assert_frame_equal(frame, recons)
-
- def test_inf_roundtrip(self):
- _skip_if_no_xlrd()
-
+ df.to_excel(self.path, 'test1')
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1')
+ tm.assert_frame_equal(df, recons)
+
+ def test_basics_with_nan(self, merge_cells, engine, ext):
+ self.frame['A'][:5] = nan
+ self.frame.to_excel(self.path, 'test1')
+ self.frame.to_excel(self.path, 'test1', columns=['A', 'B'])
+ self.frame.to_excel(self.path, 'test1', header=False)
+ self.frame.to_excel(self.path, 'test1', index=False)
+
+ @pytest.mark.parametrize("np_type", [
+ np.int8, np.int16, np.int32, np.int64])
+ def test_int_types(self, merge_cells, engine, ext, np_type):
+ # Test np.int values read come back as int (rather than float
+ # which is Excel's format).
+ frame = DataFrame(np.random.randint(-10, 10, size=(10, 2)),
+ dtype=np_type)
+ frame.to_excel(self.path, 'test1')
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1')
+ int_frame = frame.astype(np.int64)
+ tm.assert_frame_equal(int_frame, recons)
+ recons2 = read_excel(self.path, 'test1')
+ tm.assert_frame_equal(int_frame, recons2)
+
+ # test with convert_float=False comes back as float
+ float_frame = frame.astype(float)
+ recons = read_excel(self.path, 'test1', convert_float=False)
+ tm.assert_frame_equal(recons, float_frame,
+ check_index_type=False,
+ check_column_type=False)
+
+ @pytest.mark.parametrize("np_type", [
+ np.float16, np.float32, np.float64])
+ def test_float_types(self, merge_cells, engine, ext, np_type):
+ # Test np.float values read come back as float.
+ frame = DataFrame(np.random.random_sample(10), dtype=np_type)
+ frame.to_excel(self.path, 'test1')
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1').astype(np_type)
+ tm.assert_frame_equal(frame, recons, check_dtype=False)
+
+ @pytest.mark.parametrize("np_type", [np.bool8, np.bool_])
+ def test_bool_types(self, merge_cells, engine, ext, np_type):
+ # Test np.bool values read come back as float.
+ frame = (DataFrame([1, 0, True, False], dtype=np_type))
+ frame.to_excel(self.path, 'test1')
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1').astype(np_type)
+ tm.assert_frame_equal(frame, recons)
+
+ def test_inf_roundtrip(self, merge_cells, engine, ext):
frame = DataFrame([(1, np.inf), (2, 3), (5, -np.inf)])
- with ensure_clean(self.ext) as path:
- frame.to_excel(path, 'test1')
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1')
- tm.assert_frame_equal(frame, recons)
-
- def test_sheets(self):
- _skip_if_no_xlrd()
-
- with ensure_clean(self.ext) as path:
- self.frame['A'][:5] = nan
-
- self.frame.to_excel(path, 'test1')
- self.frame.to_excel(path, 'test1', columns=['A', 'B'])
- self.frame.to_excel(path, 'test1', header=False)
- self.frame.to_excel(path, 'test1', index=False)
-
- # Test writing to separate sheets
- writer = ExcelWriter(path)
- self.frame.to_excel(writer, 'test1')
- self.tsframe.to_excel(writer, 'test2')
- writer.save()
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1', index_col=0)
- tm.assert_frame_equal(self.frame, recons)
- recons = read_excel(reader, 'test2', index_col=0)
- tm.assert_frame_equal(self.tsframe, recons)
- assert 2 == len(reader.sheet_names)
- assert 'test1' == reader.sheet_names[0]
- assert 'test2' == reader.sheet_names[1]
-
- def test_colaliases(self):
- _skip_if_no_xlrd()
-
- with ensure_clean(self.ext) as path:
- self.frame['A'][:5] = nan
-
- self.frame.to_excel(path, 'test1')
- self.frame.to_excel(path, 'test1', columns=['A', 'B'])
- self.frame.to_excel(path, 'test1', header=False)
- self.frame.to_excel(path, 'test1', index=False)
-
- # column aliases
- col_aliases = Index(['AA', 'X', 'Y', 'Z'])
- self.frame2.to_excel(path, 'test1', header=col_aliases)
- reader = ExcelFile(path)
- rs = read_excel(reader, 'test1', index_col=0)
- xp = self.frame2.copy()
- xp.columns = col_aliases
- tm.assert_frame_equal(xp, rs)
-
- def test_roundtrip_indexlabels(self):
- _skip_if_no_xlrd()
-
- with ensure_clean(self.ext) as path:
-
- self.frame['A'][:5] = nan
-
- self.frame.to_excel(path, 'test1')
- self.frame.to_excel(path, 'test1', columns=['A', 'B'])
- self.frame.to_excel(path, 'test1', header=False)
- self.frame.to_excel(path, 'test1', index=False)
-
- # test index_label
- frame = (DataFrame(np.random.randn(10, 2)) >= 0)
- frame.to_excel(path, 'test1',
- index_label=['test'],
- merge_cells=self.merge_cells)
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1',
- index_col=0,
- ).astype(np.int64)
- frame.index.names = ['test']
- assert frame.index.names == recons.index.names
-
- frame = (DataFrame(np.random.randn(10, 2)) >= 0)
- frame.to_excel(path,
- 'test1',
- index_label=['test', 'dummy', 'dummy2'],
- merge_cells=self.merge_cells)
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1',
- index_col=0,
- ).astype(np.int64)
- frame.index.names = ['test']
- assert frame.index.names == recons.index.names
-
- frame = (DataFrame(np.random.randn(10, 2)) >= 0)
- frame.to_excel(path,
- 'test1',
- index_label='test',
- merge_cells=self.merge_cells)
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1',
- index_col=0,
- ).astype(np.int64)
- frame.index.names = ['test']
- tm.assert_frame_equal(frame, recons.astype(bool))
-
- with ensure_clean(self.ext) as path:
-
- self.frame.to_excel(path,
- 'test1',
- columns=['A', 'B', 'C', 'D'],
- index=False, merge_cells=self.merge_cells)
- # take 'A' and 'B' as indexes (same row as cols 'C', 'D')
- df = self.frame.copy()
- df = df.set_index(['A', 'B'])
-
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1', index_col=[0, 1])
- tm.assert_frame_equal(df, recons, check_less_precise=True)
-
- def test_excel_roundtrip_indexname(self):
- _skip_if_no_xlrd()
-
+ frame.to_excel(self.path, 'test1')
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1')
+ tm.assert_frame_equal(frame, recons)
+
+ def test_sheets(self, merge_cells, engine, ext):
+ self.frame['A'][:5] = nan
+
+ self.frame.to_excel(self.path, 'test1')
+ self.frame.to_excel(self.path, 'test1', columns=['A', 'B'])
+ self.frame.to_excel(self.path, 'test1', header=False)
+ self.frame.to_excel(self.path, 'test1', index=False)
+
+ # Test writing to separate sheets
+ writer = ExcelWriter(self.path)
+ self.frame.to_excel(writer, 'test1')
+ self.tsframe.to_excel(writer, 'test2')
+ writer.save()
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1', index_col=0)
+ tm.assert_frame_equal(self.frame, recons)
+ recons = read_excel(reader, 'test2', index_col=0)
+ tm.assert_frame_equal(self.tsframe, recons)
+ assert 2 == len(reader.sheet_names)
+ assert 'test1' == reader.sheet_names[0]
+ assert 'test2' == reader.sheet_names[1]
+
+ def test_colaliases(self, merge_cells, engine, ext):
+ self.frame['A'][:5] = nan
+
+ self.frame.to_excel(self.path, 'test1')
+ self.frame.to_excel(self.path, 'test1', columns=['A', 'B'])
+ self.frame.to_excel(self.path, 'test1', header=False)
+ self.frame.to_excel(self.path, 'test1', index=False)
+
+ # column aliases
+ col_aliases = Index(['AA', 'X', 'Y', 'Z'])
+ self.frame2.to_excel(self.path, 'test1', header=col_aliases)
+ reader = ExcelFile(self.path)
+ rs = read_excel(reader, 'test1', index_col=0)
+ xp = self.frame2.copy()
+ xp.columns = col_aliases
+ tm.assert_frame_equal(xp, rs)
+
+ def test_roundtrip_indexlabels(self, merge_cells, engine, ext):
+ self.frame['A'][:5] = nan
+
+ self.frame.to_excel(self.path, 'test1')
+ self.frame.to_excel(self.path, 'test1', columns=['A', 'B'])
+ self.frame.to_excel(self.path, 'test1', header=False)
+ self.frame.to_excel(self.path, 'test1', index=False)
+
+ # test index_label
+ frame = (DataFrame(np.random.randn(10, 2)) >= 0)
+ frame.to_excel(self.path, 'test1',
+ index_label=['test'],
+ merge_cells=merge_cells)
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1',
+ index_col=0,
+ ).astype(np.int64)
+ frame.index.names = ['test']
+ assert frame.index.names == recons.index.names
+
+ frame = (DataFrame(np.random.randn(10, 2)) >= 0)
+ frame.to_excel(self.path,
+ 'test1',
+ index_label=['test', 'dummy', 'dummy2'],
+ merge_cells=merge_cells)
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1',
+ index_col=0,
+ ).astype(np.int64)
+ frame.index.names = ['test']
+ assert frame.index.names == recons.index.names
+
+ frame = (DataFrame(np.random.randn(10, 2)) >= 0)
+ frame.to_excel(self.path,
+ 'test1',
+ index_label='test',
+ merge_cells=merge_cells)
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1',
+ index_col=0,
+ ).astype(np.int64)
+ frame.index.names = ['test']
+ tm.assert_frame_equal(frame, recons.astype(bool))
+
+ self.frame.to_excel(self.path,
+ 'test1',
+ columns=['A', 'B', 'C', 'D'],
+ index=False, merge_cells=merge_cells)
+ # take 'A' and 'B' as indexes (same row as cols 'C', 'D')
+ df = self.frame.copy()
+ df = df.set_index(['A', 'B'])
+
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1', index_col=[0, 1])
+ tm.assert_frame_equal(df, recons, check_less_precise=True)
+
+ def test_excel_roundtrip_indexname(self, merge_cells, engine, ext):
df = DataFrame(np.random.randn(10, 4))
df.index.name = 'foo'
- with ensure_clean(self.ext) as path:
- df.to_excel(path, merge_cells=self.merge_cells)
+ df.to_excel(self.path, merge_cells=merge_cells)
- xf = ExcelFile(path)
- result = read_excel(xf, xf.sheet_names[0],
- index_col=0)
+ xf = ExcelFile(self.path)
+ result = read_excel(xf, xf.sheet_names[0],
+ index_col=0)
- tm.assert_frame_equal(result, df)
- assert result.index.name == 'foo'
-
- def test_excel_roundtrip_datetime(self):
- _skip_if_no_xlrd()
+ tm.assert_frame_equal(result, df)
+ assert result.index.name == 'foo'
+ def test_excel_roundtrip_datetime(self, merge_cells, engine, ext):
# datetime.date, not sure what to test here exactly
tsf = self.tsframe.copy()
- with ensure_clean(self.ext) as path:
- tsf.index = [x.date() for x in self.tsframe.index]
- tsf.to_excel(path, 'test1', merge_cells=self.merge_cells)
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1')
- tm.assert_frame_equal(self.tsframe, recons)
+ tsf.index = [x.date() for x in self.tsframe.index]
+ tsf.to_excel(self.path, 'test1', merge_cells=merge_cells)
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1')
+ tm.assert_frame_equal(self.tsframe, recons)
# GH4133 - excel output format strings
- def test_excel_date_datetime_format(self):
- _skip_if_no_xlrd()
+ def test_excel_date_datetime_format(self, merge_cells, engine, ext):
df = DataFrame([[date(2014, 1, 31),
date(1999, 9, 24)],
[datetime(1998, 5, 26, 23, 33, 4),
@@ -1414,133 +1321,117 @@ def test_excel_date_datetime_format(self):
datetime(2014, 2, 28, 13, 5, 13)]],
index=['DATE', 'DATETIME'], columns=['X', 'Y'])
- with ensure_clean(self.ext) as filename1:
- with ensure_clean(self.ext) as filename2:
- writer1 = ExcelWriter(filename1)
- writer2 = ExcelWriter(filename2,
- date_format='DD.MM.YYYY',
- datetime_format='DD.MM.YYYY HH-MM-SS')
+ with ensure_clean(ext) as filename2:
+ writer1 = ExcelWriter(self.path)
+ writer2 = ExcelWriter(filename2,
+ date_format='DD.MM.YYYY',
+ datetime_format='DD.MM.YYYY HH-MM-SS')
- df.to_excel(writer1, 'test1')
- df.to_excel(writer2, 'test1')
+ df.to_excel(writer1, 'test1')
+ df.to_excel(writer2, 'test1')
- writer1.close()
- writer2.close()
+ writer1.close()
+ writer2.close()
- reader1 = ExcelFile(filename1)
- reader2 = ExcelFile(filename2)
+ reader1 = ExcelFile(self.path)
+ reader2 = ExcelFile(filename2)
- rs1 = read_excel(reader1, 'test1', index_col=None)
- rs2 = read_excel(reader2, 'test1', index_col=None)
+ rs1 = read_excel(reader1, 'test1', index_col=None)
+ rs2 = read_excel(reader2, 'test1', index_col=None)
- tm.assert_frame_equal(rs1, rs2)
+ tm.assert_frame_equal(rs1, rs2)
- # since the reader returns a datetime object for dates, we need
- # to use df_expected to check the result
- tm.assert_frame_equal(rs2, df_expected)
+ # since the reader returns a datetime object for dates, we need
+ # to use df_expected to check the result
+ tm.assert_frame_equal(rs2, df_expected)
- def test_to_excel_interval_no_labels(self):
+ def test_to_excel_interval_no_labels(self, merge_cells, engine, ext):
# GH19242 - test writing Interval without labels
- _skip_if_no_xlrd()
-
- with ensure_clean(self.ext) as path:
- frame = DataFrame(np.random.randint(-10, 10, size=(20, 1)),
- dtype=np.int64)
- expected = frame.copy()
- frame['new'] = pd.cut(frame[0], 10)
- expected['new'] = pd.cut(expected[0], 10).astype(str)
- frame.to_excel(path, 'test1')
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1')
- tm.assert_frame_equal(expected, recons)
-
- def test_to_excel_interval_labels(self):
+ frame = DataFrame(np.random.randint(-10, 10, size=(20, 1)),
+ dtype=np.int64)
+ expected = frame.copy()
+ frame['new'] = pd.cut(frame[0], 10)
+ expected['new'] = pd.cut(expected[0], 10).astype(str)
+ frame.to_excel(self.path, 'test1')
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1')
+ tm.assert_frame_equal(expected, recons)
+
+ def test_to_excel_interval_labels(self, merge_cells, engine, ext):
# GH19242 - test writing Interval with labels
- _skip_if_no_xlrd()
-
- with ensure_clean(self.ext) as path:
- frame = DataFrame(np.random.randint(-10, 10, size=(20, 1)),
- dtype=np.int64)
- expected = frame.copy()
- intervals = pd.cut(frame[0], 10, labels=['A', 'B', 'C', 'D', 'E',
- 'F', 'G', 'H', 'I', 'J'])
- frame['new'] = intervals
- expected['new'] = pd.Series(list(intervals))
- frame.to_excel(path, 'test1')
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1')
- tm.assert_frame_equal(expected, recons)
-
- def test_to_excel_timedelta(self):
+ frame = DataFrame(np.random.randint(-10, 10, size=(20, 1)),
+ dtype=np.int64)
+ expected = frame.copy()
+ intervals = pd.cut(frame[0], 10, labels=['A', 'B', 'C', 'D', 'E',
+ 'F', 'G', 'H', 'I', 'J'])
+ frame['new'] = intervals
+ expected['new'] = pd.Series(list(intervals))
+ frame.to_excel(self.path, 'test1')
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1')
+ tm.assert_frame_equal(expected, recons)
+
+ def test_to_excel_timedelta(self, merge_cells, engine, ext):
# GH 19242, GH9155 - test writing timedelta to xls
- _skip_if_no_xlrd()
-
- with ensure_clean('.xls') as path:
- frame = DataFrame(np.random.randint(-10, 10, size=(20, 1)),
- columns=['A'],
- dtype=np.int64
- )
- expected = frame.copy()
- frame['new'] = frame['A'].apply(lambda x: timedelta(seconds=x))
- expected['new'] = expected['A'].apply(
- lambda x: timedelta(seconds=x).total_seconds() / float(86400))
- frame.to_excel(path, 'test1')
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1')
- tm.assert_frame_equal(expected, recons)
-
- def test_to_excel_periodindex(self):
- _skip_if_no_xlrd()
-
+ if engine == 'openpyxl':
+ pytest.xfail('Timedelta roundtrip broken with openpyxl')
+ if engine == 'xlsxwriter' and (sys.version_info[0] == 2 and
+ sys.platform.startswith('linux')):
+ pytest.xfail('Not working on linux with Py2 and xlsxwriter')
+ frame = DataFrame(np.random.randint(-10, 10, size=(20, 1)),
+ columns=['A'],
+ dtype=np.int64
+ )
+ expected = frame.copy()
+ frame['new'] = frame['A'].apply(lambda x: timedelta(seconds=x))
+ expected['new'] = expected['A'].apply(
+ lambda x: timedelta(seconds=x).total_seconds() / float(86400))
+ frame.to_excel(self.path, 'test1')
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1')
+ tm.assert_frame_equal(expected, recons)
+
+ def test_to_excel_periodindex(self, merge_cells, engine, ext):
frame = self.tsframe
xp = frame.resample('M', kind='period').mean()
- with ensure_clean(self.ext) as path:
- xp.to_excel(path, 'sht1')
-
- reader = ExcelFile(path)
- rs = read_excel(reader, 'sht1', index_col=0)
- tm.assert_frame_equal(xp, rs.to_period('M'))
+ xp.to_excel(self.path, 'sht1')
- def test_to_excel_multiindex(self):
- _skip_if_no_xlrd()
+ reader = ExcelFile(self.path)
+ rs = read_excel(reader, 'sht1', index_col=0)
+ tm.assert_frame_equal(xp, rs.to_period('M'))
+ def test_to_excel_multiindex(self, merge_cells, engine, ext):
frame = self.frame
arrays = np.arange(len(frame.index) * 2).reshape(2, -1)
new_index = MultiIndex.from_arrays(arrays,
names=['first', 'second'])
frame.index = new_index
- with ensure_clean(self.ext) as path:
- frame.to_excel(path, 'test1', header=False)
- frame.to_excel(path, 'test1', columns=['A', 'B'])
+ frame.to_excel(self.path, 'test1', header=False)
+ frame.to_excel(self.path, 'test1', columns=['A', 'B'])
- # round trip
- frame.to_excel(path, 'test1', merge_cells=self.merge_cells)
- reader = ExcelFile(path)
- df = read_excel(reader, 'test1', index_col=[0, 1])
- tm.assert_frame_equal(frame, df)
+ # round trip
+ frame.to_excel(self.path, 'test1', merge_cells=merge_cells)
+ reader = ExcelFile(self.path)
+ df = read_excel(reader, 'test1', index_col=[0, 1])
+ tm.assert_frame_equal(frame, df)
# GH13511
- def test_to_excel_multiindex_nan_label(self):
- _skip_if_no_xlrd()
-
+ def test_to_excel_multiindex_nan_label(self, merge_cells, engine, ext):
frame = pd.DataFrame({'A': [None, 2, 3],
'B': [10, 20, 30],
'C': np.random.sample(3)})
frame = frame.set_index(['A', 'B'])
- with ensure_clean(self.ext) as path:
- frame.to_excel(path, merge_cells=self.merge_cells)
- df = read_excel(path, index_col=[0, 1])
- tm.assert_frame_equal(frame, df)
+ frame.to_excel(self.path, merge_cells=merge_cells)
+ df = read_excel(self.path, index_col=[0, 1])
+ tm.assert_frame_equal(frame, df)
# Test for Issue 11328. If column indices are integers, make
# sure they are handled correctly for either setting of
# merge_cells
- def test_to_excel_multiindex_cols(self):
- _skip_if_no_xlrd()
-
+ def test_to_excel_multiindex_cols(self, merge_cells, engine, ext):
frame = self.frame
arrays = np.arange(len(frame.index) * 2).reshape(2, -1)
new_index = MultiIndex.from_arrays(arrays,
@@ -1551,42 +1442,37 @@ def test_to_excel_multiindex_cols(self):
(50, 1), (50, 2)])
frame.columns = new_cols_index
header = [0, 1]
- if not self.merge_cells:
+ if not merge_cells:
header = 0
- with ensure_clean(self.ext) as path:
- # round trip
- frame.to_excel(path, 'test1', merge_cells=self.merge_cells)
- reader = ExcelFile(path)
- df = read_excel(reader, 'test1', header=header,
- index_col=[0, 1])
- if not self.merge_cells:
- fm = frame.columns.format(sparsify=False,
- adjoin=False, names=False)
- frame.columns = [".".join(map(str, q)) for q in zip(*fm)]
- tm.assert_frame_equal(frame, df)
-
- def test_to_excel_multiindex_dates(self):
- _skip_if_no_xlrd()
-
+ # round trip
+ frame.to_excel(self.path, 'test1', merge_cells=merge_cells)
+ reader = ExcelFile(self.path)
+ df = read_excel(reader, 'test1', header=header,
+ index_col=[0, 1])
+ if not merge_cells:
+ fm = frame.columns.format(sparsify=False,
+ adjoin=False, names=False)
+ frame.columns = [".".join(map(str, q)) for q in zip(*fm)]
+ tm.assert_frame_equal(frame, df)
+
+ def test_to_excel_multiindex_dates(self, merge_cells, engine, ext):
# try multiindex with dates
tsframe = self.tsframe.copy()
new_index = [tsframe.index, np.arange(len(tsframe.index))]
tsframe.index = MultiIndex.from_arrays(new_index)
- with ensure_clean(self.ext) as path:
- tsframe.index.names = ['time', 'foo']
- tsframe.to_excel(path, 'test1', merge_cells=self.merge_cells)
- reader = ExcelFile(path)
- recons = read_excel(reader, 'test1',
- index_col=[0, 1])
-
- tm.assert_frame_equal(tsframe, recons)
- assert recons.index.names == ('time', 'foo')
+ tsframe.index.names = ['time', 'foo']
+ tsframe.to_excel(self.path, 'test1', merge_cells=merge_cells)
+ reader = ExcelFile(self.path)
+ recons = read_excel(reader, 'test1',
+ index_col=[0, 1])
- def test_to_excel_multiindex_no_write_index(self):
- _skip_if_no_xlrd()
+ tm.assert_frame_equal(tsframe, recons)
+ assert recons.index.names == ('time', 'foo')
+ def test_to_excel_multiindex_no_write_index(self, merge_cells, engine,
+ ext):
# Test writing and re-reading a MI witout the index. GH 5616.
# Initial non-MI frame.
@@ -1597,53 +1483,44 @@ def test_to_excel_multiindex_no_write_index(self):
multi_index = MultiIndex.from_tuples([(70, 80), (90, 100)])
frame2.index = multi_index
- with ensure_clean(self.ext) as path:
+ # Write out to Excel without the index.
+ frame2.to_excel(self.path, 'test1', index=False)
- # Write out to Excel without the index.
- frame2.to_excel(path, 'test1', index=False)
+ # Read it back in.
+ reader = ExcelFile(self.path)
+ frame3 = read_excel(reader, 'test1')
- # Read it back in.
- reader = ExcelFile(path)
- frame3 = read_excel(reader, 'test1')
-
- # Test that it is the same as the initial frame.
- tm.assert_frame_equal(frame1, frame3)
-
- def test_to_excel_float_format(self):
- _skip_if_no_xlrd()
+ # Test that it is the same as the initial frame.
+ tm.assert_frame_equal(frame1, frame3)
+ def test_to_excel_float_format(self, merge_cells, engine, ext):
df = DataFrame([[0.123456, 0.234567, 0.567567],
[12.32112, 123123.2, 321321.2]],
index=['A', 'B'], columns=['X', 'Y', 'Z'])
- with ensure_clean(self.ext) as filename:
- df.to_excel(filename, 'test1', float_format='%.2f')
+ df.to_excel(self.path, 'test1', float_format='%.2f')
- reader = ExcelFile(filename)
- rs = read_excel(reader, 'test1', index_col=None)
- xp = DataFrame([[0.12, 0.23, 0.57],
- [12.32, 123123.20, 321321.20]],
- index=['A', 'B'], columns=['X', 'Y', 'Z'])
- tm.assert_frame_equal(rs, xp)
-
- def test_to_excel_output_encoding(self):
- _skip_if_no_xlrd()
+ reader = ExcelFile(self.path)
+ rs = read_excel(reader, 'test1', index_col=None)
+ xp = DataFrame([[0.12, 0.23, 0.57],
+ [12.32, 123123.20, 321321.20]],
+ index=['A', 'B'], columns=['X', 'Y', 'Z'])
+ tm.assert_frame_equal(rs, xp)
+ def test_to_excel_output_encoding(self, merge_cells, engine, ext):
# avoid mixed inferred_type
df = DataFrame([[u'\u0192', u'\u0193', u'\u0194'],
[u'\u0195', u'\u0196', u'\u0197']],
index=[u'A\u0192', u'B'],
columns=[u'X\u0193', u'Y', u'Z'])
- with ensure_clean('__tmp_to_excel_float_format__.' + self.ext)\
- as filename:
+ with ensure_clean('__tmp_to_excel_float_format__.' + ext) as filename:
df.to_excel(filename, sheet_name='TestSheet', encoding='utf8')
result = read_excel(filename, 'TestSheet', encoding='utf8')
tm.assert_frame_equal(result, df)
- def test_to_excel_unicode_filename(self):
- _skip_if_no_xlrd()
- with ensure_clean(u('\u0192u.') + self.ext) as filename:
+ def test_to_excel_unicode_filename(self, merge_cells, engine, ext):
+ with ensure_clean(u('\u0192u.') + ext) as filename:
try:
f = open(filename, 'wb')
except UnicodeEncodeError:
@@ -1664,7 +1541,7 @@ def test_to_excel_unicode_filename(self):
index=['A', 'B'], columns=['X', 'Y', 'Z'])
tm.assert_frame_equal(rs, xp)
- # def test_to_excel_header_styling_xls(self):
+ # def test_to_excel_header_styling_xls(self, merge_cells, engine, ext):
# import StringIO
# s = StringIO(
@@ -1711,7 +1588,7 @@ def test_to_excel_unicode_filename(self):
# assert 1 == cell_xf.border.left_line_style
# assert 2 == cell_xf.alignment.hor_align
# os.remove(filename)
- # def test_to_excel_header_styling_xlsx(self):
+ # def test_to_excel_header_styling_xlsx(self, merge_cells, engine, ext):
# import StringIO
# s = StringIO(
# """Date,ticker,type,value
@@ -1764,10 +1641,8 @@ def test_to_excel_unicode_filename(self):
# assert ws.cell(maddr).merged
# os.remove(filename)
- def test_excel_010_hemstring(self):
- _skip_if_no_xlrd()
-
- if self.merge_cells:
+ def test_excel_010_hemstring(self, merge_cells, engine, ext):
+ if merge_cells:
pytest.skip('Skip tests for merged MI format.')
from pandas.util.testing import makeCustomDataframe as mkdf
@@ -1776,12 +1651,11 @@ def test_excel_010_hemstring(self):
def roundtrip(df, header=True, parser_hdr=0, index=True):
- with ensure_clean(self.ext) as path:
- df.to_excel(path, header=header,
- merge_cells=self.merge_cells, index=index)
- xf = ExcelFile(path)
- res = read_excel(xf, xf.sheet_names[0], header=parser_hdr)
- return res
+ df.to_excel(self.path, header=header,
+ merge_cells=merge_cells, index=index)
+ xf = ExcelFile(self.path)
+ res = read_excel(xf, xf.sheet_names[0], header=parser_hdr)
+ return res
nrows = 5
ncols = 3
@@ -1817,12 +1691,11 @@ def roundtrip(df, header=True, parser_hdr=0, index=True):
assert res.shape == (1, 2)
assert res.iloc[0, 0] is not np.nan
- def test_excel_010_hemstring_raises_NotImplementedError(self):
+ def test_excel_010_hemstring_raises_NotImplementedError(self, merge_cells,
+ engine, ext):
# This test was failing only for j>1 and header=False,
# So I reproduced a simple test.
- _skip_if_no_xlrd()
-
- if self.merge_cells:
+ if merge_cells:
pytest.skip('Skip tests for merged MI format.')
from pandas.util.testing import makeCustomDataframe as mkdf
@@ -1831,12 +1704,11 @@ def test_excel_010_hemstring_raises_NotImplementedError(self):
def roundtrip2(df, header=True, parser_hdr=0, index=True):
- with ensure_clean(self.ext) as path:
- df.to_excel(path, header=header,
- merge_cells=self.merge_cells, index=index)
- xf = ExcelFile(path)
- res = read_excel(xf, xf.sheet_names[0], header=parser_hdr)
- return res
+ df.to_excel(self.path, header=header,
+ merge_cells=merge_cells, index=index)
+ xf = ExcelFile(self.path)
+ res = read_excel(xf, xf.sheet_names[0], header=parser_hdr)
+ return res
nrows = 5
ncols = 3
@@ -1846,134 +1718,119 @@ def roundtrip2(df, header=True, parser_hdr=0, index=True):
with pytest.raises(NotImplementedError):
roundtrip2(df, header=False, index=False)
- def test_duplicated_columns(self):
+ def test_duplicated_columns(self, merge_cells, engine, ext):
# Test for issue #5235
- _skip_if_no_xlrd()
-
- with ensure_clean(self.ext) as path:
- write_frame = DataFrame([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
- colnames = ['A', 'B', 'B']
-
- write_frame.columns = colnames
- write_frame.to_excel(path, 'test1')
-
- read_frame = read_excel(path, 'test1')
- read_frame.columns = colnames
- tm.assert_frame_equal(write_frame, read_frame)
-
- # 11007 / #10970
- write_frame = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]],
- columns=['A', 'B', 'A', 'B'])
- write_frame.to_excel(path, 'test1')
- read_frame = read_excel(path, 'test1')
- read_frame.columns = ['A', 'B', 'A', 'B']
- tm.assert_frame_equal(write_frame, read_frame)
-
- # 10982
- write_frame.to_excel(path, 'test1', index=False, header=False)
- read_frame = read_excel(path, 'test1', header=None)
- write_frame.columns = [0, 1, 2, 3]
- tm.assert_frame_equal(write_frame, read_frame)
-
- def test_swapped_columns(self):
- # Test for issue #5427.
- _skip_if_no_xlrd()
+ write_frame = DataFrame([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
+ colnames = ['A', 'B', 'B']
- with ensure_clean(self.ext) as path:
- write_frame = DataFrame({'A': [1, 1, 1],
- 'B': [2, 2, 2]})
- write_frame.to_excel(path, 'test1', columns=['B', 'A'])
+ write_frame.columns = colnames
+ write_frame.to_excel(self.path, 'test1')
- read_frame = read_excel(path, 'test1', header=0)
+ read_frame = read_excel(self.path, 'test1')
+ read_frame.columns = colnames
+ tm.assert_frame_equal(write_frame, read_frame)
- tm.assert_series_equal(write_frame['A'], read_frame['A'])
- tm.assert_series_equal(write_frame['B'], read_frame['B'])
+ # 11007 / #10970
+ write_frame = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]],
+ columns=['A', 'B', 'A', 'B'])
+ write_frame.to_excel(self.path, 'test1')
+ read_frame = read_excel(self.path, 'test1')
+ read_frame.columns = ['A', 'B', 'A', 'B']
+ tm.assert_frame_equal(write_frame, read_frame)
- def test_invalid_columns(self):
# 10982
- _skip_if_no_xlrd()
+ write_frame.to_excel(self.path, 'test1', index=False, header=False)
+ read_frame = read_excel(self.path, 'test1', header=None)
+ write_frame.columns = [0, 1, 2, 3]
+ tm.assert_frame_equal(write_frame, read_frame)
+
+ def test_swapped_columns(self, merge_cells, engine, ext):
+ # Test for issue #5427.
+ write_frame = DataFrame({'A': [1, 1, 1],
+ 'B': [2, 2, 2]})
+ write_frame.to_excel(self.path, 'test1', columns=['B', 'A'])
+
+ read_frame = read_excel(self.path, 'test1', header=0)
+
+ tm.assert_series_equal(write_frame['A'], read_frame['A'])
+ tm.assert_series_equal(write_frame['B'], read_frame['B'])
- with ensure_clean(self.ext) as path:
- write_frame = DataFrame({'A': [1, 1, 1],
- 'B': [2, 2, 2]})
+ def test_invalid_columns(self, merge_cells, engine, ext):
+ # 10982
+ write_frame = DataFrame({'A': [1, 1, 1],
+ 'B': [2, 2, 2]})
- with tm.assert_produces_warning(FutureWarning,
- check_stacklevel=False):
- write_frame.to_excel(path, 'test1', columns=['B', 'C'])
- expected = write_frame.reindex(columns=['B', 'C'])
- read_frame = read_excel(path, 'test1')
- tm.assert_frame_equal(expected, read_frame)
+ with tm.assert_produces_warning(FutureWarning,
+ check_stacklevel=False):
+ write_frame.to_excel(self.path, 'test1', columns=['B', 'C'])
+ expected = write_frame.reindex(columns=['B', 'C'])
+ read_frame = read_excel(self.path, 'test1')
+ tm.assert_frame_equal(expected, read_frame)
- with pytest.raises(KeyError):
- write_frame.to_excel(path, 'test1', columns=['C', 'D'])
+ with pytest.raises(KeyError):
+ write_frame.to_excel(self.path, 'test1', columns=['C', 'D'])
- def test_comment_arg(self):
+ def test_comment_arg(self, merge_cells, engine, ext):
# Re issue #18735
# Test the comment argument functionality to read_excel
- with ensure_clean(self.ext) as path:
-
- # Create file to read in
- df = DataFrame({'A': ['one', '#one', 'one'],
- 'B': ['two', 'two', '#two']})
- df.to_excel(path, 'test_c')
-
- # Read file without comment arg
- result1 = read_excel(path, 'test_c')
- result1.iloc[1, 0] = None
- result1.iloc[1, 1] = None
- result1.iloc[2, 1] = None
- result2 = read_excel(path, 'test_c', comment='#')
- tm.assert_frame_equal(result1, result2)
-
- def test_comment_default(self):
+
+ # Create file to read in
+ df = DataFrame({'A': ['one', '#one', 'one'],
+ 'B': ['two', 'two', '#two']})
+ df.to_excel(self.path, 'test_c')
+
+ # Read file without comment arg
+ result1 = read_excel(self.path, 'test_c')
+ result1.iloc[1, 0] = None
+ result1.iloc[1, 1] = None
+ result1.iloc[2, 1] = None
+ result2 = read_excel(self.path, 'test_c', comment='#')
+ tm.assert_frame_equal(result1, result2)
+
+ def test_comment_default(self, merge_cells, engine, ext):
# Re issue #18735
# Test the comment argument default to read_excel
- with ensure_clean(self.ext) as path:
- # Create file to read in
- df = DataFrame({'A': ['one', '#one', 'one'],
- 'B': ['two', 'two', '#two']})
- df.to_excel(path, 'test_c')
+ # Create file to read in
+ df = DataFrame({'A': ['one', '#one', 'one'],
+ 'B': ['two', 'two', '#two']})
+ df.to_excel(self.path, 'test_c')
- # Read file with default and explicit comment=None
- result1 = read_excel(path, 'test_c')
- result2 = read_excel(path, 'test_c', comment=None)
- tm.assert_frame_equal(result1, result2)
+ # Read file with default and explicit comment=None
+ result1 = read_excel(self.path, 'test_c')
+ result2 = read_excel(self.path, 'test_c', comment=None)
+ tm.assert_frame_equal(result1, result2)
- def test_comment_used(self):
+ def test_comment_used(self, merge_cells, engine, ext):
# Re issue #18735
# Test the comment argument is working as expected when used
- with ensure_clean(self.ext) as path:
- # Create file to read in
- df = DataFrame({'A': ['one', '#one', 'one'],
- 'B': ['two', 'two', '#two']})
- df.to_excel(path, 'test_c')
+ # Create file to read in
+ df = DataFrame({'A': ['one', '#one', 'one'],
+ 'B': ['two', 'two', '#two']})
+ df.to_excel(self.path, 'test_c')
- # Test read_frame_comment against manually produced expected output
- expected = DataFrame({'A': ['one', None, 'one'],
- 'B': ['two', None, None]})
- result = read_excel(path, 'test_c', comment='#')
- tm.assert_frame_equal(result, expected)
+ # Test read_frame_comment against manually produced expected output
+ expected = DataFrame({'A': ['one', None, 'one'],
+ 'B': ['two', None, None]})
+ result = read_excel(self.path, 'test_c', comment='#')
+ tm.assert_frame_equal(result, expected)
- def test_comment_emptyline(self):
+ def test_comment_emptyline(self, merge_cells, engine, ext):
# Re issue #18735
# Test that read_excel ignores commented lines at the end of file
- with ensure_clean(self.ext) as path:
- df = DataFrame({'a': ['1', '#2'], 'b': ['2', '3']})
- df.to_excel(path, index=False)
+ df = DataFrame({'a': ['1', '#2'], 'b': ['2', '3']})
+ df.to_excel(self.path, index=False)
- # Test that all-comment lines at EoF are ignored
- expected = DataFrame({'a': [1], 'b': [2]})
- result = read_excel(path, comment='#')
- tm.assert_frame_equal(result, expected)
+ # Test that all-comment lines at EoF are ignored
+ expected = DataFrame({'a': [1], 'b': [2]})
+ result = read_excel(self.path, comment='#')
+ tm.assert_frame_equal(result, expected)
- def test_datetimes(self):
+ def test_datetimes(self, merge_cells, engine, ext):
# Test writing and reading datetimes. For issue #9139. (xref #9185)
- _skip_if_no_xlrd()
-
datetimes = [datetime(2013, 1, 13, 1, 2, 3),
datetime(2013, 1, 13, 2, 45, 56),
datetime(2013, 1, 13, 4, 29, 49),
@@ -1986,21 +1843,18 @@ def test_datetimes(self):
datetime(2013, 1, 13, 16, 37, 0),
datetime(2013, 1, 13, 18, 20, 52)]
- with ensure_clean(self.ext) as path:
- write_frame = DataFrame({'A': datetimes})
- write_frame.to_excel(path, 'Sheet1')
- read_frame = read_excel(path, 'Sheet1', header=0)
+ write_frame = DataFrame({'A': datetimes})
+ write_frame.to_excel(self.path, 'Sheet1')
+ read_frame = read_excel(self.path, 'Sheet1', header=0)
- tm.assert_series_equal(write_frame['A'], read_frame['A'])
+ tm.assert_series_equal(write_frame['A'], read_frame['A'])
# GH7074
- def test_bytes_io(self):
- _skip_if_no_xlrd()
-
+ def test_bytes_io(self, merge_cells, engine, ext):
bio = BytesIO()
df = DataFrame(np.random.randn(10, 2))
# pass engine explicitly as there is no file path to infer from
- writer = ExcelWriter(bio, engine=self.engine_name)
+ writer = ExcelWriter(bio, engine=engine)
df.to_excel(writer)
writer.save()
bio.seek(0)
@@ -2008,62 +1862,59 @@ def test_bytes_io(self):
tm.assert_frame_equal(df, reread_df)
# GH8188
- def test_write_lists_dict(self):
- _skip_if_no_xlrd()
-
+ def test_write_lists_dict(self, merge_cells, engine, ext):
df = DataFrame({'mixed': ['a', ['b', 'c'], {'d': 'e', 'f': 2}],
'numeric': [1, 2, 3.0],
'str': ['apple', 'banana', 'cherry']})
expected = df.copy()
expected.mixed = expected.mixed.apply(str)
expected.numeric = expected.numeric.astype('int64')
- with ensure_clean(self.ext) as path:
- df.to_excel(path, 'Sheet1')
- read = read_excel(path, 'Sheet1', header=0)
- tm.assert_frame_equal(read, expected)
+
+ df.to_excel(self.path, 'Sheet1')
+ read = read_excel(self.path, 'Sheet1', header=0)
+ tm.assert_frame_equal(read, expected)
# GH13347
- def test_true_and_false_value_options(self):
+ def test_true_and_false_value_options(self, merge_cells, engine, ext):
df = pd.DataFrame([['foo', 'bar']], columns=['col1', 'col2'])
expected = df.replace({'foo': True,
'bar': False})
- with ensure_clean(self.ext) as path:
- df.to_excel(path)
- read_frame = read_excel(path, true_values=['foo'],
- false_values=['bar'])
- tm.assert_frame_equal(read_frame, expected)
- def test_freeze_panes(self):
+ df.to_excel(self.path)
+ read_frame = read_excel(self.path, true_values=['foo'],
+ false_values=['bar'])
+ tm.assert_frame_equal(read_frame, expected)
+
+ def test_freeze_panes(self, merge_cells, engine, ext):
# GH15160
expected = DataFrame([[1, 2], [3, 4]], columns=['col1', 'col2'])
- with ensure_clean(self.ext) as path:
- expected.to_excel(path, "Sheet1", freeze_panes=(1, 1))
- result = read_excel(path)
- tm.assert_frame_equal(expected, result)
+ expected.to_excel(self.path, "Sheet1", freeze_panes=(1, 1))
+ result = read_excel(self.path)
+ tm.assert_frame_equal(expected, result)
- def test_path_pathlib(self):
+ def test_path_pathlib(self, merge_cells, engine, ext):
df = tm.makeDataFrame()
- writer = partial(df.to_excel, engine=self.engine_name)
+ writer = partial(df.to_excel, engine=engine)
reader = partial(pd.read_excel)
result = tm.round_trip_pathlib(writer, reader,
- path="foo.{}".format(self.ext))
+ path="foo.{}".format(ext))
tm.assert_frame_equal(df, result)
- def test_path_localpath(self):
+ def test_path_localpath(self, merge_cells, engine, ext):
df = tm.makeDataFrame()
- writer = partial(df.to_excel, engine=self.engine_name)
+ writer = partial(df.to_excel, engine=engine)
reader = partial(pd.read_excel)
result = tm.round_trip_pathlib(writer, reader,
- path="foo.{}".format(self.ext))
+ path="foo.{}".format(ext))
tm.assert_frame_equal(df, result)
-class TestOpenpyxlTests(ExcelWriterBase):
- engine_name = 'openpyxl'
- ext = '.xlsx'
- check_skip = staticmethod(_skip_if_no_openpyxl)
+@td.skip_if_no('openpyxl')
+@pytest.mark.parametrize("merge_cells,ext,engine", [
+ (None, '.xlsx', 'openpyxl')])
+class TestOpenpyxlTests(_WriterBase):
- def test_to_excel_styleconverter(self):
+ def test_to_excel_styleconverter(self, merge_cells, ext, engine):
from openpyxl import styles
hstyle = {
@@ -2117,7 +1968,7 @@ def test_to_excel_styleconverter(self):
assert kw['number_format'] == number_format
assert kw['protection'] == protection
- def test_write_cells_merge_styled(self):
+ def test_write_cells_merge_styled(self, merge_cells, ext, engine):
from pandas.io.formats.excel import ExcelCell
sheet_name = 'merge_styled'
@@ -2138,7 +1989,7 @@ def test_write_cells_merge_styled(self):
mergestart=1, mergeend=1, style=sty_merged),
]
- with ensure_clean('.xlsx') as path:
+ with ensure_clean(ext) as path:
writer = _OpenpyxlWriter(path)
writer.write_cells(initial_cells, sheet_name=sheet_name)
writer.write_cells(merge_cells, sheet_name=sheet_name)
@@ -2150,44 +2001,41 @@ def test_write_cells_merge_styled(self):
assert xcell_a2.font == openpyxl_sty_merged
-class TestXlwtTests(ExcelWriterBase):
- ext = '.xls'
- engine_name = 'xlwt'
- check_skip = staticmethod(_skip_if_no_xlwt)
+@td.skip_if_no('xlwt')
+@pytest.mark.parametrize("merge_cells,ext,engine", [
+ (None, '.xls', 'xlwt')])
+class TestXlwtTests(_WriterBase):
- def test_excel_raise_error_on_multiindex_columns_and_no_index(self):
- _skip_if_no_xlwt()
+ def test_excel_raise_error_on_multiindex_columns_and_no_index(
+ self, merge_cells, ext, engine):
# MultiIndex as columns is not yet implemented 9794
cols = MultiIndex.from_tuples([('site', ''),
('2014', 'height'),
('2014', 'weight')])
df = DataFrame(np.random.randn(10, 3), columns=cols)
with pytest.raises(NotImplementedError):
- with ensure_clean(self.ext) as path:
+ with ensure_clean(ext) as path:
df.to_excel(path, index=False)
- def test_excel_multiindex_columns_and_index_true(self):
- _skip_if_no_xlwt()
+ def test_excel_multiindex_columns_and_index_true(self, merge_cells, ext,
+ engine):
cols = MultiIndex.from_tuples([('site', ''),
('2014', 'height'),
('2014', 'weight')])
df = pd.DataFrame(np.random.randn(10, 3), columns=cols)
- with ensure_clean(self.ext) as path:
+ with ensure_clean(ext) as path:
df.to_excel(path, index=True)
- def test_excel_multiindex_index(self):
- _skip_if_no_xlwt()
+ def test_excel_multiindex_index(self, merge_cells, ext, engine):
# MultiIndex as index works so assert no error #9794
cols = MultiIndex.from_tuples([('site', ''),
('2014', 'height'),
('2014', 'weight')])
df = DataFrame(np.random.randn(3, 10), index=cols)
- with ensure_clean(self.ext) as path:
+ with ensure_clean(ext) as path:
df.to_excel(path, index=False)
- def test_to_excel_styleconverter(self):
- _skip_if_no_xlwt()
-
+ def test_to_excel_styleconverter(self, merge_cells, ext, engine):
import xlwt
hstyle = {"font": {"bold": True},
@@ -2207,23 +2055,21 @@ def test_to_excel_styleconverter(self):
assert xlwt.Alignment.VERT_TOP == xls_style.alignment.vert
-class TestXlsxWriterTests(ExcelWriterBase):
- ext = '.xlsx'
- engine_name = 'xlsxwriter'
- check_skip = staticmethod(_skip_if_no_xlsxwriter)
+@td.skip_if_no('xlsxwriter')
+@pytest.mark.parametrize("merge_cells,ext,engine", [
+ (None, '.xlsx', 'xlsxwriter')])
+class TestXlsxWriterTests(_WriterBase):
- def test_column_format(self):
+ @td.skip_if_no('openpyxl')
+ def test_column_format(self, merge_cells, ext, engine):
# Test that column formats are applied to cells. Test for issue #9167.
# Applicable to xlsxwriter only.
- _skip_if_no_xlsxwriter()
-
with warnings.catch_warnings():
# Ignore the openpyxl lxml warning.
warnings.simplefilter("ignore")
- _skip_if_no_openpyxl()
import openpyxl
- with ensure_clean(self.ext) as path:
+ with ensure_clean(ext) as path:
frame = DataFrame({'A': [123456, 123456],
'B': [123456, 123456]})
@@ -2260,54 +2106,28 @@ def test_column_format(self):
assert read_num_format == num_format
-class TestOpenpyxlTests_NoMerge(ExcelWriterBase):
- ext = '.xlsx'
- engine_name = 'openpyxl'
- check_skip = staticmethod(_skip_if_no_openpyxl)
-
- # Test < 0.13 non-merge behaviour for MultiIndex and Hierarchical Rows.
- merge_cells = False
-
-
-class TestXlwtTests_NoMerge(ExcelWriterBase):
- ext = '.xls'
- engine_name = 'xlwt'
- check_skip = staticmethod(_skip_if_no_xlwt)
-
- # Test < 0.13 non-merge behaviour for MultiIndex and Hierarchical Rows.
- merge_cells = False
-
-
-class TestXlsxWriterTests_NoMerge(ExcelWriterBase):
- ext = '.xlsx'
- engine_name = 'xlsxwriter'
- check_skip = staticmethod(_skip_if_no_xlsxwriter)
-
- # Test < 0.13 non-merge behaviour for MultiIndex and Hierarchical Rows.
- merge_cells = False
-
-
class TestExcelWriterEngineTests(object):
- def test_ExcelWriter_dispatch(self):
- with tm.assert_raises_regex(ValueError, 'No engine'):
- ExcelWriter('nothing')
-
- try:
- import xlsxwriter # noqa
- writer_klass = _XlsxWriter
- except ImportError:
- _skip_if_no_openpyxl()
- writer_klass = _OpenpyxlWriter
-
- with ensure_clean('.xlsx') as path:
+ @pytest.mark.parametrize('klass,ext', [
+ pytest.param(_XlsxWriter, '.xlsx', marks=pytest.mark.skipif(
+ not td.safe_import('xlsxwriter'), reason='No xlsxwriter')),
+ pytest.param(_OpenpyxlWriter, '.xlsx', marks=pytest.mark.skipif(
+ not td.safe_import('openpyxl'), reason='No openpyxl')),
+ pytest.param(_XlwtWriter, '.xls', marks=pytest.mark.skipif(
+ not td.safe_import('xlwt'), reason='No xlwt'))
+ ])
+ def test_ExcelWriter_dispatch(self, klass, ext):
+ with ensure_clean(ext) as path:
writer = ExcelWriter(path)
- assert isinstance(writer, writer_klass)
+ if ext == '.xlsx' and td.safe_import('xlsxwriter'):
+ # xlsxwriter has preference over openpyxl if both installed
+ assert isinstance(writer, _XlsxWriter)
+ else:
+ assert isinstance(writer, klass)
- _skip_if_no_xlwt()
- with ensure_clean('.xls') as path:
- writer = ExcelWriter(path)
- assert isinstance(writer, _XlwtWriter)
+ def test_ExcelWriter_dispatch_raises(self):
+ with tm.assert_raises_regex(ValueError, 'No engine'):
+ ExcelWriter('nothing')
def test_register_writer(self):
# some awkward mocking to test out dispatch and such actually works
@@ -2498,11 +2318,11 @@ def custom_converter(css):
assert n_cells == (10 + 1) * (3 + 1)
+@td.skip_if_no('openpyxl')
class TestFSPath(object):
@pytest.mark.skipif(sys.version_info < (3, 6), reason='requires fspath')
def test_excelfile_fspath(self):
- _skip_if_no_openpyxl()
with tm.ensure_clean('foo.xlsx') as path:
df = DataFrame({"A": [1, 2]})
df.to_excel(path)
@@ -2513,7 +2333,6 @@ def test_excelfile_fspath(self):
@pytest.mark.skipif(sys.version_info < (3, 6), reason='requires fspath')
# @pytest.mark.xfail
def test_excelwriter_fspath(self):
- _skip_if_no_openpyxl()
with tm.ensure_clean('foo.xlsx') as path:
writer = ExcelWriter(path)
assert os.fspath(writer) == str(path)
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index 0fd5648739e5c..b2745ab5eec77 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -57,7 +57,11 @@ def safe_import(mod_name, min_version=None):
return mod
else:
import sys
- version = getattr(sys.modules[mod_name], '__version__')
+ try:
+ version = getattr(sys.modules[mod_name], '__version__')
+ except AttributeError:
+ # xlrd uses a capitalized attribute name
+ version = getattr(sys.modules[mod_name], '__VERSION__')
if version:
from distutils.version import LooseVersion
if LooseVersion(version) >= LooseVersion(min_version):
diff --git a/pandas/util/testing.py b/pandas/util/testing.py
index 0009e26f8b100..942416408e4f0 100644
--- a/pandas/util/testing.py
+++ b/pandas/util/testing.py
@@ -2165,7 +2165,7 @@ def network(t, url="http://www.google.com",
from pytest import skip
t.network = True
- @wraps(t)
+ @compat.wraps(t)
def wrapper(*args, **kwargs):
if check_before_test and not raise_on_error:
if not can_connect(url, error_classes):
| - [x] closes #19816
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
Once I started looking at it, it made sense to make the module more "pytest compatible". There was a lot of skipping being done imperatively that seemed better suited to using class-level decorators, so as I moved some of that around I also replaced the setup/teardown mechanism of the "Excel Writing" tests with a pytest fixture | https://api.github.com/repos/pandas-dev/pandas/pulls/19829 | 2018-02-21T21:33:39Z | 2018-02-26T12:21:07Z | 2018-02-26T12:21:07Z | 2018-02-26T16:15:04Z |
make ops.add_foo take just class | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 061b69f25e7ac..e4ef1b97882d9 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -6131,8 +6131,8 @@ def isin(self, values):
DataFrame._add_numeric_operations()
DataFrame._add_series_or_dataframe_operations()
-ops.add_flex_arithmetic_methods(DataFrame, **ops.frame_flex_funcs)
-ops.add_special_arithmetic_methods(DataFrame, **ops.frame_special_funcs)
+ops.add_flex_arithmetic_methods(DataFrame)
+ops.add_special_arithmetic_methods(DataFrame)
def _arrays_to_mgr(arrays, arr_names, index, columns, dtype=None):
diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index b20f208d14dc5..7bdbac66b4f31 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -37,7 +37,7 @@
construct_1d_object_array_from_listlike)
from pandas.core.dtypes.generic import (
ABCSeries,
- ABCDataFrame,
+ ABCDataFrame, ABCPanel,
ABCIndex,
ABCSparseSeries, ABCSparseArray)
@@ -711,6 +711,64 @@ def mask_cmp_op(x, y, op, allowed_types):
# Functions that add arithmetic methods to objects, given arithmetic factory
# methods
+def _get_method_wrappers(cls):
+ """
+ Find the appropriate operation-wrappers to use when defining flex/special
+ arithmetic, boolean, and comparison operations with the given class.
+
+ Parameters
+ ----------
+ cls : class
+
+ Returns
+ -------
+ arith_flex : function or None
+ comp_flex : function or None
+ arith_special : function
+ comp_special : function
+ bool_special : function
+
+ Notes
+ -----
+ None is only returned for SparseArray
+ """
+ if issubclass(cls, ABCSparseSeries):
+ # Be sure to catch this before ABCSeries and ABCSparseArray,
+ # as they will both come see SparseSeries as a subclass
+ arith_flex = _flex_method_SERIES
+ comp_flex = _flex_method_SERIES
+ arith_special = _arith_method_SPARSE_SERIES
+ comp_special = _arith_method_SPARSE_SERIES
+ bool_special = _bool_method_SERIES
+ # TODO: I don't think the functions defined by bool_method are tested
+ elif issubclass(cls, ABCSeries):
+ # Just Series; SparseSeries is caught above
+ arith_flex = _flex_method_SERIES
+ comp_flex = _flex_method_SERIES
+ arith_special = _arith_method_SERIES
+ comp_special = _comp_method_SERIES
+ bool_special = _bool_method_SERIES
+ elif issubclass(cls, ABCSparseArray):
+ arith_flex = None
+ comp_flex = None
+ arith_special = _arith_method_SPARSE_ARRAY
+ comp_special = _arith_method_SPARSE_ARRAY
+ bool_special = _arith_method_SPARSE_ARRAY
+ elif issubclass(cls, ABCPanel):
+ arith_flex = _flex_method_PANEL
+ comp_flex = _comp_method_PANEL
+ arith_special = _arith_method_PANEL
+ comp_special = _comp_method_PANEL
+ bool_special = _arith_method_PANEL
+ elif issubclass(cls, ABCDataFrame):
+ # Same for DataFrame and SparseDataFrame
+ arith_flex = _arith_method_FRAME
+ comp_flex = _flex_comp_method_FRAME
+ arith_special = _arith_method_FRAME
+ comp_special = _comp_method_FRAME
+ bool_special = _arith_method_FRAME
+ return arith_flex, comp_flex, arith_special, comp_special, bool_special
+
def _create_methods(cls, arith_method, comp_method, bool_method,
special=False):
@@ -743,16 +801,18 @@ def _create_methods(cls, arith_method, comp_method, bool_method,
# yapf: enable
new_methods['div'] = new_methods['truediv']
new_methods['rdiv'] = new_methods['rtruediv']
+ if have_divmod:
+ # divmod doesn't have an op that is supported by numexpr
+ new_methods['divmod'] = arith_method(cls, divmod, special)
+
+ new_methods.update(dict(
+ eq=comp_method(cls, operator.eq, special),
+ ne=comp_method(cls, operator.ne, special),
+ lt=comp_method(cls, operator.lt, special),
+ gt=comp_method(cls, operator.gt, special),
+ le=comp_method(cls, operator.le, special),
+ ge=comp_method(cls, operator.ge, special)))
- # Comp methods never had a default axis set
- if comp_method:
- new_methods.update(dict(
- eq=comp_method(cls, operator.eq, special),
- ne=comp_method(cls, operator.ne, special),
- lt=comp_method(cls, operator.lt, special),
- gt=comp_method(cls, operator.gt, special),
- le=comp_method(cls, operator.le, special),
- ge=comp_method(cls, operator.ge, special)))
if bool_method:
new_methods.update(
dict(and_=bool_method(cls, operator.and_, special),
@@ -762,9 +822,6 @@ def _create_methods(cls, arith_method, comp_method, bool_method,
rand_=bool_method(cls, rand_, special),
ror_=bool_method(cls, ror_, special),
rxor=bool_method(cls, rxor, special)))
- if have_divmod:
- # divmod doesn't have an op that is supported by numexpr
- new_methods['divmod'] = arith_method(cls, divmod, special)
if special:
dunderize = lambda x: '__{name}__'.format(name=x.strip('_'))
@@ -788,22 +845,17 @@ def add_methods(cls, new_methods):
# ----------------------------------------------------------------------
# Arithmetic
-def add_special_arithmetic_methods(cls, arith_method=None,
- comp_method=None, bool_method=None):
+def add_special_arithmetic_methods(cls):
"""
Adds the full suite of special arithmetic methods (``__add__``,
``__sub__``, etc.) to the class.
Parameters
----------
- arith_method : function (optional)
- factory for special arithmetic methods:
- f(cls, op, special)
- comp_method : function (optional)
- factory for rich comparison - signature: f(cls, op, special)
- bool_method : function (optional)
- factory for boolean methods - signature: f(cls, op, special)
+ cls : class
+ special methods will be defined and pinned to this class
"""
+ _, _, arith_method, comp_method, bool_method = _get_method_wrappers(cls)
new_methods = _create_methods(cls, arith_method, comp_method, bool_method,
special=True)
# inplace operators (I feel like these should get passed an `inplace=True`
@@ -836,28 +888,26 @@ def f(self, other):
__ipow__=_wrap_inplace_method(new_methods["__pow__"])))
if not compat.PY3:
new_methods["__idiv__"] = _wrap_inplace_method(new_methods["__div__"])
- if bool_method:
- new_methods.update(
- dict(__iand__=_wrap_inplace_method(new_methods["__and__"]),
- __ior__=_wrap_inplace_method(new_methods["__or__"]),
- __ixor__=_wrap_inplace_method(new_methods["__xor__"])))
+
+ new_methods.update(
+ dict(__iand__=_wrap_inplace_method(new_methods["__and__"]),
+ __ior__=_wrap_inplace_method(new_methods["__or__"]),
+ __ixor__=_wrap_inplace_method(new_methods["__xor__"])))
add_methods(cls, new_methods=new_methods)
-def add_flex_arithmetic_methods(cls, flex_arith_method, flex_comp_method=None):
+def add_flex_arithmetic_methods(cls):
"""
Adds the full suite of flex arithmetic methods (``pow``, ``mul``, ``add``)
to the class.
Parameters
----------
- flex_arith_method : function
- factory for flex arithmetic methods:
- f(cls, op, special)
- flex_comp_method : function, optional,
- factory for rich comparison - signature: f(cls, op, special)
+ cls : class
+ flex methods will be defined and pinned to this class
"""
+ flex_arith_method, flex_comp_method, _, _, _ = _get_method_wrappers(cls)
new_methods = _create_methods(cls, flex_arith_method,
flex_comp_method, bool_method=None,
special=False)
@@ -1284,14 +1334,6 @@ def flex_wrapper(self, other, level=None, fill_value=None, axis=0):
return flex_wrapper
-series_flex_funcs = dict(flex_arith_method=_flex_method_SERIES,
- flex_comp_method=_flex_method_SERIES)
-
-series_special_funcs = dict(arith_method=_arith_method_SERIES,
- comp_method=_comp_method_SERIES,
- bool_method=_bool_method_SERIES)
-
-
# -----------------------------------------------------------------------------
# DataFrame
@@ -1533,14 +1575,6 @@ def f(self, other):
return f
-frame_flex_funcs = dict(flex_arith_method=_arith_method_FRAME,
- flex_comp_method=_flex_comp_method_FRAME)
-
-frame_special_funcs = dict(arith_method=_arith_method_FRAME,
- comp_method=_comp_method_FRAME,
- bool_method=_arith_method_FRAME)
-
-
# -----------------------------------------------------------------------------
# Panel
@@ -1629,16 +1663,38 @@ def f(self, other, axis=0):
return f
-panel_special_funcs = dict(arith_method=_arith_method_PANEL,
- comp_method=_comp_method_PANEL,
- bool_method=_arith_method_PANEL)
-
-panel_flex_funcs = dict(flex_arith_method=_flex_method_PANEL,
- flex_comp_method=_comp_method_PANEL)
-
# -----------------------------------------------------------------------------
# Sparse
+def _cast_sparse_series_op(left, right, opname):
+ """
+ For SparseSeries operation, coerce to float64 if the result is expected
+ to have NaN or inf values
+
+ Parameters
+ ----------
+ left : SparseArray
+ right : SparseArray
+ opname : str
+
+ Returns
+ -------
+ left : SparseArray
+ right : SparseArray
+ """
+ opname = opname.strip('_')
+
+ if is_integer_dtype(left) and is_integer_dtype(right):
+ # series coerces to float64 if result should have NaN/inf
+ if opname in ('floordiv', 'mod') and (right.values == 0).any():
+ left = left.astype(np.float64)
+ right = right.astype(np.float64)
+ elif opname in ('rfloordiv', 'rmod') and (left.values == 0).any():
+ left = left.astype(np.float64)
+ right = right.astype(np.float64)
+
+ return left, right
+
def _arith_method_SPARSE_SERIES(cls, op, special):
"""
@@ -1674,8 +1730,8 @@ def _sparse_series_op(left, right, op, name):
new_name = get_op_result_name(left, right)
from pandas.core.sparse.array import _sparse_array_op
- result = _sparse_array_op(left.values, right.values, op, name,
- series=True)
+ lvalues, rvalues = _cast_sparse_series_op(left.values, right.values, name)
+ result = _sparse_array_op(lvalues, rvalues, op, name)
return left._constructor(result, index=new_index, name=new_name)
@@ -1697,7 +1753,7 @@ def wrapper(self, other):
dtype = getattr(other, 'dtype', None)
other = SparseArray(other, fill_value=self.fill_value,
dtype=dtype)
- return _sparse_array_op(self, other, op, name, series=False)
+ return _sparse_array_op(self, other, op, name)
elif is_scalar(other):
with np.errstate(all='ignore'):
fill = op(_get_fill(self), np.asarray(other))
@@ -1710,13 +1766,3 @@ def wrapper(self, other):
wrapper.__name__ = name
return wrapper
-
-
-sparse_array_special_funcs = dict(arith_method=_arith_method_SPARSE_ARRAY,
- comp_method=_arith_method_SPARSE_ARRAY,
- bool_method=_arith_method_SPARSE_ARRAY)
-
-sparse_series_special_funcs = dict(arith_method=_arith_method_SPARSE_SERIES,
- comp_method=_arith_method_SPARSE_SERIES,
- bool_method=_bool_method_SERIES)
-# TODO: I don't think the functions defined by bool_method are tested
diff --git a/pandas/core/panel.py b/pandas/core/panel.py
index 3be1e3ef8734d..fc7fad861df44 100644
--- a/pandas/core/panel.py
+++ b/pandas/core/panel.py
@@ -1527,8 +1527,8 @@ def _extract_axis(self, data, axis=0, intersect=False):
slicers={'major_axis': 'index',
'minor_axis': 'columns'})
-ops.add_special_arithmetic_methods(Panel, **ops.panel_special_funcs)
-ops.add_flex_arithmetic_methods(Panel, **ops.panel_flex_funcs)
+ops.add_special_arithmetic_methods(Panel)
+ops.add_flex_arithmetic_methods(Panel)
Panel._add_numeric_operations()
diff --git a/pandas/core/series.py b/pandas/core/series.py
index b42e02bc99237..26b7fd552b062 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -3100,8 +3100,8 @@ def to_period(self, freq=None, copy=True):
Series._add_series_or_dataframe_operations()
# Add arithmetic!
-ops.add_flex_arithmetic_methods(Series, **ops.series_flex_funcs)
-ops.add_special_arithmetic_methods(Series, **ops.series_special_funcs)
+ops.add_flex_arithmetic_methods(Series)
+ops.add_special_arithmetic_methods(Series)
# -----------------------------------------------------------------------------
diff --git a/pandas/core/sparse/array.py b/pandas/core/sparse/array.py
index 92c4fe932f066..5532d7522cd2d 100644
--- a/pandas/core/sparse/array.py
+++ b/pandas/core/sparse/array.py
@@ -53,20 +53,11 @@ def _get_fill(arr):
return np.asarray(arr.fill_value)
-def _sparse_array_op(left, right, op, name, series=False):
+def _sparse_array_op(left, right, op, name):
if name.startswith('__'):
# For lookups in _libs.sparse we need non-dunder op name
name = name[2:-2]
- if series and is_integer_dtype(left) and is_integer_dtype(right):
- # series coerces to float64 if result should have NaN/inf
- if name in ('floordiv', 'mod') and (right.values == 0).any():
- left = left.astype(np.float64)
- right = right.astype(np.float64)
- elif name in ('rfloordiv', 'rmod') and (left.values == 0).any():
- left = left.astype(np.float64)
- right = right.astype(np.float64)
-
# dtype used to find corresponding sparse method
if not is_dtype_equal(left.dtype, right.dtype):
dtype = find_common_type([left.dtype, right.dtype])
@@ -850,5 +841,4 @@ def _make_index(length, indices, kind):
return index
-ops.add_special_arithmetic_methods(SparseArray,
- **ops.sparse_array_special_funcs)
+ops.add_special_arithmetic_methods(SparseArray)
diff --git a/pandas/core/sparse/frame.py b/pandas/core/sparse/frame.py
index 872a17d8dbabe..d89b1d681c478 100644
--- a/pandas/core/sparse/frame.py
+++ b/pandas/core/sparse/frame.py
@@ -1014,5 +1014,5 @@ def homogenize(series_dict):
# use unaccelerated ops for sparse objects
-ops.add_flex_arithmetic_methods(SparseDataFrame, **ops.frame_flex_funcs)
-ops.add_special_arithmetic_methods(SparseDataFrame, **ops.frame_special_funcs)
+ops.add_flex_arithmetic_methods(SparseDataFrame)
+ops.add_special_arithmetic_methods(SparseDataFrame)
diff --git a/pandas/core/sparse/series.py b/pandas/core/sparse/series.py
index 26cf9dbadbbf2..7a1496bf11117 100644
--- a/pandas/core/sparse/series.py
+++ b/pandas/core/sparse/series.py
@@ -812,6 +812,5 @@ def from_coo(cls, A, dense_index=False):
# overwrite series methods with unaccelerated Sparse-specific versions
-ops.add_flex_arithmetic_methods(SparseSeries, **ops.series_flex_funcs)
-ops.add_special_arithmetic_methods(SparseSeries,
- **ops.sparse_series_special_funcs)
+ops.add_flex_arithmetic_methods(SparseSeries)
+ops.add_special_arithmetic_methods(SparseSeries)
| As discussed
Also small cleanup for Sparse ops.
| https://api.github.com/repos/pandas-dev/pandas/pulls/19828 | 2018-02-21T21:33:21Z | 2018-02-26T11:37:50Z | 2018-02-26T11:37:50Z | 2018-06-22T03:21:52Z |
Implement add_offset_array for PeriodIndex | diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 8f2d7d382a16e..e410c50fb006b 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -44,6 +44,7 @@
from pandas.util._decorators import (Appender, Substitution, cache_readonly,
deprecate_kwarg)
from pandas.compat import zip, u
+from pandas.errors import PerformanceWarning
import pandas.core.indexes.base as ibase
_index_doc_kwargs = dict(ibase._index_doc_kwargs)
@@ -746,6 +747,28 @@ def _sub_period(self, other):
# result must be Int64Index or Float64Index
return Index(new_data, name=self.name)
+ def _add_offset_array(self, other):
+ # Array/Index of DateOffset objects
+ if len(other) == 1:
+ return self + other[0]
+ else:
+ warnings.warn("Adding/subtracting array of DateOffsets to "
+ "{cls} not vectorized"
+ .format(cls=type(self).__name__), PerformanceWarning)
+ res_values = self.astype('O').values + np.array(other)
+ return self.__class__(res_values)
+
+ def _sub_offset_array(self, other):
+ # Array/Index of DateOffset objects
+ if len(other) == 1:
+ return self - other[0]
+ else:
+ warnings.warn("Adding/subtracting array of DateOffsets to "
+ "{cls} not vectorized"
+ .format(cls=type(self).__name__), PerformanceWarning)
+ res_values = self.astype('O').values - np.array(other)
+ return self.__class__(res_values)
+
def shift(self, n):
"""
Specialized shift which produces an PeriodIndex
diff --git a/pandas/tests/indexes/period/test_arithmetic.py b/pandas/tests/indexes/period/test_arithmetic.py
index 5f8f9533e9c44..c64ed96eb87c4 100644
--- a/pandas/tests/indexes/period/test_arithmetic.py
+++ b/pandas/tests/indexes/period/test_arithmetic.py
@@ -9,6 +9,7 @@
period_range, Period, PeriodIndex,
_np_version_under1p10)
import pandas.core.indexes.period as period
+from pandas.errors import PerformanceWarning
_common_mismatch = [pd.offsets.YearBegin(2),
@@ -254,32 +255,57 @@ def test_comp_nat(self, dtype):
class TestPeriodIndexArithmetic(object):
- def test_pi_add_offset_array(self):
+ @pytest.mark.parametrize('box', [np.array, pd.Index])
+ def test_pi_add_offset_array(self, box):
# GH#18849
pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('2016Q2')])
- offs = np.array([pd.offsets.QuarterEnd(n=1, startingMonth=12),
- pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
- res = pi + offs
+ offs = box([pd.offsets.QuarterEnd(n=1, startingMonth=12),
+ pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
expected = pd.PeriodIndex([pd.Period('2015Q2'), pd.Period('2015Q4')])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pi + offs
tm.assert_index_equal(res, expected)
+ with tm.assert_produces_warning(PerformanceWarning):
+ res2 = offs + pi
+ tm.assert_index_equal(res2, expected)
+
unanchored = np.array([pd.offsets.Hour(n=1),
pd.offsets.Minute(n=-2)])
+ # addition/subtraction ops with incompatible offsets should issue
+ # a PerformanceWarning and _then_ raise a TypeError.
with pytest.raises(period.IncompatibleFrequency):
- pi + unanchored
- with pytest.raises(TypeError):
- unanchored + pi
+ with tm.assert_produces_warning(PerformanceWarning):
+ pi + unanchored
+ with pytest.raises(period.IncompatibleFrequency):
+ with tm.assert_produces_warning(PerformanceWarning):
+ unanchored + pi
- @pytest.mark.xfail(reason='GH#18824 radd doesnt implement this case')
- def test_pi_radd_offset_array(self):
- # GH#18849
+ @pytest.mark.parametrize('box', [np.array, pd.Index])
+ def test_pi_sub_offset_array(self, box):
+ # GH#18824
pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('2016Q2')])
- offs = np.array([pd.offsets.QuarterEnd(n=1, startingMonth=12),
- pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
- res = offs + pi
- expected = pd.PeriodIndex([pd.Period('2015Q2'), pd.Period('2015Q4')])
+ other = box([pd.offsets.QuarterEnd(n=1, startingMonth=12),
+ pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
+
+ expected = PeriodIndex([pi[n] - other[n] for n in range(len(pi))])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pi - other
tm.assert_index_equal(res, expected)
+ anchored = box([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
+
+ # addition/subtraction ops with anchored offsets should issue
+ # a PerformanceWarning and _then_ raise a TypeError.
+ with pytest.raises(period.IncompatibleFrequency):
+ with tm.assert_produces_warning(PerformanceWarning):
+ pi - anchored
+ with pytest.raises(period.IncompatibleFrequency):
+ with tm.assert_produces_warning(PerformanceWarning):
+ anchored - pi
+
def test_pi_add_iadd_pi_raises(self):
rng = pd.period_range('1/1/2000', freq='D', periods=5)
other = pd.period_range('1/6/2000', freq='D', periods=5)
| This already works for DTI/TDI, this just rounds it out.
There will be some code de-duplication we can do if/when #19744 goes through.
| https://api.github.com/repos/pandas-dev/pandas/pulls/19826 | 2018-02-21T20:52:33Z | 2018-02-22T03:08:50Z | 2018-02-22T03:08:50Z | 2018-02-22T05:45:04Z |
Keep subclassing in apply | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index ed93503388893..9dbbe3f9e2b77 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -295,8 +295,10 @@ Other Enhancements
- ``IntervalIndex.astype`` now supports conversions between subtypes when passed an ``IntervalDtype`` (:issue:`19197`)
- :class:`IntervalIndex` and its associated constructor methods (``from_arrays``, ``from_breaks``, ``from_tuples``) have gained a ``dtype`` parameter (:issue:`19262`)
- Added :func:`SeriesGroupBy.is_monotonic_increasing` and :func:`SeriesGroupBy.is_monotonic_decreasing` (:issue:`17015`)
+- For subclassed ``DataFrames``, :func:`DataFrame.apply` will now preserve the ``Series`` subclass (if defined) when passing the data to the applied function (:issue:`19822`)
- :func:`DataFrame.from_dict` now accepts a ``columns`` argument that can be used to specify the column names when ``orient='index'`` is used (:issue:`18529`)
+
.. _whatsnew_0230.api_breaking:
Backwards incompatible API changes
diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index c65943fbbb201..9056f78ee02ed 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -162,7 +162,7 @@ def apply_empty_result(self):
pass
if reduce:
- return Series(np.nan, index=self.agg_axis)
+ return self.obj._constructor_sliced(np.nan, index=self.agg_axis)
else:
return self.obj.copy()
@@ -175,11 +175,13 @@ def apply_raw(self):
result = np.apply_along_axis(self.f, self.axis, self.values)
# TODO: mixed type case
- from pandas import DataFrame, Series
if result.ndim == 2:
- return DataFrame(result, index=self.index, columns=self.columns)
+ return self.obj._constructor(result,
+ index=self.index,
+ columns=self.columns)
else:
- return Series(result, index=self.agg_axis)
+ return self.obj._constructor_sliced(result,
+ index=self.agg_axis)
def apply_broadcast(self, target):
result_values = np.empty_like(target.values)
@@ -232,7 +234,7 @@ def apply_standard(self):
axis=self.axis,
dummy=dummy,
labels=labels)
- return Series(result, index=labels)
+ return self.obj._constructor_sliced(result, index=labels)
except Exception:
pass
@@ -291,8 +293,7 @@ def wrap_results(self):
return self.wrap_results_for_axis()
# dict of scalars
- from pandas import Series
- result = Series(results)
+ result = self.obj._constructor_sliced(results)
result.index = self.res_index
return result
@@ -379,7 +380,6 @@ def wrap_results_for_axis(self):
# we have a non-series and don't want inference
elif not isinstance(results[0], ABCSeries):
from pandas import Series
-
result = Series(results)
result.index = self.res_index
diff --git a/pandas/tests/frame/test_subclass.py b/pandas/tests/frame/test_subclass.py
index c52b512c2930a..caaa311e9ee96 100644
--- a/pandas/tests/frame/test_subclass.py
+++ b/pandas/tests/frame/test_subclass.py
@@ -514,3 +514,59 @@ def test_subclassed_wide_to_long(self):
long_frame = pd.wide_to_long(df, ["A", "B"], i="id", j="year")
tm.assert_frame_equal(long_frame, expected)
+
+ def test_subclassed_apply(self):
+ # GH 19822
+
+ def check_row_subclass(row):
+ assert isinstance(row, tm.SubclassedSeries)
+
+ def strech(row):
+ if row["variable"] == "height":
+ row["value"] += 0.5
+ return row
+
+ df = tm.SubclassedDataFrame([
+ ['John', 'Doe', 'height', 5.5],
+ ['Mary', 'Bo', 'height', 6.0],
+ ['John', 'Doe', 'weight', 130],
+ ['Mary', 'Bo', 'weight', 150]],
+ columns=['first', 'last', 'variable', 'value'])
+
+ df.apply(lambda x: check_row_subclass(x))
+ df.apply(lambda x: check_row_subclass(x), axis=1)
+
+ expected = tm.SubclassedDataFrame([
+ ['John', 'Doe', 'height', 6.0],
+ ['Mary', 'Bo', 'height', 6.5],
+ ['John', 'Doe', 'weight', 130],
+ ['Mary', 'Bo', 'weight', 150]],
+ columns=['first', 'last', 'variable', 'value'])
+
+ result = df.apply(lambda x: strech(x), axis=1)
+ assert isinstance(result, tm.SubclassedDataFrame)
+ tm.assert_frame_equal(result, expected)
+
+ expected = tm.SubclassedDataFrame([
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3]])
+
+ result = df.apply(lambda x: tm.SubclassedSeries([1, 2, 3]), axis=1)
+ assert isinstance(result, tm.SubclassedDataFrame)
+ tm.assert_frame_equal(result, expected)
+
+ result = df.apply(lambda x: [1, 2, 3], axis=1, result_type="expand")
+ assert isinstance(result, tm.SubclassedDataFrame)
+ tm.assert_frame_equal(result, expected)
+
+ expected = tm.SubclassedSeries([
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3]])
+
+ result = df.apply(lambda x: [1, 2, 3], axis=1)
+ assert not isinstance(result, tm.SubclassedDataFrame)
+ tm.assert_series_equal(result, expected)
| When generating new objects on apply, it calls `self.obj._constructor` and `self.obj._constructior_sliced` instead of: `DataFrame` and `Series`; keeping subclassing.
- [x] closes #19822
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] keeps subclass inside `DataFrame.apply`
| https://api.github.com/repos/pandas-dev/pandas/pulls/19823 | 2018-02-21T19:14:17Z | 2018-02-24T15:10:35Z | 2018-02-24T15:10:35Z | 2018-02-24T15:10:37Z |
Fix rfloordiv return type, un-xfail Timedelta tests | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 76c4fa08fca4d..4290ae68ce785 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -765,6 +765,7 @@ Timedelta
- Bug in :func:`Timedelta.__floordiv__`, :func:`Timedelta.__rfloordiv__` where operating with a ``Tick`` object would raise a ``TypeError`` instead of returning a numeric value (:issue:`19738`)
- Bug in :func:`Period.asfreq` where periods near ``datetime(1, 1, 1)`` could be converted incorrectly (:issue:`19643`)
- Bug in :func:`Timedelta.total_seconds()` causing precision errors i.e. ``Timedelta('30S').total_seconds()==30.000000000000004`` (:issue:`19458`)
+- Bug in :func: `Timedelta.__rmod__` where operating with a ``numpy.timedelta64`` returned a ``timedelta64`` object instead of a ``Timedelta`` (:issue:`19820`)
- Multiplication of :class:`TimedeltaIndex` by ``TimedeltaIndex`` will now raise ``TypeError`` instead of raising ``ValueError`` in cases of length mis-match (:issue`19333`)
-
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 78fdeb988e0f2..15d6252f93592 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1109,7 +1109,11 @@ class Timedelta(_Timedelta):
return self // other.delta
return NotImplemented
- if hasattr(other, 'dtype'):
+ elif is_timedelta64_object(other):
+ # convert to Timedelta below
+ pass
+
+ elif hasattr(other, 'dtype'):
if other.dtype.kind == 'm':
# also timedelta-like
return _broadcast_floordiv_td64(self.value, other, _floordiv)
@@ -1144,7 +1148,11 @@ class Timedelta(_Timedelta):
return other.delta // self
return NotImplemented
- if hasattr(other, 'dtype'):
+ elif is_timedelta64_object(other):
+ # convert to Timedelta below
+ pass
+
+ elif hasattr(other, 'dtype'):
if other.dtype.kind == 'm':
# also timedelta-like
return _broadcast_floordiv_td64(self.value, other, _rfloordiv)
diff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py
index 48da23f3575ab..90f745c2a641c 100644
--- a/pandas/tests/scalar/timedelta/test_arithmetic.py
+++ b/pandas/tests/scalar/timedelta/test_arithmetic.py
@@ -441,7 +441,6 @@ def test_mod_timedeltalike(self):
result = td % NaT
assert result is NaT
- @pytest.mark.xfail(reason='GH#19378 floordiv td64 returns td64')
def test_mod_timedelta64_nat(self):
# GH#19365
td = Timedelta(hours=37)
@@ -449,7 +448,6 @@ def test_mod_timedelta64_nat(self):
result = td % np.timedelta64('NaT', 'ns')
assert result is NaT
- @pytest.mark.xfail(reason='GH#19378 floordiv td64 returns td64')
def test_mod_timedelta64(self):
# GH#19365
td = Timedelta(hours=37)
@@ -458,7 +456,6 @@ def test_mod_timedelta64(self):
assert isinstance(result, Timedelta)
assert result == Timedelta(hours=1)
- @pytest.mark.xfail(reason='GH#19378 floordiv by Tick not implemented')
def test_mod_offset(self):
# GH#19365
td = Timedelta(hours=37)
@@ -505,7 +502,6 @@ def test_rmod_pytimedelta(self):
assert isinstance(result, Timedelta)
assert result == Timedelta(minutes=1)
- @pytest.mark.xfail(reason='GH#19378 floordiv by Tick not implemented')
def test_rmod_timedelta64(self):
# GH#19365
td = Timedelta(minutes=3)
@@ -564,7 +560,6 @@ def test_divmod(self):
assert np.isnan(result[0])
assert result[1] is pd.NaT
- @pytest.mark.xfail(reason='GH#19378 floordiv by Tick not implemented')
def test_divmod_offset(self):
# GH#19365
td = Timedelta(days=2, hours=6)
@@ -588,7 +583,6 @@ def test_rdivmod_pytimedelta(self):
assert isinstance(result[1], Timedelta)
assert result[1] == Timedelta(hours=6)
- @pytest.mark.xfail(reason='GH#19378 floordiv by Tick not implemented')
def test_rdivmod_offset(self):
result = divmod(pd.offsets.Hour(54), Timedelta(hours=-4))
assert result[0] == -14
| - [ ] closes #xxxx
- [x] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry | https://api.github.com/repos/pandas-dev/pandas/pulls/19820 | 2018-02-21T18:16:05Z | 2018-02-22T11:15:41Z | 2018-02-22T11:15:41Z | 2018-06-22T03:22:39Z |
fix Timedelta.__mul__(NaT) | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index a4b943f995a33..a24eabc219764 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -735,6 +735,7 @@ Datetimelike
Timedelta
^^^^^^^^^
+- Bug in :func:`Timedelta.__mul__` where multiplying by ``NaT`` returned ``NaT`` instead of raising a ``TypeError`` (:issue:`19819`)
- Bug in :class:`Series` with ``dtype='timedelta64[ns]`` where addition or subtraction of ``TimedeltaIndex`` had results cast to ``dtype='int64'`` (:issue:`17250`)
- Bug in :class:`Series` with ``dtype='timedelta64[ns]`` where addition or subtraction of ``TimedeltaIndex`` could return a ``Series`` with an incorrect name (:issue:`19043`)
- Bug in :func:`Timedelta.__floordiv__` and :func:`Timedelta.__rfloordiv__` dividing by many incompatible numpy objects was incorrectly allowed (:issue:`18846`)
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 78fdeb988e0f2..1285cbb9ff62b 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1057,7 +1057,7 @@ class Timedelta(_Timedelta):
return other * self.to_timedelta64()
elif other is NaT:
- return NaT
+ raise TypeError('Cannot multiply Timedelta with NaT')
elif not (is_integer_object(other) or is_float_object(other)):
# only integers and floats allowed
diff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py
index 48da23f3575ab..8460633febba9 100644
--- a/pandas/tests/scalar/timedelta/test_arithmetic.py
+++ b/pandas/tests/scalar/timedelta/test_arithmetic.py
@@ -216,6 +216,16 @@ class TestTimedeltaMultiplicationDivision(object):
# ---------------------------------------------------------------
# Timedelta.__mul__, __rmul__
+ @pytest.mark.parametrize('td_nat', [pd.NaT,
+ np.timedelta64('NaT', 'ns'),
+ np.timedelta64('NaT')])
+ @pytest.mark.parametrize('op', [operator.mul, ops.rmul])
+ def test_td_mul_nat(self, op, td_nat):
+ # GH#19819
+ td = Timedelta(10, unit='d')
+ with pytest.raises(TypeError):
+ op(td, td_nat)
+
@pytest.mark.parametrize('op', [operator.mul, ops.rmul])
def test_td_mul_scalar(self, op):
# GH#19738
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 4257c610fb960..a80c5d6611b8a 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -62,11 +62,6 @@ def test_unary_ops(self):
assert abs(-td) == td
assert abs(-td) == Timedelta('10d')
- def test_binary_ops_nat(self):
- td = Timedelta(10, unit='d')
- # FIXME: The next test is wrong: td * NaT should raise
- assert (td * pd.NaT) is pd.NaT
-
class TestTimedeltaComparison(object):
def test_comparison_object_array(self):
| - [ ] closes #xxxx
- [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/19819 | 2018-02-21T17:49:17Z | 2018-02-22T11:12:52Z | 2018-02-22T11:12:52Z | 2018-06-22T03:22:56Z |
Update df.to_stata() docstring | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index d81d22173bfbd..e34aaaae9b887 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1612,7 +1612,7 @@ def to_stata(self, fname, convert_dates=None, write_index=True,
time_stamp : datetime
A datetime to use as file creation date. Default is the current
time.
- dataset_label : str
+ data_label : str
A label for the data set. Must be 80 characters or smaller.
variable_labels : dict
Dictionary containing columns as keys and variable labels as
@@ -1635,10 +1635,18 @@ def to_stata(self, fname, convert_dates=None, write_index=True,
Examples
--------
+ >>> data.to_stata('./data_file.dta')
+
+ Or with dates
+
+ >>> data.to_stata('./date_data_file.dta', {2 : 'tw'})
+
+ Alternatively you can create an instance of the StataWriter class
+
>>> writer = StataWriter('./data_file.dta', data)
>>> writer.write_file()
- Or with dates
+ With dates:
>>> writer = StataWriter('./date_data_file.dta', data, {2 : 'tw'})
>>> writer.write_file()
| Updates the docstring for the `to_stata()` method to fix the `dataset_label` parameter. See #19817. Also changes the examples; it's a little weird for the examples for `to_stata()` to detail the `StataWriter` class.
- [ ] closes #19817
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/19818 | 2018-02-21T17:04:17Z | 2018-02-22T02:20:06Z | 2018-02-22T02:20:06Z | 2018-02-22T02:20:09Z |
ASV: excel asv occasional failure | diff --git a/asv_bench/benchmarks/io/excel.py b/asv_bench/benchmarks/io/excel.py
index a7c6c43d15026..58ab6bb8046c5 100644
--- a/asv_bench/benchmarks/io/excel.py
+++ b/asv_bench/benchmarks/io/excel.py
@@ -25,13 +25,12 @@ def setup(self, engine):
self.writer_read.save()
self.bio_read.seek(0)
- self.bio_write = BytesIO()
- self.bio_write.seek(0)
- self.writer_write = ExcelWriter(self.bio_write, engine=engine)
-
def time_read_excel(self, engine):
read_excel(self.bio_read)
def time_write_excel(self, engine):
- self.df.to_excel(self.writer_write, sheet_name='Sheet1')
- self.writer_write.save()
+ bio_write = BytesIO()
+ bio_write.seek(0)
+ writer_write = ExcelWriter(bio_write, engine=engine)
+ self.df.to_excel(writer_write, sheet_name='Sheet1')
+ writer_write.save()
| closes #19779 | https://api.github.com/repos/pandas-dev/pandas/pulls/19811 | 2018-02-21T11:05:51Z | 2018-02-21T11:53:21Z | 2018-02-21T11:53:21Z | 2018-02-21T11:53:21Z |
BF: Skip test_read_excel_parse_dates if no xlwt which is used in to_excel | diff --git a/pandas/tests/io/test_excel.py b/pandas/tests/io/test_excel.py
index ebb8424b78ed4..4c790a0f0f64a 100644
--- a/pandas/tests/io/test_excel.py
+++ b/pandas/tests/io/test_excel.py
@@ -968,6 +968,7 @@ def test_read_excel_chunksize(self):
def test_read_excel_parse_dates(self):
# GH 11544, 12051
_skip_if_no_openpyxl()
+ _skip_if_no_xlwt() # for df2.to_excel
df = DataFrame(
{'col': [1, 2, 3],
| https://api.github.com/repos/pandas-dev/pandas/pulls/19803 | 2018-02-20T22:37:24Z | 2018-02-21T11:30:59Z | 2018-02-21T11:30:59Z | 2018-02-21T17:49:01Z | |
ENH: Add columns parameter to from_dict | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index a4b943f995a33..f3dca23d1039f 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -295,6 +295,7 @@ Other Enhancements
- ``IntervalIndex.astype`` now supports conversions between subtypes when passed an ``IntervalDtype`` (:issue:`19197`)
- :class:`IntervalIndex` and its associated constructor methods (``from_arrays``, ``from_breaks``, ``from_tuples``) have gained a ``dtype`` parameter (:issue:`19262`)
- Added :func:`SeriesGroupBy.is_monotonic_increasing` and :func:`SeriesGroupBy.is_monotonic_decreasing` (:issue:`17015`)
+- :func:`DataFrame.from_dict` now accepts a ``columns`` argument that can be used to specify the column names when ``orient='index'`` is used (:issue:`18529`)
.. _whatsnew_0230.api_breaking:
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index d81d22173bfbd..d006fd755cd35 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -876,7 +876,7 @@ def dot(self, other):
# IO methods (to / from other formats)
@classmethod
- def from_dict(cls, data, orient='columns', dtype=None):
+ def from_dict(cls, data, orient='columns', dtype=None, columns=None):
"""
Construct DataFrame from dict of array-like or dicts
@@ -890,12 +890,17 @@ def from_dict(cls, data, orient='columns', dtype=None):
(default). Otherwise if the keys should be rows, pass 'index'.
dtype : dtype, default None
Data type to force, otherwise infer
+ columns: list, default None
+ Column labels to use when orient='index'. Raises a ValueError
+ if used with orient='columns'
+
+ .. versionadded:: 0.23.0
Returns
-------
DataFrame
"""
- index, columns = None, None
+ index = None
orient = orient.lower()
if orient == 'index':
if len(data) > 0:
@@ -904,7 +909,11 @@ def from_dict(cls, data, orient='columns', dtype=None):
data = _from_nested_dict(data)
else:
data, index = list(data.values()), list(data.keys())
- elif orient != 'columns': # pragma: no cover
+ elif orient == 'columns':
+ if columns is not None:
+ raise ValueError("cannot use columns parameter with "
+ "orient='columns'")
+ else: # pragma: no cover
raise ValueError('only recognize index or columns for orient')
return cls(data, index=index, columns=columns, dtype=dtype)
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 8abd88d8a379c..394997201f320 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -1091,6 +1091,25 @@ def test_constructor_orient(self):
xp = DataFrame.from_dict(a).T.reindex(list(a.keys()))
tm.assert_frame_equal(rs, xp)
+ def test_from_dict_columns_parameter(self):
+ # GH 18529
+ # Test new columns parameter for from_dict that was added to make
+ # from_items(..., orient='index', columns=[...]) easier to replicate
+ result = DataFrame.from_dict(OrderedDict([('A', [1, 2]),
+ ('B', [4, 5])]),
+ orient='index', columns=['one', 'two'])
+ expected = DataFrame([[1, 2], [4, 5]], index=['A', 'B'],
+ columns=['one', 'two'])
+ tm.assert_frame_equal(result, expected)
+
+ msg = "cannot use columns parameter with orient='columns'"
+ with tm.assert_raises_regex(ValueError, msg):
+ DataFrame.from_dict(dict([('A', [1, 2]), ('B', [4, 5])]),
+ orient='columns', columns=['one', 'two'])
+ with tm.assert_raises_regex(ValueError, msg):
+ DataFrame.from_dict(dict([('A', [1, 2]), ('B', [4, 5])]),
+ columns=['one', 'two'])
+
def test_constructor_Series_named(self):
a = Series([1, 2, 3], index=['a', 'b', 'c'], name='x')
df = DataFrame(a)
| - [x] xref #18529
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
@jorisvandenbossche it seems to have been quite straightforward to implement this but let me know if I missed anything.
| https://api.github.com/repos/pandas-dev/pandas/pulls/19802 | 2018-02-20T21:56:46Z | 2018-02-22T10:34:47Z | 2018-02-22T10:34:47Z | 2018-02-22T10:47:52Z |
dispatch Series[datetime64] comparison ops to DatetimeIndex | diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index eb8133a1bbf97..c9b446b97e956 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -138,11 +138,9 @@ def wrapper(self, other):
result = func(np.asarray(other))
result = com._values_from_object(result)
- if isinstance(other, Index):
- o_mask = other.values.view('i8') == libts.iNaT
- else:
- o_mask = other.view('i8') == libts.iNaT
-
+ # Make sure to pass an array to result[...]; indexing with
+ # Series breaks with older version of numpy
+ o_mask = np.array(isna(other))
if o_mask.any():
result[o_mask] = nat_result
diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index 83f17a332f4be..931e91b941a7e 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -10,8 +10,7 @@
import numpy as np
import pandas as pd
-from pandas._libs import (lib, index as libindex,
- algos as libalgos, ops as libops)
+from pandas._libs import algos as libalgos, ops as libops
from pandas import compat
from pandas.util._decorators import Appender
@@ -1127,24 +1126,20 @@ def na_op(x, y):
# integer comparisons
# we have a datetime/timedelta and may need to convert
+ assert not needs_i8_conversion(x)
mask = None
- if (needs_i8_conversion(x) or
- (not is_scalar(y) and needs_i8_conversion(y))):
-
- if is_scalar(y):
- mask = isna(x)
- y = libindex.convert_scalar(x, com._values_from_object(y))
- else:
- mask = isna(x) | isna(y)
- y = y.view('i8')
+ if not is_scalar(y) and needs_i8_conversion(y):
+ mask = isna(x) | isna(y)
+ y = y.view('i8')
x = x.view('i8')
- try:
+ method = getattr(x, name, None)
+ if method is not None:
with np.errstate(all='ignore'):
- result = getattr(x, name)(y)
+ result = method(y)
if result is NotImplemented:
raise TypeError("invalid type comparison")
- except AttributeError:
+ else:
result = op(x, y)
if mask is not None and mask.any():
@@ -1174,6 +1169,14 @@ def wrapper(self, other, axis=None):
return self._constructor(res_values, index=self.index,
name=res_name)
+ if is_datetime64_dtype(self) or is_datetime64tz_dtype(self):
+ # Dispatch to DatetimeIndex to ensure identical
+ # Series/Index behavior
+ res_values = dispatch_to_index_op(op, self, other,
+ pd.DatetimeIndex)
+ return self._constructor(res_values, index=self.index,
+ name=res_name)
+
elif is_timedelta64_dtype(self):
res_values = dispatch_to_index_op(op, self, other,
pd.TimedeltaIndex)
@@ -1191,8 +1194,7 @@ def wrapper(self, other, axis=None):
elif isinstance(other, (np.ndarray, pd.Index)):
# do not check length of zerodim array
# as it will broadcast
- if (not is_scalar(lib.item_from_zerodim(other)) and
- len(self) != len(other)):
+ if other.ndim != 0 and len(self) != len(other):
raise ValueError('Lengths must match to compare')
res_values = na_op(self.values, np.asarray(other))
diff --git a/pandas/tests/indexes/datetimes/test_partial_slicing.py b/pandas/tests/indexes/datetimes/test_partial_slicing.py
index 6bb4229883525..f263ac78cd343 100644
--- a/pandas/tests/indexes/datetimes/test_partial_slicing.py
+++ b/pandas/tests/indexes/datetimes/test_partial_slicing.py
@@ -2,7 +2,7 @@
import pytest
-from datetime import datetime, date
+from datetime import datetime
import numpy as np
import pandas as pd
import operator as op
@@ -349,7 +349,7 @@ def test_loc_datetime_length_one(self):
@pytest.mark.parametrize('datetimelike', [
Timestamp('20130101'), datetime(2013, 1, 1),
- date(2013, 1, 1), np.datetime64('2013-01-01T00:00', 'ns')])
+ np.datetime64('2013-01-01T00:00', 'ns')])
@pytest.mark.parametrize('op,expected', [
(op.lt, [True, False, False, False]),
(op.le, [True, True, False, False]),
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 5b8d9cfab3e0d..ec0d7296e540e 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -88,6 +88,23 @@ def test_ser_cmp_result_names(self, names, op):
class TestTimestampSeriesComparison(object):
+ def test_dt64ser_cmp_date_invalid(self):
+ # GH#19800 datetime.date comparison raises to
+ # match DatetimeIndex/Timestamp. This also matches the behavior
+ # of stdlib datetime.datetime
+ ser = pd.Series(pd.date_range('20010101', periods=10), name='dates')
+ date = ser.iloc[0].to_pydatetime().date()
+ assert not (ser == date).any()
+ assert (ser != date).all()
+ with pytest.raises(TypeError):
+ ser > date
+ with pytest.raises(TypeError):
+ ser < date
+ with pytest.raises(TypeError):
+ ser >= date
+ with pytest.raises(TypeError):
+ ser <= date
+
def test_dt64ser_cmp_period_scalar(self):
ser = Series(pd.period_range('2000-01-01', periods=10, freq='D'))
val = Period('2000-01-04', freq='D')
diff --git a/pandas/tests/test_base.py b/pandas/tests/test_base.py
index 4b5ad336139b0..6247079e4ac3a 100644
--- a/pandas/tests/test_base.py
+++ b/pandas/tests/test_base.py
@@ -10,7 +10,7 @@
import pandas as pd
import pandas.compat as compat
from pandas.core.dtypes.common import (
- is_object_dtype, is_datetimetz,
+ is_object_dtype, is_datetimetz, is_datetime64_dtype,
needs_i8_conversion)
import pandas.util.testing as tm
from pandas import (Series, Index, DatetimeIndex, TimedeltaIndex,
@@ -296,14 +296,21 @@ def test_none_comparison(self):
# result = None != o # noqa
# assert result.iat[0]
# assert result.iat[1]
+ if (is_datetime64_dtype(o) or is_datetimetz(o)):
+ # Following DatetimeIndex (and Timestamp) convention,
+ # inequality comparisons with Series[datetime64] raise
+ with pytest.raises(TypeError):
+ None > o
+ with pytest.raises(TypeError):
+ o > None
+ else:
+ result = None > o
+ assert not result.iat[0]
+ assert not result.iat[1]
- result = None > o
- assert not result.iat[0]
- assert not result.iat[1]
-
- result = o < None
- assert not result.iat[0]
- assert not result.iat[1]
+ result = o < None
+ assert not result.iat[0]
+ assert not result.iat[1]
def test_ndarray_compat_properties(self):
| When we tried this a few weeks ago (#19524) there were idiosyncratic CI errors. Hopefully the smaller scope here will avoid that problem.
If this works, we'll be very nearly ready to move these ops to the Block level and ensure consistency with DataFrame in addition to Index/Series. | https://api.github.com/repos/pandas-dev/pandas/pulls/19800 | 2018-02-20T21:16:13Z | 2018-03-01T22:54:43Z | 2018-03-01T22:54:43Z | 2018-06-22T03:24:44Z |
DOC: Edit installation instructions for clarity. | diff --git a/doc/source/install.rst b/doc/source/install.rst
index c4e331d64e721..4ff63d59024b2 100644
--- a/doc/source/install.rst
+++ b/doc/source/install.rst
@@ -6,7 +6,7 @@
Installation
============
-The easiest way for the majority of users to install pandas is to install it
+The easiest way to install pandas is to install it
as part of the `Anaconda <http://docs.continuum.io/anaconda/>`__ distribution, a
cross platform distribution for data analysis and scientific computing.
This is the recommended installation method for most users.
@@ -40,7 +40,7 @@ packages that make up the `SciPy <http://www.scipy.org/>`__ stack
(Linux, Mac OS X, Windows) Python distribution for data analytics and
scientific computing.
-After running a simple installer, the user will have access to pandas and the
+After running the installer, the user will have access to pandas and the
rest of the `SciPy <http://www.scipy.org/>`__ stack without needing to install
anything else, and without needing to wait for any software to be compiled.
@@ -51,9 +51,9 @@ A full list of the packages available as part of the
`Anaconda <http://docs.continuum.io/anaconda/>`__ distribution
`can be found here <http://docs.continuum.io/anaconda/pkg-docs.html>`__.
-An additional advantage of installing with Anaconda is that you don't require
-admin rights to install it, it will install in the user's home directory, and
-this also makes it trivial to delete Anaconda at a later date (just delete
+Another advantage to installing Anaconda is that you don't need
+admin rights to install it. Anaconda can install in the user's home directory,
+which makes it trivial to delete Anaconda if you decide (just delete
that folder).
.. _install.miniconda:
@@ -85,9 +85,9 @@ downloading and running the `Miniconda
will do this for you. The installer
`can be found here <http://conda.pydata.org/miniconda.html>`__
-The next step is to create a new conda environment (these are analogous to a
-virtualenv but they also allow you to specify precisely which Python version
-to install also). Run the following commands from a terminal window::
+The next step is to create a new conda environment. A conda environment is like a
+virtualenv that allows you to specify a specific version of Python and set of libraries.
+Run the following commands from a terminal window::
conda create -n name_of_my_env python
@@ -118,8 +118,8 @@ distribution::
conda install anaconda
-If you require any packages that are available to pip but not conda, simply
-install pip, and use pip to install these packages::
+If you need packages that are available to pip but not conda, then
+install pip, and then use pip to install those packages::
conda install pip
pip install django
@@ -134,15 +134,12 @@ pandas can be installed via pip from
pip install pandas
-This will likely require the installation of a number of dependencies,
-including NumPy, will require a compiler to compile required bits of code,
-and can take a few minutes to complete.
Installing using your Linux distribution's package manager.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The commands in this table will install pandas for Python 3 from your distribution.
-To install pandas for Python 2 you may need to use the package ``python-pandas``.
+To install pandas for Python 2, you may need to use the ``python-pandas`` package.
.. csv-table::
:header: "Distribution", "Status", "Download / Repository Link", "Install method"
@@ -169,9 +166,9 @@ See the :ref:`contributing documentation <contributing>` for complete instructio
Running the test suite
~~~~~~~~~~~~~~~~~~~~~~
-pandas is equipped with an exhaustive set of unit tests covering about 97% of
+pandas is equipped with an exhaustive set of unit tests, covering about 97% of
the codebase as of this writing. To run it on your machine to verify that
-everything is working (and you have all of the dependencies, soft and hard,
+everything is working (and that you have all of the dependencies, soft and hard,
installed), make sure you have `pytest
<http://doc.pytest.org/en/latest/>`__ and run:
@@ -214,8 +211,8 @@ Recommended Dependencies
.. note::
- You are highly encouraged to install these libraries, as they provide large speedups, especially
- if working with large data sets.
+ You are highly encouraged to install these libraries, as they provide speed improvements, especially
+ when working with large data sets.
.. _install.optional_dependencies:
| Rewrote some lines to ease reading. Didn't change substance. | https://api.github.com/repos/pandas-dev/pandas/pulls/19798 | 2018-02-20T20:21:41Z | 2018-02-21T10:56:22Z | 2018-02-21T10:56:22Z | 2018-02-21T10:56:32Z |
TST: move more series tests to test_arithmetic | diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index f727edf8fb7d8..5b8d9cfab3e0d 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -1,17 +1,26 @@
# -*- coding: utf-8 -*-
from datetime import datetime, timedelta
import operator
+from decimal import Decimal
import numpy as np
import pytest
-from pandas import Series, Timestamp, Period
+from pandas import Series, Timestamp, Timedelta, Period, NaT
from pandas._libs.tslibs.period import IncompatibleFrequency
import pandas as pd
import pandas.util.testing as tm
+@pytest.fixture
+def tdser():
+ """
+ Return a Series with dtype='timedelta64[ns]', including a NaT.
+ """
+ return Series(['59 Days', '59 Days', 'NaT'], dtype='timedelta64[ns]')
+
+
# ------------------------------------------------------------------
# Comparisons
@@ -262,6 +271,97 @@ def test_cmp_series_period_series_mixed_freq(self):
# ------------------------------------------------------------------
# Arithmetic
+class TestSeriesDivision(object):
+ # __div__, __rdiv__, __floordiv__, __rfloordiv__
+ # for non-timestamp/timedelta/period dtypes
+
+ def test_divide_decimal(self):
+ # resolves issue GH#9787
+ expected = Series([Decimal(5)])
+
+ ser = Series([Decimal(10)])
+ result = ser / Decimal(2)
+
+ tm.assert_series_equal(result, expected)
+
+ ser = Series([Decimal(10)])
+ result = ser // Decimal(2)
+
+ tm.assert_series_equal(result, expected)
+
+ def test_div_equiv_binop(self):
+ # Test Series.div as well as Series.__div__
+ # float/integer issue
+ # GH#7785
+ first = Series([1, 0], name='first')
+ second = Series([-0.01, -0.02], name='second')
+ expected = Series([-0.01, -np.inf])
+
+ result = second.div(first)
+ tm.assert_series_equal(result, expected, check_names=False)
+
+ result = second / first
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('dtype2', [
+ np.int64, np.int32, np.int16, np.int8,
+ np.float64, np.float32, np.float16,
+ np.uint64, np.uint32, np.uint16, np.uint8])
+ @pytest.mark.parametrize('dtype1', [np.int64, np.float64, np.uint64])
+ def test_ser_div_ser(self, dtype1, dtype2):
+ # no longer do integer div for any ops, but deal with the 0's
+ first = Series([3, 4, 5, 8], name='first').astype(dtype1)
+ second = Series([0, 0, 0, 3], name='second').astype(dtype2)
+
+ with np.errstate(all='ignore'):
+ expected = Series(first.values.astype(np.float64) / second.values,
+ dtype='float64', name=None)
+ expected.iloc[0:3] = np.inf
+
+ result = first / second
+ tm.assert_series_equal(result, expected)
+ assert not result.equals(second / first)
+
+ def test_rdiv_zero_compat(self):
+ # GH#8674
+ zero_array = np.array([0] * 5)
+ data = np.random.randn(5)
+ expected = Series([0.] * 5)
+
+ result = zero_array / Series(data)
+ tm.assert_series_equal(result, expected)
+
+ result = Series(zero_array) / data
+ tm.assert_series_equal(result, expected)
+
+ result = Series(zero_array) / Series(data)
+ tm.assert_series_equal(result, expected)
+
+ def test_div_zero_inf_signs(self):
+ # GH#9144, inf signing
+ ser = Series([-1, 0, 1], name='first')
+ expected = Series([-np.inf, np.nan, np.inf], name='first')
+
+ result = ser / 0
+ tm.assert_series_equal(result, expected)
+
+ def test_rdiv_zero(self):
+ # GH#9144
+ ser = Series([-1, 0, 1], name='first')
+ expected = Series([0.0, np.nan, 0.0], name='first')
+
+ result = 0 / ser
+ tm.assert_series_equal(result, expected)
+
+ def test_floordiv_div(self):
+ # GH#9144
+ ser = Series([-1, 0, 1], name='first')
+
+ result = ser // 0
+ expected = Series([-np.inf, np.nan, np.inf], name='first')
+ tm.assert_series_equal(result, expected)
+
+
class TestSeriesArithmetic(object):
# Standard, numeric, or otherwise not-Timestamp/Timedelta/Period dtypes
@pytest.mark.parametrize('data', [
@@ -316,6 +416,20 @@ def test_series_radd_str(self):
tm.assert_series_equal('a' + ser, pd.Series(['ax', np.nan, 'ax']))
tm.assert_series_equal(ser + 'a', pd.Series(['xa', np.nan, 'xa']))
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_series_with_dtype_radd_timedelta(self, dtype):
+ # note this test is _not_ aimed at timedelta64-dtyped Series
+ ser = pd.Series([pd.Timedelta('1 days'), pd.Timedelta('2 days'),
+ pd.Timedelta('3 days')], dtype=dtype)
+ expected = pd.Series([pd.Timedelta('4 days'), pd.Timedelta('5 days'),
+ pd.Timedelta('6 days')])
+
+ result = pd.Timedelta('3 days') + ser
+ tm.assert_series_equal(result, expected)
+
+ result = ser + pd.Timedelta('3 days')
+ tm.assert_series_equal(result, expected)
+
class TestPeriodSeriesArithmetic(object):
def test_ops_series_timedelta(self):
@@ -377,3 +491,361 @@ def test_dt64ser_sub_datetime_dtype(self):
ser = Series([ts])
result = pd.to_timedelta(np.abs(ser - dt))
assert result.dtype == 'timedelta64[ns]'
+
+
+class TestTimedeltaSeriesAdditionSubtraction(object):
+ # Tests for Series[timedelta64[ns]] __add__, __sub__, __radd__, __rsub__
+
+ # ------------------------------------------------------------------
+ # Operations with int-like others
+
+ def test_td64series_add_int_series_invalid(self, tdser):
+ with pytest.raises(TypeError):
+ tdser + Series([2, 3, 4])
+
+ @pytest.mark.xfail(reason='GH#19123 integer interpreted as nanoseconds')
+ def test_td64series_radd_int_series_invalid(self, tdser):
+ with pytest.raises(TypeError):
+ Series([2, 3, 4]) + tdser
+
+ def test_td64series_sub_int_series_invalid(self, tdser):
+ with pytest.raises(TypeError):
+ tdser - Series([2, 3, 4])
+
+ @pytest.mark.xfail(reason='GH#19123 integer interpreted as nanoseconds')
+ def test_td64series_rsub_int_series_invalid(self, tdser):
+ with pytest.raises(TypeError):
+ Series([2, 3, 4]) - tdser
+
+ def test_td64_series_add_intlike(self):
+ # GH#19123
+ tdi = pd.TimedeltaIndex(['59 days', '59 days', 'NaT'])
+ ser = Series(tdi)
+
+ other = Series([20, 30, 40], dtype='uint8')
+
+ pytest.raises(TypeError, ser.__add__, 1)
+ pytest.raises(TypeError, ser.__sub__, 1)
+
+ pytest.raises(TypeError, ser.__add__, other)
+ pytest.raises(TypeError, ser.__sub__, other)
+
+ pytest.raises(TypeError, ser.__add__, other.values)
+ pytest.raises(TypeError, ser.__sub__, other.values)
+
+ pytest.raises(TypeError, ser.__add__, pd.Index(other))
+ pytest.raises(TypeError, ser.__sub__, pd.Index(other))
+
+ @pytest.mark.parametrize('scalar', [1, 1.5, np.array(2)])
+ def test_td64series_add_sub_numeric_scalar_invalid(self, scalar, tdser):
+ with pytest.raises(TypeError):
+ tdser + scalar
+ with pytest.raises(TypeError):
+ scalar + tdser
+ with pytest.raises(TypeError):
+ tdser - scalar
+ with pytest.raises(TypeError):
+ scalar - tdser
+
+ @pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16',
+ 'uint64', 'uint32', 'uint16', 'uint8',
+ 'float64', 'float32', 'float16'])
+ @pytest.mark.parametrize('vector', [
+ np.array([1, 2, 3]),
+ pd.Index([1, 2, 3]),
+ pytest.param(Series([1, 2, 3]),
+ marks=pytest.mark.xfail(reason='GH#19123 integer '
+ 'interpreted as nanos'))
+ ])
+ def test_td64series_add_sub_numeric_array_invalid(self, vector,
+ dtype, tdser):
+ vector = vector.astype(dtype)
+ with pytest.raises(TypeError):
+ tdser + vector
+ with pytest.raises(TypeError):
+ vector + tdser
+ with pytest.raises(TypeError):
+ tdser - vector
+ with pytest.raises(TypeError):
+ vector - tdser
+
+ # ------------------------------------------------------------------
+ # Operations with datetime-like others
+
+ def test_td64series_add_sub_timestamp(self):
+ # GH#11925
+ tdser = Series(pd.timedelta_range('1 day', periods=3))
+ ts = Timestamp('2012-01-01')
+ expected = Series(pd.date_range('2012-01-02', periods=3))
+ tm.assert_series_equal(ts + tdser, expected)
+ tm.assert_series_equal(tdser + ts, expected)
+
+ expected2 = Series(pd.date_range('2011-12-31', periods=3, freq='-1D'))
+ tm.assert_series_equal(ts - tdser, expected2)
+ tm.assert_series_equal(ts + (-tdser), expected2)
+
+ with pytest.raises(TypeError):
+ tdser - ts
+
+ # ------------------------------------------------------------------
+ # Operations with timedelta-like others (including DateOffsets)
+
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('Egon', 'Venkman', None),
+ ('NCC1701D', 'NCC1701D', 'NCC1701D')])
+ def test_td64_series_with_tdi(self, names):
+ # GH#17250 make sure result dtype is correct
+ # GH#19043 make sure names are propagated correctly
+ tdi = pd.TimedeltaIndex(['0 days', '1 day'], name=names[0])
+ ser = Series([Timedelta(hours=3), Timedelta(hours=4)], name=names[1])
+ expected = Series([Timedelta(hours=3), Timedelta(days=1, hours=4)],
+ name=names[2])
+
+ result = tdi + ser
+ tm.assert_series_equal(result, expected)
+ assert result.dtype == 'timedelta64[ns]'
+
+ result = ser + tdi
+ tm.assert_series_equal(result, expected)
+ assert result.dtype == 'timedelta64[ns]'
+
+ expected = Series([Timedelta(hours=-3), Timedelta(days=1, hours=-4)],
+ name=names[2])
+
+ result = tdi - ser
+ tm.assert_series_equal(result, expected)
+ assert result.dtype == 'timedelta64[ns]'
+
+ result = ser - tdi
+ tm.assert_series_equal(result, -expected)
+ assert result.dtype == 'timedelta64[ns]'
+
+ def test_td64_sub_NaT(self):
+ # GH#18808
+ ser = Series([NaT, Timedelta('1s')])
+ res = ser - NaT
+ expected = Series([NaT, NaT], dtype='timedelta64[ns]')
+ tm.assert_series_equal(res, expected)
+
+
+class TestTimedeltaSeriesMultiplicationDivision(object):
+ # Tests for Series[timedelta64[ns]]
+ # __mul__, __rmul__, __div__, __rdiv__, __floordiv__, __rfloordiv__
+
+ # ------------------------------------------------------------------
+ # __floordiv__, __rfloordiv__
+
+ @pytest.mark.parametrize('scalar_td', [
+ timedelta(minutes=5, seconds=4),
+ Timedelta('5m4s'),
+ Timedelta('5m4s').to_timedelta64()])
+ def test_timedelta_floordiv(self, scalar_td):
+ # GH#18831
+ td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
+ td1.iloc[2] = np.nan
+
+ result = td1 // scalar_td
+ expected = Series([0, 0, np.nan])
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('scalar_td', [
+ timedelta(minutes=5, seconds=4),
+ Timedelta('5m4s'),
+ Timedelta('5m4s').to_timedelta64()])
+ def test_timedelta_rfloordiv(self, scalar_td):
+ # GH#18831
+ td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
+ td1.iloc[2] = np.nan
+ result = scalar_td // td1
+ expected = Series([1, 1, np.nan])
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('scalar_td', [
+ timedelta(minutes=5, seconds=4),
+ Timedelta('5m4s'),
+ Timedelta('5m4s').to_timedelta64()])
+ def test_timedelta_rfloordiv_explicit(self, scalar_td):
+ # GH#18831
+ td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
+ td1.iloc[2] = np.nan
+
+ # We can test __rfloordiv__ using this syntax,
+ # see `test_timedelta_rfloordiv`
+ result = td1.__rfloordiv__(scalar_td)
+ expected = Series([1, 1, np.nan])
+ tm.assert_series_equal(result, expected)
+
+ # ------------------------------------------------------------------
+ # Operations with int-like others
+
+ @pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16',
+ 'uint64', 'uint32', 'uint16', 'uint8',
+ 'float64', 'float32', 'float16'])
+ @pytest.mark.parametrize('vector', [np.array([20, 30, 40]),
+ pd.Index([20, 30, 40]),
+ Series([20, 30, 40])])
+ def test_td64series_div_numeric_array(self, vector, dtype, tdser):
+ # GH#4521
+ # divide/multiply by integers
+ vector = vector.astype(dtype)
+ expected = Series(['2.95D', '1D 23H 12m', 'NaT'],
+ dtype='timedelta64[ns]')
+
+ result = tdser / vector
+ tm.assert_series_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ vector / tdser
+
+ @pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16',
+ 'uint64', 'uint32', 'uint16', 'uint8',
+ 'float64', 'float32', 'float16'])
+ @pytest.mark.parametrize('vector', [np.array([20, 30, 40]),
+ pd.Index([20, 30, 40]),
+ Series([20, 30, 40])])
+ def test_td64series_mul_numeric_array(self, vector, dtype, tdser):
+ # GH#4521
+ # divide/multiply by integers
+ vector = vector.astype(dtype)
+
+ expected = Series(['1180 Days', '1770 Days', 'NaT'],
+ dtype='timedelta64[ns]')
+
+ result = tdser * vector
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16',
+ 'uint64', 'uint32', 'uint16', 'uint8',
+ 'float64', 'float32', 'float16'])
+ @pytest.mark.parametrize('vector', [
+ np.array([20, 30, 40]),
+ pytest.param(pd.Index([20, 30, 40]),
+ marks=pytest.mark.xfail(reason='__mul__ raises '
+ 'instead of returning '
+ 'NotImplemented')),
+ Series([20, 30, 40])
+ ])
+ def test_td64series_rmul_numeric_array(self, vector, dtype, tdser):
+ # GH#4521
+ # divide/multiply by integers
+ vector = vector.astype(dtype)
+
+ expected = Series(['1180 Days', '1770 Days', 'NaT'],
+ dtype='timedelta64[ns]')
+
+ result = vector * tdser
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('one', [1, np.array(1), 1.0, np.array(1.0)])
+ def test_td64series_mul_numeric_scalar(self, one, tdser):
+ # GH#4521
+ # divide/multiply by integers
+ expected = Series(['-59 Days', '-59 Days', 'NaT'],
+ dtype='timedelta64[ns]')
+
+ result = tdser * (-one)
+ tm.assert_series_equal(result, expected)
+ result = (-one) * tdser
+ tm.assert_series_equal(result, expected)
+
+ expected = Series(['118 Days', '118 Days', 'NaT'],
+ dtype='timedelta64[ns]')
+
+ result = tdser * (2 * one)
+ tm.assert_series_equal(result, expected)
+ result = (2 * one) * tdser
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('two', [
+ 2, 2.0,
+ pytest.param(np.array(2),
+ marks=pytest.mark.xfail(reason='GH#19011 is_list_like '
+ 'incorrectly True.')),
+ pytest.param(np.array(2.0),
+ marks=pytest.mark.xfail(reason='GH#19011 is_list_like '
+ 'incorrectly True.')),
+ ])
+ def test_td64series_div_numeric_scalar(self, two, tdser):
+ # GH#4521
+ # divide/multiply by integers
+ expected = Series(['29.5D', '29.5D', 'NaT'], dtype='timedelta64[ns]')
+
+ result = tdser / two
+ tm.assert_series_equal(result, expected)
+
+ # ------------------------------------------------------------------
+ # Operations with timedelta-like others
+
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('Egon', 'Venkman', None),
+ ('NCC1701D', 'NCC1701D', 'NCC1701D')])
+ def test_tdi_mul_int_series(self, names):
+ # GH#19042
+ tdi = pd.TimedeltaIndex(['0days', '1day', '2days', '3days', '4days'],
+ name=names[0])
+ ser = Series([0, 1, 2, 3, 4], dtype=np.int64, name=names[1])
+
+ expected = Series(['0days', '1day', '4days', '9days', '16days'],
+ dtype='timedelta64[ns]',
+ name=names[2])
+
+ result = ser * tdi
+ tm.assert_series_equal(result, expected)
+
+ # The direct operation tdi * ser still needs to be fixed.
+ result = ser.__rmul__(tdi)
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('Egon', 'Venkman', None),
+ ('NCC1701D', 'NCC1701D', 'NCC1701D')])
+ def test_float_series_rdiv_tdi(self, names):
+ # GH#19042
+ # TODO: the direct operation TimedeltaIndex / Series still
+ # needs to be fixed.
+ tdi = pd.TimedeltaIndex(['0days', '1day', '2days', '3days', '4days'],
+ name=names[0])
+ ser = Series([1.5, 3, 4.5, 6, 7.5], dtype=np.float64, name=names[1])
+
+ expected = Series([tdi[n] / ser[n] for n in range(len(ser))],
+ dtype='timedelta64[ns]',
+ name=names[2])
+
+ result = ser.__rdiv__(tdi)
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('scalar_td', [
+ timedelta(minutes=5, seconds=4),
+ Timedelta('5m4s'),
+ Timedelta('5m4s').to_timedelta64()])
+ def test_td64series_mul_timedeltalike_invalid(self, scalar_td):
+ td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
+ td1.iloc[2] = np.nan
+
+ # check that we are getting a TypeError
+ # with 'operate' (from core/ops.py) for the ops that are not
+ # defined
+ pattern = 'operate|unsupported|cannot|not supported'
+ with tm.assert_raises_regex(TypeError, pattern):
+ td1 * scalar_td
+ with tm.assert_raises_regex(TypeError, pattern):
+ scalar_td * td1
+
+
+class TestTimedeltaSeriesInvalidArithmeticOps(object):
+ @pytest.mark.parametrize('scalar_td', [
+ timedelta(minutes=5, seconds=4),
+ Timedelta('5m4s'),
+ Timedelta('5m4s').to_timedelta64()])
+ def test_td64series_pow_invalid(self, scalar_td):
+ td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
+ td1.iloc[2] = np.nan
+
+ # check that we are getting a TypeError
+ # with 'operate' (from core/ops.py) for the ops that are not
+ # defined
+ pattern = 'operate|unsupported|cannot|not supported'
+ with tm.assert_raises_regex(TypeError, pattern):
+ scalar_td ** td1
+ with tm.assert_raises_regex(TypeError, pattern):
+ td1 ** scalar_td
diff --git a/pandas/tests/series/test_operators.py b/pandas/tests/series/test_operators.py
index 554b3e15d8f10..f90fcce973f00 100644
--- a/pandas/tests/series/test_operators.py
+++ b/pandas/tests/series/test_operators.py
@@ -9,7 +9,7 @@
import operator
from itertools import product, starmap
-from numpy import nan, inf
+from numpy import nan
import numpy as np
import pandas as pd
@@ -29,11 +29,6 @@
from .common import TestData
-@pytest.fixture
-def tdser():
- return Series(['59 Days', '59 Days', 'NaT'], dtype='timedelta64[ns]')
-
-
class TestSeriesComparisons(object):
def test_series_comparison_scalars(self):
series = Series(date_range('1/1/2000', periods=10))
@@ -579,291 +574,7 @@ def test_comp_ops_df_compat(self):
left.to_frame() < right.to_frame()
-class TestSeriesArithmetic(object):
- def test_divide_decimal(self):
- """ resolves issue #9787 """
- from decimal import Decimal
-
- expected = Series([Decimal(5)])
-
- s = Series([Decimal(10)])
- s = s / Decimal(2)
-
- assert_series_equal(expected, s)
-
- s = Series([Decimal(10)])
- s = s // Decimal(2)
-
- assert_series_equal(expected, s)
-
- @pytest.mark.parametrize(
- 'dtype2',
- [
- np.int64, np.int32, np.int16, np.int8,
- np.float64, np.float32, np.float16,
- np.uint64, np.uint32,
- np.uint16, np.uint8
- ])
- @pytest.mark.parametrize('dtype1', [np.int64, np.float64, np.uint64])
- def test_ser_div_ser(self, dtype1, dtype2):
- # no longer do integer div for any ops, but deal with the 0's
- first = Series([3, 4, 5, 8], name='first').astype(dtype1)
- second = Series([0, 0, 0, 3], name='second').astype(dtype2)
-
- with np.errstate(all='ignore'):
- expected = Series(first.values.astype(np.float64) / second.values,
- dtype='float64', name=None)
- expected.iloc[0:3] = np.inf
-
- result = first / second
- assert_series_equal(result, expected)
- assert not result.equals(second / first)
-
- def test_div_equiv_binop(self):
- # Test Series.div as well as Series.__div__
- # float/integer issue
- # GH#7785
- first = pd.Series([1, 0], name='first')
- second = pd.Series([-0.01, -0.02], name='second')
- expected = Series([-0.01, -np.inf])
-
- result = second.div(first)
- assert_series_equal(result, expected, check_names=False)
-
- result = second / first
- assert_series_equal(result, expected)
-
- def test_rdiv_zero_compat(self):
- # GH#8674
- zero_array = np.array([0] * 5)
- data = np.random.randn(5)
- expected = pd.Series([0.] * 5)
-
- result = zero_array / pd.Series(data)
- assert_series_equal(result, expected)
-
- result = pd.Series(zero_array) / data
- assert_series_equal(result, expected)
-
- result = pd.Series(zero_array) / pd.Series(data)
- assert_series_equal(result, expected)
-
- def test_div_zero_inf_signs(self):
- # GH#9144, inf signing
- ser = Series([-1, 0, 1], name='first')
- expected = Series([-np.inf, np.nan, np.inf], name='first')
-
- result = ser / 0
- assert_series_equal(result, expected)
-
- def test_rdiv_zero(self):
- # GH#9144
- ser = Series([-1, 0, 1], name='first')
- expected = Series([0.0, np.nan, 0.0], name='first')
-
- result = 0 / ser
- assert_series_equal(result, expected)
-
- def test_floordiv_div(self):
- # GH#9144
- ser = Series([-1, 0, 1], name='first')
-
- result = ser // 0
- expected = Series([-inf, nan, inf], name='first')
- assert_series_equal(result, expected)
-
-
-class TestTimedeltaSeriesArithmeticWithIntegers(object):
- # Tests for Series with dtype 'timedelta64[ns]' arithmetic operations
- # with integer and int-like others
-
- # ------------------------------------------------------------------
- # Addition and Subtraction
-
- def test_td64series_add_int_series_invalid(self, tdser):
- with pytest.raises(TypeError):
- tdser + Series([2, 3, 4])
-
- @pytest.mark.xfail(reason='GH#19123 integer interpreted as nanoseconds')
- def test_td64series_radd_int_series_invalid(self, tdser):
- with pytest.raises(TypeError):
- Series([2, 3, 4]) + tdser
-
- def test_td64series_sub_int_series_invalid(self, tdser):
- with pytest.raises(TypeError):
- tdser - Series([2, 3, 4])
-
- @pytest.mark.xfail(reason='GH#19123 integer interpreted as nanoseconds')
- def test_td64series_rsub_int_series_invalid(self, tdser):
- with pytest.raises(TypeError):
- Series([2, 3, 4]) - tdser
-
- def test_td64_series_add_intlike(self):
- # GH#19123
- tdi = pd.TimedeltaIndex(['59 days', '59 days', 'NaT'])
- ser = Series(tdi)
-
- other = Series([20, 30, 40], dtype='uint8')
-
- pytest.raises(TypeError, ser.__add__, 1)
- pytest.raises(TypeError, ser.__sub__, 1)
-
- pytest.raises(TypeError, ser.__add__, other)
- pytest.raises(TypeError, ser.__sub__, other)
-
- pytest.raises(TypeError, ser.__add__, other.values)
- pytest.raises(TypeError, ser.__sub__, other.values)
-
- pytest.raises(TypeError, ser.__add__, pd.Index(other))
- pytest.raises(TypeError, ser.__sub__, pd.Index(other))
-
- @pytest.mark.parametrize('scalar', [1, 1.5, np.array(2)])
- def test_td64series_add_sub_numeric_scalar_invalid(self, scalar, tdser):
- with pytest.raises(TypeError):
- tdser + scalar
- with pytest.raises(TypeError):
- scalar + tdser
- with pytest.raises(TypeError):
- tdser - scalar
- with pytest.raises(TypeError):
- scalar - tdser
-
- @pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16',
- 'uint64', 'uint32', 'uint16', 'uint8',
- 'float64', 'float32', 'float16'])
- @pytest.mark.parametrize('vector', [
- np.array([1, 2, 3]),
- pd.Index([1, 2, 3]),
- pytest.param(Series([1, 2, 3]),
- marks=pytest.mark.xfail(reason='GH#19123 integer '
- 'interpreted as nanos'))
- ])
- def test_td64series_add_sub_numeric_array_invalid(self, vector,
- dtype, tdser):
- vector = vector.astype(dtype)
- with pytest.raises(TypeError):
- tdser + vector
- with pytest.raises(TypeError):
- vector + tdser
- with pytest.raises(TypeError):
- tdser - vector
- with pytest.raises(TypeError):
- vector - tdser
-
- # ------------------------------------------------------------------
- # Multiplicaton and Division
-
- @pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16',
- 'uint64', 'uint32', 'uint16', 'uint8',
- 'float64', 'float32', 'float16'])
- @pytest.mark.parametrize('vector', [np.array([20, 30, 40]),
- pd.Index([20, 30, 40]),
- Series([20, 30, 40])])
- def test_td64series_div_numeric_array(self, vector, dtype, tdser):
- # GH 4521
- # divide/multiply by integers
- vector = vector.astype(dtype)
- expected = Series(['2.95D', '1D 23H 12m', 'NaT'],
- dtype='timedelta64[ns]')
-
- result = tdser / vector
- assert_series_equal(result, expected)
-
- with pytest.raises(TypeError):
- vector / tdser
-
- @pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16',
- 'uint64', 'uint32', 'uint16', 'uint8',
- 'float64', 'float32', 'float16'])
- @pytest.mark.parametrize('vector', [np.array([20, 30, 40]),
- pd.Index([20, 30, 40]),
- Series([20, 30, 40])])
- def test_td64series_mul_numeric_array(self, vector, dtype, tdser):
- # GH 4521
- # divide/multiply by integers
- vector = vector.astype(dtype)
-
- expected = Series(['1180 Days', '1770 Days', 'NaT'],
- dtype='timedelta64[ns]')
-
- result = tdser * vector
- assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16',
- 'uint64', 'uint32', 'uint16', 'uint8',
- 'float64', 'float32', 'float16'])
- @pytest.mark.parametrize('vector', [
- np.array([20, 30, 40]),
- pytest.param(pd.Index([20, 30, 40]),
- marks=pytest.mark.xfail(reason='__mul__ raises '
- 'instead of returning '
- 'NotImplemented')),
- Series([20, 30, 40])
- ])
- def test_td64series_rmul_numeric_array(self, vector, dtype, tdser):
- # GH 4521
- # divide/multiply by integers
- vector = vector.astype(dtype)
-
- expected = Series(['1180 Days', '1770 Days', 'NaT'],
- dtype='timedelta64[ns]')
-
- result = vector * tdser
- assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('one', [1, np.array(1), 1.0, np.array(1.0)])
- def test_td64series_mul_numeric_scalar(self, one, tdser):
- # GH 4521
- # divide/multiply by integers
- expected = Series(['-59 Days', '-59 Days', 'NaT'],
- dtype='timedelta64[ns]')
-
- result = tdser * (-one)
- assert_series_equal(result, expected)
- result = (-one) * tdser
- assert_series_equal(result, expected)
-
- expected = Series(['118 Days', '118 Days', 'NaT'],
- dtype='timedelta64[ns]')
-
- result = tdser * (2 * one)
- assert_series_equal(result, expected)
- result = (2 * one) * tdser
- assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('two', [
- 2, 2.0,
- pytest.param(np.array(2),
- marks=pytest.mark.xfail(reason='GH#19011 is_list_like '
- 'incorrectly True.')),
- pytest.param(np.array(2.0),
- marks=pytest.mark.xfail(reason='GH#19011 is_list_like '
- 'incorrectly True.')),
- ])
- def test_td64series_div_numeric_scalar(self, two, tdser):
- # GH 4521
- # divide/multiply by integers
- expected = Series(['29.5D', '29.5D', 'NaT'], dtype='timedelta64[ns]')
-
- result = tdser / two
- assert_series_equal(result, expected)
-
-
class TestTimedeltaSeriesArithmetic(object):
- def test_td64series_add_sub_timestamp(self):
- # GH11925
- tdser = Series(timedelta_range('1 day', periods=3))
- ts = Timestamp('2012-01-01')
- expected = Series(date_range('2012-01-02', periods=3))
- assert_series_equal(ts + tdser, expected)
- assert_series_equal(tdser + ts, expected)
-
- expected2 = Series(date_range('2011-12-31', periods=3, freq='-1D'))
- assert_series_equal(ts - tdser, expected2)
- assert_series_equal(ts + (-tdser), expected2)
-
- with pytest.raises(TypeError):
- tdser - ts
def test_timedelta64_operations_with_DateOffset(self):
# GH 10699
@@ -1081,13 +792,6 @@ def test_timedelta64_ops_nat(self):
assert_series_equal(timedelta_series / nan,
nat_series_dtype_timedelta)
- def test_td64_sub_NaT(self):
- # GH#18808
- ser = Series([NaT, Timedelta('1s')])
- res = ser - NaT
- expected = Series([NaT, NaT], dtype='timedelta64[ns]')
- tm.assert_series_equal(res, expected)
-
@pytest.mark.parametrize('scalar_td', [timedelta(minutes=5, seconds=4),
Timedelta(minutes=5, seconds=4),
Timedelta('5m4s').to_timedelta64()])
@@ -1103,135 +807,6 @@ def test_operators_timedelta64_with_timedelta(self, scalar_td):
td1 / scalar_td
scalar_td / td1
- @pytest.mark.parametrize('scalar_td', [
- timedelta(minutes=5, seconds=4),
- Timedelta('5m4s'),
- Timedelta('5m4s').to_timedelta64()])
- def test_operators_timedelta64_with_timedelta_invalid(self, scalar_td):
- td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
- td1.iloc[2] = np.nan
-
- # check that we are getting a TypeError
- # with 'operate' (from core/ops.py) for the ops that are not
- # defined
- pattern = 'operate|unsupported|cannot|not supported'
- with tm.assert_raises_regex(TypeError, pattern):
- td1 * scalar_td
- with tm.assert_raises_regex(TypeError, pattern):
- scalar_td * td1
- with tm.assert_raises_regex(TypeError, pattern):
- scalar_td ** td1
- with tm.assert_raises_regex(TypeError, pattern):
- td1 ** scalar_td
-
- @pytest.mark.parametrize('scalar_td', [
- timedelta(minutes=5, seconds=4),
- Timedelta('5m4s'),
- Timedelta('5m4s').to_timedelta64()])
- def test_timedelta_rfloordiv(self, scalar_td):
- # GH#18831
- td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
- td1.iloc[2] = np.nan
- result = scalar_td // td1
- expected = Series([1, 1, np.nan])
- tm.assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('scalar_td', [
- timedelta(minutes=5, seconds=4),
- Timedelta('5m4s'),
- Timedelta('5m4s').to_timedelta64()])
- def test_timedelta_rfloordiv_explicit(self, scalar_td):
- # GH#18831
- td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
- td1.iloc[2] = np.nan
-
- # We can test __rfloordiv__ using this syntax,
- # see `test_timedelta_rfloordiv`
- result = td1.__rfloordiv__(scalar_td)
- expected = Series([1, 1, np.nan])
- tm.assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('scalar_td', [
- timedelta(minutes=5, seconds=4),
- Timedelta('5m4s'),
- Timedelta('5m4s').to_timedelta64()])
- def test_timedelta_floordiv(self, scalar_td):
- # GH#18831
- td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
- td1.iloc[2] = np.nan
-
- result = td1 // scalar_td
- expected = Series([0, 0, np.nan])
- tm.assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('names', [(None, None, None),
- ('Egon', 'Venkman', None),
- ('NCC1701D', 'NCC1701D', 'NCC1701D')])
- def test_td64_series_with_tdi(self, names):
- # GH#17250 make sure result dtype is correct
- # GH#19043 make sure names are propagated correctly
- tdi = pd.TimedeltaIndex(['0 days', '1 day'], name=names[0])
- ser = Series([Timedelta(hours=3), Timedelta(hours=4)], name=names[1])
- expected = Series([Timedelta(hours=3), Timedelta(days=1, hours=4)],
- name=names[2])
-
- result = tdi + ser
- tm.assert_series_equal(result, expected)
- assert result.dtype == 'timedelta64[ns]'
-
- result = ser + tdi
- tm.assert_series_equal(result, expected)
- assert result.dtype == 'timedelta64[ns]'
-
- expected = Series([Timedelta(hours=-3), Timedelta(days=1, hours=-4)],
- name=names[2])
-
- result = tdi - ser
- tm.assert_series_equal(result, expected)
- assert result.dtype == 'timedelta64[ns]'
-
- result = ser - tdi
- tm.assert_series_equal(result, -expected)
- assert result.dtype == 'timedelta64[ns]'
-
- @pytest.mark.parametrize('names', [(None, None, None),
- ('Egon', 'Venkman', None),
- ('NCC1701D', 'NCC1701D', 'NCC1701D')])
- def test_tdi_mul_int_series(self, names):
- # GH#19042
- tdi = pd.TimedeltaIndex(['0days', '1day', '2days', '3days', '4days'],
- name=names[0])
- ser = Series([0, 1, 2, 3, 4], dtype=np.int64, name=names[1])
-
- expected = Series(['0days', '1day', '4days', '9days', '16days'],
- dtype='timedelta64[ns]',
- name=names[2])
-
- result = ser * tdi
- tm.assert_series_equal(result, expected)
-
- # The direct operation tdi * ser still needs to be fixed.
- result = ser.__rmul__(tdi)
- tm.assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('names', [(None, None, None),
- ('Egon', 'Venkman', None),
- ('NCC1701D', 'NCC1701D', 'NCC1701D')])
- def test_float_series_rdiv_tdi(self, names):
- # GH#19042
- # TODO: the direct operation TimedeltaIndex / Series still
- # needs to be fixed.
- tdi = pd.TimedeltaIndex(['0days', '1day', '2days', '3days', '4days'],
- name=names[0])
- ser = Series([1.5, 3, 4.5, 6, 7.5], dtype=np.float64, name=names[1])
-
- expected = Series([tdi[n] / ser[n] for n in range(len(ser))],
- dtype='timedelta64[ns]',
- name=names[2])
-
- result = ser.__rdiv__(tdi)
- tm.assert_series_equal(result, expected)
-
class TestDatetimeSeriesArithmetic(object):
@pytest.mark.parametrize(
@@ -1994,138 +1569,6 @@ def test_operators_reverse_object(self, op):
expected = op(1., arr.astype(float))
assert_series_equal(result.astype(float), expected)
- def test_arith_ops_df_compat(self):
- # GH 1134
- s1 = pd.Series([1, 2, 3], index=list('ABC'), name='x')
- s2 = pd.Series([2, 2, 2], index=list('ABD'), name='x')
-
- exp = pd.Series([3.0, 4.0, np.nan, np.nan],
- index=list('ABCD'), name='x')
- assert_series_equal(s1 + s2, exp)
- assert_series_equal(s2 + s1, exp)
-
- exp = pd.DataFrame({'x': [3.0, 4.0, np.nan, np.nan]},
- index=list('ABCD'))
- assert_frame_equal(s1.to_frame() + s2.to_frame(), exp)
- assert_frame_equal(s2.to_frame() + s1.to_frame(), exp)
-
- # different length
- s3 = pd.Series([1, 2, 3], index=list('ABC'), name='x')
- s4 = pd.Series([2, 2, 2, 2], index=list('ABCD'), name='x')
-
- exp = pd.Series([3, 4, 5, np.nan],
- index=list('ABCD'), name='x')
- assert_series_equal(s3 + s4, exp)
- assert_series_equal(s4 + s3, exp)
-
- exp = pd.DataFrame({'x': [3, 4, 5, np.nan]},
- index=list('ABCD'))
- assert_frame_equal(s3.to_frame() + s4.to_frame(), exp)
- assert_frame_equal(s4.to_frame() + s3.to_frame(), exp)
-
- def test_bool_ops_df_compat(self):
- # GH 1134
- s1 = pd.Series([True, False, True], index=list('ABC'), name='x')
- s2 = pd.Series([True, True, False], index=list('ABD'), name='x')
-
- exp = pd.Series([True, False, False, False],
- index=list('ABCD'), name='x')
- assert_series_equal(s1 & s2, exp)
- assert_series_equal(s2 & s1, exp)
-
- # True | np.nan => True
- exp = pd.Series([True, True, True, False],
- index=list('ABCD'), name='x')
- assert_series_equal(s1 | s2, exp)
- # np.nan | True => np.nan, filled with False
- exp = pd.Series([True, True, False, False],
- index=list('ABCD'), name='x')
- assert_series_equal(s2 | s1, exp)
-
- # DataFrame doesn't fill nan with False
- exp = pd.DataFrame({'x': [True, False, np.nan, np.nan]},
- index=list('ABCD'))
- assert_frame_equal(s1.to_frame() & s2.to_frame(), exp)
- assert_frame_equal(s2.to_frame() & s1.to_frame(), exp)
-
- exp = pd.DataFrame({'x': [True, True, np.nan, np.nan]},
- index=list('ABCD'))
- assert_frame_equal(s1.to_frame() | s2.to_frame(), exp)
- assert_frame_equal(s2.to_frame() | s1.to_frame(), exp)
-
- # different length
- s3 = pd.Series([True, False, True], index=list('ABC'), name='x')
- s4 = pd.Series([True, True, True, True], index=list('ABCD'), name='x')
-
- exp = pd.Series([True, False, True, False],
- index=list('ABCD'), name='x')
- assert_series_equal(s3 & s4, exp)
- assert_series_equal(s4 & s3, exp)
-
- # np.nan | True => np.nan, filled with False
- exp = pd.Series([True, True, True, False],
- index=list('ABCD'), name='x')
- assert_series_equal(s3 | s4, exp)
- # True | np.nan => True
- exp = pd.Series([True, True, True, True],
- index=list('ABCD'), name='x')
- assert_series_equal(s4 | s3, exp)
-
- exp = pd.DataFrame({'x': [True, False, True, np.nan]},
- index=list('ABCD'))
- assert_frame_equal(s3.to_frame() & s4.to_frame(), exp)
- assert_frame_equal(s4.to_frame() & s3.to_frame(), exp)
-
- exp = pd.DataFrame({'x': [True, True, True, np.nan]},
- index=list('ABCD'))
- assert_frame_equal(s3.to_frame() | s4.to_frame(), exp)
- assert_frame_equal(s4.to_frame() | s3.to_frame(), exp)
-
- def test_series_frame_radd_bug(self):
- # GH 353
- vals = Series(tm.rands_array(5, 10))
- result = 'foo_' + vals
- expected = vals.map(lambda x: 'foo_' + x)
- assert_series_equal(result, expected)
-
- frame = DataFrame({'vals': vals})
- result = 'foo_' + frame
- expected = DataFrame({'vals': vals.map(lambda x: 'foo_' + x)})
- assert_frame_equal(result, expected)
-
- # really raise this time
- with pytest.raises(TypeError):
- datetime.now() + self.ts
-
- with pytest.raises(TypeError):
- self.ts + datetime.now()
-
- @pytest.mark.parametrize('dtype', [None, object])
- def test_series_with_dtype_radd_timedelta(self, dtype):
- ser = pd.Series([pd.Timedelta('1 days'), pd.Timedelta('2 days'),
- pd.Timedelta('3 days')], dtype=dtype)
- expected = pd.Series([pd.Timedelta('4 days'), pd.Timedelta('5 days'),
- pd.Timedelta('6 days')])
-
- result = pd.Timedelta('3 days') + ser
- assert_series_equal(result, expected)
-
- result = ser + pd.Timedelta('3 days')
- assert_series_equal(result, expected)
-
- def test_operators_frame(self):
- # rpow does not work with DataFrame
- df = DataFrame({'A': self.ts})
-
- assert_series_equal(self.ts + self.ts, self.ts + df['A'],
- check_names=False)
- assert_series_equal(self.ts ** self.ts, self.ts ** df['A'],
- check_names=False)
- assert_series_equal(self.ts < self.ts, self.ts < df['A'],
- check_names=False)
- assert_series_equal(self.ts / self.ts, self.ts / df['A'],
- check_names=False)
-
def test_operators_combine(self):
def _check_fill(meth, op, a, b, fill_value=0):
exp_index = a.index.union(b.index)
@@ -2231,15 +1674,6 @@ def test_datetime64_with_index(self):
df['result'] = df['date'] - df.index
assert_series_equal(df['result'], df['expected'], check_names=False)
- def test_dti_tz_convert_to_utc(self):
- base = pd.DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03'],
- tz='UTC')
- idx1 = base.tz_convert('Asia/Tokyo')[:2]
- idx2 = base.tz_convert('US/Eastern')[1:]
-
- res = Series([1, 2], index=idx1) + Series([1, 1], index=idx2)
- assert_series_equal(res, Series([np.nan, 3, np.nan], index=base))
-
def test_op_duplicate_index(self):
# GH14227
s1 = Series([1, 2], index=[1, 1])
@@ -2294,3 +1728,130 @@ def test_idxminmax_with_inf(self):
assert np.isnan(s.idxmin(skipna=False))
assert s.idxmax() == 0
np.isnan(s.idxmax(skipna=False))
+
+
+class TestSeriesOperationsDataFrameCompat(object):
+ def test_operators_frame(self):
+ # rpow does not work with DataFrame
+ ts = tm.makeTimeSeries()
+ ts.name = 'ts'
+
+ df = DataFrame({'A': ts})
+
+ assert_series_equal(ts + ts, ts + df['A'],
+ check_names=False)
+ assert_series_equal(ts ** ts, ts ** df['A'],
+ check_names=False)
+ assert_series_equal(ts < ts, ts < df['A'],
+ check_names=False)
+ assert_series_equal(ts / ts, ts / df['A'],
+ check_names=False)
+
+ def test_series_frame_radd_bug(self):
+ # GH#353
+ vals = Series(tm.rands_array(5, 10))
+ result = 'foo_' + vals
+ expected = vals.map(lambda x: 'foo_' + x)
+ assert_series_equal(result, expected)
+
+ frame = DataFrame({'vals': vals})
+ result = 'foo_' + frame
+ expected = DataFrame({'vals': vals.map(lambda x: 'foo_' + x)})
+ assert_frame_equal(result, expected)
+
+ ts = tm.makeTimeSeries()
+ ts.name = 'ts'
+
+ # really raise this time
+ with pytest.raises(TypeError):
+ datetime.now() + ts
+
+ with pytest.raises(TypeError):
+ ts + datetime.now()
+
+ def test_bool_ops_df_compat(self):
+ # GH 1134
+ s1 = pd.Series([True, False, True], index=list('ABC'), name='x')
+ s2 = pd.Series([True, True, False], index=list('ABD'), name='x')
+
+ exp = pd.Series([True, False, False, False],
+ index=list('ABCD'), name='x')
+ assert_series_equal(s1 & s2, exp)
+ assert_series_equal(s2 & s1, exp)
+
+ # True | np.nan => True
+ exp = pd.Series([True, True, True, False],
+ index=list('ABCD'), name='x')
+ assert_series_equal(s1 | s2, exp)
+ # np.nan | True => np.nan, filled with False
+ exp = pd.Series([True, True, False, False],
+ index=list('ABCD'), name='x')
+ assert_series_equal(s2 | s1, exp)
+
+ # DataFrame doesn't fill nan with False
+ exp = pd.DataFrame({'x': [True, False, np.nan, np.nan]},
+ index=list('ABCD'))
+ assert_frame_equal(s1.to_frame() & s2.to_frame(), exp)
+ assert_frame_equal(s2.to_frame() & s1.to_frame(), exp)
+
+ exp = pd.DataFrame({'x': [True, True, np.nan, np.nan]},
+ index=list('ABCD'))
+ assert_frame_equal(s1.to_frame() | s2.to_frame(), exp)
+ assert_frame_equal(s2.to_frame() | s1.to_frame(), exp)
+
+ # different length
+ s3 = pd.Series([True, False, True], index=list('ABC'), name='x')
+ s4 = pd.Series([True, True, True, True], index=list('ABCD'), name='x')
+
+ exp = pd.Series([True, False, True, False],
+ index=list('ABCD'), name='x')
+ assert_series_equal(s3 & s4, exp)
+ assert_series_equal(s4 & s3, exp)
+
+ # np.nan | True => np.nan, filled with False
+ exp = pd.Series([True, True, True, False],
+ index=list('ABCD'), name='x')
+ assert_series_equal(s3 | s4, exp)
+ # True | np.nan => True
+ exp = pd.Series([True, True, True, True],
+ index=list('ABCD'), name='x')
+ assert_series_equal(s4 | s3, exp)
+
+ exp = pd.DataFrame({'x': [True, False, True, np.nan]},
+ index=list('ABCD'))
+ assert_frame_equal(s3.to_frame() & s4.to_frame(), exp)
+ assert_frame_equal(s4.to_frame() & s3.to_frame(), exp)
+
+ exp = pd.DataFrame({'x': [True, True, True, np.nan]},
+ index=list('ABCD'))
+ assert_frame_equal(s3.to_frame() | s4.to_frame(), exp)
+ assert_frame_equal(s4.to_frame() | s3.to_frame(), exp)
+
+ def test_arith_ops_df_compat(self):
+ # GH#1134
+ s1 = pd.Series([1, 2, 3], index=list('ABC'), name='x')
+ s2 = pd.Series([2, 2, 2], index=list('ABD'), name='x')
+
+ exp = pd.Series([3.0, 4.0, np.nan, np.nan],
+ index=list('ABCD'), name='x')
+ assert_series_equal(s1 + s2, exp)
+ assert_series_equal(s2 + s1, exp)
+
+ exp = pd.DataFrame({'x': [3.0, 4.0, np.nan, np.nan]},
+ index=list('ABCD'))
+ assert_frame_equal(s1.to_frame() + s2.to_frame(), exp)
+ assert_frame_equal(s2.to_frame() + s1.to_frame(), exp)
+
+ # different length
+ s3 = pd.Series([1, 2, 3], index=list('ABC'), name='x')
+ s4 = pd.Series([2, 2, 2, 2], index=list('ABCD'), name='x')
+
+ exp = pd.Series([3, 4, 5, np.nan],
+ index=list('ABCD'), name='x')
+ assert_series_equal(s3 + s4, exp)
+ assert_series_equal(s4 + s3, exp)
+
+ exp = pd.DataFrame({'x': [3, 4, 5, np.nan]},
+ index=list('ABCD'))
+ assert_frame_equal(s3.to_frame() + s4.to_frame(), exp)
+ assert_frame_equal(s4.to_frame() + s3.to_frame(), exp)
diff --git a/pandas/tests/series/test_timezones.py b/pandas/tests/series/test_timezones.py
index 2e15c964e4e93..b54645d04bd1a 100644
--- a/pandas/tests/series/test_timezones.py
+++ b/pandas/tests/series/test_timezones.py
@@ -88,6 +88,15 @@ def test_series_tz_convert(self):
tm.assert_raises_regex(TypeError, "Cannot convert tz-naive",
ts.tz_convert, 'US/Eastern')
+ def test_series_tz_convert_to_utc(self):
+ base = DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03'],
+ tz='UTC')
+ idx1 = base.tz_convert('Asia/Tokyo')[:2]
+ idx2 = base.tz_convert('US/Eastern')[1:]
+
+ res = Series([1, 2], index=idx1) + Series([1, 1], index=idx2)
+ tm.assert_series_equal(res, Series([np.nan, 3, np.nan], index=base))
+
# -----------------------------------------------------------------
# Series.append
| Doesn't overlap with other outstanding PRs.
Per usual, there is more that _could_ be done, but we're doing this in pieces.
- [ ] 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/19794 | 2018-02-20T18:08:31Z | 2018-02-21T23:50:05Z | 2018-02-21T23:50:05Z | 2018-06-22T03:24:31Z |
Raise OptionError instead of KeyError in __getattr__. Fixes #19789. | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index ca5749afd11bc..1a8fa5a89468a 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -908,3 +908,4 @@ Other
^^^^^
- Improved error message when attempting to use a Python keyword as an identifier in a ``numexpr`` backed query (:issue:`18221`)
+- Bug in accessing a :func:`pandas.get_option`, which raised ``KeyError`` rather than ``OptionError`` when looking up a non-existant option key in some cases (:issue:`19789`)
diff --git a/pandas/core/config.py b/pandas/core/config.py
index 692aed178719d..369e0568346ef 100644
--- a/pandas/core/config.py
+++ b/pandas/core/config.py
@@ -196,7 +196,10 @@ def __getattr__(self, key):
if prefix:
prefix += "."
prefix += key
- v = object.__getattribute__(self, "d")[key]
+ try:
+ v = object.__getattribute__(self, "d")[key]
+ except KeyError:
+ raise OptionError("No such option")
if isinstance(v, dict):
return DictWrapper(v, prefix)
else:
diff --git a/pandas/tests/test_config.py b/pandas/tests/test_config.py
index 8d6f36ac6a798..91ce65dcce9b2 100644
--- a/pandas/tests/test_config.py
+++ b/pandas/tests/test_config.py
@@ -428,3 +428,9 @@ def test_option_context_scope(self):
# Ensure the current context is reset
assert self.cf.get_option(option_name) == original_value
+
+ def test_dictwrapper_getattr(self):
+ options = self.cf.options
+ # GH 19789
+ pytest.raises(self.cf.OptionError, getattr, options, 'bananas')
+ assert not hasattr(options, 'bananas')
| - [x] closes #19789
- [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/19790 | 2018-02-20T14:51:37Z | 2018-02-24T15:08:17Z | 2018-02-24T15:08:17Z | 2018-02-24T15:08:19Z |
parametrize a whole mess of tests | diff --git a/pandas/tests/indexes/datetimes/test_arithmetic.py b/pandas/tests/indexes/datetimes/test_arithmetic.py
index ddc97636ae0a8..9ce34e9b22efb 100644
--- a/pandas/tests/indexes/datetimes/test_arithmetic.py
+++ b/pandas/tests/indexes/datetimes/test_arithmetic.py
@@ -614,19 +614,19 @@ def test_sub_dti_dti(self):
result = dti2 - dti1
tm.assert_index_equal(result, expected)
- def test_sub_period(self):
- # GH 13078
+ @pytest.mark.parametrize('freq', [None, 'D'])
+ def test_sub_period(self, freq):
+ # GH#13078
# not supported, check TypeError
p = pd.Period('2011-01-01', freq='D')
- for freq in [None, 'D']:
- idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=freq)
+ idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=freq)
- with pytest.raises(TypeError):
- idx - p
+ with pytest.raises(TypeError):
+ idx - p
- with pytest.raises(TypeError):
- p - idx
+ with pytest.raises(TypeError):
+ p - idx
def test_ufunc_coercions(self):
idx = date_range('2011-01-01', periods=3, freq='2D', name='x')
diff --git a/pandas/tests/indexes/datetimes/test_construction.py b/pandas/tests/indexes/datetimes/test_construction.py
index 197a42bdaacbb..176f5bd0c1a2a 100644
--- a/pandas/tests/indexes/datetimes/test_construction.py
+++ b/pandas/tests/indexes/datetimes/test_construction.py
@@ -351,52 +351,51 @@ def test_constructor_coverage(self):
freq='B')
pytest.raises(ValueError, DatetimeIndex, periods=10, freq='D')
- def test_constructor_datetime64_tzformat(self):
- # see gh-6572: ISO 8601 format results in pytz.FixedOffset
- for freq in ['AS', 'W-SUN']:
- idx = date_range('2013-01-01T00:00:00-05:00',
- '2016-01-01T23:59:59-05:00', freq=freq)
- expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
- freq=freq, tz=pytz.FixedOffset(-300))
- tm.assert_index_equal(idx, expected)
- # Unable to use `US/Eastern` because of DST
- expected_i8 = date_range('2013-01-01T00:00:00',
- '2016-01-01T23:59:59', freq=freq,
- tz='America/Lima')
- tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
-
- idx = date_range('2013-01-01T00:00:00+09:00',
- '2016-01-01T23:59:59+09:00', freq=freq)
- expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
- freq=freq, tz=pytz.FixedOffset(540))
- tm.assert_index_equal(idx, expected)
- expected_i8 = date_range('2013-01-01T00:00:00',
- '2016-01-01T23:59:59', freq=freq,
- tz='Asia/Tokyo')
- tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
+ @pytest.mark.parametrize('freq', ['AS', 'W-SUN'])
+ def test_constructor_datetime64_tzformat(self, freq):
+ # see GH#6572: ISO 8601 format results in pytz.FixedOffset
+ idx = date_range('2013-01-01T00:00:00-05:00',
+ '2016-01-01T23:59:59-05:00', freq=freq)
+ expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
+ freq=freq, tz=pytz.FixedOffset(-300))
+ tm.assert_index_equal(idx, expected)
+ # Unable to use `US/Eastern` because of DST
+ expected_i8 = date_range('2013-01-01T00:00:00',
+ '2016-01-01T23:59:59', freq=freq,
+ tz='America/Lima')
+ tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
+
+ idx = date_range('2013-01-01T00:00:00+09:00',
+ '2016-01-01T23:59:59+09:00', freq=freq)
+ expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
+ freq=freq, tz=pytz.FixedOffset(540))
+ tm.assert_index_equal(idx, expected)
+ expected_i8 = date_range('2013-01-01T00:00:00',
+ '2016-01-01T23:59:59', freq=freq,
+ tz='Asia/Tokyo')
+ tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
# Non ISO 8601 format results in dateutil.tz.tzoffset
- for freq in ['AS', 'W-SUN']:
- idx = date_range('2013/1/1 0:00:00-5:00', '2016/1/1 23:59:59-5:00',
- freq=freq)
- expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
- freq=freq, tz=pytz.FixedOffset(-300))
- tm.assert_index_equal(idx, expected)
- # Unable to use `US/Eastern` because of DST
- expected_i8 = date_range('2013-01-01T00:00:00',
- '2016-01-01T23:59:59', freq=freq,
- tz='America/Lima')
- tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
-
- idx = date_range('2013/1/1 0:00:00+9:00',
- '2016/1/1 23:59:59+09:00', freq=freq)
- expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
- freq=freq, tz=pytz.FixedOffset(540))
- tm.assert_index_equal(idx, expected)
- expected_i8 = date_range('2013-01-01T00:00:00',
- '2016-01-01T23:59:59', freq=freq,
- tz='Asia/Tokyo')
- tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
+ idx = date_range('2013/1/1 0:00:00-5:00', '2016/1/1 23:59:59-5:00',
+ freq=freq)
+ expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
+ freq=freq, tz=pytz.FixedOffset(-300))
+ tm.assert_index_equal(idx, expected)
+ # Unable to use `US/Eastern` because of DST
+ expected_i8 = date_range('2013-01-01T00:00:00',
+ '2016-01-01T23:59:59', freq=freq,
+ tz='America/Lima')
+ tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
+
+ idx = date_range('2013/1/1 0:00:00+9:00',
+ '2016/1/1 23:59:59+09:00', freq=freq)
+ expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
+ freq=freq, tz=pytz.FixedOffset(540))
+ tm.assert_index_equal(idx, expected)
+ expected_i8 = date_range('2013-01-01T00:00:00',
+ '2016-01-01T23:59:59', freq=freq,
+ tz='Asia/Tokyo')
+ tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
def test_constructor_dtype(self):
@@ -451,36 +450,35 @@ def test_dti_constructor_preserve_dti_freq(self):
rng2 = DatetimeIndex(rng)
assert rng.freq == rng2.freq
- def test_dti_constructor_years_only(self):
+ @pytest.mark.parametrize('tz', [None, 'UTC', 'Asia/Tokyo',
+ 'dateutil/US/Pacific'])
+ def test_dti_constructor_years_only(self, tz):
# GH 6961
- for tz in [None, 'UTC', 'Asia/Tokyo', 'dateutil/US/Pacific']:
- rng1 = date_range('2014', '2015', freq='M', tz=tz)
- expected1 = date_range('2014-01-31', '2014-12-31', freq='M', tz=tz)
+ rng1 = date_range('2014', '2015', freq='M', tz=tz)
+ expected1 = date_range('2014-01-31', '2014-12-31', freq='M', tz=tz)
- rng2 = date_range('2014', '2015', freq='MS', tz=tz)
- expected2 = date_range('2014-01-01', '2015-01-01', freq='MS',
- tz=tz)
+ rng2 = date_range('2014', '2015', freq='MS', tz=tz)
+ expected2 = date_range('2014-01-01', '2015-01-01', freq='MS', tz=tz)
- rng3 = date_range('2014', '2020', freq='A', tz=tz)
- expected3 = date_range('2014-12-31', '2019-12-31', freq='A', tz=tz)
+ rng3 = date_range('2014', '2020', freq='A', tz=tz)
+ expected3 = date_range('2014-12-31', '2019-12-31', freq='A', tz=tz)
- rng4 = date_range('2014', '2020', freq='AS', tz=tz)
- expected4 = date_range('2014-01-01', '2020-01-01', freq='AS',
- tz=tz)
+ rng4 = date_range('2014', '2020', freq='AS', tz=tz)
+ expected4 = date_range('2014-01-01', '2020-01-01', freq='AS', tz=tz)
- for rng, expected in [(rng1, expected1), (rng2, expected2),
- (rng3, expected3), (rng4, expected4)]:
- tm.assert_index_equal(rng, expected)
+ for rng, expected in [(rng1, expected1), (rng2, expected2),
+ (rng3, expected3), (rng4, expected4)]:
+ tm.assert_index_equal(rng, expected)
- def test_dti_constructor_small_int(self):
+ @pytest.mark.parametrize('dtype', [np.int64, np.int32, np.int16, np.int8])
+ def test_dti_constructor_small_int(self, dtype):
# GH 13721
exp = DatetimeIndex(['1970-01-01 00:00:00.00000000',
'1970-01-01 00:00:00.00000001',
'1970-01-01 00:00:00.00000002'])
- for dtype in [np.int64, np.int32, np.int16, np.int8]:
- arr = np.array([0, 10, 20], dtype=dtype)
- tm.assert_index_equal(DatetimeIndex(arr), exp)
+ arr = np.array([0, 10, 20], dtype=dtype)
+ tm.assert_index_equal(DatetimeIndex(arr), exp)
def test_ctor_str_intraday(self):
rng = DatetimeIndex(['1-1-2000 00:00:01'])
@@ -499,7 +497,7 @@ def test_index_cast_datetime64_other_units(self):
assert (idx.values == conversion.ensure_datetime64ns(arr)).all()
def test_constructor_int64_nocopy(self):
- # #1624
+ # GH#1624
arr = np.arange(1000, dtype=np.int64)
index = DatetimeIndex(arr)
@@ -512,19 +510,17 @@ def test_constructor_int64_nocopy(self):
arr[50:100] = -1
assert (index.asi8[50:100] != -1).all()
- def test_from_freq_recreate_from_data(self):
- freqs = ['M', 'Q', 'A', 'D', 'B', 'BH', 'T', 'S', 'L', 'U', 'H', 'N',
- 'C']
-
- for f in freqs:
- org = DatetimeIndex(start='2001/02/01 09:00', freq=f, periods=1)
- idx = DatetimeIndex(org, freq=f)
- tm.assert_index_equal(idx, org)
-
- org = DatetimeIndex(start='2001/02/01 09:00', freq=f,
- tz='US/Pacific', periods=1)
- idx = DatetimeIndex(org, freq=f, tz='US/Pacific')
- tm.assert_index_equal(idx, org)
+ @pytest.mark.parametrize('freq', ['M', 'Q', 'A', 'D', 'B', 'BH',
+ 'T', 'S', 'L', 'U', 'H', 'N', 'C'])
+ def test_from_freq_recreate_from_data(self, freq):
+ org = DatetimeIndex(start='2001/02/01 09:00', freq=freq, periods=1)
+ idx = DatetimeIndex(org, freq=freq)
+ tm.assert_index_equal(idx, org)
+
+ org = DatetimeIndex(start='2001/02/01 09:00', freq=freq,
+ tz='US/Pacific', periods=1)
+ idx = DatetimeIndex(org, freq=freq, tz='US/Pacific')
+ tm.assert_index_equal(idx, org)
def test_datetimeindex_constructor_misc(self):
arr = ['1/1/2005', '1/2/2005', 'Jn 3, 2005', '2005-01-04']
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 3738398d017f8..d2ec465468dfb 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -222,16 +222,13 @@ def test_range_misspecified(self):
with tm.assert_raises_regex(ValueError, msg):
date_range()
- def test_compat_replace(self):
+ @pytest.mark.parametrize('f', [compat.long, int])
+ def test_compat_replace(self, f):
# https://github.com/statsmodels/statsmodels/issues/3349
# replace should take ints/longs for compat
-
- for f in [compat.long, int]:
- result = date_range(Timestamp('1960-04-01 00:00:00',
- freq='QS-JAN'),
- periods=f(76),
- freq='QS-JAN')
- assert len(result) == 76
+ result = date_range(Timestamp('1960-04-01 00:00:00', freq='QS-JAN'),
+ periods=f(76), freq='QS-JAN')
+ assert len(result) == 76
def test_catch_infinite_loop(self):
offset = offsets.DateOffset(minute=5)
@@ -484,24 +481,24 @@ def test_range_tz_dateutil(self):
assert dr[0] == start
assert dr[2] == end
- def test_range_closed(self):
+ @pytest.mark.parametrize('freq', ["1D", "3D", "2M", "7W", "3H", "A"])
+ def test_range_closed(self, freq):
begin = datetime(2011, 1, 1)
end = datetime(2014, 1, 1)
- for freq in ["1D", "3D", "2M", "7W", "3H", "A"]:
- closed = date_range(begin, end, closed=None, freq=freq)
- left = date_range(begin, end, closed="left", freq=freq)
- right = date_range(begin, end, closed="right", freq=freq)
- expected_left = left
- expected_right = right
+ closed = date_range(begin, end, closed=None, freq=freq)
+ left = date_range(begin, end, closed="left", freq=freq)
+ right = date_range(begin, end, closed="right", freq=freq)
+ expected_left = left
+ expected_right = right
- if end == closed[-1]:
- expected_left = closed[:-1]
- if begin == closed[0]:
- expected_right = closed[1:]
+ if end == closed[-1]:
+ expected_left = closed[:-1]
+ if begin == closed[0]:
+ expected_right = closed[1:]
- tm.assert_index_equal(expected_left, left)
- tm.assert_index_equal(expected_right, right)
+ tm.assert_index_equal(expected_left, left)
+ tm.assert_index_equal(expected_right, right)
def test_range_closed_with_tz_aware_start_end(self):
# GH12409, GH12684
@@ -546,28 +543,28 @@ def test_range_closed_with_tz_aware_start_end(self):
tm.assert_index_equal(expected_left, left)
tm.assert_index_equal(expected_right, right)
- def test_range_closed_boundary(self):
- # GH 11804
- for closed in ['right', 'left', None]:
- right_boundary = date_range('2015-09-12', '2015-12-01',
- freq='QS-MAR', closed=closed)
- left_boundary = date_range('2015-09-01', '2015-09-12',
- freq='QS-MAR', closed=closed)
- both_boundary = date_range('2015-09-01', '2015-12-01',
- freq='QS-MAR', closed=closed)
- expected_right = expected_left = expected_both = both_boundary
-
- if closed == 'right':
- expected_left = both_boundary[1:]
- if closed == 'left':
- expected_right = both_boundary[:-1]
- if closed is None:
- expected_right = both_boundary[1:]
- expected_left = both_boundary[:-1]
-
- tm.assert_index_equal(right_boundary, expected_right)
- tm.assert_index_equal(left_boundary, expected_left)
- tm.assert_index_equal(both_boundary, expected_both)
+ @pytest.mark.parametrize('closed', ['right', 'left', None])
+ def test_range_closed_boundary(self, closed):
+ # GH#11804
+ right_boundary = date_range('2015-09-12', '2015-12-01',
+ freq='QS-MAR', closed=closed)
+ left_boundary = date_range('2015-09-01', '2015-09-12',
+ freq='QS-MAR', closed=closed)
+ both_boundary = date_range('2015-09-01', '2015-12-01',
+ freq='QS-MAR', closed=closed)
+ expected_right = expected_left = expected_both = both_boundary
+
+ if closed == 'right':
+ expected_left = both_boundary[1:]
+ if closed == 'left':
+ expected_right = both_boundary[:-1]
+ if closed is None:
+ expected_right = both_boundary[1:]
+ expected_left = both_boundary[:-1]
+
+ tm.assert_index_equal(right_boundary, expected_right)
+ tm.assert_index_equal(left_boundary, expected_left)
+ tm.assert_index_equal(both_boundary, expected_both)
def test_years_only(self):
# GH 6961
diff --git a/pandas/tests/indexes/datetimes/test_datetime.py b/pandas/tests/indexes/datetimes/test_datetime.py
index 05678b0c8dd45..2cf33644377ab 100644
--- a/pandas/tests/indexes/datetimes/test_datetime.py
+++ b/pandas/tests/indexes/datetimes/test_datetime.py
@@ -356,12 +356,11 @@ def test_does_not_convert_mixed_integer(self):
assert cols.dtype == joined.dtype
tm.assert_numpy_array_equal(cols.values, joined.values)
- def test_join_self(self):
+ @pytest.mark.parametrize('how', ['outer', 'inner', 'left', 'right'])
+ def test_join_self(self, how):
index = date_range('1/1/2000', periods=10)
- kinds = 'outer', 'inner', 'left', 'right'
- for kind in kinds:
- joined = index.join(index, how=kind)
- assert index is joined
+ joined = index.join(index, how=how)
+ assert index is joined
def assert_index_parameters(self, index):
assert index.freq == '40960N'
@@ -381,18 +380,17 @@ def test_ns_index(self):
freq=index.freq)
self.assert_index_parameters(new_index)
- def test_join_with_period_index(self):
+ @pytest.mark.parametrize('how', ['left', 'right', 'inner', 'outer'])
+ def test_join_with_period_index(self, how):
df = tm.makeCustomDataframe(
10, 10, data_gen_f=lambda *args: np.random.randint(2),
c_idx_type='p', r_idx_type='dt')
s = df.iloc[:5, 0]
- joins = 'left', 'right', 'inner', 'outer'
- for join in joins:
- with tm.assert_raises_regex(ValueError,
- 'can only call with other '
- 'PeriodIndex-ed objects'):
- df.columns.join(s.index, how=join)
+ with tm.assert_raises_regex(ValueError,
+ 'can only call with other '
+ 'PeriodIndex-ed objects'):
+ df.columns.join(s.index, how=how)
def test_factorize(self):
idx1 = DatetimeIndex(['2014-01', '2014-01', '2014-02', '2014-02',
@@ -439,18 +437,18 @@ def test_factorize(self):
tm.assert_numpy_array_equal(arr, exp_arr)
tm.assert_index_equal(idx, idx3)
- def test_factorize_tz(self):
- # GH 13750
- for tz in [None, 'UTC', 'US/Eastern', 'Asia/Tokyo']:
- base = pd.date_range('2016-11-05', freq='H', periods=100, tz=tz)
- idx = base.repeat(5)
+ @pytest.mark.parametrize('tz', [None, 'UTC', 'US/Eastern', 'Asia/Tokyo'])
+ def test_factorize_tz(self, tz):
+ # GH#13750
+ base = pd.date_range('2016-11-05', freq='H', periods=100, tz=tz)
+ idx = base.repeat(5)
- exp_arr = np.arange(100, dtype=np.intp).repeat(5)
+ exp_arr = np.arange(100, dtype=np.intp).repeat(5)
- for obj in [idx, pd.Series(idx)]:
- arr, res = obj.factorize()
- tm.assert_numpy_array_equal(arr, exp_arr)
- tm.assert_index_equal(res, base)
+ for obj in [idx, pd.Series(idx)]:
+ arr, res = obj.factorize()
+ tm.assert_numpy_array_equal(arr, exp_arr)
+ tm.assert_index_equal(res, base)
def test_factorize_dst(self):
# GH 13750
diff --git a/pandas/tests/indexes/datetimes/test_indexing.py b/pandas/tests/indexes/datetimes/test_indexing.py
index 48ceefd6368c0..a9f1a5e608ac7 100644
--- a/pandas/tests/indexes/datetimes/test_indexing.py
+++ b/pandas/tests/indexes/datetimes/test_indexing.py
@@ -346,25 +346,25 @@ def test_take_invalid_kwargs(self):
indices, mode='clip')
# TODO: This method came from test_datetime; de-dup with version above
- def test_take2(self):
+ @pytest.mark.parametrize('tz', [None, 'US/Eastern', 'Asia/Tokyo'])
+ def test_take2(self, tz):
dates = [datetime(2010, 1, 1, 14), datetime(2010, 1, 1, 15),
datetime(2010, 1, 1, 17), datetime(2010, 1, 1, 21)]
- for tz in [None, 'US/Eastern', 'Asia/Tokyo']:
- idx = DatetimeIndex(start='2010-01-01 09:00',
- end='2010-02-01 09:00', freq='H', tz=tz,
- name='idx')
- expected = DatetimeIndex(dates, freq=None, name='idx', tz=tz)
+ idx = DatetimeIndex(start='2010-01-01 09:00',
+ end='2010-02-01 09:00', freq='H', tz=tz,
+ name='idx')
+ expected = DatetimeIndex(dates, freq=None, name='idx', tz=tz)
- taken1 = idx.take([5, 6, 8, 12])
- taken2 = idx[[5, 6, 8, 12]]
+ taken1 = idx.take([5, 6, 8, 12])
+ taken2 = idx[[5, 6, 8, 12]]
- for taken in [taken1, taken2]:
- tm.assert_index_equal(taken, expected)
- assert isinstance(taken, DatetimeIndex)
- assert taken.freq is None
- assert taken.tz == expected.tz
- assert taken.name == expected.name
+ for taken in [taken1, taken2]:
+ tm.assert_index_equal(taken, expected)
+ assert isinstance(taken, DatetimeIndex)
+ assert taken.freq is None
+ assert taken.tz == expected.tz
+ assert taken.name == expected.name
def test_take_fill_value(self):
# GH 12631
diff --git a/pandas/tests/indexes/datetimes/test_missing.py b/pandas/tests/indexes/datetimes/test_missing.py
index adc0b7b3d81e8..c8d47caa7e947 100644
--- a/pandas/tests/indexes/datetimes/test_missing.py
+++ b/pandas/tests/indexes/datetimes/test_missing.py
@@ -1,50 +1,52 @@
+import pytest
+
import pandas as pd
import pandas.util.testing as tm
class TestDatetimeIndex(object):
- def test_fillna_datetime64(self):
+ @pytest.mark.parametrize('tz', ['US/Eastern', 'Asia/Tokyo'])
+ def test_fillna_datetime64(self, tz):
# GH 11343
- for tz in ['US/Eastern', 'Asia/Tokyo']:
- idx = pd.DatetimeIndex(['2011-01-01 09:00', pd.NaT,
- '2011-01-01 11:00'])
-
- exp = pd.DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00',
- '2011-01-01 11:00'])
- tm.assert_index_equal(
- idx.fillna(pd.Timestamp('2011-01-01 10:00')), exp)
-
- # tz mismatch
- exp = pd.Index([pd.Timestamp('2011-01-01 09:00'),
- pd.Timestamp('2011-01-01 10:00', tz=tz),
- pd.Timestamp('2011-01-01 11:00')], dtype=object)
- tm.assert_index_equal(
- idx.fillna(pd.Timestamp('2011-01-01 10:00', tz=tz)), exp)
-
- # object
- exp = pd.Index([pd.Timestamp('2011-01-01 09:00'), 'x',
- pd.Timestamp('2011-01-01 11:00')], dtype=object)
- tm.assert_index_equal(idx.fillna('x'), exp)
-
- idx = pd.DatetimeIndex(['2011-01-01 09:00', pd.NaT,
- '2011-01-01 11:00'], tz=tz)
-
- exp = pd.DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00',
- '2011-01-01 11:00'], tz=tz)
- tm.assert_index_equal(
- idx.fillna(pd.Timestamp('2011-01-01 10:00', tz=tz)), exp)
-
- exp = pd.Index([pd.Timestamp('2011-01-01 09:00', tz=tz),
- pd.Timestamp('2011-01-01 10:00'),
- pd.Timestamp('2011-01-01 11:00', tz=tz)],
- dtype=object)
- tm.assert_index_equal(
- idx.fillna(pd.Timestamp('2011-01-01 10:00')), exp)
-
- # object
- exp = pd.Index([pd.Timestamp('2011-01-01 09:00', tz=tz),
- 'x',
- pd.Timestamp('2011-01-01 11:00', tz=tz)],
- dtype=object)
- tm.assert_index_equal(idx.fillna('x'), exp)
+ idx = pd.DatetimeIndex(['2011-01-01 09:00', pd.NaT,
+ '2011-01-01 11:00'])
+
+ exp = pd.DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00',
+ '2011-01-01 11:00'])
+ tm.assert_index_equal(
+ idx.fillna(pd.Timestamp('2011-01-01 10:00')), exp)
+
+ # tz mismatch
+ exp = pd.Index([pd.Timestamp('2011-01-01 09:00'),
+ pd.Timestamp('2011-01-01 10:00', tz=tz),
+ pd.Timestamp('2011-01-01 11:00')], dtype=object)
+ tm.assert_index_equal(
+ idx.fillna(pd.Timestamp('2011-01-01 10:00', tz=tz)), exp)
+
+ # object
+ exp = pd.Index([pd.Timestamp('2011-01-01 09:00'), 'x',
+ pd.Timestamp('2011-01-01 11:00')], dtype=object)
+ tm.assert_index_equal(idx.fillna('x'), exp)
+
+ idx = pd.DatetimeIndex(['2011-01-01 09:00', pd.NaT,
+ '2011-01-01 11:00'], tz=tz)
+
+ exp = pd.DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00',
+ '2011-01-01 11:00'], tz=tz)
+ tm.assert_index_equal(
+ idx.fillna(pd.Timestamp('2011-01-01 10:00', tz=tz)), exp)
+
+ exp = pd.Index([pd.Timestamp('2011-01-01 09:00', tz=tz),
+ pd.Timestamp('2011-01-01 10:00'),
+ pd.Timestamp('2011-01-01 11:00', tz=tz)],
+ dtype=object)
+ tm.assert_index_equal(
+ idx.fillna(pd.Timestamp('2011-01-01 10:00')), exp)
+
+ # object
+ exp = pd.Index([pd.Timestamp('2011-01-01 09:00', tz=tz),
+ 'x',
+ pd.Timestamp('2011-01-01 11:00', tz=tz)],
+ dtype=object)
+ tm.assert_index_equal(idx.fillna('x'), exp)
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index b42cd454803b8..ed7e425924097 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -96,111 +96,111 @@ def test_numpy_minmax(self):
tm.assert_raises_regex(
ValueError, errmsg, np.argmax, dr, out=0)
- def test_repeat_range(self):
+ @pytest.mark.parametrize('tz', tz)
+ def test_repeat_range(self, tz):
rng = date_range('1/1/2000', '1/1/2001')
result = rng.repeat(5)
assert result.freq is None
assert len(result) == 5 * len(rng)
- for tz in self.tz:
- index = pd.date_range('2001-01-01', periods=2, freq='D', tz=tz)
- exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01',
- '2001-01-02', '2001-01-02'], tz=tz)
- for res in [index.repeat(2), np.repeat(index, 2)]:
- tm.assert_index_equal(res, exp)
- assert res.freq is None
-
- index = pd.date_range('2001-01-01', periods=2, freq='2D', tz=tz)
- exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01',
- '2001-01-03', '2001-01-03'], tz=tz)
- for res in [index.repeat(2), np.repeat(index, 2)]:
- tm.assert_index_equal(res, exp)
- assert res.freq is None
-
- index = pd.DatetimeIndex(['2001-01-01', 'NaT', '2003-01-01'],
- tz=tz)
- exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01', '2001-01-01',
- 'NaT', 'NaT', 'NaT',
- '2003-01-01', '2003-01-01', '2003-01-01'],
- tz=tz)
- for res in [index.repeat(3), np.repeat(index, 3)]:
- tm.assert_index_equal(res, exp)
- assert res.freq is None
-
- def test_repeat(self):
+ index = pd.date_range('2001-01-01', periods=2, freq='D', tz=tz)
+ exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01',
+ '2001-01-02', '2001-01-02'], tz=tz)
+ for res in [index.repeat(2), np.repeat(index, 2)]:
+ tm.assert_index_equal(res, exp)
+ assert res.freq is None
+
+ index = pd.date_range('2001-01-01', periods=2, freq='2D', tz=tz)
+ exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01',
+ '2001-01-03', '2001-01-03'], tz=tz)
+ for res in [index.repeat(2), np.repeat(index, 2)]:
+ tm.assert_index_equal(res, exp)
+ assert res.freq is None
+
+ index = pd.DatetimeIndex(['2001-01-01', 'NaT', '2003-01-01'],
+ tz=tz)
+ exp = pd.DatetimeIndex(['2001-01-01', '2001-01-01', '2001-01-01',
+ 'NaT', 'NaT', 'NaT',
+ '2003-01-01', '2003-01-01', '2003-01-01'],
+ tz=tz)
+ for res in [index.repeat(3), np.repeat(index, 3)]:
+ tm.assert_index_equal(res, exp)
+ assert res.freq is None
+
+ @pytest.mark.parametrize('tz', tz)
+ def test_repeat(self, tz):
reps = 2
msg = "the 'axis' parameter is not supported"
- for tz in self.tz:
- rng = pd.date_range(start='2016-01-01', periods=2,
- freq='30Min', tz=tz)
-
- expected_rng = DatetimeIndex([
- Timestamp('2016-01-01 00:00:00', tz=tz, freq='30T'),
- Timestamp('2016-01-01 00:00:00', tz=tz, freq='30T'),
- Timestamp('2016-01-01 00:30:00', tz=tz, freq='30T'),
- Timestamp('2016-01-01 00:30:00', tz=tz, freq='30T'),
- ])
-
- res = rng.repeat(reps)
- tm.assert_index_equal(res, expected_rng)
- assert res.freq is None
+ rng = pd.date_range(start='2016-01-01', periods=2,
+ freq='30Min', tz=tz)
- tm.assert_index_equal(np.repeat(rng, reps), expected_rng)
- tm.assert_raises_regex(ValueError, msg, np.repeat,
- rng, reps, axis=1)
+ expected_rng = DatetimeIndex([
+ Timestamp('2016-01-01 00:00:00', tz=tz, freq='30T'),
+ Timestamp('2016-01-01 00:00:00', tz=tz, freq='30T'),
+ Timestamp('2016-01-01 00:30:00', tz=tz, freq='30T'),
+ Timestamp('2016-01-01 00:30:00', tz=tz, freq='30T'),
+ ])
- def test_resolution(self):
+ res = rng.repeat(reps)
+ tm.assert_index_equal(res, expected_rng)
+ assert res.freq is None
+
+ tm.assert_index_equal(np.repeat(rng, reps), expected_rng)
+ tm.assert_raises_regex(ValueError, msg, np.repeat,
+ rng, reps, axis=1)
+
+ @pytest.mark.parametrize('tz', tz)
+ def test_resolution(self, tz):
for freq, expected in zip(['A', 'Q', 'M', 'D', 'H', 'T',
'S', 'L', 'U'],
['day', 'day', 'day', 'day', 'hour',
'minute', 'second', 'millisecond',
'microsecond']):
- for tz in self.tz:
- idx = pd.date_range(start='2013-04-01', periods=30, freq=freq,
- tz=tz)
- assert idx.resolution == expected
+ idx = pd.date_range(start='2013-04-01', periods=30, freq=freq,
+ tz=tz)
+ assert idx.resolution == expected
- def test_value_counts_unique(self):
+ @pytest.mark.parametrize('tz', tz)
+ def test_value_counts_unique(self, tz):
# GH 7735
- for tz in self.tz:
- idx = pd.date_range('2011-01-01 09:00', freq='H', periods=10)
- # create repeated values, 'n'th element is repeated by n+1 times
- idx = DatetimeIndex(np.repeat(idx.values, range(1, len(idx) + 1)),
- tz=tz)
+ idx = pd.date_range('2011-01-01 09:00', freq='H', periods=10)
+ # create repeated values, 'n'th element is repeated by n+1 times
+ idx = DatetimeIndex(np.repeat(idx.values, range(1, len(idx) + 1)),
+ tz=tz)
- exp_idx = pd.date_range('2011-01-01 18:00', freq='-1H', periods=10,
- tz=tz)
- expected = Series(range(10, 0, -1), index=exp_idx, dtype='int64')
+ exp_idx = pd.date_range('2011-01-01 18:00', freq='-1H', periods=10,
+ tz=tz)
+ expected = Series(range(10, 0, -1), index=exp_idx, dtype='int64')
- for obj in [idx, Series(idx)]:
- tm.assert_series_equal(obj.value_counts(), expected)
+ for obj in [idx, Series(idx)]:
+ tm.assert_series_equal(obj.value_counts(), expected)
- expected = pd.date_range('2011-01-01 09:00', freq='H', periods=10,
- tz=tz)
- tm.assert_index_equal(idx.unique(), expected)
+ expected = pd.date_range('2011-01-01 09:00', freq='H', periods=10,
+ tz=tz)
+ tm.assert_index_equal(idx.unique(), expected)
- idx = DatetimeIndex(['2013-01-01 09:00', '2013-01-01 09:00',
- '2013-01-01 09:00', '2013-01-01 08:00',
- '2013-01-01 08:00', pd.NaT], tz=tz)
+ idx = DatetimeIndex(['2013-01-01 09:00', '2013-01-01 09:00',
+ '2013-01-01 09:00', '2013-01-01 08:00',
+ '2013-01-01 08:00', pd.NaT], tz=tz)
- exp_idx = DatetimeIndex(['2013-01-01 09:00', '2013-01-01 08:00'],
- tz=tz)
- expected = Series([3, 2], index=exp_idx)
+ exp_idx = DatetimeIndex(['2013-01-01 09:00', '2013-01-01 08:00'],
+ tz=tz)
+ expected = Series([3, 2], index=exp_idx)
- for obj in [idx, Series(idx)]:
- tm.assert_series_equal(obj.value_counts(), expected)
+ for obj in [idx, Series(idx)]:
+ tm.assert_series_equal(obj.value_counts(), expected)
- exp_idx = DatetimeIndex(['2013-01-01 09:00', '2013-01-01 08:00',
- pd.NaT], tz=tz)
- expected = Series([3, 2, 1], index=exp_idx)
+ exp_idx = DatetimeIndex(['2013-01-01 09:00', '2013-01-01 08:00',
+ pd.NaT], tz=tz)
+ expected = Series([3, 2, 1], index=exp_idx)
- for obj in [idx, Series(idx)]:
- tm.assert_series_equal(obj.value_counts(dropna=False),
- expected)
+ for obj in [idx, Series(idx)]:
+ tm.assert_series_equal(obj.value_counts(dropna=False),
+ expected)
- tm.assert_index_equal(idx.unique(), exp_idx)
+ tm.assert_index_equal(idx.unique(), exp_idx)
def test_nonunique_contains(self):
# GH 9512
@@ -324,15 +324,16 @@ def test_drop_duplicates(self):
res = Series(idx).drop_duplicates(keep=False)
tm.assert_series_equal(res, Series(base[5:], index=np.arange(5, 31)))
- def test_infer_freq(self):
+ @pytest.mark.parametrize('freq', [
+ 'A', '2A', '-2A', 'Q', '-1Q', 'M', '-1M', 'D', '3D',
+ '-3D', 'W', '-1W', 'H', '2H', '-2H', 'T', '2T', 'S',
+ '-3S'])
+ def test_infer_freq(self, freq):
# GH 11018
- for freq in ['A', '2A', '-2A', 'Q', '-1Q', 'M', '-1M', 'D', '3D',
- '-3D', 'W', '-1W', 'H', '2H', '-2H', 'T', '2T', 'S',
- '-3S']:
- idx = pd.date_range('2011-01-01 09:00:00', freq=freq, periods=10)
- result = pd.DatetimeIndex(idx.asi8, freq='infer')
- tm.assert_index_equal(idx, result)
- assert result.freq == freq
+ idx = pd.date_range('2011-01-01 09:00:00', freq=freq, periods=10)
+ result = pd.DatetimeIndex(idx.asi8, freq='infer')
+ tm.assert_index_equal(idx, result)
+ assert result.freq == freq
def test_nat_new(self):
idx = pd.date_range('2011-01-01', freq='D', periods=5, name='x')
@@ -344,57 +345,57 @@ def test_nat_new(self):
exp = np.array([tslib.iNaT] * 5, dtype=np.int64)
tm.assert_numpy_array_equal(result, exp)
- def test_nat(self):
+ @pytest.mark.parametrize('tz', [None, 'US/Eastern', 'UTC'])
+ def test_nat(self, tz):
assert pd.DatetimeIndex._na_value is pd.NaT
assert pd.DatetimeIndex([])._na_value is pd.NaT
- for tz in [None, 'US/Eastern', 'UTC']:
- idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], tz=tz)
- assert idx._can_hold_na
+ idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], tz=tz)
+ assert idx._can_hold_na
- tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
- assert not idx.hasnans
- tm.assert_numpy_array_equal(idx._nan_idxs,
- np.array([], dtype=np.intp))
+ tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
+ assert not idx.hasnans
+ tm.assert_numpy_array_equal(idx._nan_idxs,
+ np.array([], dtype=np.intp))
- idx = pd.DatetimeIndex(['2011-01-01', 'NaT'], tz=tz)
- assert idx._can_hold_na
+ idx = pd.DatetimeIndex(['2011-01-01', 'NaT'], tz=tz)
+ assert idx._can_hold_na
- tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
- assert idx.hasnans
- tm.assert_numpy_array_equal(idx._nan_idxs,
- np.array([1], dtype=np.intp))
+ tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
+ assert idx.hasnans
+ tm.assert_numpy_array_equal(idx._nan_idxs,
+ np.array([1], dtype=np.intp))
- def test_equals(self):
+ @pytest.mark.parametrize('tz', [None, 'UTC', 'US/Eastern', 'Asia/Tokyo'])
+ def test_equals(self, tz):
# GH 13107
- for tz in [None, 'UTC', 'US/Eastern', 'Asia/Tokyo']:
- idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02', 'NaT'])
- assert idx.equals(idx)
- assert idx.equals(idx.copy())
- assert idx.equals(idx.astype(object))
- assert idx.astype(object).equals(idx)
- assert idx.astype(object).equals(idx.astype(object))
- assert not idx.equals(list(idx))
- assert not idx.equals(pd.Series(idx))
-
- idx2 = pd.DatetimeIndex(['2011-01-01', '2011-01-02', 'NaT'],
- tz='US/Pacific')
- assert not idx.equals(idx2)
- assert not idx.equals(idx2.copy())
- assert not idx.equals(idx2.astype(object))
- assert not idx.astype(object).equals(idx2)
- assert not idx.equals(list(idx2))
- assert not idx.equals(pd.Series(idx2))
-
- # same internal, different tz
- idx3 = pd.DatetimeIndex._simple_new(idx.asi8, tz='US/Pacific')
- tm.assert_numpy_array_equal(idx.asi8, idx3.asi8)
- assert not idx.equals(idx3)
- assert not idx.equals(idx3.copy())
- assert not idx.equals(idx3.astype(object))
- assert not idx.astype(object).equals(idx3)
- assert not idx.equals(list(idx3))
- assert not idx.equals(pd.Series(idx3))
+ idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02', 'NaT'])
+ assert idx.equals(idx)
+ assert idx.equals(idx.copy())
+ assert idx.equals(idx.astype(object))
+ assert idx.astype(object).equals(idx)
+ assert idx.astype(object).equals(idx.astype(object))
+ assert not idx.equals(list(idx))
+ assert not idx.equals(pd.Series(idx))
+
+ idx2 = pd.DatetimeIndex(['2011-01-01', '2011-01-02', 'NaT'],
+ tz='US/Pacific')
+ assert not idx.equals(idx2)
+ assert not idx.equals(idx2.copy())
+ assert not idx.equals(idx2.astype(object))
+ assert not idx.astype(object).equals(idx2)
+ assert not idx.equals(list(idx2))
+ assert not idx.equals(pd.Series(idx2))
+
+ # same internal, different tz
+ idx3 = pd.DatetimeIndex._simple_new(idx.asi8, tz='US/Pacific')
+ tm.assert_numpy_array_equal(idx.asi8, idx3.asi8)
+ assert not idx.equals(idx3)
+ assert not idx.equals(idx3.copy())
+ assert not idx.equals(idx3.astype(object))
+ assert not idx.astype(object).equals(idx3)
+ assert not idx.equals(list(idx3))
+ assert not idx.equals(pd.Series(idx3))
class TestBusinessDatetimeIndex(object):
diff --git a/pandas/tests/indexes/datetimes/test_scalar_compat.py b/pandas/tests/indexes/datetimes/test_scalar_compat.py
index 83e7a0cd68d63..6f0756949edc6 100644
--- a/pandas/tests/indexes/datetimes/test_scalar_compat.py
+++ b/pandas/tests/indexes/datetimes/test_scalar_compat.py
@@ -38,18 +38,21 @@ def test_dti_date_out_of_range(self):
pytest.raises(ValueError, DatetimeIndex, ['1400-01-01'])
pytest.raises(ValueError, DatetimeIndex, [datetime(1400, 1, 1)])
- def test_dti_timestamp_fields(self):
+ @pytest.mark.parametrize('field', [
+ 'dayofweek', 'dayofyear', 'week', 'weekofyear', 'quarter',
+ 'days_in_month', 'is_month_start', 'is_month_end',
+ 'is_quarter_start', 'is_quarter_end', 'is_year_start',
+ 'is_year_end', 'weekday_name'])
+ def test_dti_timestamp_fields(self, field):
# extra fields from DatetimeIndex like quarter and week
idx = tm.makeDateIndex(100)
+ expected = getattr(idx, field)[-1]
+ result = getattr(Timestamp(idx[-1]), field)
+ assert result == expected
- fields = ['dayofweek', 'dayofyear', 'week', 'weekofyear', 'quarter',
- 'days_in_month', 'is_month_start', 'is_month_end',
- 'is_quarter_start', 'is_quarter_end', 'is_year_start',
- 'is_year_end', 'weekday_name']
- for f in fields:
- expected = getattr(idx, f)[-1]
- result = getattr(Timestamp(idx[-1]), f)
- assert result == expected
+ def test_dti_timestamp_freq_fields(self):
+ # extra fields from DatetimeIndex like quarter and week
+ idx = tm.makeDateIndex(100)
assert idx.freq == Timestamp(idx[-1], idx.freq).freq
assert idx.freqstr == Timestamp(idx[-1], idx.freq).freqstr
diff --git a/pandas/tests/indexes/datetimes/test_timezones.py b/pandas/tests/indexes/datetimes/test_timezones.py
index 62854676d43be..217610b76cf0f 100644
--- a/pandas/tests/indexes/datetimes/test_timezones.py
+++ b/pandas/tests/indexes/datetimes/test_timezones.py
@@ -170,17 +170,17 @@ def test_dti_tz_convert_hour_overflow_dst_timestamps(self, tz):
expected = Index([9, 9, 9])
tm.assert_index_equal(ut.hour, expected)
- def test_dti_tz_convert_trans_pos_plus_1__bug(self):
+ @pytest.mark.parametrize('freq, n', [('H', 1), ('T', 60), ('S', 3600)])
+ def test_dti_tz_convert_trans_pos_plus_1__bug(self, freq, n):
# Regression test for tslib.tz_convert(vals, tz1, tz2).
# See https://github.com/pandas-dev/pandas/issues/4496 for details.
- for freq, n in [('H', 1), ('T', 60), ('S', 3600)]:
- idx = date_range(datetime(2011, 3, 26, 23),
- datetime(2011, 3, 27, 1), freq=freq)
- idx = idx.tz_localize('UTC')
- idx = idx.tz_convert('Europe/Moscow')
+ idx = date_range(datetime(2011, 3, 26, 23),
+ datetime(2011, 3, 27, 1), freq=freq)
+ idx = idx.tz_localize('UTC')
+ idx = idx.tz_convert('Europe/Moscow')
- expected = np.repeat(np.array([3, 4, 5]), np.array([n, n, 1]))
- tm.assert_index_equal(idx.hour, Index(expected))
+ expected = np.repeat(np.array([3, 4, 5]), np.array([n, n, 1]))
+ tm.assert_index_equal(idx.hour, Index(expected))
def test_dti_tz_convert_dst(self):
for freq, n in [('H', 1), ('T', 60), ('S', 3600)]:
@@ -700,20 +700,20 @@ def test_dti_tz_constructors(self, tzstr):
# -------------------------------------------------------------
# Unsorted
- def test_join_utc_convert(self):
+ @pytest.mark.parametrize('how', ['inner', 'outer', 'left', 'right'])
+ def test_join_utc_convert(self, how):
rng = date_range('1/1/2011', periods=100, freq='H', tz='utc')
left = rng.tz_convert('US/Eastern')
right = rng.tz_convert('Europe/Berlin')
- for how in ['inner', 'outer', 'left', 'right']:
- result = left.join(left[:-5], how=how)
- assert isinstance(result, DatetimeIndex)
- assert result.tz == left.tz
+ result = left.join(left[:-5], how=how)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz == left.tz
- result = left.join(right[:-5], how=how)
- assert isinstance(result, DatetimeIndex)
- assert result.tz.zone == 'UTC'
+ result = left.join(right[:-5], how=how)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz.zone == 'UTC'
def test_dti_drop_dont_lose_tz(self):
# GH#2621
diff --git a/pandas/tests/indexes/datetimes/test_tools.py b/pandas/tests/indexes/datetimes/test_tools.py
index b5926933544e8..fbf0977a04d82 100644
--- a/pandas/tests/indexes/datetimes/test_tools.py
+++ b/pandas/tests/indexes/datetimes/test_tools.py
@@ -1013,18 +1013,20 @@ def test_string_na_nat_conversion(self, cache):
assert_series_equal(dresult, expected, check_names=False)
assert dresult.name == 'foo'
+ @pytest.mark.parametrize('dtype', [
+ 'datetime64[h]', 'datetime64[m]',
+ 'datetime64[s]', 'datetime64[ms]',
+ 'datetime64[us]', 'datetime64[ns]'])
@pytest.mark.parametrize('cache', [True, False])
- def test_dti_constructor_numpy_timeunits(self, cache):
+ def test_dti_constructor_numpy_timeunits(self, cache, dtype):
# GH 9114
base = pd.to_datetime(['2000-01-01T00:00', '2000-01-02T00:00', 'NaT'],
cache=cache)
- for dtype in ['datetime64[h]', 'datetime64[m]', 'datetime64[s]',
- 'datetime64[ms]', 'datetime64[us]', 'datetime64[ns]']:
- values = base.values.astype(dtype)
+ values = base.values.astype(dtype)
- tm.assert_index_equal(DatetimeIndex(values), base)
- tm.assert_index_equal(to_datetime(values, cache=cache), base)
+ tm.assert_index_equal(DatetimeIndex(values), base)
+ tm.assert_index_equal(to_datetime(values, cache=cache), base)
@pytest.mark.parametrize('cache', [True, False])
def test_dayfirst(self, cache):
diff --git a/pandas/tests/indexes/period/test_arithmetic.py b/pandas/tests/indexes/period/test_arithmetic.py
index 5f8f9533e9c44..e16d346542b9e 100644
--- a/pandas/tests/indexes/period/test_arithmetic.py
+++ b/pandas/tests/indexes/period/test_arithmetic.py
@@ -613,7 +613,8 @@ def test_pi_ops(self):
exp = pd.Index([0, -1, -2, -3], name='idx')
tm.assert_index_equal(result, exp)
- def test_pi_ops_errors(self):
+ @pytest.mark.parametrize('ng', ["str", 1.5])
+ def test_pi_ops_errors(self, ng):
idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
freq='M', name='idx')
ser = pd.Series(idx)
@@ -621,34 +622,33 @@ def test_pi_ops_errors(self):
msg = r"unsupported operand type\(s\)"
for obj in [idx, ser]:
- for ng in ["str", 1.5]:
- with tm.assert_raises_regex(TypeError, msg):
- obj + ng
+ with tm.assert_raises_regex(TypeError, msg):
+ obj + ng
- with pytest.raises(TypeError):
- # error message differs between PY2 and 3
- ng + obj
+ with pytest.raises(TypeError):
+ # error message differs between PY2 and 3
+ ng + obj
+
+ with tm.assert_raises_regex(TypeError, msg):
+ obj - ng
- with tm.assert_raises_regex(TypeError, msg):
- obj - ng
+ with pytest.raises(TypeError):
+ np.add(obj, ng)
+ if _np_version_under1p10:
+ assert np.add(ng, obj) is NotImplemented
+ else:
with pytest.raises(TypeError):
- np.add(obj, ng)
+ np.add(ng, obj)
- if _np_version_under1p10:
- assert np.add(ng, obj) is NotImplemented
- else:
- with pytest.raises(TypeError):
- np.add(ng, obj)
+ with pytest.raises(TypeError):
+ np.subtract(obj, ng)
+ if _np_version_under1p10:
+ assert np.subtract(ng, obj) is NotImplemented
+ else:
with pytest.raises(TypeError):
- np.subtract(obj, ng)
-
- if _np_version_under1p10:
- assert np.subtract(ng, obj) is NotImplemented
- else:
- with pytest.raises(TypeError):
- np.subtract(ng, obj)
+ np.subtract(ng, obj)
def test_pi_ops_nat(self):
idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
diff --git a/pandas/tests/indexes/period/test_asfreq.py b/pandas/tests/indexes/period/test_asfreq.py
index c8724b2a3bc91..ea59a57069faa 100644
--- a/pandas/tests/indexes/period/test_asfreq.py
+++ b/pandas/tests/indexes/period/test_asfreq.py
@@ -8,9 +8,6 @@
class TestPeriodIndex(object):
- def setup_method(self, method):
- pass
-
def test_asfreq(self):
pi1 = PeriodIndex(freq='A', start='1/1/2001', end='1/1/2001')
pi2 = PeriodIndex(freq='Q', start='1/1/2001', end='1/1/2001')
@@ -85,21 +82,21 @@ def test_asfreq_nat(self):
expected = PeriodIndex(['2011Q1', '2011Q1', 'NaT', '2011Q2'], freq='Q')
tm.assert_index_equal(result, expected)
- def test_asfreq_mult_pi(self):
+ @pytest.mark.parametrize('freq', ['D', '3D'])
+ def test_asfreq_mult_pi(self, freq):
pi = PeriodIndex(['2001-01', '2001-02', 'NaT', '2001-03'], freq='2M')
- for freq in ['D', '3D']:
- result = pi.asfreq(freq)
- exp = PeriodIndex(['2001-02-28', '2001-03-31', 'NaT',
- '2001-04-30'], freq=freq)
- tm.assert_index_equal(result, exp)
- assert result.freq == exp.freq
-
- result = pi.asfreq(freq, how='S')
- exp = PeriodIndex(['2001-01-01', '2001-02-01', 'NaT',
- '2001-03-01'], freq=freq)
- tm.assert_index_equal(result, exp)
- assert result.freq == exp.freq
+ result = pi.asfreq(freq)
+ exp = PeriodIndex(['2001-02-28', '2001-03-31', 'NaT',
+ '2001-04-30'], freq=freq)
+ tm.assert_index_equal(result, exp)
+ assert result.freq == exp.freq
+
+ result = pi.asfreq(freq, how='S')
+ exp = PeriodIndex(['2001-01-01', '2001-02-01', 'NaT',
+ '2001-03-01'], freq=freq)
+ tm.assert_index_equal(result, exp)
+ assert result.freq == exp.freq
def test_asfreq_combined_pi(self):
pi = pd.PeriodIndex(['2001-01-01 00:00', '2001-01-02 02:00', 'NaT'],
diff --git a/pandas/tests/indexes/period/test_construction.py b/pandas/tests/indexes/period/test_construction.py
index eca80d17b1dc3..be741592ec7a2 100644
--- a/pandas/tests/indexes/period/test_construction.py
+++ b/pandas/tests/indexes/period/test_construction.py
@@ -286,14 +286,14 @@ def test_constructor_simple_new_empty(self):
result = idx._simple_new(idx, name='p', freq='M')
tm.assert_index_equal(result, idx)
- def test_constructor_floats(self):
- # GH13079
- for floats in [[1.1, 2.1], np.array([1.1, 2.1])]:
- with pytest.raises(TypeError):
- pd.PeriodIndex._simple_new(floats, freq='M')
+ @pytest.mark.parametrize('floats', [[1.1, 2.1], np.array([1.1, 2.1])])
+ def test_constructor_floats(self, floats):
+ # GH#13079
+ with pytest.raises(TypeError):
+ pd.PeriodIndex._simple_new(floats, freq='M')
- with pytest.raises(TypeError):
- pd.PeriodIndex(floats, freq='M')
+ with pytest.raises(TypeError):
+ pd.PeriodIndex(floats, freq='M')
def test_constructor_nat(self):
pytest.raises(ValueError, period_range, start='NaT',
@@ -343,16 +343,14 @@ def test_constructor_freq_mult(self):
with tm.assert_raises_regex(ValueError, msg):
period_range('2011-01', periods=3, freq='0M')
- def test_constructor_freq_mult_dti_compat(self):
- import itertools
- mults = [1, 2, 3, 4, 5]
- freqs = ['A', 'M', 'D', 'T', 'S']
- for mult, freq in itertools.product(mults, freqs):
- freqstr = str(mult) + freq
- pidx = PeriodIndex(start='2014-04-01', freq=freqstr, periods=10)
- expected = date_range(start='2014-04-01', freq=freqstr,
- periods=10).to_period(freqstr)
- tm.assert_index_equal(pidx, expected)
+ @pytest.mark.parametrize('freq', ['A', 'M', 'D', 'T', 'S'])
+ @pytest.mark.parametrize('mult', [1, 2, 3, 4, 5])
+ def test_constructor_freq_mult_dti_compat(self, mult, freq):
+ freqstr = str(mult) + freq
+ pidx = PeriodIndex(start='2014-04-01', freq=freqstr, periods=10)
+ expected = date_range(start='2014-04-01', freq=freqstr,
+ periods=10).to_period(freqstr)
+ tm.assert_index_equal(pidx, expected)
def test_constructor_freq_combined(self):
for freq in ['1D1H', '1H1D']:
@@ -445,11 +443,12 @@ def test_constructor_error(self):
with tm.assert_raises_regex(ValueError, msg):
PeriodIndex(start=start)
- def test_recreate_from_data(self):
- for o in ['M', 'Q', 'A', 'D', 'B', 'T', 'S', 'L', 'U', 'N', 'H']:
- org = PeriodIndex(start='2001/04/01', freq=o, periods=1)
- idx = PeriodIndex(org.values, freq=o)
- tm.assert_index_equal(idx, org)
+ @pytest.mark.parametrize('freq', ['M', 'Q', 'A', 'D', 'B',
+ 'T', 'S', 'L', 'U', 'N', 'H'])
+ def test_recreate_from_data(self, freq):
+ org = PeriodIndex(start='2001/04/01', freq=freq, periods=1)
+ idx = PeriodIndex(org.values, freq=freq)
+ tm.assert_index_equal(idx, org)
def test_map_with_string_constructor(self):
raw = [2005, 2007, 2009]
diff --git a/pandas/tests/indexes/period/test_ops.py b/pandas/tests/indexes/period/test_ops.py
index 3b6641bc7ad5c..7d117b0b626cf 100644
--- a/pandas/tests/indexes/period/test_ops.py
+++ b/pandas/tests/indexes/period/test_ops.py
@@ -1,5 +1,6 @@
import numpy as np
+import pytest
import pandas as pd
import pandas._libs.tslib as tslib
@@ -368,37 +369,37 @@ def test_nat(self):
tm.assert_numpy_array_equal(idx._nan_idxs,
np.array([1], dtype=np.intp))
- def test_equals(self):
- # GH 13107
- for freq in ['D', 'M']:
- idx = pd.PeriodIndex(['2011-01-01', '2011-01-02', 'NaT'],
- freq=freq)
- assert idx.equals(idx)
- assert idx.equals(idx.copy())
- assert idx.equals(idx.astype(object))
- assert idx.astype(object).equals(idx)
- assert idx.astype(object).equals(idx.astype(object))
- assert not idx.equals(list(idx))
- assert not idx.equals(pd.Series(idx))
-
- idx2 = pd.PeriodIndex(['2011-01-01', '2011-01-02', 'NaT'],
- freq='H')
- assert not idx.equals(idx2)
- assert not idx.equals(idx2.copy())
- assert not idx.equals(idx2.astype(object))
- assert not idx.astype(object).equals(idx2)
- assert not idx.equals(list(idx2))
- assert not idx.equals(pd.Series(idx2))
-
- # same internal, different tz
- idx3 = pd.PeriodIndex._simple_new(idx.asi8, freq='H')
- tm.assert_numpy_array_equal(idx.asi8, idx3.asi8)
- assert not idx.equals(idx3)
- assert not idx.equals(idx3.copy())
- assert not idx.equals(idx3.astype(object))
- assert not idx.astype(object).equals(idx3)
- assert not idx.equals(list(idx3))
- assert not idx.equals(pd.Series(idx3))
+ @pytest.mark.parametrize('freq', ['D', 'M'])
+ def test_equals(self, freq):
+ # GH#13107
+ idx = pd.PeriodIndex(['2011-01-01', '2011-01-02', 'NaT'],
+ freq=freq)
+ assert idx.equals(idx)
+ assert idx.equals(idx.copy())
+ assert idx.equals(idx.astype(object))
+ assert idx.astype(object).equals(idx)
+ assert idx.astype(object).equals(idx.astype(object))
+ assert not idx.equals(list(idx))
+ assert not idx.equals(pd.Series(idx))
+
+ idx2 = pd.PeriodIndex(['2011-01-01', '2011-01-02', 'NaT'],
+ freq='H')
+ assert not idx.equals(idx2)
+ assert not idx.equals(idx2.copy())
+ assert not idx.equals(idx2.astype(object))
+ assert not idx.astype(object).equals(idx2)
+ assert not idx.equals(list(idx2))
+ assert not idx.equals(pd.Series(idx2))
+
+ # same internal, different tz
+ idx3 = pd.PeriodIndex._simple_new(idx.asi8, freq='H')
+ tm.assert_numpy_array_equal(idx.asi8, idx3.asi8)
+ assert not idx.equals(idx3)
+ assert not idx.equals(idx3.copy())
+ assert not idx.equals(idx3.astype(object))
+ assert not idx.astype(object).equals(idx3)
+ assert not idx.equals(list(idx3))
+ assert not idx.equals(pd.Series(idx3))
class TestPeriodIndexSeriesMethods(object):
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index 4c0c865928031..dd437363cfc1d 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -27,11 +27,11 @@ def create_index(self):
def test_pickle_compat_construction(self):
pass
- def test_pickle_round_trip(self):
- for freq in ['D', 'M', 'A']:
- idx = PeriodIndex(['2016-05-16', 'NaT', NaT, np.NaN], freq=freq)
- result = tm.round_trip_pickle(idx)
- tm.assert_index_equal(result, idx)
+ @pytest.mark.parametrize('freq', ['D', 'M', 'A'])
+ def test_pickle_round_trip(self, freq):
+ idx = PeriodIndex(['2016-05-16', 'NaT', NaT, np.NaN], freq=freq)
+ result = tm.round_trip_pickle(idx)
+ tm.assert_index_equal(result, idx)
@pytest.mark.parametrize('klass', [list, tuple, np.array, Series])
def test_where(self, klass):
diff --git a/pandas/tests/indexes/period/test_setops.py b/pandas/tests/indexes/period/test_setops.py
index 1ac05f9fa94b7..ec0836dfa174b 100644
--- a/pandas/tests/indexes/period/test_setops.py
+++ b/pandas/tests/indexes/period/test_setops.py
@@ -14,24 +14,21 @@ def _permute(obj):
class TestPeriodIndex(object):
- def setup_method(self, method):
- pass
-
- def test_joins(self):
+ @pytest.mark.parametrize('kind', ['inner', 'outer', 'left', 'right'])
+ def test_joins(self, kind):
index = period_range('1/1/2000', '1/20/2000', freq='D')
- for kind in ['inner', 'outer', 'left', 'right']:
- joined = index.join(index[:-5], how=kind)
+ joined = index.join(index[:-5], how=kind)
- assert isinstance(joined, PeriodIndex)
- assert joined.freq == index.freq
+ assert isinstance(joined, PeriodIndex)
+ assert joined.freq == index.freq
- def test_join_self(self):
+ @pytest.mark.parametrize('kind', ['inner', 'outer', 'left', 'right'])
+ def test_join_self(self, kind):
index = period_range('1/1/2000', '1/20/2000', freq='D')
- for kind in ['inner', 'outer', 'left', 'right']:
- res = index.join(index, how=kind)
- assert index is res
+ res = index.join(index, how=kind)
+ assert index is res
def test_join_does_not_recur(self):
df = tm.makeCustomDataframe(
diff --git a/pandas/tests/indexes/period/test_tools.py b/pandas/tests/indexes/period/test_tools.py
index 97500f2f5ed95..38c6f257b2206 100644
--- a/pandas/tests/indexes/period/test_tools.py
+++ b/pandas/tests/indexes/period/test_tools.py
@@ -1,5 +1,6 @@
import numpy as np
from datetime import datetime, timedelta
+import pytest
import pandas as pd
import pandas.util.testing as tm
@@ -29,32 +30,10 @@ def test_annual(self):
def test_monthly(self):
self._check_freq('M', '1970-01')
- def test_weekly(self):
- self._check_freq('W-THU', '1970-01-01')
-
- def test_daily(self):
- self._check_freq('D', '1970-01-01')
-
- def test_business_daily(self):
- self._check_freq('B', '1970-01-01')
-
- def test_hourly(self):
- self._check_freq('H', '1970-01-01')
-
- def test_minutely(self):
- self._check_freq('T', '1970-01-01')
-
- def test_secondly(self):
- self._check_freq('S', '1970-01-01')
-
- def test_millisecondly(self):
- self._check_freq('L', '1970-01-01')
-
- def test_microsecondly(self):
- self._check_freq('U', '1970-01-01')
-
- def test_nanosecondly(self):
- self._check_freq('N', '1970-01-01')
+ @pytest.mark.parametrize('freq', ['W-THU', 'D', 'B', 'H', 'T',
+ 'S', 'L', 'U', 'N'])
+ def test_freq(self, freq):
+ self._check_freq(freq, '1970-01-01')
def test_negone_ordinals(self):
freqs = ['A', 'M', 'Q', 'D', 'H', 'T', 'S']
@@ -75,19 +54,6 @@ def test_negone_ordinals(self):
class TestPeriodIndex(object):
-
- def setup_method(self, method):
- pass
-
- def test_tolist(self):
- index = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
- rs = index.tolist()
- for x in rs:
- assert isinstance(x, Period)
-
- recon = PeriodIndex(rs)
- tm.assert_index_equal(index, recon)
-
def test_to_timestamp(self):
index = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
series = Series(1, index=index, name='foo')
@@ -129,24 +95,6 @@ def _get_with_delta(delta, freq='A-DEC'):
tm.assert_index_equal(result.index, exp_index)
assert result.name == 'foo'
- def test_to_timestamp_quarterly_bug(self):
- years = np.arange(1960, 2000).repeat(4)
- quarters = np.tile(lrange(1, 5), 40)
-
- pindex = PeriodIndex(year=years, quarter=quarters)
-
- stamps = pindex.to_timestamp('D', 'end')
- expected = DatetimeIndex([x.to_timestamp('D', 'end') for x in pindex])
- tm.assert_index_equal(stamps, expected)
-
- def test_to_timestamp_preserve_name(self):
- index = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009',
- name='foo')
- assert index.name == 'foo'
-
- conv = index.to_timestamp('D')
- assert conv.name == 'foo'
-
def test_to_timestamp_repr_is_code(self):
zs = [Timestamp('99-04-17 00:00:00', tz='UTC'),
Timestamp('2001-04-17 00:00:00', tz='UTC'),
@@ -155,57 +103,6 @@ def test_to_timestamp_repr_is_code(self):
for z in zs:
assert eval(repr(z)) == z
- def test_to_timestamp_pi_nat(self):
- # GH 7228
- index = PeriodIndex(['NaT', '2011-01', '2011-02'], freq='M',
- name='idx')
-
- result = index.to_timestamp('D')
- expected = DatetimeIndex([pd.NaT, datetime(2011, 1, 1),
- datetime(2011, 2, 1)], name='idx')
- tm.assert_index_equal(result, expected)
- assert result.name == 'idx'
-
- result2 = result.to_period(freq='M')
- tm.assert_index_equal(result2, index)
- assert result2.name == 'idx'
-
- result3 = result.to_period(freq='3M')
- exp = PeriodIndex(['NaT', '2011-01', '2011-02'], freq='3M', name='idx')
- tm.assert_index_equal(result3, exp)
- assert result3.freqstr == '3M'
-
- msg = ('Frequency must be positive, because it'
- ' represents span: -2A')
- with tm.assert_raises_regex(ValueError, msg):
- result.to_period(freq='-2A')
-
- def test_to_timestamp_pi_mult(self):
- idx = PeriodIndex(['2011-01', 'NaT', '2011-02'], freq='2M', name='idx')
- result = idx.to_timestamp()
- expected = DatetimeIndex(
- ['2011-01-01', 'NaT', '2011-02-01'], name='idx')
- tm.assert_index_equal(result, expected)
- result = idx.to_timestamp(how='E')
- expected = DatetimeIndex(
- ['2011-02-28', 'NaT', '2011-03-31'], name='idx')
- tm.assert_index_equal(result, expected)
-
- def test_to_timestamp_pi_combined(self):
- idx = PeriodIndex(start='2011', periods=2, freq='1D1H', name='idx')
- result = idx.to_timestamp()
- expected = DatetimeIndex(
- ['2011-01-01 00:00', '2011-01-02 01:00'], name='idx')
- tm.assert_index_equal(result, expected)
- result = idx.to_timestamp(how='E')
- expected = DatetimeIndex(
- ['2011-01-02 00:59:59', '2011-01-03 01:59:59'], name='idx')
- tm.assert_index_equal(result, expected)
- result = idx.to_timestamp(how='E', freq='H')
- expected = DatetimeIndex(
- ['2011-01-02 00:00', '2011-01-03 01:00'], name='idx')
- tm.assert_index_equal(result, expected)
-
def test_to_timestamp_to_period_astype(self):
idx = DatetimeIndex([pd.NaT, '2011-01-01', '2011-02-01'], name='idx')
@@ -238,47 +135,26 @@ def test_dti_to_period(self):
tm.assert_index_equal(pi3, period_range('1/1/2005', '11/1/2005',
freq='M').asfreq('3D'))
- def test_period_astype_to_timestamp(self):
- pi = pd.PeriodIndex(['2011-01', '2011-02', '2011-03'], freq='M')
-
- exp = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'])
- tm.assert_index_equal(pi.astype('datetime64[ns]'), exp)
-
- exp = pd.DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31'])
- tm.assert_index_equal(pi.astype('datetime64[ns]', how='end'), exp)
-
- exp = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
- tz='US/Eastern')
- res = pi.astype('datetime64[ns, US/Eastern]')
- tm.assert_index_equal(pi.astype('datetime64[ns, US/Eastern]'), exp)
-
- exp = pd.DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31'],
- tz='US/Eastern')
- res = pi.astype('datetime64[ns, US/Eastern]', how='end')
- tm.assert_index_equal(res, exp)
-
- def test_to_period_quarterly(self):
+ @pytest.mark.parametrize('month', MONTHS)
+ def test_to_period_quarterly(self, month):
# make sure we can make the round trip
- for month in MONTHS:
- freq = 'Q-%s' % month
- rng = period_range('1989Q3', '1991Q3', freq=freq)
- stamps = rng.to_timestamp()
- result = stamps.to_period(freq)
- tm.assert_index_equal(rng, result)
-
- def test_to_period_quarterlyish(self):
- offsets = ['BQ', 'QS', 'BQS']
- for off in offsets:
- rng = date_range('01-Jan-2012', periods=8, freq=off)
- prng = rng.to_period()
- assert prng.freq == 'Q-DEC'
+ freq = 'Q-%s' % month
+ rng = period_range('1989Q3', '1991Q3', freq=freq)
+ stamps = rng.to_timestamp()
+ result = stamps.to_period(freq)
+ tm.assert_index_equal(rng, result)
+
+ @pytest.mark.parametrize('off', ['BQ', 'QS', 'BQS'])
+ def test_to_period_quarterlyish(self, off):
+ rng = date_range('01-Jan-2012', periods=8, freq=off)
+ prng = rng.to_period()
+ assert prng.freq == 'Q-DEC'
- def test_to_period_annualish(self):
- offsets = ['BA', 'AS', 'BAS']
- for off in offsets:
- rng = date_range('01-Jan-2012', periods=8, freq=off)
- prng = rng.to_period()
- assert prng.freq == 'A-DEC'
+ @pytest.mark.parametrize('off', ['BA', 'AS', 'BAS'])
+ def test_to_period_annualish(self, off):
+ rng = date_range('01-Jan-2012', periods=8, freq=off)
+ prng = rng.to_period()
+ assert prng.freq == 'A-DEC'
def test_to_period_monthish(self):
offsets = ['MS', 'BM']
@@ -304,12 +180,6 @@ def test_period_dt64_round_trip(self):
pi = dti.to_period(freq='H')
tm.assert_index_equal(pi.to_timestamp(), dti)
- def test_to_timestamp_1703(self):
- index = period_range('1/1/2012', periods=4, freq='D')
-
- result = index.to_timestamp()
- assert result[0] == Timestamp('1/1/2012')
-
def test_combine_first(self):
# GH 3367
didx = pd.DatetimeIndex(start='1950-01-31', end='1950-07-31', freq='M')
@@ -325,26 +195,137 @@ def test_combine_first(self):
dtype=np.float64)
tm.assert_series_equal(result, expected)
- def test_searchsorted(self):
- for freq in ['D', '2D']:
- pidx = pd.PeriodIndex(['2014-01-01', '2014-01-02', '2014-01-03',
- '2014-01-04', '2014-01-05'], freq=freq)
+ @pytest.mark.parametrize('freq', ['D', '2D'])
+ def test_searchsorted(self, freq):
+ pidx = pd.PeriodIndex(['2014-01-01', '2014-01-02', '2014-01-03',
+ '2014-01-04', '2014-01-05'], freq=freq)
+
+ p1 = pd.Period('2014-01-01', freq=freq)
+ assert pidx.searchsorted(p1) == 0
+
+ p2 = pd.Period('2014-01-04', freq=freq)
+ assert pidx.searchsorted(p2) == 3
+
+ msg = "Input has different freq=H from PeriodIndex"
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ pidx.searchsorted(pd.Period('2014-01-01', freq='H'))
+
+ msg = "Input has different freq=5D from PeriodIndex"
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ pidx.searchsorted(pd.Period('2014-01-01', freq='5D'))
+
+ with tm.assert_produces_warning(FutureWarning):
+ pidx.searchsorted(key=p2)
+
+
+class TestPeriodIndexConversion(object):
+ def test_tolist(self):
+ index = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
+ rs = index.tolist()
+ for x in rs:
+ assert isinstance(x, Period)
+
+ recon = PeriodIndex(rs)
+ tm.assert_index_equal(index, recon)
+
+ def test_to_timestamp_pi_nat(self):
+ # GH#7228
+ index = PeriodIndex(['NaT', '2011-01', '2011-02'], freq='M',
+ name='idx')
+
+ result = index.to_timestamp('D')
+ expected = DatetimeIndex([pd.NaT, datetime(2011, 1, 1),
+ datetime(2011, 2, 1)], name='idx')
+ tm.assert_index_equal(result, expected)
+ assert result.name == 'idx'
+
+ result2 = result.to_period(freq='M')
+ tm.assert_index_equal(result2, index)
+ assert result2.name == 'idx'
+
+ result3 = result.to_period(freq='3M')
+ exp = PeriodIndex(['NaT', '2011-01', '2011-02'],
+ freq='3M', name='idx')
+ tm.assert_index_equal(result3, exp)
+ assert result3.freqstr == '3M'
+
+ msg = ('Frequency must be positive, because it'
+ ' represents span: -2A')
+ with tm.assert_raises_regex(ValueError, msg):
+ result.to_period(freq='-2A')
+
+ def test_to_timestamp_preserve_name(self):
+ index = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009',
+ name='foo')
+ assert index.name == 'foo'
+
+ conv = index.to_timestamp('D')
+ assert conv.name == 'foo'
+
+ def test_to_timestamp_quarterly_bug(self):
+ years = np.arange(1960, 2000).repeat(4)
+ quarters = np.tile(lrange(1, 5), 40)
+
+ pindex = PeriodIndex(year=years, quarter=quarters)
+
+ stamps = pindex.to_timestamp('D', 'end')
+ expected = DatetimeIndex([x.to_timestamp('D', 'end') for x in pindex])
+ tm.assert_index_equal(stamps, expected)
+
+ def test_to_timestamp_pi_mult(self):
+ idx = PeriodIndex(['2011-01', 'NaT', '2011-02'],
+ freq='2M', name='idx')
+
+ result = idx.to_timestamp()
+ expected = DatetimeIndex(['2011-01-01', 'NaT', '2011-02-01'],
+ name='idx')
+ tm.assert_index_equal(result, expected)
- p1 = pd.Period('2014-01-01', freq=freq)
- assert pidx.searchsorted(p1) == 0
+ result = idx.to_timestamp(how='E')
+ expected = DatetimeIndex(['2011-02-28', 'NaT', '2011-03-31'],
+ name='idx')
+ tm.assert_index_equal(result, expected)
- p2 = pd.Period('2014-01-04', freq=freq)
- assert pidx.searchsorted(p2) == 3
+ def test_to_timestamp_pi_combined(self):
+ idx = PeriodIndex(start='2011', periods=2, freq='1D1H', name='idx')
- msg = "Input has different freq=H from PeriodIndex"
- with tm.assert_raises_regex(
- period.IncompatibleFrequency, msg):
- pidx.searchsorted(pd.Period('2014-01-01', freq='H'))
+ result = idx.to_timestamp()
+ expected = DatetimeIndex(['2011-01-01 00:00', '2011-01-02 01:00'],
+ name='idx')
+ tm.assert_index_equal(result, expected)
- msg = "Input has different freq=5D from PeriodIndex"
- with tm.assert_raises_regex(
- period.IncompatibleFrequency, msg):
- pidx.searchsorted(pd.Period('2014-01-01', freq='5D'))
+ result = idx.to_timestamp(how='E')
+ expected = DatetimeIndex(['2011-01-02 00:59:59',
+ '2011-01-03 01:59:59'],
+ name='idx')
+ tm.assert_index_equal(result, expected)
- with tm.assert_produces_warning(FutureWarning):
- pidx.searchsorted(key=p2)
+ result = idx.to_timestamp(how='E', freq='H')
+ expected = DatetimeIndex(['2011-01-02 00:00', '2011-01-03 01:00'],
+ name='idx')
+ tm.assert_index_equal(result, expected)
+
+ def test_period_astype_to_timestamp(self):
+ pi = pd.PeriodIndex(['2011-01', '2011-02', '2011-03'], freq='M')
+
+ exp = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'])
+ tm.assert_index_equal(pi.astype('datetime64[ns]'), exp)
+
+ exp = pd.DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31'])
+ tm.assert_index_equal(pi.astype('datetime64[ns]', how='end'), exp)
+
+ exp = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
+ tz='US/Eastern')
+ res = pi.astype('datetime64[ns, US/Eastern]')
+ tm.assert_index_equal(pi.astype('datetime64[ns, US/Eastern]'), exp)
+
+ exp = pd.DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31'],
+ tz='US/Eastern')
+ res = pi.astype('datetime64[ns, US/Eastern]', how='end')
+ tm.assert_index_equal(res, exp)
+
+ def test_to_timestamp_1703(self):
+ index = period_range('1/1/2012', periods=4, freq='D')
+
+ result = index.to_timestamp()
+ assert result[0] == Timestamp('1/1/2012')
diff --git a/pandas/tests/indexes/timedeltas/test_arithmetic.py b/pandas/tests/indexes/timedeltas/test_arithmetic.py
index 3dc60ed33b958..19d1a2ec98209 100644
--- a/pandas/tests/indexes/timedeltas/test_arithmetic.py
+++ b/pandas/tests/indexes/timedeltas/test_arithmetic.py
@@ -654,19 +654,19 @@ def test_dti_tdi_numeric_ops(self):
expected = DatetimeIndex(['20121231', pd.NaT, '20130101'])
tm.assert_index_equal(result, expected)
- def test_sub_period(self):
+ @pytest.mark.parametrize('freq', [None, 'H'])
+ def test_sub_period(self, freq):
# GH 13078
# not supported, check TypeError
p = pd.Period('2011-01-01', freq='D')
- for freq in [None, 'H']:
- idx = pd.TimedeltaIndex(['1 hours', '2 hours'], freq=freq)
+ idx = pd.TimedeltaIndex(['1 hours', '2 hours'], freq=freq)
- with pytest.raises(TypeError):
- idx - p
+ with pytest.raises(TypeError):
+ idx - p
- with pytest.raises(TypeError):
- p - idx
+ with pytest.raises(TypeError):
+ p - idx
def test_addition_ops(self):
# with datetimes/timedelta and tdi/dti
diff --git a/pandas/tests/indexes/timedeltas/test_ops.py b/pandas/tests/indexes/timedeltas/test_ops.py
index 690ba66b6f5ef..49737e5359c2f 100644
--- a/pandas/tests/indexes/timedeltas/test_ops.py
+++ b/pandas/tests/indexes/timedeltas/test_ops.py
@@ -227,14 +227,15 @@ def test_drop_duplicates(self):
res = Series(idx).drop_duplicates(keep=False)
tm.assert_series_equal(res, Series(base[5:], index=np.arange(5, 31)))
- def test_infer_freq(self):
- # GH 11018
- for freq in ['D', '3D', '-3D', 'H', '2H', '-2H', 'T', '2T', 'S', '-3S'
- ]:
- idx = pd.timedelta_range('1', freq=freq, periods=10)
- result = pd.TimedeltaIndex(idx.asi8, freq='infer')
- tm.assert_index_equal(idx, result)
- assert result.freq == freq
+ @pytest.mark.parametrize('freq', ['D', '3D', '-3D',
+ 'H', '2H', '-2H',
+ 'T', '2T', 'S', '-3S'])
+ def test_infer_freq(self, freq):
+ # GH#11018
+ idx = pd.timedelta_range('1', freq=freq, periods=10)
+ result = pd.TimedeltaIndex(idx.asi8, freq='infer')
+ tm.assert_index_equal(idx, result)
+ assert result.freq == freq
def test_nat_new(self):
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta.py b/pandas/tests/indexes/timedeltas/test_timedelta.py
index ce0f3b89b753e..37db9d704aa1f 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta.py
@@ -102,13 +102,11 @@ def test_factorize(self):
tm.assert_numpy_array_equal(arr, exp_arr)
tm.assert_index_equal(idx, idx3)
- def test_join_self(self):
-
+ @pytest.mark.parametrize('kind', ['outer', 'inner', 'left', 'right'])
+ def test_join_self(self, kind):
index = timedelta_range('1 day', periods=10)
- kinds = 'outer', 'inner', 'left', 'right'
- for kind in kinds:
- joined = index.join(index, how=kind)
- tm.assert_index_equal(index, joined)
+ joined = index.join(index, how=kind)
+ tm.assert_index_equal(index, joined)
def test_does_not_convert_mixed_integer(self):
df = tm.makeCustomDataframe(10, 10,
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index 41b3bb55bfff1..dff5433adcf79 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -20,21 +20,21 @@
class TestPeriodProperties(object):
"Test properties such as year, month, weekday, etc...."
- def test_is_leap_year(self):
+ @pytest.mark.parametrize('freq', ['A', 'M', 'D', 'H'])
+ def test_is_leap_year(self, freq):
# GH 13727
- for freq in ['A', 'M', 'D', 'H']:
- p = Period('2000-01-01 00:00:00', freq=freq)
- assert p.is_leap_year
- assert isinstance(p.is_leap_year, bool)
+ p = Period('2000-01-01 00:00:00', freq=freq)
+ assert p.is_leap_year
+ assert isinstance(p.is_leap_year, bool)
- p = Period('1999-01-01 00:00:00', freq=freq)
- assert not p.is_leap_year
+ p = Period('1999-01-01 00:00:00', freq=freq)
+ assert not p.is_leap_year
- p = Period('2004-01-01 00:00:00', freq=freq)
- assert p.is_leap_year
+ p = Period('2004-01-01 00:00:00', freq=freq)
+ assert p.is_leap_year
- p = Period('2100-01-01 00:00:00', freq=freq)
- assert not p.is_leap_year
+ p = Period('2100-01-01 00:00:00', freq=freq)
+ assert not p.is_leap_year
def test_quarterly_negative_ordinals(self):
p = Period(ordinal=-1, freq='Q-DEC')
@@ -52,40 +52,40 @@ def test_quarterly_negative_ordinals(self):
assert p.month == 11
assert isinstance(p, Period)
- def test_period_cons_quarterly(self):
+ @pytest.mark.parametrize('month', MONTHS)
+ def test_period_cons_quarterly(self, month):
# bugs in scikits.timeseries
- for month in MONTHS:
- freq = 'Q-%s' % month
- exp = Period('1989Q3', freq=freq)
- assert '1989Q3' in str(exp)
- stamp = exp.to_timestamp('D', how='end')
- p = Period(stamp, freq=freq)
- assert p == exp
-
- stamp = exp.to_timestamp('3D', how='end')
- p = Period(stamp, freq=freq)
- assert p == exp
-
- def test_period_cons_annual(self):
+ freq = 'Q-%s' % month
+ exp = Period('1989Q3', freq=freq)
+ assert '1989Q3' in str(exp)
+ stamp = exp.to_timestamp('D', how='end')
+ p = Period(stamp, freq=freq)
+ assert p == exp
+
+ stamp = exp.to_timestamp('3D', how='end')
+ p = Period(stamp, freq=freq)
+ assert p == exp
+
+ @pytest.mark.parametrize('month', MONTHS)
+ def test_period_cons_annual(self, month):
# bugs in scikits.timeseries
- for month in MONTHS:
- freq = 'A-%s' % month
- exp = Period('1989', freq=freq)
- stamp = exp.to_timestamp('D', how='end') + timedelta(days=30)
- p = Period(stamp, freq=freq)
- assert p == exp + 1
- assert isinstance(p, Period)
-
- def test_period_cons_weekly(self):
- for num in range(10, 17):
- daystr = '2011-02-%d' % num
- for day in DAYS:
- freq = 'W-%s' % day
-
- result = Period(daystr, freq=freq)
- expected = Period(daystr, freq='D').asfreq(freq)
- assert result == expected
- assert isinstance(result, Period)
+ freq = 'A-%s' % month
+ exp = Period('1989', freq=freq)
+ stamp = exp.to_timestamp('D', how='end') + timedelta(days=30)
+ p = Period(stamp, freq=freq)
+ assert p == exp + 1
+ assert isinstance(p, Period)
+
+ @pytest.mark.parametrize('day', DAYS)
+ @pytest.mark.parametrize('num', range(10, 17))
+ def test_period_cons_weekly(self, num, day):
+ daystr = '2011-02-%d' % num
+ freq = 'W-%s' % day
+
+ result = Period(daystr, freq=freq)
+ expected = Period(daystr, freq='D').asfreq(freq)
+ assert result == expected
+ assert isinstance(result, Period)
def test_period_from_ordinal(self):
p = pd.Period('2011-01', freq='M')
@@ -212,58 +212,59 @@ def test_period_cons_combined(self):
with tm.assert_raises_regex(ValueError, msg):
Period('2011-01', freq='1D1W')
- def test_timestamp_tz_arg(self):
- for case in ['Europe/Brussels', 'Asia/Tokyo', 'US/Pacific']:
- p = Period('1/1/2005', freq='M').to_timestamp(tz=case)
- exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)
- exp_zone = pytz.timezone(case).normalize(p)
-
- assert p == exp
- assert p.tz == exp_zone.tzinfo
- assert p.tz == exp.tz
-
- p = Period('1/1/2005', freq='3H').to_timestamp(tz=case)
- exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)
- exp_zone = pytz.timezone(case).normalize(p)
-
- assert p == exp
- assert p.tz == exp_zone.tzinfo
- assert p.tz == exp.tz
-
- p = Period('1/1/2005', freq='A').to_timestamp(freq='A', tz=case)
- exp = Timestamp('31/12/2005', tz='UTC').tz_convert(case)
- exp_zone = pytz.timezone(case).normalize(p)
-
- assert p == exp
- assert p.tz == exp_zone.tzinfo
- assert p.tz == exp.tz
-
- p = Period('1/1/2005', freq='A').to_timestamp(freq='3H', tz=case)
- exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)
- exp_zone = pytz.timezone(case).normalize(p)
-
- assert p == exp
- assert p.tz == exp_zone.tzinfo
- assert p.tz == exp.tz
-
- def test_timestamp_tz_arg_dateutil(self):
+ @pytest.mark.parametrize('tzstr', ['Europe/Brussels',
+ 'Asia/Tokyo', 'US/Pacific'])
+ def test_timestamp_tz_arg(self, tzstr):
+ p = Period('1/1/2005', freq='M').to_timestamp(tz=tzstr)
+ exp = Timestamp('1/1/2005', tz='UTC').tz_convert(tzstr)
+ exp_zone = pytz.timezone(tzstr).normalize(p)
+
+ assert p == exp
+ assert p.tz == exp_zone.tzinfo
+ assert p.tz == exp.tz
+
+ p = Period('1/1/2005', freq='3H').to_timestamp(tz=tzstr)
+ exp = Timestamp('1/1/2005', tz='UTC').tz_convert(tzstr)
+ exp_zone = pytz.timezone(tzstr).normalize(p)
+
+ assert p == exp
+ assert p.tz == exp_zone.tzinfo
+ assert p.tz == exp.tz
+
+ p = Period('1/1/2005', freq='A').to_timestamp(freq='A', tz=tzstr)
+ exp = Timestamp('31/12/2005', tz='UTC').tz_convert(tzstr)
+ exp_zone = pytz.timezone(tzstr).normalize(p)
+
+ assert p == exp
+ assert p.tz == exp_zone.tzinfo
+ assert p.tz == exp.tz
+
+ p = Period('1/1/2005', freq='A').to_timestamp(freq='3H', tz=tzstr)
+ exp = Timestamp('1/1/2005', tz='UTC').tz_convert(tzstr)
+ exp_zone = pytz.timezone(tzstr).normalize(p)
+
+ assert p == exp
+ assert p.tz == exp_zone.tzinfo
+ assert p.tz == exp.tz
+
+ @pytest.mark.parametrize('tzstr', ['dateutil/Europe/Brussels',
+ 'dateutil/Asia/Tokyo',
+ 'dateutil/US/Pacific'])
+ def test_timestamp_tz_arg_dateutil(self, tzstr):
from pandas._libs.tslibs.timezones import dateutil_gettz
from pandas._libs.tslibs.timezones import maybe_get_tz
- for case in ['dateutil/Europe/Brussels', 'dateutil/Asia/Tokyo',
- 'dateutil/US/Pacific']:
- p = Period('1/1/2005', freq='M').to_timestamp(
- tz=maybe_get_tz(case))
- exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)
- assert p == exp
- assert p.tz == dateutil_gettz(case.split('/', 1)[1])
- assert p.tz == exp.tz
-
- p = Period('1/1/2005',
- freq='M').to_timestamp(freq='3H', tz=maybe_get_tz(case))
- exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)
- assert p == exp
- assert p.tz == dateutil_gettz(case.split('/', 1)[1])
- assert p.tz == exp.tz
+ tz = maybe_get_tz(tzstr)
+ p = Period('1/1/2005', freq='M').to_timestamp(tz=tz)
+ exp = Timestamp('1/1/2005', tz='UTC').tz_convert(tzstr)
+ assert p == exp
+ assert p.tz == dateutil_gettz(tzstr.split('/', 1)[1])
+ assert p.tz == exp.tz
+
+ p = Period('1/1/2005', freq='M').to_timestamp(freq='3H', tz=tz)
+ exp = Timestamp('1/1/2005', tz='UTC').tz_convert(tzstr)
+ assert p == exp
+ assert p.tz == dateutil_gettz(tzstr.split('/', 1)[1])
+ assert p.tz == exp.tz
def test_timestamp_tz_arg_dateutil_from_string(self):
from pandas._libs.tslibs.timezones import dateutil_gettz
@@ -1403,14 +1404,14 @@ def test_sub_offset_nat(self):
timedelta(hours=23, minutes=30)]:
assert p - o is tslib.NaT
- def test_nat_ops(self):
- for freq in ['M', '2M', '3M']:
- p = Period('NaT', freq=freq)
- assert p + 1 is tslib.NaT
- assert 1 + p is tslib.NaT
- assert p - 1 is tslib.NaT
- assert p - Period('2011-01', freq=freq) is tslib.NaT
- assert Period('2011-01', freq=freq) - p is tslib.NaT
+ @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
+ def test_nat_ops(self, freq):
+ p = Period('NaT', freq=freq)
+ assert p + 1 is tslib.NaT
+ assert 1 + p is tslib.NaT
+ assert p - 1 is tslib.NaT
+ assert p - Period('2011-01', freq=freq) is tslib.NaT
+ assert Period('2011-01', freq=freq) - p is tslib.NaT
def test_period_ops_offset(self):
p = Period('2011-04-01', freq='D')
| What it says on the tin. Because this is a big diff, nothing is moved or changed other than parametrizing tests. | https://api.github.com/repos/pandas-dev/pandas/pulls/19785 | 2018-02-20T06:06:59Z | 2018-02-22T00:11:32Z | 2018-02-22T00:11:32Z | 2018-06-22T03:23:57Z |
DOC: correct Series.searchsorted example | diff --git a/pandas/core/base.py b/pandas/core/base.py
index 0ca029ffd4c25..ebd69a5f9aac1 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -1165,21 +1165,16 @@ def factorize(self, sort=False, na_sentinel=-1):
>>> x.searchsorted([1, 3], side='right')
array([1, 3])
- >>> x = pd.Categorical(['apple', 'bread', 'bread', 'cheese', 'milk' ])
+ >>> x = pd.Categorical(['apple', 'bread', 'bread',
+ 'cheese', 'milk'], ordered=True)
[apple, bread, bread, cheese, milk]
Categories (4, object): [apple < bread < cheese < milk]
>>> x.searchsorted('bread')
array([1]) # Note: an array, not a scalar
- >>> x.searchsorted(['bread'])
- array([1])
-
- >>> x.searchsorted(['bread', 'eggs'])
- array([1, 4])
-
- >>> x.searchsorted(['bread', 'eggs'], side='right')
- array([3, 4]) # eggs before milk
+ >>> x.searchsorted(['bread'], side='right')
+ array([3])
""")
@Substitution(klass='IndexOpsMixin')
| two major changes:
- categories must be ordered using series.searchsorted.
- delete last two exsamples because of `ValueError: Value(s) to be inserted must be in categories`.
- [ ] 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/19784 | 2018-02-20T05:04:00Z | 2018-02-21T10:38:42Z | 2018-02-21T10:38:42Z | 2018-02-21T14:04:57Z |
BUG: GH19458 fixes precision issue in TimeDelta.total_seconds() | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index f31d0a5a0667c..349d7607559c5 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -733,6 +733,7 @@ Datetimelike
- Bug in :func:`to_datetime` where passing an out-of-bounds datetime with ``errors='coerce'`` and ``utc=True`` would raise ``OutOfBoundsDatetime`` instead of parsing to ``NaT`` (:issue:`19612`)
- Bug in :func:`Timedelta.__add__`, :func:`Timedelta.__sub__` where adding or subtracting a ``np.timedelta64`` object would return another ``np.timedelta64`` instead of a ``Timedelta`` (:issue:`19738`)
- Bug in :func:`Timedelta.__floordiv__`, :func:`Timedelta.__rfloordiv__` where operating with a ``Tick`` object would raise a ``TypeError`` instead of returning a numeric value (:issue:`19738`)
+- Bug in :func:`Timedelta.total_seconds()` causing precision errors i.e. `Timedelta('30S').total_seconds()==30.000000000000004` (:issue:`19458`)
Timezones
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 4483225e1801d..78fdeb988e0f2 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -739,7 +739,7 @@ cdef class _Timedelta(timedelta):
"""
Total duration of timedelta in seconds (to ns precision)
"""
- return 1e-9 * self.value
+ return self.value / 1e9
def view(self, dtype):
""" array view compat """
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 0f7fb84c6520b..4257c610fb960 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -512,6 +512,15 @@ def test_implementation_limits(self):
with pytest.raises(OverflowError):
Timedelta(max_td.value + 1, 'ns')
+ def test_total_seconds_precision(self):
+ # GH 19458
+ assert Timedelta('30S').total_seconds() == 30.0
+ assert Timedelta('0').total_seconds() == 0.0
+ assert Timedelta('-2S').total_seconds() == -2.0
+ assert Timedelta('5.324S').total_seconds() == 5.324
+ assert (Timedelta('30S').total_seconds() - 30.0) < 1e-20
+ assert (30.0 - Timedelta('30S').total_seconds()) < 1e-20
+
def test_timedelta_arithmetic(self):
data = pd.Series(['nat', '32 days'], dtype='timedelta64[ns]')
deltas = [timedelta(days=1), Timedelta(1, unit='D')]
| - [X] closes #19458
- [X] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [X] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/19783 | 2018-02-20T04:01:37Z | 2018-02-20T11:20:47Z | 2018-02-20T11:20:46Z | 2018-02-20T12:10:09Z |
Sparse Ops Cleanup | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index b96af6af3707f..1aeda86c55eff 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3995,7 +3995,7 @@ def _combine_const(self, other, func, errors='raise', try_cast=True):
try_cast=try_cast)
return self._constructor(new_data)
- def _compare_frame(self, other, func, str_rep, try_cast=True):
+ def _compare_frame(self, other, func, str_rep):
# compare_frame assumes self._indexed_same(other)
import pandas.core.computation.expressions as expressions
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 4b543262fc485..41e499da8e008 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -928,7 +928,7 @@ def insert(self, loc, item):
def delete(self, loc):
"""
- Make a new DatetimeIndex with passed location(s) deleted.
+ Make a new TimedeltaIndex with passed location(s) deleted.
Parameters
----------
diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index da65f1f31ed2a..ad6102eb6ad0f 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -721,9 +721,7 @@ def add_flex_arithmetic_methods(cls, flex_arith_method, flex_comp_method=None):
subtract=new_methods['sub'],
divide=new_methods['div']))
# opt out of bool flex methods for now
- for k in ('ror_', 'rxor', 'rand_'):
- if k in new_methods:
- new_methods.pop(k)
+ assert not any(kname in new_methods for kname in ('ror_', 'rxor', 'rand_'))
add_methods(cls, new_methods=new_methods)
@@ -1080,19 +1078,19 @@ def na_op(x, y):
try:
result = lib.scalar_binop(x, y, op)
except:
- msg = ("cannot compare a dtyped [{dtype}] array "
- "with a scalar of type [{type}]"
- ).format(dtype=x.dtype, type=type(y).__name__)
- raise TypeError(msg)
+ raise TypeError("cannot compare a dtyped [{dtype}] array "
+ "with a scalar of type [{typ}]"
+ .format(dtype=x.dtype,
+ typ=type(y).__name__))
return result
+ fill_int = lambda x: x.fillna(0)
+ fill_bool = lambda x: x.fillna(False).astype(bool)
+
def wrapper(self, other):
is_self_int_dtype = is_integer_dtype(self.dtype)
- fill_int = lambda x: x.fillna(0)
- fill_bool = lambda x: x.fillna(False).astype(bool)
-
self, other = _align_method_SERIES(self, other, align_asobject=True)
if isinstance(other, ABCDataFrame):
@@ -1232,10 +1230,10 @@ def to_series(right):
elif right.ndim == 2:
if left.shape != right.shape:
- msg = ("Unable to coerce to DataFrame, shape "
- "must be {req_shape}: given {given_shape}"
- ).format(req_shape=left.shape, given_shape=right.shape)
- raise ValueError(msg)
+ raise ValueError("Unable to coerce to DataFrame, shape "
+ "must be {req_shape}: given {given_shape}"
+ .format(req_shape=left.shape,
+ given_shape=right.shape))
right = left._constructor(right, index=left.index,
columns=left.columns)
@@ -1293,8 +1291,8 @@ def na_op(x, y):
result[mask] = op(xrav, y)
else:
raise TypeError("cannot perform operation {op} between "
- "objects of type {x} and {y}".format(
- op=name, x=type(x), y=type(y)))
+ "objects of type {x} and {y}"
+ .format(op=name, x=type(x), y=type(y)))
result, changed = maybe_upcast_putmask(result, ~mask, np.nan)
result = result.reshape(x.shape)
@@ -1355,7 +1353,7 @@ def f(self, other, axis=default_axis, level=None):
if not self._indexed_same(other):
self, other = self.align(other, 'outer',
level=level, copy=False)
- return self._compare_frame(other, na_op, str_rep, try_cast=False)
+ return self._compare_frame(other, na_op, str_rep)
elif isinstance(other, ABCSeries):
return _combine_series_frame(self, other, na_op,
@@ -1380,7 +1378,7 @@ def f(self, other):
if not self._indexed_same(other):
raise ValueError('Can only compare identically-labeled '
'DataFrame objects')
- return self._compare_frame(other, func, str_rep, try_cast=True)
+ return self._compare_frame(other, func, str_rep)
elif isinstance(other, ABCSeries):
return _combine_series_frame(self, other, func,
@@ -1532,10 +1530,6 @@ def wrapper(self, other):
.format(other=type(other)))
wrapper.__name__ = name
- if name.startswith("__"):
- # strip special method names, e.g. `__add__` needs to be `add` when
- # passed to _sparse_series_op
- name = name[2:-2]
return wrapper
@@ -1568,7 +1562,7 @@ def wrapper(self, other):
dtype = getattr(other, 'dtype', None)
other = SparseArray(other, fill_value=self.fill_value,
dtype=dtype)
- return _sparse_array_op(self, other, op, name)
+ return _sparse_array_op(self, other, op, name, series=False)
elif is_scalar(other):
with np.errstate(all='ignore'):
fill = op(_get_fill(self), np.asarray(other))
@@ -1579,8 +1573,6 @@ def wrapper(self, other):
raise TypeError('operation with {other} not supported'
.format(other=type(other)))
- if name.startswith("__"):
- name = name[2:-2]
wrapper.__name__ = name
return wrapper
@@ -1591,4 +1583,5 @@ def wrapper(self, other):
sparse_series_special_funcs = dict(arith_method=_arith_method_SPARSE_SERIES,
comp_method=_arith_method_SPARSE_SERIES,
- bool_method=None)
+ bool_method=_bool_method_SERIES)
+# TODO: I don't think the functions defined by bool_method are tested
diff --git a/pandas/core/sparse/array.py b/pandas/core/sparse/array.py
index 4f7152666f7bf..92c4fe932f066 100644
--- a/pandas/core/sparse/array.py
+++ b/pandas/core/sparse/array.py
@@ -54,6 +54,9 @@ def _get_fill(arr):
def _sparse_array_op(left, right, op, name, series=False):
+ if name.startswith('__'):
+ # For lookups in _libs.sparse we need non-dunder op name
+ name = name[2:-2]
if series and is_integer_dtype(left) and is_integer_dtype(right):
# series coerces to float64 if result should have NaN/inf
@@ -119,6 +122,10 @@ def _sparse_array_op(left, right, op, name, series=False):
def _wrap_result(name, data, sparse_index, fill_value, dtype=None):
""" wrap op result to have correct dtype """
+ if name.startswith('__'):
+ # e.g. __eq__ --> eq
+ name = name[2:-2]
+
if name in ('eq', 'ne', 'lt', 'gt', 'le', 'ge'):
dtype = np.bool
diff --git a/pandas/core/sparse/frame.py b/pandas/core/sparse/frame.py
index 19b126216db81..872a17d8dbabe 100644
--- a/pandas/core/sparse/frame.py
+++ b/pandas/core/sparse/frame.py
@@ -551,7 +551,6 @@ def _combine_frame(self, other, func, fill_value=None, level=None):
return self._constructor(index=new_index).__finalize__(self)
new_data = {}
- new_fill_value = None
if fill_value is not None:
# TODO: be a bit more intelligent here
for col in new_columns:
@@ -568,6 +567,7 @@ def _combine_frame(self, other, func, fill_value=None, level=None):
new_data[col] = func(this[col], other[col])
# if the fill values are the same use them? or use a valid one
+ new_fill_value = None
other_fill_value = getattr(other, 'default_fill_value', np.nan)
if self.default_fill_value == other_fill_value:
new_fill_value = self.default_fill_value
diff --git a/pandas/core/sparse/series.py b/pandas/core/sparse/series.py
index 335a4c80adc63..26cf9dbadbbf2 100644
--- a/pandas/core/sparse/series.py
+++ b/pandas/core/sparse/series.py
@@ -811,10 +811,7 @@ def from_coo(cls, A, dense_index=False):
return _coo_to_sparse_series(A, dense_index=dense_index)
-# overwrite series methods with unaccelerated versions
-ops.add_special_arithmetic_methods(SparseSeries, **ops.series_special_funcs)
+# overwrite series methods with unaccelerated Sparse-specific versions
ops.add_flex_arithmetic_methods(SparseSeries, **ops.series_flex_funcs)
-# overwrite basic arithmetic to use SparseSeries version
-# force methods to overwrite previous definitions.
ops.add_special_arithmetic_methods(SparseSeries,
**ops.sparse_series_special_funcs)
| This is in preparation for implementing the direct-pinning discussed [here](https://github.com/pandas-dev/pandas/pull/19649#discussion_r167527010). The main roadblock to that is SparseSeries which calls ops.add_special_arithmetic_methods twice. This PR gets rid of the double-call, so the follow-up will be straight-forward.
A handful of cleanups are done here too:
- unrelated docstring fix for TimedeltaIndex.replace
- minor formatting improvements
- remove an unused kwarg for DataFrame._compare_frame
- remove a loop in add_flex_arithmetic_methods, replace with an assertion that it is unnecessary
- fix names for some SparseArray method names, e.g. ATM `SparseArray.__eq__.__name__ == 'eq'`
| https://api.github.com/repos/pandas-dev/pandas/pulls/19782 | 2018-02-20T03:14:27Z | 2018-02-21T00:15:57Z | 2018-02-21T00:15:57Z | 2018-02-21T00:18:17Z |
DOC: RangeIndex as default index | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index b96af6af3707f..b25dbe4fac6da 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -251,11 +251,11 @@ class DataFrame(NDFrame):
data : numpy ndarray (structured or homogeneous), dict, or DataFrame
Dict can contain Series, arrays, constants, or list-like objects
index : Index or array-like
- Index to use for resulting frame. Will default to np.arange(n) if
+ Index to use for resulting frame. Will default to RangeIndex if
no indexing information part of input data and no index provided
columns : Index or array-like
Column labels to use for resulting frame. Will default to
- np.arange(n) if no column labels are provided
+ RangeIndex (0, 1, 2, ..., n) if no column labels are provided
dtype : dtype, default None
Data type to force. Only a single dtype is allowed. If None, infer
copy : boolean, default False
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 90dc14836ab55..b54b95d986b97 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -131,7 +131,7 @@ class Series(base.IndexOpsMixin, generic.NDFrame):
index : array-like or Index (1d)
Values must be hashable and have the same length as `data`.
Non-unique index values are allowed. Will default to
- RangeIndex(len(data)) if not provided. If both a dict and index
+ RangeIndex (0, 1, 2, ..., n) if not provided. If both a dict and index
sequence are used, the index will override the keys found in the
dict.
dtype : numpy.dtype or None
| Small correction to DataFrame docstring | https://api.github.com/repos/pandas-dev/pandas/pulls/19781 | 2018-02-20T03:04:38Z | 2018-02-22T02:17:54Z | 2018-02-22T02:17:54Z | 2018-02-22T10:35:50Z |
DOC: added plotting module to the api reference docs | diff --git a/doc/source/api.rst b/doc/source/api.rst
index 103b0fe9ff019..46c6fb46b9d41 100644
--- a/doc/source/api.rst
+++ b/doc/source/api.rst
@@ -2378,15 +2378,23 @@ Style Export and Import
Styler.to_excel
Plotting
-~~~~~~~~
+--------
-.. currentmodule:: pandas
+.. currentmodule:: pandas.plotting
+
+The following functions are contained in the `pandas.plotting` module.
.. autosummary::
:toctree: generated/
- plotting.register_matplotlib_converters
- plotting.deregister_matplotlib_converters
+ andrews_curves
+ bootstrap_plot
+ deregister_matplotlib_converters
+ lag_plot
+ parallel_coordinates
+ radviz
+ register_matplotlib_converters
+ scatter_matrix
.. currentmodule:: pandas
| - [x ] closes #19777
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/19780 | 2018-02-20T02:46:01Z | 2018-02-22T00:18:04Z | 2018-02-22T00:18:04Z | 2018-02-22T00:18:40Z |
CI: remove PIP & old conda build in favor of pandas-ci builds | diff --git a/.travis.yml b/.travis.yml
index b1168f18315c3..22ef6c819c6d4 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -50,9 +50,6 @@ matrix:
packages:
- python-gtk2
# In allow_failures
- - dist: trusty
- env:
- - JOB="3.5" TEST_ARGS="--skip-slow --skip-network"
- dist: trusty
env:
- JOB="3.6" TEST_ARGS="--skip-slow --skip-network" PANDAS_TESTING_MODE="deprecate" CONDA_FORGE=true COVERAGE=true
@@ -63,36 +60,26 @@ matrix:
# In allow_failures
- dist: trusty
env:
- - JOB="3.6_PIP_BUILD_TEST" TEST_ARGS="--skip-slow" PIP_BUILD_TEST=true
+ - JOB="3.6_NUMPY_DEV" TEST_ARGS="--skip-slow --skip-network" PANDAS_TESTING_MODE="deprecate"
addons:
apt:
packages:
- xsel
# In allow_failures
- - dist: trusty
- env:
- - JOB="3.6_NUMPY_DEV" TEST_ARGS="--skip-slow --skip-network" PANDAS_TESTING_MODE="deprecate"
- # In allow_failures
- dist: trusty
env:
- JOB="3.6_DOC" DOC=true
allow_failures:
- - dist: trusty
- env:
- - JOB="3.5" TEST_ARGS="--skip-slow --skip-network"
- dist: trusty
env:
- JOB="2.7_SLOW" SLOW=true
- dist: trusty
env:
- - JOB="3.6_PIP_BUILD_TEST" TEST_ARGS="--skip-slow" PIP_BUILD_TEST=true
+ - JOB="3.6_NUMPY_DEV" TEST_ARGS="--skip-slow --skip-network" PANDAS_TESTING_MODE="deprecate"
addons:
apt:
packages:
- xsel
- - dist: trusty
- env:
- - JOB="3.6_NUMPY_DEV" TEST_ARGS="--skip-slow --skip-network" PANDAS_TESTING_MODE="deprecate"
- dist: trusty
env:
- JOB="3.6_DOC" DOC=true
diff --git a/ci/install_travis.sh b/ci/install_travis.sh
index 458ff083b65eb..9ccb4baf25505 100755
--- a/ci/install_travis.sh
+++ b/ci/install_travis.sh
@@ -115,15 +115,6 @@ if [ "$COVERAGE" ]; then
pip install coverage pytest-cov
fi
-echo
-if [ -z "$PIP_BUILD_TEST" ] ; then
-
- # build but don't install
- echo "[build em]"
- time python setup.py build_ext --inplace || exit 1
-
-fi
-
# we may have run installations
echo
echo "[conda installs]"
@@ -161,23 +152,8 @@ conda list pandas
pip list --format columns |grep pandas
# build and install
-echo
-
-if [ "$PIP_BUILD_TEST" ]; then
-
- # build & install testing
- echo "[building release]"
- time bash scripts/build_dist_for_release.sh || exit 1
- conda uninstall -y cython
- time pip install dist/*tar.gz || exit 1
-
-else
-
- # install our pandas
- echo "[running setup.py develop]"
- python setup.py develop || exit 1
-
-fi
+echo "[running setup.py develop]"
+python setup.py develop || exit 1
echo
echo "[show pandas]"
diff --git a/ci/requirements-3.6_PIP_BUILD_TEST.build b/ci/requirements-3.6_PIP_BUILD_TEST.build
deleted file mode 100644
index 1c4b46aea3865..0000000000000
--- a/ci/requirements-3.6_PIP_BUILD_TEST.build
+++ /dev/null
@@ -1,6 +0,0 @@
-python=3.6*
-python-dateutil
-pytz
-nomkl
-numpy
-cython
diff --git a/ci/requirements-3.6_PIP_BUILD_TEST.pip b/ci/requirements-3.6_PIP_BUILD_TEST.pip
deleted file mode 100644
index f4617133cad5b..0000000000000
--- a/ci/requirements-3.6_PIP_BUILD_TEST.pip
+++ /dev/null
@@ -1,6 +0,0 @@
-xarray
-geopandas
-seaborn
-pandas_datareader
-statsmodels
-scikit-learn
diff --git a/ci/requirements-3.6_PIP_BUILD_TEST.sh b/ci/requirements-3.6_PIP_BUILD_TEST.sh
deleted file mode 100644
index 3a8cf673b32f2..0000000000000
--- a/ci/requirements-3.6_PIP_BUILD_TEST.sh
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash
-
-source activate pandas
-
-echo "install 36 PIP_BUILD_TEST"
-
-conda install -n pandas -c conda-forge pyarrow dask pyqt qtpy
diff --git a/ci/script_multi.sh b/ci/script_multi.sh
index 45c61ee3172fe..2b2d4d5488b91 100755
--- a/ci/script_multi.sh
+++ b/ci/script_multi.sh
@@ -23,23 +23,7 @@ fi
export PYTHONHASHSEED=$(python -c 'import random; print(random.randint(1, 4294967295))')
echo PYTHONHASHSEED=$PYTHONHASHSEED
-if [ "$PIP_BUILD_TEST" ] ; then
- echo "[build-test]"
-
- echo "[env]"
- pip list --format columns |grep pandas
-
- echo "[running]"
- cd /tmp
- unset PYTHONPATH
-
- echo "[build-test: single]"
- python -c 'import pandas; pandas.test(["--skip-slow", "--skip-network", "-r xX", "-m single"])'
-
- echo "[build-test: not single]"
- python -c 'import pandas; pandas.test(["-n 2", "--skip-slow", "--skip-network", "-r xX", "-m not single"])'
-
-elif [ "$DOC" ]; then
+if [ "$DOC" ]; then
echo "We are not running pytest as this is a doc-build"
elif [ "$COVERAGE" ]; then
diff --git a/ci/script_single.sh b/ci/script_single.sh
index 021a5a7714fb5..f376c920ac71b 100755
--- a/ci/script_single.sh
+++ b/ci/script_single.sh
@@ -21,10 +21,7 @@ if echo "$TEST_ARGS" | grep -e --skip-network -q; then
export http_proxy=http://1.2.3.4 https_proxy=http://1.2.3.4;
fi
-if [ "$PIP_BUILD_TEST" ]; then
- echo "We are not running pytest as this is a build test."
-
-elif [ "$DOC" ]; then
+if [ "$DOC" ]; then
echo "We are not running pytest as this is a doc-build"
elif [ "$COVERAGE" ]; then
| xref https://github.com/pandas-dev/pandas-ci/pull/3
| https://api.github.com/repos/pandas-dev/pandas/pulls/19775 | 2018-02-19T20:02:37Z | 2018-02-19T23:05:15Z | 2018-02-19T23:05:15Z | 2018-02-19T23:05:15Z |
BUG: DataFrame.diff(axis=0) with DatetimeTZ data | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 90ce6b47728fb..ac527387ae6a1 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -833,6 +833,7 @@ Timezones
- Bug in the :class:`DataFrame` constructor, where tz-aware Datetimeindex and a given column name will result in an empty ``DataFrame`` (:issue:`19157`)
- Bug in :func:`Timestamp.tz_localize` where localizing a timestamp near the minimum or maximum valid values could overflow and return a timestamp with an incorrect nanosecond value (:issue:`12677`)
- Bug when iterating over :class:`DatetimeIndex` that was localized with fixed timezone offset that rounded nanosecond precision to microseconds (:issue:`19603`)
+- Bug in :func:`DataFrame.diff` that raised an ``IndexError`` with tz-aware values (:issue:`18578`)
Offsets
^^^^^^^
diff --git a/pandas/core/internals.py b/pandas/core/internals.py
index 00ef8f9cef598..240c9b1f3377c 100644
--- a/pandas/core/internals.py
+++ b/pandas/core/internals.py
@@ -2905,6 +2905,35 @@ def shift(self, periods, axis=0, mgr=None):
return [self.make_block_same_class(new_values,
placement=self.mgr_locs)]
+ def diff(self, n, axis=0, mgr=None):
+ """1st discrete difference
+
+ Parameters
+ ----------
+ n : int, number of periods to diff
+ axis : int, axis to diff upon. default 0
+ mgr : default None
+
+ Return
+ ------
+ A list with a new TimeDeltaBlock.
+
+ Note
+ ----
+ The arguments here are mimicking shift so they are called correctly
+ by apply.
+ """
+ if axis == 0:
+ # Cannot currently calculate diff across multiple blocks since this
+ # function is invoked via apply
+ raise NotImplementedError
+ new_values = (self.values - self.shift(n, axis=axis)[0].values).asi8
+
+ # Reshape the new_values like how algos.diff does for timedelta data
+ new_values = new_values.reshape(1, len(new_values))
+ new_values = new_values.astype('timedelta64[ns]')
+ return [TimeDeltaBlock(new_values, placement=self.mgr_locs.indexer)]
+
def concat_same_type(self, to_concat, placement=None):
"""
Concatenate list of single blocks of the same type.
diff --git a/pandas/tests/frame/test_timeseries.py b/pandas/tests/frame/test_timeseries.py
index e1bc310e1e934..ceb6c942c81b1 100644
--- a/pandas/tests/frame/test_timeseries.py
+++ b/pandas/tests/frame/test_timeseries.py
@@ -57,6 +57,32 @@ def test_diff(self):
1), 'z': pd.Series(1)}).astype('float64')
assert_frame_equal(result, expected)
+ @pytest.mark.parametrize('tz', [None, 'UTC'])
+ def test_diff_datetime_axis0(self, tz):
+ # GH 18578
+ df = DataFrame({0: date_range('2010', freq='D', periods=2, tz=tz),
+ 1: date_range('2010', freq='D', periods=2, tz=tz)})
+
+ result = df.diff(axis=0)
+ expected = DataFrame({0: pd.TimedeltaIndex(['NaT', '1 days']),
+ 1: pd.TimedeltaIndex(['NaT', '1 days'])})
+ assert_frame_equal(result, expected)
+
+ @pytest.mark.parametrize('tz', [None, 'UTC'])
+ def test_diff_datetime_axis1(self, tz):
+ # GH 18578
+ df = DataFrame({0: date_range('2010', freq='D', periods=2, tz=tz),
+ 1: date_range('2010', freq='D', periods=2, tz=tz)})
+ if tz is None:
+ result = df.diff(axis=1)
+ expected = DataFrame({0: pd.TimedeltaIndex(['NaT', 'NaT']),
+ 1: pd.TimedeltaIndex(['0 days',
+ '0 days'])})
+ assert_frame_equal(result, expected)
+ else:
+ with pytest.raises(NotImplementedError):
+ result = df.diff(axis=1)
+
def test_diff_timedelta(self):
# GH 4533
df = DataFrame(dict(time=[Timestamp('20130101 9:01'),
| - [x] closes #18578
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Unfortunately, `DataFrame.diff` doesn't work correctly with axis=1; it returns values like so after this patch:
```
In [2]: df = DataFrame({0: date_range('2010', freq='D', periods=2, tz='utc'),
...: 1: date_range('2010', freq='D', periods=2, tz='utc')})
...:
In [3]: df.diff(axis=1)
Out[3]:
0 1
0 NaT NaT
1 NaT NaT
```
I believe this is because `diff` is implemented by iterating over the 2 DatetimeTZBlocks (via `BlockManager.apply`, but `diff` needs data from both blocks at once. (Is it possible to consolidate 2 DatetimeTZBlocks?) I made this raise a `NotImplimentedError` for now. | https://api.github.com/repos/pandas-dev/pandas/pulls/19773 | 2018-02-19T18:42:01Z | 2018-03-01T22:50:35Z | 2018-03-01T22:50:35Z | 2018-03-01T23:48:14Z |
BUG: Fix MultiIndex .loc with all numpy arrays | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 76c4fa08fca4d..e6ed71c719c9a 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -833,6 +833,7 @@ MultiIndex
- Bug in :func:`MultiIndex.get_loc` which would cast boolean to integer labels (:issue:`19086`)
- Bug in :func:`MultiIndex.get_loc` which would fail to locate keys containing ``NaN`` (:issue:`18485`)
- Bug in :func:`MultiIndex.get_loc` in large :class:`MultiIndex`, would fail when levels had different dtypes (:issue:`18520`)
+- Bug in indexing where nested indexers having only numpy arrays are handled incorrectly (:issue:`19686`)
I/O
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 352ce921d1d44..eb3aeda7902fc 100755
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -2107,10 +2107,9 @@ def is_nested_tuple(tup, labels):
if not isinstance(tup, tuple):
return False
- # are we nested tuple of: tuple,list,slice
for i, k in enumerate(tup):
- if isinstance(k, (tuple, list, slice)):
+ if is_list_like(k) or isinstance(k, slice):
return isinstance(labels, MultiIndex)
return False
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index 433b0d87ac005..86a5a82441ee8 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -8,7 +8,7 @@
import pandas as pd
from pandas.compat import lrange, StringIO
-from pandas import Series, DataFrame, Timestamp, date_range, MultiIndex
+from pandas import Series, DataFrame, Timestamp, date_range, MultiIndex, Index
from pandas.util import testing as tm
from pandas.tests.indexing.common import Base
@@ -711,3 +711,44 @@ def test_identity_slice_returns_new_object(self):
original_series[:3] = [7, 8, 9]
assert all(sliced_series[:3] == [7, 8, 9])
+
+ @pytest.mark.parametrize(
+ 'indexer_type_1',
+ (list, tuple, set, slice, np.ndarray, Series, Index))
+ @pytest.mark.parametrize(
+ 'indexer_type_2',
+ (list, tuple, set, slice, np.ndarray, Series, Index))
+ def test_loc_getitem_nested_indexer(self, indexer_type_1, indexer_type_2):
+ # GH #19686
+ # .loc should work with nested indexers which can be
+ # any list-like objects (see `pandas.api.types.is_list_like`) or slices
+
+ def convert_nested_indexer(indexer_type, keys):
+ if indexer_type == np.ndarray:
+ return np.array(keys)
+ if indexer_type == slice:
+ return slice(*keys)
+ return indexer_type(keys)
+
+ a = [10, 20, 30]
+ b = [1, 2, 3]
+ index = pd.MultiIndex.from_product([a, b])
+ df = pd.DataFrame(
+ np.arange(len(index), dtype='int64'),
+ index=index, columns=['Data'])
+
+ keys = ([10, 20], [2, 3])
+ types = (indexer_type_1, indexer_type_2)
+
+ # check indexers with all the combinations of nested objects
+ # of all the valid types
+ indexer = tuple(
+ convert_nested_indexer(indexer_type, k)
+ for indexer_type, k in zip(types, keys))
+
+ result = df.loc[indexer, 'Data']
+ expected = pd.Series(
+ [1, 2, 4, 5], name='Data',
+ index=pd.MultiIndex.from_product(keys))
+
+ tm.assert_series_equal(result, expected)
| - [x] closes #19686
- [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/19772 | 2018-02-19T18:12:17Z | 2018-02-23T01:40:20Z | 2018-02-23T01:40:20Z | 2018-02-23T03:50:50Z |
Fix Timedelta floordiv, rfloordiv with offset, fix td64 return types | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 11c49995372f5..56c30615a20fa 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -716,6 +716,8 @@ Datetimelike
- Bug in :class:`Timestamp` and :func:`to_datetime` where a string representing a barely out-of-bounds timestamp would be incorrectly rounded down instead of raising ``OutOfBoundsDatetime`` (:issue:`19382`)
- Bug in :func:`Timestamp.floor` :func:`DatetimeIndex.floor` where time stamps far in the future and past were not rounded correctly (:issue:`19206`)
- Bug in :func:`to_datetime` where passing an out-of-bounds datetime with ``errors='coerce'`` and ``utc=True`` would raise ``OutOfBoundsDatetime`` instead of parsing to ``NaT`` (:issue:`19612`)
+- Bug in :func:`Timedelta.__add__`, :func:`Timedelta.__sub__` where adding or subtracting a ``np.timedelta64`` object would return another ``np.timedelta64`` instead of a ``Timedelta`` (:issue:`19738`)
+- Bug in :func:`Timedelta.__floordiv__`, :func:`Timedelta.__rfloordiv__` where operating with a ``Tick`` object would raise a ``TypeError`` instead of returning a numeric value (:issue:`19738`)
-
Timezones
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 37693068e0974..bd1fefa7403a8 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -478,11 +478,16 @@ def _binary_op_method_timedeltalike(op, name):
elif other is NaT:
return NaT
+ elif is_timedelta64_object(other):
+ # convert to Timedelta below; avoid catching this in
+ # has-dtype check before then
+ pass
+
elif is_datetime64_object(other) or PyDateTime_CheckExact(other):
# the PyDateTime_CheckExact case is for a datetime object that
# is specifically *not* a Timestamp, as the Timestamp case will be
# handled after `_validate_ops_compat` returns False below
- from ..tslib import Timestamp
+ from timestamps import Timestamp
return op(self, Timestamp(other))
# We are implicitly requiring the canonical behavior to be
# defined by Timestamp methods.
@@ -503,6 +508,9 @@ def _binary_op_method_timedeltalike(op, name):
# failed to parse as timedelta
return NotImplemented
+ if other is NaT:
+ # e.g. if original other was timedelta64('NaT')
+ return NaT
return Timedelta(op(self.value, other.value), unit='ns')
f.__name__ = name
@@ -1096,6 +1104,9 @@ class Timedelta(_Timedelta):
# just defer
if hasattr(other, '_typ'):
# Series, DataFrame, ...
+ if other._typ == 'dateoffset' and hasattr(other, 'delta'):
+ # Tick offset
+ return self // other.delta
return NotImplemented
if hasattr(other, 'dtype'):
@@ -1128,6 +1139,9 @@ class Timedelta(_Timedelta):
# just defer
if hasattr(other, '_typ'):
# Series, DataFrame, ...
+ if other._typ == 'dateoffset' and hasattr(other, 'delta'):
+ # Tick offset
+ return other.delta // self
return NotImplemented
if hasattr(other, 'dtype'):
diff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py
index 90c911c24f6a9..c6f1a6a1032cd 100644
--- a/pandas/tests/scalar/timedelta/test_arithmetic.py
+++ b/pandas/tests/scalar/timedelta/test_arithmetic.py
@@ -100,7 +100,6 @@ def test_td_add_pytimedelta(self, op):
assert isinstance(result, Timedelta)
assert result == Timedelta(days=19)
- @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
@pytest.mark.parametrize('op', [operator.add, ops.radd])
def test_td_add_timedelta64(self, op):
td = Timedelta(10, unit='d')
@@ -130,13 +129,11 @@ def test_td_sub_pytimedelta(self):
assert isinstance(result, Timedelta)
assert result == expected
- @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
def test_td_sub_timedelta64(self):
td = Timedelta(10, unit='d')
expected = Timedelta(0, unit='ns')
result = td - td.to_timedelta64()
assert isinstance(result, Timedelta)
- # comparison fails even if we comment out the isinstance assertion
assert result == expected
def test_td_sub_nat(self):
@@ -144,7 +141,6 @@ def test_td_sub_nat(self):
result = td - NaT
assert result is NaT
- @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
def test_td_sub_td64_nat(self):
td = Timedelta(10, unit='d')
result = td - np.timedelta64('NaT')
@@ -171,7 +167,6 @@ def test_td_rsub_pytimedelta(self):
assert isinstance(result, Timedelta)
assert result == expected
- @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
def test_td_rsub_timedelta64(self):
td = Timedelta(10, unit='d')
expected = Timedelta(0, unit='ns')
@@ -188,7 +183,6 @@ def test_td_rsub_nat(self):
result = np.datetime64('NaT') - td
assert result is NaT
- @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
def test_td_rsub_td64_nat(self):
td = Timedelta(10, unit='d')
result = np.timedelta64('NaT') - td
@@ -304,6 +298,12 @@ def test_td_floordiv_null_scalar(self):
assert np.isnan(td // NaT)
assert np.isnan(td // np.timedelta64('NaT'))
+ def test_td_floordiv_offsets(self):
+ # GH#19738
+ td = Timedelta(hours=3, minutes=4)
+ assert td // pd.offsets.Hour(1) == 3
+ assert td // pd.offsets.Minute(2) == 92
+
def test_td_floordiv_invalid_scalar(self):
# GH#18846
td = Timedelta(hours=3, minutes=4)
@@ -322,7 +322,7 @@ def test_td_floordiv_numeric_scalar(self):
assert td // np.int32(2.0) == expected
assert td // np.uint8(2.0) == expected
- def test_floordiv_timedeltalike_array(self):
+ def test_td_floordiv_timedeltalike_array(self):
# GH#18846
td = Timedelta(hours=3, minutes=4)
scalar = Timedelta(hours=3, minutes=3)
@@ -371,6 +371,10 @@ def test_td_rfloordiv_null_scalar(self):
assert np.isnan(td.__rfloordiv__(NaT))
assert np.isnan(td.__rfloordiv__(np.timedelta64('NaT')))
+ def test_td_rfloordiv_offsets(self):
+ # GH#19738
+ assert pd.offsets.Hour(1) // Timedelta(minutes=25) == 2
+
def test_td_rfloordiv_invalid_scalar(self):
# GH#18846
td = Timedelta(hours=3, minutes=3)
| Fixes xfails introduced in #19752.
| https://api.github.com/repos/pandas-dev/pandas/pulls/19770 | 2018-02-19T17:45:25Z | 2018-02-19T23:16:37Z | 2018-02-19T23:16:37Z | 2018-06-22T03:23:40Z |
DEPR: remove pandas.core.common is_* | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 2f820043d7b6f..5520e3af8b0ed 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -388,6 +388,23 @@ Convert to an xarray DataArray
p.to_xarray()
+
+
+.. _whatsnew_0230.api_breaking.core_common:
+
+pandas.core.common removals
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The following error & warning messages are removed from ``pandas.core.common`` (:issue:`13634`, :issue:`19769`):
+
+- ``PerformanceWarning``
+- ``UnsupportedFunctionCall``
+- ``UnsortedIndexError``
+- ``AbstractMethodError``
+
+These are available from import from ``pandas.errors`` (since 0.19.0).
+
+
.. _whatsnew_0230.api_breaking.apply:
Changes to make output of ``DataFrame.apply`` consistent
@@ -638,6 +655,7 @@ Removal of prior version deprecations/changes
- The modules `pandas.tools.hashing` and `pandas.util.hashing` have been removed (:issue:`16223`)
- The top-level functions ``pd.rolling_*``, ``pd.expanding_*`` and ``pd.ewm*`` have been removed (Deprecated since v0.18).
Instead, use the DataFrame/Series methods :attr:`~DataFrame.rolling`, :attr:`~DataFrame.expanding` and :attr:`~DataFrame.ewm` (:issue:`18723`)
+- Imports from ``pandas.core.common`` for functions such as ``is_datetime64_dtype`` are now removed. These are located in ``pandas.api.types``. (:issue:`13634`, :issue:`19769`)
.. _whatsnew_0230.performance:
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 0ca029ffd4c25..d061c4144cff9 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -17,7 +17,7 @@
is_extension_array_dtype)
from pandas.util._validators import validate_bool_kwarg
-
+from pandas.errors import AbstractMethodError
from pandas.core import common as com, algorithms
import pandas.core.nanops as nanops
import pandas._libs.lib as lib
@@ -46,7 +46,7 @@ class StringMixin(object):
# Formatting
def __unicode__(self):
- raise com.AbstractMethodError(self)
+ raise AbstractMethodError(self)
def __str__(self):
"""
@@ -278,10 +278,10 @@ def _gotitem(self, key, ndim, subset=None):
subset to act on
"""
- raise com.AbstractMethodError(self)
+ raise AbstractMethodError(self)
def aggregate(self, func, *args, **kwargs):
- raise com.AbstractMethodError(self)
+ raise AbstractMethodError(self)
agg = aggregate
@@ -1252,4 +1252,4 @@ def duplicated(self, keep='first'):
# abstracts
def _update_inplace(self, result, **kwargs):
- raise com.AbstractMethodError(self)
+ raise AbstractMethodError(self)
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 6748db825acf0..278c07b544011 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -2,8 +2,6 @@
Misc tools for implementing data structures
"""
-import sys
-import warnings
from datetime import datetime, timedelta
from functools import partial
import inspect
@@ -20,66 +18,8 @@
from pandas.core.dtypes.inference import _iterable_not_string
from pandas.core.dtypes.missing import isna, isnull, notnull # noqa
from pandas.api import types
-from pandas.core.dtypes import common
from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
-# compat
-from pandas.errors import ( # noqa
- PerformanceWarning, UnsupportedFunctionCall, UnsortedIndexError,
- AbstractMethodError)
-
-# back-compat of public API
-# deprecate these functions
-m = sys.modules['pandas.core.common']
-for t in [t for t in dir(types) if not t.startswith('_')]:
-
- def outer(t=t):
-
- def wrapper(*args, **kwargs):
- warnings.warn("pandas.core.common.{t} is deprecated. "
- "import from the public API: "
- "pandas.api.types.{t} instead".format(t=t),
- DeprecationWarning, stacklevel=3)
- return getattr(types, t)(*args, **kwargs)
- return wrapper
-
- setattr(m, t, outer(t))
-
-# back-compat for non-public functions
-# deprecate these functions
-for t in ['is_datetime_arraylike',
- 'is_datetime_or_timedelta_dtype',
- 'is_datetimelike',
- 'is_datetimelike_v_numeric',
- 'is_datetimelike_v_object',
- 'is_datetimetz',
- 'is_int_or_datetime_dtype',
- 'is_period_arraylike',
- 'is_string_like',
- 'is_string_like_dtype']:
-
- def outer(t=t):
-
- def wrapper(*args, **kwargs):
- warnings.warn("pandas.core.common.{t} is deprecated. "
- "These are not longer public API functions, "
- "but can be imported from "
- "pandas.api.types.{t} instead".format(t=t),
- DeprecationWarning, stacklevel=3)
- return getattr(common, t)(*args, **kwargs)
- return wrapper
-
- setattr(m, t, outer(t))
-
-
-# deprecate array_equivalent
-
-def array_equivalent(*args, **kwargs):
- warnings.warn("'pandas.core.common.array_equivalent' is deprecated and "
- "is no longer public API", DeprecationWarning, stacklevel=2)
- from pandas.core.dtypes import missing
- return missing.array_equivalent(*args, **kwargs)
-
class SettingWithCopyError(ValueError):
pass
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index df656092f476e..772568ee84737 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -16,7 +16,7 @@
from pandas.core.indexes.timedeltas import TimedeltaIndex
from pandas.tseries.offsets import DateOffset, Tick, Day, delta_to_nanoseconds
from pandas.core.indexes.period import PeriodIndex
-import pandas.core.common as com
+from pandas.errors import AbstractMethodError
import pandas.core.algorithms as algos
from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
@@ -205,10 +205,10 @@ def __setattr__(self, attr, value):
def __getitem__(self, key):
try:
return super(Resampler, self).__getitem__(key)
- except (KeyError, com.AbstractMethodError):
+ except (KeyError, AbstractMethodError):
# compat for deprecated
- if isinstance(self.obj, com.ABCSeries):
+ if isinstance(self.obj, ABCSeries):
return self._deprecated('__getitem__')[key]
raise
@@ -233,7 +233,7 @@ def _convert_obj(self, obj):
return obj
def _get_binner_for_time(self):
- raise com.AbstractMethodError(self)
+ raise AbstractMethodError(self)
def _set_binner(self):
"""
@@ -372,10 +372,10 @@ def transform(self, arg, *args, **kwargs):
arg, *args, **kwargs)
def _downsample(self, f):
- raise com.AbstractMethodError(self)
+ raise AbstractMethodError(self)
def _upsample(self, f, limit=None, fill_value=None):
- raise com.AbstractMethodError(self)
+ raise AbstractMethodError(self)
def _gotitem(self, key, ndim, subset=None):
"""
@@ -464,7 +464,7 @@ def _get_resampler_for_grouping(self, groupby, **kwargs):
def _wrap_result(self, result):
""" potentially wrap any results """
- if isinstance(result, com.ABCSeries) and self._selection is not None:
+ if isinstance(result, ABCSeries) and self._selection is not None:
result.name = self._selection
if isinstance(result, ABCSeries) and result.empty:
diff --git a/pandas/tests/api/test_types.py b/pandas/tests/api/test_types.py
index 7e6430accc546..bd4891326c751 100644
--- a/pandas/tests/api/test_types.py
+++ b/pandas/tests/api/test_types.py
@@ -3,10 +3,8 @@
import pytest
from warnings import catch_warnings
-import numpy as np
import pandas
-from pandas.core import common as com
from pandas.api import types
from pandas.util import testing as tm
@@ -52,42 +50,6 @@ def check_deprecation(self, fold, fnew):
except AttributeError:
pytest.raises(AttributeError, lambda: fnew('foo'))
- def test_deprecation_core_common(self):
-
- # test that we are in fact deprecating
- # the pandas.core.common introspectors
- for t in self.allowed:
- self.check_deprecation(getattr(com, t), getattr(types, t))
-
- def test_deprecation_core_common_array_equivalent(self):
-
- with tm.assert_produces_warning(DeprecationWarning):
- com.array_equivalent(np.array([1, 2]), np.array([1, 2]))
-
- def test_deprecation_core_common_moved(self):
-
- # these are in pandas.core.dtypes.common
- l = ['is_datetime_arraylike',
- 'is_datetime_or_timedelta_dtype',
- 'is_datetimelike',
- 'is_datetimelike_v_numeric',
- 'is_datetimelike_v_object',
- 'is_datetimetz',
- 'is_int_or_datetime_dtype',
- 'is_period_arraylike',
- 'is_string_like',
- 'is_string_like_dtype']
-
- from pandas.core.dtypes import common as c
- for t in l:
- self.check_deprecation(getattr(com, t), getattr(c, t))
-
- def test_removed_from_core_common(self):
-
- for t in ['is_null_datelike_scalar',
- 'ensure_float']:
- pytest.raises(AttributeError, lambda: getattr(com, t))
-
def test_deprecated_from_api_types(self):
for t in self.deprecated:
| xref #13990
xref #19304 | https://api.github.com/repos/pandas-dev/pandas/pulls/19769 | 2018-02-19T17:30:28Z | 2018-02-22T00:12:22Z | 2018-02-22T00:12:22Z | 2018-02-22T00:12:51Z |
DOC: correct Panel.apply exsample | diff --git a/pandas/core/panel.py b/pandas/core/panel.py
index 2cb80e938afb9..7f973992fb07f 100644
--- a/pandas/core/panel.py
+++ b/pandas/core/panel.py
@@ -1020,7 +1020,7 @@ def apply(self, func, axis='major', **kwargs):
Equivalent to previous:
- >>> p.apply(lambda x: x.sum(), axis='minor')
+ >>> p.apply(lambda x: x.sum(), axis='major')
Return the shapes of each DataFrame over axis 2 (i.e the shapes of
items x major), as a Series
| - [ ] 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/19766 | 2018-02-19T16:02:22Z | 2018-02-19T16:10:32Z | 2018-02-19T16:10:32Z | 2018-02-20T01:45:57Z |
DOC/BLD: update vendored IPython.sphinxext version | diff --git a/doc/sphinxext/ipython_sphinxext/ipython_console_highlighting.py b/doc/sphinxext/ipython_sphinxext/ipython_console_highlighting.py
index c5ec26aefd442..b93a151fb3cb0 100644
--- a/doc/sphinxext/ipython_sphinxext/ipython_console_highlighting.py
+++ b/doc/sphinxext/ipython_sphinxext/ipython_console_highlighting.py
@@ -1,116 +1,28 @@
-"""reST directive for syntax-highlighting ipython interactive sessions.
-
-XXX - See what improvements can be made based on the new (as of Sept 2009)
-'pycon' lexer for the python console. At the very least it will give better
-highlighted tracebacks.
"""
+reST directive for syntax-highlighting ipython interactive sessions.
-#-----------------------------------------------------------------------------
-# Needed modules
-
-# Standard library
-import re
-
-# Third party
-from pygments.lexer import Lexer, do_insertions
-from pygments.lexers.agile import (PythonConsoleLexer, PythonLexer,
- PythonTracebackLexer)
-from pygments.token import Comment, Generic
+"""
from sphinx import highlighting
-
-#-----------------------------------------------------------------------------
-# Global constants
-line_re = re.compile('.*?\n')
-
-#-----------------------------------------------------------------------------
-# Code begins - classes and functions
-
-
-class IPythonConsoleLexer(Lexer):
-
- """
- For IPython console output or doctests, such as:
-
- .. sourcecode:: ipython
-
- In [1]: a = 'foo'
-
- In [2]: a
- Out[2]: 'foo'
-
- In [3]: print(a)
- foo
-
- In [4]: 1 / 0
-
- Notes:
-
- - Tracebacks are not currently supported.
-
- - It assumes the default IPython prompts, not customized ones.
- """
-
- name = 'IPython console session'
- aliases = ['ipython']
- mimetypes = ['text/x-ipython-console']
- input_prompt = re.compile("(In \[[0-9]+\]: )|( \.\.\.+:)")
- output_prompt = re.compile("(Out\[[0-9]+\]: )|( \.\.\.+:)")
- continue_prompt = re.compile(" \.\.\.+:")
- tb_start = re.compile("\-+")
-
- def get_tokens_unprocessed(self, text):
- pylexer = PythonLexer(**self.options)
- tblexer = PythonTracebackLexer(**self.options)
-
- curcode = ''
- insertions = []
- for match in line_re.finditer(text):
- line = match.group()
- input_prompt = self.input_prompt.match(line)
- continue_prompt = self.continue_prompt.match(line.rstrip())
- output_prompt = self.output_prompt.match(line)
- if line.startswith("#"):
- insertions.append((len(curcode),
- [(0, Comment, line)]))
- elif input_prompt is not None:
- insertions.append((len(curcode),
- [(0, Generic.Prompt, input_prompt.group())]))
- curcode += line[input_prompt.end():]
- elif continue_prompt is not None:
- insertions.append((len(curcode),
- [(0, Generic.Prompt, continue_prompt.group())]))
- curcode += line[continue_prompt.end():]
- elif output_prompt is not None:
- # Use the 'error' token for output. We should probably make
- # our own token, but error is typically in a bright color like
- # red, so it works fine for our output prompts.
- insertions.append((len(curcode),
- [(0, Generic.Error, output_prompt.group())]))
- curcode += line[output_prompt.end():]
- else:
- if curcode:
- for item in do_insertions(insertions,
- pylexer.get_tokens_unprocessed(curcode)):
- yield item
- curcode = ''
- insertions = []
- yield match.start(), Generic.Output, line
- if curcode:
- for item in do_insertions(insertions,
- pylexer.get_tokens_unprocessed(curcode)):
- yield item
-
+from IPython.lib.lexers import IPyLexer
def setup(app):
"""Setup as a sphinx extension."""
# This is only a lexer, so adding it below to pygments appears sufficient.
- # But if somebody knows that the right API usage should be to do that via
+ # But if somebody knows what the right API usage should be to do that via
# sphinx, by all means fix it here. At least having this setup.py
# suppresses the sphinx warning we'd get without it.
- pass
+ metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
+ return metadata
+
+# Register the extension as a valid pygments lexer.
+# Alternatively, we could register the lexer with pygments instead. This would
+# require using setuptools entrypoints: http://pygments.org/docs/plugins
+
+ipy2 = IPyLexer(python3=False)
+ipy3 = IPyLexer(python3=True)
-#-----------------------------------------------------------------------------
-# Register the extension as a valid pygments lexer
-highlighting.lexers['ipython'] = IPythonConsoleLexer()
+highlighting.lexers['ipython'] = ipy2
+highlighting.lexers['ipython2'] = ipy2
+highlighting.lexers['ipython3'] = ipy3
diff --git a/doc/sphinxext/ipython_sphinxext/ipython_directive.py b/doc/sphinxext/ipython_sphinxext/ipython_directive.py
index 5616d732eb1c6..a0e6728861b66 100644
--- a/doc/sphinxext/ipython_sphinxext/ipython_directive.py
+++ b/doc/sphinxext/ipython_sphinxext/ipython_directive.py
@@ -83,8 +83,29 @@
See http://matplotlib.org/sampledoc/ipython_directive.html for additional
documentation.
-ToDo
-----
+Pseudo-Decorators
+=================
+
+Note: Only one decorator is supported per input. If more than one decorator
+is specified, then only the last one is used.
+
+In addition to the Pseudo-Decorators/options described at the above link,
+several enhancements have been made. The directive will emit a message to the
+console at build-time if code-execution resulted in an exception or warning.
+You can suppress these on a per-block basis by specifying the :okexcept:
+or :okwarning: options:
+
+.. code-block:: rst
+
+ .. ipython::
+ :okexcept:
+ :okwarning:
+
+ In [1]: 1/0
+ In [2]: # raise warning.
+
+To Do
+-----
- Turn the ad-hoc test() function into a real test suite.
- Break up ipython-specific functionality from matplotlib stuff into better
@@ -98,48 +119,31 @@
- VáclavŠmilauer <eudoxos-AT-arcig.cz>: Prompt generalizations.
- Skipper Seabold, refactoring, cleanups, pure python addition
"""
-from __future__ import print_function
-from __future__ import unicode_literals
#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------
# Stdlib
+import atexit
+import errno
import os
import re
import sys
import tempfile
import ast
-from pandas.compat import zip, range, map, lmap, u, text_type, cStringIO as StringIO
import warnings
-
-# To keep compatibility with various python versions
-try:
- from hashlib import md5
-except ImportError:
- from md5 import md5
+import shutil
+from io import StringIO
# Third-party
-import sphinx
from docutils.parsers.rst import directives
-from docutils import nodes
-from sphinx.util.compat import Directive
+from docutils.parsers.rst import Directive
# Our own
-try:
- from traitlets.config import Config
-except ImportError:
- from IPython import Config
+from traitlets.config import Config
from IPython import InteractiveShell
from IPython.core.profiledir import ProfileDir
-from IPython.utils import io
-from IPython.utils.py3compat import PY3
-
-if PY3:
- from io import StringIO
-else:
- from StringIO import StringIO
#-----------------------------------------------------------------------------
# Globals
@@ -191,8 +195,8 @@ def block_parser(part, rgxin, rgxout, fmtin, fmtout):
continue
if line_stripped.startswith('@'):
- # we're assuming at most one decorator -- may need to
- # rethink
+ # Here is where we assume there is, at most, one decorator.
+ # Might need to rethink this.
decorator = line_stripped
continue
@@ -223,12 +227,17 @@ def block_parser(part, rgxin, rgxout, fmtin, fmtout):
if matchout or nextline.startswith('#'):
break
elif nextline.startswith(continuation):
+ # The default ipython_rgx* treat the space following the colon as optional.
+ # However, If the space is there we must consume it or code
+ # employing the cython_magic extension will fail to execute.
+ #
+ # This works with the default ipython_rgx* patterns,
+ # If you modify them, YMMV.
nextline = nextline[Nc:]
if nextline and nextline[0] == ' ':
nextline = nextline[1:]
inputline += '\n' + nextline
-
else:
rest.append(nextline)
i+= 1
@@ -250,42 +259,19 @@ def block_parser(part, rgxin, rgxout, fmtin, fmtout):
return block
-class DecodingStringIO(StringIO, object):
- def __init__(self,buf='',encodings=('utf8',), *args, **kwds):
- super(DecodingStringIO, self).__init__(buf, *args, **kwds)
- self.set_encodings(encodings)
-
- def set_encodings(self, encodings):
- self.encodings = encodings
-
- def write(self,data):
- if isinstance(data, text_type):
- return super(DecodingStringIO, self).write(data)
- else:
- for enc in self.encodings:
- try:
- data = data.decode(enc)
- return super(DecodingStringIO, self).write(data)
- except :
- pass
- # default to brute utf8 if no encoding succeeded
- return super(DecodingStringIO, self).write(data.decode('utf8', 'replace'))
-
-
class EmbeddedSphinxShell(object):
"""An embedded IPython instance to run inside Sphinx"""
- def __init__(self, exec_lines=None,state=None):
+ def __init__(self, exec_lines=None):
- self.cout = DecodingStringIO(u'')
+ self.cout = StringIO()
if exec_lines is None:
exec_lines = []
- self.state = state
-
# Create config object for IPython
config = Config()
+ config.HistoryManager.hist_file = ':memory:'
config.InteractiveShell.autocall = False
config.InteractiveShell.autoindent = False
config.InteractiveShell.colors = 'NoColor'
@@ -297,17 +283,9 @@ def __init__(self, exec_lines=None,state=None):
profile = ProfileDir.create_profile_dir(pdir)
# Create and initialize global ipython, but don't start its mainloop.
- # This will persist across different EmbededSphinxShell instances.
+ # This will persist across different EmbeddedSphinxShell instances.
IP = InteractiveShell.instance(config=config, profile_dir=profile)
-
- # io.stdout redirect must be done after instantiating InteractiveShell
- io.stdout = self.cout
- io.stderr = self.cout
-
- # For debugging, so we can see normal output, use this:
- #from IPython.utils.io import Tee
- #io.stdout = Tee(self.cout, channel='stdout') # dbg
- #io.stderr = Tee(self.cout, channel='stderr') # dbg
+ atexit.register(self.cleanup)
# Store a few parts of IPython we'll need.
self.IP = IP
@@ -316,12 +294,17 @@ def __init__(self, exec_lines=None,state=None):
self.input = ''
self.output = ''
+ self.tmp_profile_dir = tmp_profile_dir
self.is_verbatim = False
self.is_doctest = False
self.is_suppress = False
# Optionally, provide more detailed information to shell.
+ # this is assigned by the SetUp method of IPythonDirective
+ # to point at itself.
+ #
+ # So, you can access handy things at self.directive.state
self.directive = None
# on the first call to the savefig decorator, we'll import
@@ -332,6 +315,9 @@ def __init__(self, exec_lines=None,state=None):
for line in exec_lines:
self.process_input_line(line, store_history=False)
+ def cleanup(self):
+ shutil.rmtree(self.tmp_profile_dir, ignore_errors=True)
+
def clear_cout(self):
self.cout.seek(0)
self.cout.truncate(0)
@@ -346,11 +332,7 @@ def process_input_line(self, line, store_history=True):
splitter.push(line)
more = splitter.push_accepts_more()
if not more:
- try:
- source_raw = splitter.source_raw_reset()[1]
- except:
- # recent ipython #4504
- source_raw = splitter.raw_reset()
+ source_raw = splitter.raw_reset()
self.IP.run_cell(source_raw, store_history=store_history)
finally:
sys.stdout = stdout
@@ -368,9 +350,9 @@ def process_image(self, decorator):
source_dir = self.source_dir
saveargs = decorator.split(' ')
filename = saveargs[1]
- # insert relative path to image file in source
- outfile = os.path.relpath(os.path.join(savefig_dir,filename),
- source_dir)
+ # insert relative path to image file in source (as absolute path for Sphinx)
+ outfile = '/' + os.path.relpath(os.path.join(savefig_dir,filename),
+ source_dir)
imagerows = ['.. image:: %s'%outfile]
@@ -403,17 +385,10 @@ def process_input(self, data, input_prompt, lineno):
is_savefig = decorator is not None and \
decorator.startswith('@savefig')
- # set the encodings to be used by DecodingStringIO
- # to convert the execution output into unicode if
- # needed. this attrib is set by IpythonDirective.run()
- # based on the specified block options, defaulting to ['ut
- self.cout.set_encodings(self.output_encoding)
-
input_lines = input.split('\n')
-
if len(input_lines) > 1:
- if input_lines[-1] != "":
- input_lines.append('') # make sure there's a blank line
+ if input_lines[-1] != "":
+ input_lines.append('') # make sure there's a blank line
# so splitter buffer gets reset
continuation = ' %s:'%''.join(['.']*(len(str(lineno))+2))
@@ -456,30 +431,75 @@ def process_input(self, data, input_prompt, lineno):
ret.append(formatted_line)
if not is_suppress and len(rest.strip()) and is_verbatim:
- # the "rest" is the standard output of the
- # input, which needs to be added in
- # verbatim mode
+ # The "rest" is the standard output of the input. This needs to be
+ # added when in verbatim mode. If there is no "rest", then we don't
+ # add it, as the new line will be added by the processed output.
ret.append(rest)
+ # Fetch the processed output. (This is not the submitted output.)
self.cout.seek(0)
- output = self.cout.read()
+ processed_output = self.cout.read()
if not is_suppress and not is_semicolon:
- ret.append(output)
- elif is_semicolon: # get spacing right
+ #
+ # In IPythonDirective.run, the elements of `ret` are eventually
+ # combined such that '' entries correspond to newlines. So if
+ # `processed_output` is equal to '', then the adding it to `ret`
+ # ensures that there is a blank line between consecutive inputs
+ # that have no outputs, as in:
+ #
+ # In [1]: x = 4
+ #
+ # In [2]: x = 5
+ #
+ # When there is processed output, it has a '\n' at the tail end. So
+ # adding the output to `ret` will provide the necessary spacing
+ # between consecutive input/output blocks, as in:
+ #
+ # In [1]: x
+ # Out[1]: 5
+ #
+ # In [2]: x
+ # Out[2]: 5
+ #
+ # When there is stdout from the input, it also has a '\n' at the
+ # tail end, and so this ensures proper spacing as well. E.g.:
+ #
+ # In [1]: print x
+ # 5
+ #
+ # In [2]: x = 5
+ #
+ # When in verbatim mode, `processed_output` is empty (because
+ # nothing was passed to IP. Sometimes the submitted code block has
+ # an Out[] portion and sometimes it does not. When it does not, we
+ # need to ensure proper spacing, so we have to add '' to `ret`.
+ # However, if there is an Out[] in the submitted code, then we do
+ # not want to add a newline as `process_output` has stuff to add.
+ # The difficulty is that `process_input` doesn't know if
+ # `process_output` will be called---so it doesn't know if there is
+ # Out[] in the code block. The requires that we include a hack in
+ # `process_block`. See the comments there.
+ #
+ ret.append(processed_output)
+ elif is_semicolon:
+ # Make sure there is a newline after the semicolon.
ret.append('')
# context information
- filename = self.state.document.current_source
- lineno = self.state.document.current_line
+ filename = "Unknown"
+ lineno = 0
+ if self.directive.state:
+ filename = self.directive.state.document.current_source
+ lineno = self.directive.state.document.current_line
# output any exceptions raised during execution to stdout
# unless :okexcept: has been specified.
- if not is_okexcept and "Traceback" in output:
+ if not is_okexcept and "Traceback" in processed_output:
s = "\nException in %s at block ending on line %s\n" % (filename, lineno)
s += "Specify :okexcept: as an option in the ipython:: block to suppress this message\n"
sys.stdout.write('\n\n>>>' + ('-' * 73))
sys.stdout.write(s)
- sys.stdout.write(output)
+ sys.stdout.write(processed_output)
sys.stdout.write('<<<' + ('-' * 73) + '\n\n')
# output any warning raised during execution to stdout
@@ -490,28 +510,32 @@ def process_input(self, data, input_prompt, lineno):
s += "Specify :okwarning: as an option in the ipython:: block to suppress this message\n"
sys.stdout.write('\n\n>>>' + ('-' * 73))
sys.stdout.write(s)
- sys.stdout.write('-' * 76 + '\n')
+ sys.stdout.write(('-' * 76) + '\n')
s=warnings.formatwarning(w.message, w.category,
w.filename, w.lineno, w.line)
sys.stdout.write(s)
sys.stdout.write('<<<' + ('-' * 73) + '\n')
self.cout.truncate(0)
- return (ret, input_lines, output, is_doctest, decorator, image_file,
- image_directive)
+
+ return (ret, input_lines, processed_output,
+ is_doctest, decorator, image_file, image_directive)
- def process_output(self, data, output_prompt,
- input_lines, output, is_doctest, decorator, image_file):
+ def process_output(self, data, output_prompt, input_lines, output,
+ is_doctest, decorator, image_file):
"""
Process data block for OUTPUT token.
"""
+ # Recall: `data` is the submitted output, and `output` is the processed
+ # output from `input_lines`.
+
TAB = ' ' * 4
if is_doctest and output is not None:
- found = output
+ found = output # This is the processed output
found = found.strip()
submitted = data.strip()
@@ -522,7 +546,7 @@ def process_output(self, data, output_prompt,
source = self.directive.state.document.current_source
content = self.directive.content
# Add tabs and join into a single string.
- content = '\n'.join(TAB + line for line in content)
+ content = '\n'.join([TAB + line for line in content])
# Make sure the output contains the output prompt.
ind = found.find(output_prompt)
@@ -553,6 +577,31 @@ def process_output(self, data, output_prompt,
else:
self.custom_doctest(decorator, input_lines, found, submitted)
+ # When in verbatim mode, this holds additional submitted output
+ # to be written in the final Sphinx output.
+ # https://github.com/ipython/ipython/issues/5776
+ out_data = []
+
+ is_verbatim = decorator=='@verbatim' or self.is_verbatim
+ if is_verbatim and data.strip():
+ # Note that `ret` in `process_block` has '' as its last element if
+ # the code block was in verbatim mode. So if there is no submitted
+ # output, then we will have proper spacing only if we do not add
+ # an additional '' to `out_data`. This is why we condition on
+ # `and data.strip()`.
+
+ # The submitted output has no output prompt. If we want the
+ # prompt and the code to appear, we need to join them now
+ # instead of adding them separately---as this would create an
+ # undesired newline. How we do this ultimately depends on the
+ # format of the output regex. I'll do what works for the default
+ # prompt for now, and we might have to adjust if it doesn't work
+ # in other cases. Finally, the submitted output does not have
+ # a trailing newline, so we must add it manually.
+ out_data.append("{0} {1}\n".format(output_prompt, data))
+
+ return out_data
+
def process_comment(self, data):
"""Process data fPblock for COMMENT token."""
if not self.is_suppress:
@@ -563,9 +612,7 @@ def save_image(self, image_file):
Saves the image file to disk.
"""
self.ensure_pyplot()
- command = ('plt.gcf().savefig("%s", bbox_inches="tight", '
- 'dpi=100)' % image_file)
-
+ command = 'plt.gcf().savefig("%s")'%image_file
#print 'SAVEFIG', command # dbg
self.process_input_line('bookmark ipy_thisdir', store_history=False)
self.process_input_line('cd -b ipy_savedir', store_history=False)
@@ -588,18 +635,53 @@ def process_block(self, block):
image_file = None
image_directive = None
+ found_input = False
for token, data in block:
if token == COMMENT:
out_data = self.process_comment(data)
elif token == INPUT:
- (out_data, input_lines, output, is_doctest, decorator,
- image_file, image_directive) = \
+ found_input = True
+ (out_data, input_lines, output, is_doctest,
+ decorator, image_file, image_directive) = \
self.process_input(data, input_prompt, lineno)
elif token == OUTPUT:
+ if not found_input:
+
+ TAB = ' ' * 4
+ linenumber = 0
+ source = 'Unavailable'
+ content = 'Unavailable'
+ if self.directive:
+ linenumber = self.directive.state.document.current_line
+ source = self.directive.state.document.current_source
+ content = self.directive.content
+ # Add tabs and join into a single string.
+ content = '\n'.join([TAB + line for line in content])
+
+ e = ('\n\nInvalid block: Block contains an output prompt '
+ 'without an input prompt.\n\n'
+ 'Document source: {0}\n\n'
+ 'Content begins at line {1}: \n\n{2}\n\n'
+ 'Problematic block within content: \n\n{TAB}{3}\n\n')
+ e = e.format(source, linenumber, content, block, TAB=TAB)
+
+ # Write, rather than include in exception, since Sphinx
+ # will truncate tracebacks.
+ sys.stdout.write(e)
+ raise RuntimeError('An invalid block was detected.')
+
out_data = \
- self.process_output(data, output_prompt,
- input_lines, output, is_doctest,
- decorator, image_file)
+ self.process_output(data, output_prompt, input_lines,
+ output, is_doctest, decorator,
+ image_file)
+ if out_data:
+ # Then there was user submitted output in verbatim mode.
+ # We need to remove the last element of `ret` that was
+ # added in `process_input`, as it is '' and would introduce
+ # an undesirable newline.
+ assert(ret[-1] == '')
+ del ret[-1]
+
if out_data:
ret.extend(out_data)
@@ -740,8 +822,7 @@ class IPythonDirective(Directive):
'verbatim' : directives.flag,
'doctest' : directives.flag,
'okexcept': directives.flag,
- 'okwarning': directives.flag,
- 'output_encoding': directives.unchanged_required
+ 'okwarning': directives.flag
}
shell = None
@@ -753,14 +834,9 @@ def get_config_options(self):
config = self.state.document.settings.env.config
# get config variables to set figure output directory
- confdir = self.state.document.settings.env.app.confdir
savefig_dir = config.ipython_savefig_dir
- source_dir = os.path.dirname(self.state.document.current_source)
- if savefig_dir is None:
- savefig_dir = config.html_static_path
- if isinstance(savefig_dir, list):
- savefig_dir = savefig_dir[0] # safe to assume only one path?
- savefig_dir = os.path.join(confdir, savefig_dir)
+ source_dir = self.state.document.settings.env.srcdir
+ savefig_dir = os.path.join(source_dir, savefig_dir)
# get regex and prompt stuff
rgxin = config.ipython_rgxin
@@ -779,6 +855,12 @@ def setup(self):
(savefig_dir, source_dir, rgxin, rgxout, promptin, promptout,
mplbackend, exec_lines, hold_count) = self.get_config_options()
+ try:
+ os.makedirs(savefig_dir)
+ except OSError as e:
+ if e.errno != errno.EEXIST:
+ raise
+
if self.shell is None:
# We will be here many times. However, when the
# EmbeddedSphinxShell is created, its interactive shell member
@@ -786,13 +868,11 @@ def setup(self):
if mplbackend and 'matplotlib.backends' not in sys.modules:
import matplotlib
- # Repeated calls to use() will not hurt us since `mplbackend`
- # is the same each time.
matplotlib.use(mplbackend)
# Must be called after (potentially) importing matplotlib and
# setting its backend since exec_lines might import pylab.
- self.shell = EmbeddedSphinxShell(exec_lines, self.state)
+ self.shell = EmbeddedSphinxShell(exec_lines)
# Store IPython directive to enable better error messages
self.shell.directive = self
@@ -800,14 +880,9 @@ def setup(self):
# reset the execution count if we haven't processed this doc
#NOTE: this may be borked if there are multiple seen_doc tmp files
#check time stamp?
- if self.state.document.current_source not in self.seen_docs:
+ if not self.state.document.current_source in self.seen_docs:
self.shell.IP.history_manager.reset()
self.shell.IP.execution_count = 1
- try:
- self.shell.IP.prompt_manager.width = 0
- except AttributeError:
- # GH14003: class promptManager has removed after IPython 5.x
- pass
self.seen_docs.add(self.state.document.current_source)
# and attach to shell so we don't have to pass them around
@@ -846,13 +921,13 @@ def run(self):
self.shell.is_okexcept = 'okexcept' in options
self.shell.is_okwarning = 'okwarning' in options
- self.shell.output_encoding = [options.get('output_encoding', 'utf8')]
-
# handle pure python code
if 'python' in self.arguments:
content = self.content
self.content = self.shell.process_pure_python(content)
+ # parts consists of all text within the ipython-block.
+ # Each part is an input/output block.
parts = '\n'.join(self.content).split('\n\n')
lines = ['.. code-block:: ipython', '']
@@ -863,7 +938,8 @@ def run(self):
if len(block):
rows, figure = self.shell.process_block(block)
for row in rows:
- lines.extend([' %s'%line for line in row.split('\n')])
+ lines.extend([' {0}'.format(line)
+ for line in row.split('\n')])
if figure is not None:
figures.append(figure)
@@ -873,7 +949,7 @@ def run(self):
lines.extend(figure.split('\n'))
lines.append('')
- if len(lines)>2:
+ if len(lines) > 2:
if debug:
print('\n'.join(lines))
else:
@@ -893,7 +969,7 @@ def setup(app):
setup.app = app
app.add_directive('ipython', IPythonDirective)
- app.add_config_value('ipython_savefig_dir', None, 'env')
+ app.add_config_value('ipython_savefig_dir', 'savefig', 'env')
app.add_config_value('ipython_rgxin',
re.compile('In \[(\d+)\]:\s?(.*)\s*'), 'env')
app.add_config_value('ipython_rgxout',
@@ -914,6 +990,9 @@ def setup(app):
app.add_config_value('ipython_holdcount', True, 'env')
+ metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
+ return metadata
+
# Simple smoke test, needs to be converted to a proper automatic test.
def test():
@@ -1074,7 +1153,7 @@ def test():
#ipython_directive.DEBUG = True # dbg
#options = dict(suppress=True) # dbg
- options = dict()
+ options = {}
for example in examples:
content = example.split('\n')
IPythonDirective('debug', arguments=None, options=options,
| updated to commit cc353b25b0fff58e4ed13899df9b3c8153df01d9 from ipython/ipython
xref https://github.com/pandas-dev/pandas/issues/18147, https://github.com/pandas-dev/pandas/pull/19687
Alternative for https://github.com/pandas-dev/pandas/pull/19657 until new release of IPython is out | https://api.github.com/repos/pandas-dev/pandas/pulls/19765 | 2018-02-19T10:59:16Z | 2018-02-19T13:18:18Z | 2018-02-19T13:18:18Z | 2018-02-19T13:18:45Z |
DOC: fix various warnings and errors in the docs (from deprecations/api changes | diff --git a/doc/source/advanced.rst b/doc/source/advanced.rst
index c455fbb8d0687..c81842d3d9212 100644
--- a/doc/source/advanced.rst
+++ b/doc/source/advanced.rst
@@ -274,7 +274,7 @@ Passing a list of labels or tuples works similar to reindexing:
df.loc[[('bar', 'two'), ('qux', 'one')]]
-.. info::
+.. note::
It is important to note that tuples and lists are not treated identically
in pandas when it comes to indexing. Whereas a tuple is interpreted as one
diff --git a/doc/source/dsintro.rst b/doc/source/dsintro.rst
index 78e2fdb46f659..582750b16f40d 100644
--- a/doc/source/dsintro.rst
+++ b/doc/source/dsintro.rst
@@ -506,7 +506,7 @@ to be inserted (for example, a ``Series`` or NumPy array), or a function
of one argument to be called on the ``DataFrame``. A *copy* of the original
DataFrame is returned, with the new values inserted.
-.. versionmodified:: 0.23.0
+.. versionchanged:: 0.23.0
Starting with Python 3.6 the order of ``**kwargs`` is preserved. This allows
for *dependent* assignment, where an expression later in ``**kwargs`` can refer
diff --git a/doc/source/io.rst b/doc/source/io.rst
index 7bb34e4d232dd..6120f7d25a0c3 100644
--- a/doc/source/io.rst
+++ b/doc/source/io.rst
@@ -2262,6 +2262,7 @@ is not round-trippable, nor are any names beginning with 'level_' within a
indicate missing values and the subsequent read cannot distinguish the intent.
.. ipython:: python
+ :okwarning:
df.index.name = 'index'
df.to_json('test.json', orient='table')
diff --git a/doc/source/whatsnew/v0.10.0.txt b/doc/source/whatsnew/v0.10.0.txt
index a0c4a3e0073f9..222a2da23865c 100644
--- a/doc/source/whatsnew/v0.10.0.txt
+++ b/doc/source/whatsnew/v0.10.0.txt
@@ -411,15 +411,23 @@ N Dimensional Panels (Experimental)
Adding experimental support for Panel4D and factory functions to create n-dimensional named panels.
:ref:`Docs <dsintro.panel4d>` for NDim. Here is a taste of what to expect.
- .. ipython:: python
- :okwarning:
-
- p4d = Panel4D(randn(2, 2, 5, 4),
- labels=['Label1','Label2'],
- items=['Item1', 'Item2'],
- major_axis=date_range('1/1/2000', periods=5),
- minor_axis=['A', 'B', 'C', 'D'])
- p4d
+.. code-block:: ipython
+
+ In [58]: p4d = Panel4D(randn(2, 2, 5, 4),
+ ....: labels=['Label1','Label2'],
+ ....: items=['Item1', 'Item2'],
+ ....: major_axis=date_range('1/1/2000', periods=5),
+ ....: minor_axis=['A', 'B', 'C', 'D'])
+ ....:
+
+ In [59]: p4d
+ Out[59]:
+ <class 'pandas.core.panelnd.Panel4D'>
+ Dimensions: 2 (labels) x 2 (items) x 5 (major_axis) x 4 (minor_axis)
+ Labels axis: Label1 to Label2
+ Items axis: Item1 to Item2
+ Major_axis axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00
+ Minor_axis axis: A to D
diff --git a/doc/source/whatsnew/v0.13.1.txt b/doc/source/whatsnew/v0.13.1.txt
index 5e5653945fefa..51ca6116d42ce 100644
--- a/doc/source/whatsnew/v0.13.1.txt
+++ b/doc/source/whatsnew/v0.13.1.txt
@@ -140,14 +140,21 @@ API changes
applied would be called with an empty ``Series`` to guess whether a
``Series`` or ``DataFrame`` should be returned:
- .. ipython:: python
+ .. code-block:: ipython
+
+ In [32]: def applied_func(col):
+ ....: print("Apply function being called with: ", col)
+ ....: return col.sum()
+ ....:
- def applied_func(col):
- print("Apply function being called with: ", col)
- return col.sum()
+ In [33]: empty = DataFrame(columns=['a', 'b'])
- empty = DataFrame(columns=['a', 'b'])
- empty.apply(applied_func)
+ In [34]: empty.apply(applied_func)
+ Apply function being called with: Series([], Length: 0, dtype: float64)
+ Out[34]:
+ a NaN
+ b NaN
+ Length: 2, dtype: float64
Now, when ``apply`` is called on an empty ``DataFrame``: if the ``reduce``
argument is ``True`` a ``Series`` will returned, if it is ``False`` a
@@ -155,10 +162,22 @@ API changes
function being applied will be called with an empty series to try and guess
the return type.
- .. ipython:: python
+ .. code-block:: ipython
+
+ In [35]: empty.apply(applied_func, reduce=True)
+ Out[35]:
+ a NaN
+ b NaN
+ Length: 2, dtype: float64
+
+ In [36]: empty.apply(applied_func, reduce=False)
+ Out[36]:
+ Empty DataFrame
+ Columns: [a, b]
+ Index: []
+
+ [0 rows x 2 columns]
- empty.apply(applied_func, reduce=True)
- empty.apply(applied_func, reduce=False)
Prior Version Deprecations/Changes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/doc/source/whatsnew/v0.15.0.txt b/doc/source/whatsnew/v0.15.0.txt
index ef17904d5ab1a..c5ef6c8c9d74a 100644
--- a/doc/source/whatsnew/v0.15.0.txt
+++ b/doc/source/whatsnew/v0.15.0.txt
@@ -1044,7 +1044,7 @@ Other:
idx = MultiIndex.from_product([['a'], range(3), list("pqr")], names=['foo', 'bar', 'baz'])
idx.set_names('qux', level=0)
- idx.set_names(['qux','baz'], level=[0,1])
+ idx.set_names(['qux','corge'], level=[0,1])
idx.set_levels(['a','b','c'], level='bar')
idx.set_levels([['a','b','c'],[1,2,3]], level=[1,2])
diff --git a/doc/source/whatsnew/v0.21.0.txt b/doc/source/whatsnew/v0.21.0.txt
index 3e673bd4cbc28..0c2e494f29bc1 100644
--- a/doc/source/whatsnew/v0.21.0.txt
+++ b/doc/source/whatsnew/v0.21.0.txt
@@ -894,17 +894,14 @@ imported. Matplotlib plot methods (``plt.plot``, ``ax.plot``, ...), will not
nicely format the x-axis for ``DatetimeIndex`` or ``PeriodIndex`` values. You
must explicitly register these methods:
-.. ipython:: python
-
- from pandas.tseries import converter
- converter.register()
-
- fig, ax = plt.subplots()
- plt.plot(pd.date_range('2017', periods=6), range(6))
-
Pandas built-in ``Series.plot`` and ``DataFrame.plot`` *will* register these
converters on first-use (:issue:17710).
+.. note::
+
+ This change has been temporarily reverted in pandas 0.21.1,
+ for more details see :ref:`here <whatsnew_0211.converters>`.
+
.. _whatsnew_0210.api:
Other API Changes
diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index a2198d9103528..97f451dd1f56a 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -197,6 +197,7 @@ A ``DataFrame`` can now be written to and subsequently read back via JSON while
Please note that the string `index` is not supported with the round trip format, as it is used by default in ``write_json`` to indicate a missing index name.
.. ipython:: python
+ :okwarning:
df.index.name = 'index'
df.to_json('test.json', orient='table')
diff --git a/doc/source/whatsnew/v0.8.0.txt b/doc/source/whatsnew/v0.8.0.txt
index b9cece752981e..b2d1d16e86990 100644
--- a/doc/source/whatsnew/v0.8.0.txt
+++ b/doc/source/whatsnew/v0.8.0.txt
@@ -217,12 +217,12 @@ nanosecond support (the ``nanosecond`` field store the nanosecond value between
``DatetimeIndex`` to regular NumPy arrays.
If you have code that requires an array of ``datetime.datetime`` objects, you
-have a couple of options. First, the ``asobject`` property of ``DatetimeIndex``
+have a couple of options. First, the ``astype(object)`` method of ``DatetimeIndex``
produces an array of ``Timestamp`` objects:
.. ipython:: python
- stamp_array = rng.asobject
+ stamp_array = rng.astype(object)
stamp_array
stamp_array[5]
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index a001037b573d4..32101a5c3c5ec 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -114,7 +114,7 @@
- if `axis` is 1 or `'columns'` then `by` may contain column
levels and/or index labels
- .. versionmodified:: 0.23.0
+ .. versionchanged:: 0.23.0
Allow specifying index or column level names.""",
versionadded_to_excel='',
optional_labels="""labels : array-like, optional
@@ -2696,7 +2696,7 @@ def assign(self, **kwargs):
or modified columns. All items are computed first, and then assigned
in alphabetical order.
- .. versionmodified :: 0.23.0
+ .. versionchanged :: 0.23.0
Keyword argument order is maintained for Python 3.6 and later.
| https://api.github.com/repos/pandas-dev/pandas/pulls/19763 | 2018-02-19T10:36:33Z | 2018-02-20T09:20:56Z | 2018-02-20T09:20:56Z | 2018-02-20T09:21:04Z | |
ENH: ISO8601-compliant datetime string conversion in `iterrows()` and Series construction. | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 99a3773603fc4..7f33372f765fb 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -766,7 +766,6 @@ Datetimelike
- Bug in :func:`to_datetime` where passing an out-of-bounds datetime with ``errors='coerce'`` and ``utc=True`` would raise ``OutOfBoundsDatetime`` instead of parsing to ``NaT`` (:issue:`19612`)
- Bug in :class:`DatetimeIndex` and :class:`TimedeltaIndex` addition and subtraction where name of the returned object was not always set consistently. (:issue:`19744`)
- Bug in :class:`DatetimeIndex` and :class:`TimedeltaIndex` addition and subtraction where operations with numpy arrays raised ``TypeError`` (:issue:`19847`)
--
Timedelta
^^^^^^^^^
@@ -918,6 +917,7 @@ Reshaping
- :func:`Series.rename` now accepts ``axis`` as a kwarg (:issue:`18589`)
- Comparisons between :class:`Series` and :class:`Index` would return a ``Series`` with an incorrect name, ignoring the ``Index``'s name attribute (:issue:`19582`)
- Bug in :func:`qcut` where datetime and timedelta data with ``NaT`` present raised a ``ValueError`` (:issue:`19768`)
+- Bug in :func:`DataFrame.iterrows`, which would infers strings not compliant to `ISO8601 <https://en.wikipedia.org/wiki/ISO_8601>`_ to datetimes (:issue:`19671`)
Other
^^^^^
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 352ce29f5c37b..b1d0dc2a2442e 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -904,16 +904,23 @@ def maybe_infer_to_datetimelike(value, convert_dates=False):
def try_datetime(v):
# safe coerce to datetime64
try:
- v = tslib.array_to_datetime(v, errors='raise')
+ # GH19671
+ v = tslib.array_to_datetime(v,
+ require_iso8601=True,
+ errors='raise')
except ValueError:
# we might have a sequence of the same-datetimes with tz's
# if so coerce to a DatetimeIndex; if they are not the same,
- # then these stay as object dtype
+ # then these stay as object dtype, xref GH19671
try:
- from pandas import to_datetime
- return to_datetime(v)
- except Exception:
+ from pandas._libs.tslibs import conversion
+ from pandas import DatetimeIndex
+
+ values, tz = conversion.datetime_to_datetime64(v)
+ return DatetimeIndex(values).tz_localize(
+ 'UTC').tz_convert(tz=tz)
+ except (ValueError, TypeError):
pass
except Exception:
diff --git a/pandas/core/internals.py b/pandas/core/internals.py
index d385185fbb558..00ef8f9cef598 100644
--- a/pandas/core/internals.py
+++ b/pandas/core/internals.py
@@ -2602,8 +2602,8 @@ def _maybe_coerce_values(self, values):
"""Input validation for values passed to __init__. Ensure that
we have datetime64ns, coercing if necessary.
- Parametetrs
- -----------
+ Parameters
+ ----------
values : array-like
Must be convertible to datetime64
diff --git a/pandas/tests/dtypes/test_cast.py b/pandas/tests/dtypes/test_cast.py
index 31bd962b67afb..96a9e3227b40b 100644
--- a/pandas/tests/dtypes/test_cast.py
+++ b/pandas/tests/dtypes/test_cast.py
@@ -301,6 +301,10 @@ def test_maybe_infer_to_datetimelike(self):
[NaT, 'b', 1]]))
assert result.size == 6
+ # GH19671
+ result = Series(['M1701', Timestamp('20130101')])
+ assert result.dtype.kind == 'O'
+
class TestConvert(object):
diff --git a/pandas/tests/frame/test_api.py b/pandas/tests/frame/test_api.py
index 91fe7f99ca681..8ba5469480e64 100644
--- a/pandas/tests/frame/test_api.py
+++ b/pandas/tests/frame/test_api.py
@@ -15,7 +15,8 @@
from numpy.random import randn
import numpy as np
-from pandas import DataFrame, Series, date_range, timedelta_range, Categorical
+from pandas import (DataFrame, Series, date_range, timedelta_range,
+ Categorical, SparseDataFrame)
import pandas as pd
from pandas.util.testing import (assert_almost_equal,
@@ -214,6 +215,18 @@ def test_iterrows(self):
exp = self.mixed_frame.loc[k]
self._assert_series_equal(v, exp)
+ def test_iterrows_iso8601(self):
+ # GH19671
+ if self.klass == SparseDataFrame:
+ pytest.xfail(reason='SparseBlock datetime type not implemented.')
+
+ s = self.klass(
+ {'non_iso8601': ['M1701', 'M1802', 'M1903', 'M2004'],
+ 'iso8601': date_range('2000-01-01', periods=4, freq='M')})
+ for k, v in s.iterrows():
+ exp = s.loc[k]
+ self._assert_series_equal(v, exp)
+
def test_itertuples(self):
for i, tup in enumerate(self.frame.itertuples()):
s = self.klass._constructor_sliced(tup[1:])
| - [x] closes https://github.com/pandas-dev/pandas/issues/19671
- [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/19762 | 2018-02-19T09:19:19Z | 2018-02-25T23:05:25Z | 2018-02-25T23:05:25Z | 2018-02-25T23:17:37Z |
DOC: correct Period.strftime exsample | diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index c11a8b149bc13..32ffe4e6d0453 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -1403,7 +1403,7 @@ cdef class _Period(object):
Examples
--------
- >>> a = Period(freq='Q@JUL', year=2006, quarter=1)
+ >>> a = Period(freq='Q-JUL', year=2006, quarter=1)
>>> a.strftime('%F-Q%q')
'2006-Q1'
>>> # Output the last month in the quarter of this date
| - [ ] 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/19758 | 2018-02-19T02:55:34Z | 2018-02-19T13:52:14Z | 2018-02-19T13:52:14Z | 2018-02-19T14:49:48Z |
ENH: fake http proxy in case of --skip-network testing | diff --git a/ci/script_multi.sh b/ci/script_multi.sh
index 6c354fc4cab0b..45c61ee3172fe 100755
--- a/ci/script_multi.sh
+++ b/ci/script_multi.sh
@@ -12,6 +12,11 @@ if [ -n "$LOCALE_OVERRIDE" ]; then
python -c "$pycmd"
fi
+# Enforce absent network during testing by faking a proxy
+if echo "$TEST_ARGS" | grep -e --skip-network -q; then
+ export http_proxy=http://1.2.3.4 https_proxy=http://1.2.3.4;
+fi
+
# Workaround for pytest-xdist flaky collection order
# https://github.com/pytest-dev/pytest/issues/920
# https://github.com/pytest-dev/pytest/issues/1075
diff --git a/ci/script_single.sh b/ci/script_single.sh
index 74b0e897f1d73..021a5a7714fb5 100755
--- a/ci/script_single.sh
+++ b/ci/script_single.sh
@@ -16,6 +16,11 @@ if [ "$SLOW" ]; then
TEST_ARGS="--only-slow --skip-network"
fi
+# Enforce absent network during testing by faking a proxy
+if echo "$TEST_ARGS" | grep -e --skip-network -q; then
+ export http_proxy=http://1.2.3.4 https_proxy=http://1.2.3.4;
+fi
+
if [ "$PIP_BUILD_TEST" ]; then
echo "We are not running pytest as this is a build test."
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index b438d6a6137b0..a595d9f18d6b8 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -53,6 +53,7 @@ def test_xarray(df):
assert df.to_xarray() is not None
+@tm.network
def test_statsmodels():
statsmodels = import_module('statsmodels') # noqa
@@ -73,6 +74,7 @@ def test_scikit_learn(df):
clf.predict(digits.data[-1:])
+@tm.network
def test_seaborn():
seaborn = import_module('seaborn')
| - [ ] tests added / passed - most likely they will fail until #19754 is merged. there might be more
- [ ] whatsnew entry - probably not worthwhile for this
| https://api.github.com/repos/pandas-dev/pandas/pulls/19757 | 2018-02-19T02:49:43Z | 2018-02-19T15:38:41Z | 2018-02-19T15:38:41Z | 2018-02-20T22:35:27Z |
ENH: implement Timedelta.__mod__ and __divmod__ | diff --git a/doc/source/timedeltas.rst b/doc/source/timedeltas.rst
index 50cff4c7bbdfb..5f3a01f0725d4 100644
--- a/doc/source/timedeltas.rst
+++ b/doc/source/timedeltas.rst
@@ -283,6 +283,20 @@ Rounded division (floor-division) of a ``timedelta64[ns]`` Series by a scalar
td // pd.Timedelta(days=3, hours=4)
pd.Timedelta(days=3, hours=4) // td
+.. _timedeltas.mod_divmod:
+
+The mod (%) and divmod operations are defined for ``Timedelta`` when operating with another timedelta-like or with a numeric argument.
+
+.. ipython:: python
+
+ pd.Timedelta(hours=37) % datetime.timedelta(hours=2)
+
+ # divmod against a timedelta-like returns a pair (int, Timedelta)
+ divmod(datetime.timedelta(hours=2), pd.Timedelta(minutes=11))
+
+ # divmod against a numeric returns a pair (Timedelta, Timedelta)
+ divmod(pd.Timedelta(hours=25), 86400000000000)
+
Attributes
----------
diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 11c49995372f5..aa1e434aae6e9 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -117,6 +117,20 @@ resetting indexes. See the :ref:`Sorting by Indexes and Values
# Sort by 'second' (index) and 'A' (column)
df_multi.sort_values(by=['second', 'A'])
+.. _whatsnew_0230.enhancements.timedelta_mod
+
+Timedelta mod method
+^^^^^^^^^^^^^^^^^^^^
+
+``mod`` (%) and ``divmod`` operations are now defined on ``Timedelta`` objects
+when operating with either timedelta-like or with numeric arguments.
+See the :ref:`documentation here <timedeltas.mod_divmod>`. (:issue:`19365`)
+
+.. ipython:: python
+
+ td = pd.Timedelta(hours=37)
+ td % pd.Timedelta(minutes=45)
+
.. _whatsnew_0230.enhancements.ran_inf:
``.rank()`` handles ``inf`` values when ``NaN`` are present
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 37693068e0974..f10175fddd00b 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1149,6 +1149,24 @@ class Timedelta(_Timedelta):
return np.nan
return other.value // self.value
+ def __mod__(self, other):
+ # Naive implementation, room for optimization
+ return self.__divmod__(other)[1]
+
+ def __rmod__(self, other):
+ # Naive implementation, room for optimization
+ return self.__rdivmod__(other)[1]
+
+ def __divmod__(self, other):
+ # Naive implementation, room for optimization
+ div = self // other
+ return div, self - div * other
+
+ def __rdivmod__(self, other):
+ # Naive implementation, room for optimization
+ div = other // self
+ return div, other - div * self
+
cdef _floordiv(int64_t value, right):
return value // right
diff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py
index 90c911c24f6a9..43e9491b9de0b 100644
--- a/pandas/tests/scalar/timedelta/test_arithmetic.py
+++ b/pandas/tests/scalar/timedelta/test_arithmetic.py
@@ -420,3 +420,189 @@ def test_td_rfloordiv_numeric_series(self):
assert res is NotImplemented
with pytest.raises(TypeError):
ser // td
+
+ def test_mod_timedeltalike(self):
+ # GH#19365
+ td = Timedelta(hours=37)
+
+ # Timedelta-like others
+ result = td % Timedelta(hours=6)
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(hours=1)
+
+ result = td % timedelta(minutes=60)
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(0)
+
+ result = td % NaT
+ assert result is NaT
+
+ @pytest.mark.xfail(reason='GH#19378 floordiv td64 returns td64')
+ def test_mod_timedelta64_nat(self):
+ # GH#19365
+ td = Timedelta(hours=37)
+
+ result = td % np.timedelta64('NaT', 'ns')
+ assert result is NaT
+
+ @pytest.mark.xfail(reason='GH#19378 floordiv td64 returns td64')
+ def test_mod_timedelta64(self):
+ # GH#19365
+ td = Timedelta(hours=37)
+
+ result = td % np.timedelta64(2, 'h')
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(hours=1)
+
+ @pytest.mark.xfail(reason='GH#19378 floordiv by Tick not implemented')
+ def test_mod_offset(self):
+ # GH#19365
+ td = Timedelta(hours=37)
+
+ result = td % pd.offsets.Hour(5)
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(hours=2)
+
+ # ----------------------------------------------------------------
+ # Timedelta.__mod__, __rmod__
+
+ def test_mod_numeric(self):
+ # GH#19365
+ td = Timedelta(hours=37)
+
+ # Numeric Others
+ result = td % 2
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(0)
+
+ result = td % 1e12
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(minutes=3, seconds=20)
+
+ result = td % int(1e12)
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(minutes=3, seconds=20)
+
+ def test_mod_invalid(self):
+ # GH#19365
+ td = Timedelta(hours=37)
+
+ with pytest.raises(TypeError):
+ td % pd.Timestamp('2018-01-22')
+
+ with pytest.raises(TypeError):
+ td % []
+
+ def test_rmod_pytimedelta(self):
+ # GH#19365
+ td = Timedelta(minutes=3)
+
+ result = timedelta(minutes=4) % td
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(minutes=1)
+
+ @pytest.mark.xfail(reason='GH#19378 floordiv by Tick not implemented')
+ def test_rmod_timedelta64(self):
+ # GH#19365
+ td = Timedelta(minutes=3)
+ result = np.timedelta64(5, 'm') % td
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(minutes=2)
+
+ def test_rmod_invalid(self):
+ # GH#19365
+ td = Timedelta(minutes=3)
+
+ with pytest.raises(TypeError):
+ pd.Timestamp('2018-01-22') % td
+
+ with pytest.raises(TypeError):
+ 15 % td
+
+ with pytest.raises(TypeError):
+ 16.0 % td
+
+ with pytest.raises(TypeError):
+ np.array([22, 24]) % td
+
+ # ----------------------------------------------------------------
+ # Timedelta.__divmod__, __rdivmod__
+
+ def test_divmod_numeric(self):
+ # GH#19365
+ td = Timedelta(days=2, hours=6)
+
+ result = divmod(td, 53 * 3600 * 1e9)
+ assert result[0] == Timedelta(1, unit='ns')
+ assert isinstance(result[1], Timedelta)
+ assert result[1] == Timedelta(hours=1)
+
+ assert result
+ result = divmod(td, np.nan)
+ assert result[0] is pd.NaT
+ assert result[1] is pd.NaT
+
+ def test_divmod(self):
+ # GH#19365
+ td = Timedelta(days=2, hours=6)
+
+ result = divmod(td, timedelta(days=1))
+ assert result[0] == 2
+ assert isinstance(result[1], Timedelta)
+ assert result[1] == Timedelta(hours=6)
+
+ result = divmod(td, 54)
+ assert result[0] == Timedelta(hours=1)
+ assert isinstance(result[1], Timedelta)
+ assert result[1] == Timedelta(0)
+
+ result = divmod(td, pd.NaT)
+ assert np.isnan(result[0])
+ assert result[1] is pd.NaT
+
+ @pytest.mark.xfail(reason='GH#19378 floordiv by Tick not implemented')
+ def test_divmod_offset(self):
+ # GH#19365
+ td = Timedelta(days=2, hours=6)
+
+ result = divmod(td, pd.offsets.Hour(-4))
+ assert result[0] == -14
+ assert isinstance(result[1], Timedelta)
+ assert result[1] == Timedelta(hours=-2)
+
+ def test_divmod_invalid(self):
+ # GH#19365
+ td = Timedelta(days=2, hours=6)
+
+ with pytest.raises(TypeError):
+ divmod(td, pd.Timestamp('2018-01-22'))
+
+ def test_rdivmod_pytimedelta(self):
+ # GH#19365
+ result = divmod(timedelta(days=2, hours=6), Timedelta(days=1))
+ assert result[0] == 2
+ assert isinstance(result[1], Timedelta)
+ assert result[1] == Timedelta(hours=6)
+
+ @pytest.mark.xfail(reason='GH#19378 floordiv by Tick not implemented')
+ def test_rdivmod_offset(self):
+ result = divmod(pd.offsets.Hour(54), Timedelta(hours=-4))
+ assert result[0] == -14
+ assert isinstance(result[1], Timedelta)
+ assert result[1] == Timedelta(hours=-2)
+
+ def test_rdivmod_invalid(self):
+ # GH#19365
+ td = Timedelta(minutes=3)
+
+ with pytest.raises(TypeError):
+ divmod(pd.Timestamp('2018-01-22'), td)
+
+ with pytest.raises(TypeError):
+ divmod(15, td)
+
+ with pytest.raises(TypeError):
+ divmod(16.0, td)
+
+ with pytest.raises(TypeError):
+ divmod(np.array([22, 24]), td)
| This implements exclusively the `__mod__, __rmod__, __divmod__, __rdivmod__` parts of #19365, does _not_ implement any of the bugfixes or tests that got rolled into that PR. Several tests are xfailed for now, will be fixed after #19738. These tests will be rebased/moved to test_arithmetic after #19752.
- [ ] closes #xxxx
- [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/19755 | 2018-02-19T00:04:04Z | 2018-02-19T23:16:05Z | 2018-02-19T23:16:05Z | 2018-06-22T03:23:22Z |
TST: add test for numpy ops, esp. nanmin/max bug for np<1.13 | diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py
index df3c49a73d227..dffb303af6ae1 100644
--- a/pandas/tests/test_nanops.py
+++ b/pandas/tests/test_nanops.py
@@ -13,6 +13,7 @@
import pandas.core.nanops as nanops
import pandas.util.testing as tm
import pandas.util._test_decorators as td
+from pandas.compat.numpy import _np_version_under1p13
use_bn = nanops._USE_BOTTLENECK
@@ -1015,3 +1016,34 @@ def test_use_bottleneck():
assert not pd.get_option('use_bottleneck')
pd.set_option('use_bottleneck', use_bn)
+
+
+@pytest.mark.parametrize("numpy_op, expected", [
+ (np.sum, 10),
+ (np.nansum, 10),
+ (np.mean, 2.5),
+ (np.nanmean, 2.5),
+ (np.median, 2.5),
+ (np.nanmedian, 2.5),
+ (np.min, 1),
+ (np.max, 4),
+])
+def test_numpy_ops(numpy_op, expected):
+ # GH8383
+ result = numpy_op(pd.Series([1, 2, 3, 4]))
+ assert result == expected
+
+
+@pytest.mark.parametrize("numpy_op, expected", [
+ (np.nanmin, 1),
+ (np.nanmax, 4),
+])
+def test_numpy_ops_np_version_under1p13(numpy_op, expected):
+ # GH8383
+ result = numpy_op(pd.Series([1, 2, 3, 4]))
+ if _np_version_under1p13:
+ # bug for numpy < 1.13, where result is a series, should be a scalar
+ with pytest.raises(ValueError):
+ assert result == expected
+ else:
+ assert result == expected
| - [x] closes #8383
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
The bug in #8383 concerns np.nanmin and np.nanmax only, don't know if I'm testing too much. | https://api.github.com/repos/pandas-dev/pandas/pulls/19753 | 2018-02-18T22:13:06Z | 2018-02-19T13:50:57Z | 2018-02-19T13:50:57Z | 2018-05-18T18:09:17Z |
split off scalar tests to submodules | diff --git a/pandas/tests/scalar/interval/__init__.py b/pandas/tests/scalar/interval/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/scalar/test_interval.py b/pandas/tests/scalar/interval/test_interval.py
similarity index 100%
rename from pandas/tests/scalar/test_interval.py
rename to pandas/tests/scalar/interval/test_interval.py
diff --git a/pandas/tests/scalar/period/__init__.py b/pandas/tests/scalar/period/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/scalar/test_period.py b/pandas/tests/scalar/period/test_period.py
similarity index 100%
rename from pandas/tests/scalar/test_period.py
rename to pandas/tests/scalar/period/test_period.py
diff --git a/pandas/tests/scalar/test_period_asfreq.py b/pandas/tests/scalar/period/test_period_asfreq.py
similarity index 100%
rename from pandas/tests/scalar/test_period_asfreq.py
rename to pandas/tests/scalar/period/test_period_asfreq.py
diff --git a/pandas/tests/scalar/timedelta/__init__.py b/pandas/tests/scalar/timedelta/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py
new file mode 100644
index 0000000000000..90c911c24f6a9
--- /dev/null
+++ b/pandas/tests/scalar/timedelta/test_arithmetic.py
@@ -0,0 +1,422 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for scalar Timedelta arithmetic ops
+"""
+from datetime import datetime, timedelta
+import operator
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas.util.testing as tm
+from pandas.core import ops
+from pandas import Timedelta, Timestamp, NaT
+
+
+class TestTimedeltaAdditionSubtraction(object):
+ """
+ Tests for Timedelta methods:
+
+ __add__, __radd__,
+ __sub__, __rsub__
+ """
+ @pytest.mark.parametrize('ten_seconds', [
+ Timedelta(10, unit='s'),
+ timedelta(seconds=10),
+ np.timedelta64(10, 's'),
+ np.timedelta64(10000000000, 'ns'),
+ pd.offsets.Second(10)])
+ def test_td_add_sub_ten_seconds(self, ten_seconds):
+ # GH#6808
+ base = Timestamp('20130101 09:01:12.123456')
+ expected_add = Timestamp('20130101 09:01:22.123456')
+ expected_sub = Timestamp('20130101 09:01:02.123456')
+
+ result = base + ten_seconds
+ assert result == expected_add
+
+ result = base - ten_seconds
+ assert result == expected_sub
+
+ @pytest.mark.parametrize('one_day_ten_secs', [
+ Timedelta('1 day, 00:00:10'),
+ Timedelta('1 days, 00:00:10'),
+ timedelta(days=1, seconds=10),
+ np.timedelta64(1, 'D') + np.timedelta64(10, 's'),
+ pd.offsets.Day() + pd.offsets.Second(10)])
+ def test_td_add_sub_one_day_ten_seconds(self, one_day_ten_secs):
+ # GH#6808
+ base = Timestamp('20130102 09:01:12.123456')
+ expected_add = Timestamp('20130103 09:01:22.123456')
+ expected_sub = Timestamp('20130101 09:01:02.123456')
+
+ result = base + one_day_ten_secs
+ assert result == expected_add
+
+ result = base - one_day_ten_secs
+ assert result == expected_sub
+
+ @pytest.mark.parametrize('op', [operator.add, ops.radd])
+ def test_td_add_datetimelike_scalar(self, op):
+ # GH#19738
+ td = Timedelta(10, unit='d')
+
+ result = op(td, datetime(2016, 1, 1))
+ if op is operator.add:
+ # datetime + Timedelta does _not_ call Timedelta.__radd__,
+ # so we get a datetime back instead of a Timestamp
+ assert isinstance(result, Timestamp)
+ assert result == Timestamp(2016, 1, 11)
+
+ result = op(td, Timestamp('2018-01-12 18:09'))
+ assert isinstance(result, Timestamp)
+ assert result == Timestamp('2018-01-22 18:09')
+
+ result = op(td, np.datetime64('2018-01-12'))
+ assert isinstance(result, Timestamp)
+ assert result == Timestamp('2018-01-22')
+
+ result = op(td, NaT)
+ assert result is NaT
+
+ with pytest.raises(TypeError):
+ op(td, 2)
+ with pytest.raises(TypeError):
+ op(td, 2.0)
+
+ @pytest.mark.parametrize('op', [operator.add, ops.radd])
+ def test_td_add_td(self, op):
+ td = Timedelta(10, unit='d')
+
+ result = op(td, Timedelta(days=10))
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(days=20)
+
+ @pytest.mark.parametrize('op', [operator.add, ops.radd])
+ def test_td_add_pytimedelta(self, op):
+ td = Timedelta(10, unit='d')
+ result = op(td, timedelta(days=9))
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(days=19)
+
+ @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
+ @pytest.mark.parametrize('op', [operator.add, ops.radd])
+ def test_td_add_timedelta64(self, op):
+ td = Timedelta(10, unit='d')
+ result = op(td, np.timedelta64(-4, 'D'))
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(days=6)
+
+ @pytest.mark.parametrize('op', [operator.add, ops.radd])
+ def test_td_add_offset(self, op):
+ td = Timedelta(10, unit='d')
+
+ result = op(td, pd.offsets.Hour(6))
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(days=10, hours=6)
+
+ def test_td_sub_td(self):
+ td = Timedelta(10, unit='d')
+ expected = Timedelta(0, unit='ns')
+ result = td - td
+ assert isinstance(result, Timedelta)
+ assert result == expected
+
+ def test_td_sub_pytimedelta(self):
+ td = Timedelta(10, unit='d')
+ expected = Timedelta(0, unit='ns')
+ result = td - td.to_pytimedelta()
+ assert isinstance(result, Timedelta)
+ assert result == expected
+
+ @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
+ def test_td_sub_timedelta64(self):
+ td = Timedelta(10, unit='d')
+ expected = Timedelta(0, unit='ns')
+ result = td - td.to_timedelta64()
+ assert isinstance(result, Timedelta)
+ # comparison fails even if we comment out the isinstance assertion
+ assert result == expected
+
+ def test_td_sub_nat(self):
+ td = Timedelta(10, unit='d')
+ result = td - NaT
+ assert result is NaT
+
+ @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
+ def test_td_sub_td64_nat(self):
+ td = Timedelta(10, unit='d')
+ result = td - np.timedelta64('NaT')
+ assert result is NaT
+
+ def test_td_sub_offset(self):
+ td = Timedelta(10, unit='d')
+ result = td - pd.offsets.Hour(1)
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(239, unit='h')
+
+ def test_td_sub_numeric_raises(self):
+ td = td = Timedelta(10, unit='d')
+ with pytest.raises(TypeError):
+ td - 2
+ with pytest.raises(TypeError):
+ td - 2.0
+
+ def test_td_rsub_pytimedelta(self):
+ td = Timedelta(10, unit='d')
+ expected = Timedelta(0, unit='ns')
+
+ result = td.to_pytimedelta() - td
+ assert isinstance(result, Timedelta)
+ assert result == expected
+
+ @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
+ def test_td_rsub_timedelta64(self):
+ td = Timedelta(10, unit='d')
+ expected = Timedelta(0, unit='ns')
+
+ result = td.to_timedelta64() - td
+ assert isinstance(result, Timedelta)
+ assert result == expected
+
+ def test_td_rsub_nat(self):
+ td = Timedelta(10, unit='d')
+ result = NaT - td
+ assert result is NaT
+
+ result = np.datetime64('NaT') - td
+ assert result is NaT
+
+ @pytest.mark.xfail(reason='GH#19738 argument not converted to Timedelta')
+ def test_td_rsub_td64_nat(self):
+ td = Timedelta(10, unit='d')
+ result = np.timedelta64('NaT') - td
+ assert result is NaT
+
+ def test_td_rsub_offset(self):
+ result = pd.offsets.Hour(1) - Timedelta(10, unit='d')
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(-239, unit='h')
+
+ def test_td_rsub_numeric_raises(self):
+ td = td = Timedelta(10, unit='d')
+ with pytest.raises(TypeError):
+ 2 - td
+ with pytest.raises(TypeError):
+ 2.0 - td
+
+
+class TestTimedeltaMultiplicationDivision(object):
+ """
+ Tests for Timedelta methods:
+
+ __mul__, __rmul__,
+ __div__, __rdiv__,
+ __truediv__, __rtruediv__,
+ __floordiv__, __rfloordiv__,
+ __mod__, __rmod__,
+ __divmod__, __rdivmod__
+ """
+
+ # ---------------------------------------------------------------
+ # Timedelta.__mul__, __rmul__
+
+ @pytest.mark.parametrize('op', [operator.mul, ops.rmul])
+ def test_td_mul_scalar(self, op):
+ # GH#19738
+ td = Timedelta(minutes=3)
+
+ result = op(td, 2)
+ assert result == Timedelta(minutes=6)
+
+ result = op(td, 1.5)
+ assert result == Timedelta(minutes=4, seconds=30)
+
+ assert op(td, np.nan) is NaT
+
+ assert op(-1, td).value == -1 * td.value
+ assert op(-1.0, td).value == -1.0 * td.value
+
+ with pytest.raises(TypeError):
+ # timedelta * datetime is gibberish
+ op(td, Timestamp(2016, 1, 2))
+
+ with pytest.raises(TypeError):
+ # invalid multiply with another timedelta
+ op(td, td)
+
+ # ---------------------------------------------------------------
+ # Timedelta.__div__, __truediv__
+
+ def test_td_div_timedeltalike_scalar(self):
+ # GH#19738
+ td = Timedelta(10, unit='d')
+
+ result = td / pd.offsets.Hour(1)
+ assert result == 240
+
+ assert td / td == 1
+ assert td / np.timedelta64(60, 'h') == 4
+
+ assert np.isnan(td / NaT)
+
+ def test_td_div_numeric_scalar(self):
+ # GH#19738
+ td = Timedelta(10, unit='d')
+
+ result = td / 2
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(days=5)
+
+ result = td / 5.0
+ assert isinstance(result, Timedelta)
+ assert result == Timedelta(days=2)
+
+ # ---------------------------------------------------------------
+ # Timedelta.__rdiv__
+
+ def test_td_rdiv_timedeltalike_scalar(self):
+ # GH#19738
+ td = Timedelta(10, unit='d')
+ result = pd.offsets.Hour(1) / td
+ assert result == 1 / 240.0
+
+ assert np.timedelta64(60, 'h') / td == 0.25
+
+ # ---------------------------------------------------------------
+ # Timedelta.__floordiv__
+
+ def test_td_floordiv_timedeltalike_scalar(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=4)
+ scalar = Timedelta(hours=3, minutes=3)
+
+ assert td // scalar == 1
+ assert -td // scalar.to_pytimedelta() == -2
+ assert (2 * td) // scalar.to_timedelta64() == 2
+
+ def test_td_floordiv_null_scalar(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=4)
+
+ assert td // np.nan is NaT
+ assert np.isnan(td // NaT)
+ assert np.isnan(td // np.timedelta64('NaT'))
+
+ def test_td_floordiv_invalid_scalar(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=4)
+
+ with pytest.raises(TypeError):
+ td // np.datetime64('2016-01-01', dtype='datetime64[us]')
+
+ def test_td_floordiv_numeric_scalar(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=4)
+
+ expected = Timedelta(hours=1, minutes=32)
+ assert td // 2 == expected
+ assert td // 2.0 == expected
+ assert td // np.float64(2.0) == expected
+ assert td // np.int32(2.0) == expected
+ assert td // np.uint8(2.0) == expected
+
+ def test_floordiv_timedeltalike_array(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=4)
+ scalar = Timedelta(hours=3, minutes=3)
+
+ # Array-like others
+ assert td // np.array(scalar.to_timedelta64()) == 1
+
+ res = (3 * td) // np.array([scalar.to_timedelta64()])
+ expected = np.array([3], dtype=np.int64)
+ tm.assert_numpy_array_equal(res, expected)
+
+ res = (10 * td) // np.array([scalar.to_timedelta64(),
+ np.timedelta64('NaT')])
+ expected = np.array([10, np.nan])
+ tm.assert_numpy_array_equal(res, expected)
+
+ def test_td_floordiv_numeric_series(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=4)
+ ser = pd.Series([1], dtype=np.int64)
+ res = td // ser
+ assert res.dtype.kind == 'm'
+
+ # ---------------------------------------------------------------
+ # Timedelta.__rfloordiv__
+
+ def test_td_rfloordiv_timedeltalike_scalar(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=3)
+ scalar = Timedelta(hours=3, minutes=4)
+
+ # scalar others
+ # x // Timedelta is defined only for timedelta-like x. int-like,
+ # float-like, and date-like, in particular, should all either
+ # a) raise TypeError directly or
+ # b) return NotImplemented, following which the reversed
+ # operation will raise TypeError.
+ assert td.__rfloordiv__(scalar) == 1
+ assert (-td).__rfloordiv__(scalar.to_pytimedelta()) == -2
+ assert (2 * td).__rfloordiv__(scalar.to_timedelta64()) == 0
+
+ def test_td_rfloordiv_null_scalar(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=3)
+
+ assert np.isnan(td.__rfloordiv__(NaT))
+ assert np.isnan(td.__rfloordiv__(np.timedelta64('NaT')))
+
+ def test_td_rfloordiv_invalid_scalar(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=3)
+
+ dt64 = np.datetime64('2016-01-01', dtype='datetime64[us]')
+ with pytest.raises(TypeError):
+ td.__rfloordiv__(dt64)
+
+ def test_td_rfloordiv_numeric_scalar(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=3)
+
+ assert td.__rfloordiv__(np.nan) is NotImplemented
+ assert td.__rfloordiv__(3.5) is NotImplemented
+ assert td.__rfloordiv__(2) is NotImplemented
+
+ with pytest.raises(TypeError):
+ td.__rfloordiv__(np.float64(2.0))
+ with pytest.raises(TypeError):
+ td.__rfloordiv__(np.int32(2.0))
+ with pytest.raises(TypeError):
+ td.__rfloordiv__(np.uint8(9))
+
+ def test_td_rfloordiv_timedeltalike_array(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=3)
+ scalar = Timedelta(hours=3, minutes=4)
+
+ # Array-like others
+ assert td.__rfloordiv__(np.array(scalar.to_timedelta64())) == 1
+
+ res = td.__rfloordiv__(np.array([(3 * scalar).to_timedelta64()]))
+ expected = np.array([3], dtype=np.int64)
+ tm.assert_numpy_array_equal(res, expected)
+
+ arr = np.array([(10 * scalar).to_timedelta64(),
+ np.timedelta64('NaT')])
+ res = td.__rfloordiv__(arr)
+ expected = np.array([10, np.nan])
+ tm.assert_numpy_array_equal(res, expected)
+
+ def test_td_rfloordiv_numeric_series(self):
+ # GH#18846
+ td = Timedelta(hours=3, minutes=3)
+ ser = pd.Series([1], dtype=np.int64)
+ res = td.__rfloordiv__(ser)
+ assert res is NotImplemented
+ with pytest.raises(TypeError):
+ ser // td
diff --git a/pandas/tests/scalar/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
similarity index 83%
rename from pandas/tests/scalar/test_timedelta.py
rename to pandas/tests/scalar/timedelta/test_timedelta.py
index 667266be2a89b..420b66b4ce0dc 100644
--- a/pandas/tests/scalar/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -74,46 +74,6 @@ class Other:
assert td.__mul__(other) is NotImplemented
assert td.__floordiv__(other) is NotImplemented
- def test_timedelta_ops_scalar(self):
- # GH 6808
- base = pd.to_datetime('20130101 09:01:12.123456')
- expected_add = pd.to_datetime('20130101 09:01:22.123456')
- expected_sub = pd.to_datetime('20130101 09:01:02.123456')
-
- for offset in [pd.to_timedelta(10, unit='s'), timedelta(seconds=10),
- np.timedelta64(10, 's'),
- np.timedelta64(10000000000, 'ns'),
- pd.offsets.Second(10)]:
- result = base + offset
- assert result == expected_add
-
- result = base - offset
- assert result == expected_sub
-
- base = pd.to_datetime('20130102 09:01:12.123456')
- expected_add = pd.to_datetime('20130103 09:01:22.123456')
- expected_sub = pd.to_datetime('20130101 09:01:02.123456')
-
- for offset in [pd.to_timedelta('1 day, 00:00:10'),
- pd.to_timedelta('1 days, 00:00:10'),
- timedelta(days=1, seconds=10),
- np.timedelta64(1, 'D') + np.timedelta64(10, 's'),
- pd.offsets.Day() + pd.offsets.Second(10)]:
- result = base + offset
- assert result == expected_add
-
- result = base - offset
- assert result == expected_sub
-
- def test_ops_offsets(self):
- td = Timedelta(10, unit='d')
- assert Timedelta(241, unit='h') == td + pd.offsets.Hour(1)
- assert Timedelta(241, unit='h') == pd.offsets.Hour(1) + td
- assert 240 == td / pd.offsets.Hour(1)
- assert 1 / 240.0 == pd.offsets.Hour(1) / td
- assert Timedelta(239, unit='h') == td - pd.offsets.Hour(1)
- assert Timedelta(-239, unit='h') == pd.offsets.Hour(1) - td
-
def test_unary_ops(self):
td = Timedelta(10, unit='d')
@@ -129,130 +89,8 @@ def test_unary_ops(self):
def test_binary_ops_nat(self):
td = Timedelta(10, unit='d')
-
- assert (td - pd.NaT) is pd.NaT
- assert (td + pd.NaT) is pd.NaT
+ # FIXME: The next test is wrong: td * NaT should raise
assert (td * pd.NaT) is pd.NaT
- assert (td / pd.NaT) is np.nan
- assert (td // pd.NaT) is np.nan
- assert (td // np.timedelta64('NaT')) is np.nan
-
- def test_binary_ops_integers(self):
- td = Timedelta(10, unit='d')
-
- assert td * 2 == Timedelta(20, unit='d')
- assert td / 2 == Timedelta(5, unit='d')
- assert td // 2 == Timedelta(5, unit='d')
-
- # invert
- assert td * -1 == Timedelta('-10d')
- assert -1 * td == Timedelta('-10d')
-
- # can't operate with integers
- pytest.raises(TypeError, lambda: td + 2)
- pytest.raises(TypeError, lambda: td - 2)
-
- def test_binary_ops_with_timedelta(self):
- td = Timedelta(10, unit='d')
-
- assert td - td == Timedelta(0, unit='ns')
- assert td + td == Timedelta(20, unit='d')
- assert td / td == 1
-
- # invalid multiply with another timedelta
- pytest.raises(TypeError, lambda: td * td)
-
- def test_floordiv(self):
- # GH#18846
- td = Timedelta(hours=3, minutes=4)
- scalar = Timedelta(hours=3, minutes=3)
-
- # scalar others
- assert td // scalar == 1
- assert -td // scalar.to_pytimedelta() == -2
- assert (2 * td) // scalar.to_timedelta64() == 2
-
- assert td // np.nan is pd.NaT
- assert np.isnan(td // pd.NaT)
- assert np.isnan(td // np.timedelta64('NaT'))
-
- with pytest.raises(TypeError):
- td // np.datetime64('2016-01-01', dtype='datetime64[us]')
-
- expected = Timedelta(hours=1, minutes=32)
- assert td // 2 == expected
- assert td // 2.0 == expected
- assert td // np.float64(2.0) == expected
- assert td // np.int32(2.0) == expected
- assert td // np.uint8(2.0) == expected
-
- # Array-like others
- assert td // np.array(scalar.to_timedelta64()) == 1
-
- res = (3 * td) // np.array([scalar.to_timedelta64()])
- expected = np.array([3], dtype=np.int64)
- tm.assert_numpy_array_equal(res, expected)
-
- res = (10 * td) // np.array([scalar.to_timedelta64(),
- np.timedelta64('NaT')])
- expected = np.array([10, np.nan])
- tm.assert_numpy_array_equal(res, expected)
-
- ser = pd.Series([1], dtype=np.int64)
- res = td // ser
- assert res.dtype.kind == 'm'
-
- def test_rfloordiv(self):
- # GH#18846
- td = Timedelta(hours=3, minutes=3)
- scalar = Timedelta(hours=3, minutes=4)
-
- # scalar others
- # x // Timedelta is defined only for timedelta-like x. int-like,
- # float-like, and date-like, in particular, should all either
- # a) raise TypeError directly or
- # b) return NotImplemented, following which the reversed
- # operation will raise TypeError.
- assert td.__rfloordiv__(scalar) == 1
- assert (-td).__rfloordiv__(scalar.to_pytimedelta()) == -2
- assert (2 * td).__rfloordiv__(scalar.to_timedelta64()) == 0
-
- assert np.isnan(td.__rfloordiv__(pd.NaT))
- assert np.isnan(td.__rfloordiv__(np.timedelta64('NaT')))
-
- dt64 = np.datetime64('2016-01-01', dtype='datetime64[us]')
- with pytest.raises(TypeError):
- td.__rfloordiv__(dt64)
-
- assert td.__rfloordiv__(np.nan) is NotImplemented
- assert td.__rfloordiv__(3.5) is NotImplemented
- assert td.__rfloordiv__(2) is NotImplemented
-
- with pytest.raises(TypeError):
- td.__rfloordiv__(np.float64(2.0))
- with pytest.raises(TypeError):
- td.__rfloordiv__(np.int32(2.0))
- with pytest.raises(TypeError):
- td.__rfloordiv__(np.uint8(9))
-
- # Array-like others
- assert td.__rfloordiv__(np.array(scalar.to_timedelta64())) == 1
-
- res = td.__rfloordiv__(np.array([(3 * scalar).to_timedelta64()]))
- expected = np.array([3], dtype=np.int64)
- tm.assert_numpy_array_equal(res, expected)
-
- arr = np.array([(10 * scalar).to_timedelta64(),
- np.timedelta64('NaT')])
- res = td.__rfloordiv__(arr)
- expected = np.array([10, np.nan])
- tm.assert_numpy_array_equal(res, expected)
-
- ser = pd.Series([1], dtype=np.int64)
- res = td.__rfloordiv__(ser)
- assert res is NotImplemented
- with pytest.raises(TypeError):
- ser // td
class TestTimedeltaComparison(object):
diff --git a/pandas/tests/scalar/test_timestamp.py b/pandas/tests/scalar/timestamp/test_timestamp.py
similarity index 100%
rename from pandas/tests/scalar/test_timestamp.py
rename to pandas/tests/scalar/timestamp/test_timestamp.py
| Spun off from #19738, implements test_arithmetic for timedeltas, _moves_ and organizes tests without changing anything in the non-test code.
A handful of xfail tests are implemented (these are fixed in #19378) | https://api.github.com/repos/pandas-dev/pandas/pulls/19752 | 2018-02-18T20:34:27Z | 2018-02-19T16:45:31Z | 2018-02-19T16:45:31Z | 2018-06-22T03:31:08Z |
DEPR: Add deprecation warning for factorize() order keyword | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 35856b64c171a..ed3069943bb6a 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -610,6 +610,7 @@ Deprecations
- The ``broadcast`` parameter of ``.apply()`` is deprecated in favor of ``result_type='broadcast'`` (:issue:`18577`)
- The ``reduce`` parameter of ``.apply()`` is deprecated in favor of ``result_type='reduce'`` (:issue:`18577`)
+- The ``order`` parameter of :func:`factorize` is deprecated and will be removed in a future release (:issue:`19727`)
.. _whatsnew_0230.prior_deprecations:
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index c754c063fce8e..624045a3d64bc 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -32,6 +32,7 @@
from pandas.core import common as com
from pandas._libs import algos, lib, hashtable as htable
from pandas._libs.tslib import iNaT
+from pandas.util._decorators import deprecate_kwarg
# --------------- #
@@ -436,6 +437,7 @@ def isin(comps, values):
return f(comps, values)
+@deprecate_kwarg(old_arg_name='order', new_arg_name=None)
def factorize(values, sort=False, order=None, na_sentinel=-1, size_hint=None):
"""
Encode input values as an enumerated type or categorical variable
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index b1e3177547ac6..884b1eb7342c6 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -248,6 +248,15 @@ def test_uint64_factorize(self):
tm.assert_numpy_array_equal(labels, exp_labels)
tm.assert_numpy_array_equal(uniques, exp_uniques)
+ def test_deprecate_order(self):
+ # gh 19727 - check warning is raised for deprecated keyword, order.
+ # Test not valid once order keyword is removed.
+ data = np.array([2**63, 1, 2**63], dtype=np.uint64)
+ with tm.assert_produces_warning(expected_warning=FutureWarning):
+ algos.factorize(data, order=True)
+ with tm.assert_produces_warning(False):
+ algos.factorize(data)
+
class TestUnique(object):
diff --git a/pandas/tests/util/test_util.py b/pandas/tests/util/test_util.py
index 3b0a428218771..2bc017ef226ce 100644
--- a/pandas/tests/util/test_util.py
+++ b/pandas/tests/util/test_util.py
@@ -34,9 +34,14 @@ def _f2(new=False):
def _f3(new=0):
return new
+ @deprecate_kwarg('old', None)
+ def _f4(old=True, unchanged=True):
+ return old
+
self.f1 = _f1
self.f2 = _f2
self.f3 = _f3
+ self.f4 = _f4
def test_deprecate_kwarg(self):
x = 78
@@ -72,6 +77,15 @@ def test_bad_deprecate_kwarg(self):
def f4(new=None):
pass
+ def test_deprecate_keyword(self):
+ x = 9
+ with tm.assert_produces_warning(FutureWarning):
+ result = self.f4(old=x)
+ assert result is x
+ with tm.assert_produces_warning(None):
+ result = self.f4(unchanged=x)
+ assert result is True
+
def test_rands():
r = tm.rands(10)
diff --git a/pandas/util/_decorators.py b/pandas/util/_decorators.py
index eed9cee54efb3..1753bc8b8fc33 100644
--- a/pandas/util/_decorators.py
+++ b/pandas/util/_decorators.py
@@ -65,8 +65,9 @@ def deprecate_kwarg(old_arg_name, new_arg_name, mapping=None, stacklevel=2):
----------
old_arg_name : str
Name of argument in function to deprecate
- new_arg_name : str
- Name of preferred argument in function
+ new_arg_name : str or None
+ Name of preferred argument in function. Use None to raise warning that
+ ``old_arg_name`` keyword is deprecated.
mapping : dict or callable
If mapping is present, use it to translate old arguments to
new arguments. A callable must do its own value checking;
@@ -82,12 +83,15 @@ def deprecate_kwarg(old_arg_name, new_arg_name, mapping=None, stacklevel=2):
...
>>> f(columns='should work ok')
should work ok
+
>>> f(cols='should raise warning')
FutureWarning: cols is deprecated, use columns instead
warnings.warn(msg, FutureWarning)
should raise warning
+
>>> f(cols='should error', columns="can\'t pass do both")
TypeError: Can only specify 'cols' or 'columns', not both
+
>>> @deprecate_kwarg('old', 'new', {'yes': True, 'no': False})
... def f(new=False):
... print('yes!' if new else 'no!')
@@ -96,6 +100,25 @@ def deprecate_kwarg(old_arg_name, new_arg_name, mapping=None, stacklevel=2):
FutureWarning: old='yes' is deprecated, use new=True instead
warnings.warn(msg, FutureWarning)
yes!
+
+
+ To raise a warning that a keyword will be removed entirely in the future
+
+ >>> @deprecate_kwarg(old_arg_name='cols', new_arg_name=None)
+ ... def f(cols='', another_param=''):
+ ... print(cols)
+ ...
+ >>> f(cols='should raise warning')
+ FutureWarning: the 'cols' keyword is deprecated and will be removed in a
+ future version please takes steps to stop use of 'cols'
+ should raise warning
+ >>> f(another_param='should not raise warning')
+ should not raise warning
+
+ >>> f(cols='should raise warning', another_param='')
+ FutureWarning: the 'cols' keyword is deprecated and will be removed in a
+ future version please takes steps to stop use of 'cols'
+ should raise warning
"""
if mapping is not None and not hasattr(mapping, 'get') and \
@@ -107,6 +130,17 @@ def _deprecate_kwarg(func):
@wraps(func)
def wrapper(*args, **kwargs):
old_arg_value = kwargs.pop(old_arg_name, None)
+
+ if new_arg_name is None and old_arg_value is not None:
+ msg = (
+ "the '{old_name}' keyword is deprecated and will be "
+ "removed in a future version "
+ "please takes steps to stop use of '{old_name}'"
+ ).format(old_name=old_arg_name)
+ warnings.warn(msg, FutureWarning, stacklevel=stacklevel)
+ kwargs[old_arg_name] = old_arg_value
+ return func(*args, **kwargs)
+
if old_arg_value is not None:
if mapping is not None:
if hasattr(mapping, 'get'):
| #### What's this PR do?
In response to #19727.
Adds functionality to the ``deprecate_kwargs`` utility. Currently, the utility doesn't allow the deprecation of an old keyword without having a new one in place. The change proposed here allows the deprecation of an *old* keyword without specifying a *new* keyword by allowing users to pass ``new_arg_name=None`` to ``deprecate_kwargs``.
#### PR checklist
- [X] closes #19727
- [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/19751 | 2018-02-18T19:54:51Z | 2018-02-21T11:37:47Z | 2018-02-21T11:37:47Z | 2018-02-22T05:17:15Z |
FIX: const-correctness in numpy helpers | diff --git a/pandas/_libs/src/numpy_helper.h b/pandas/_libs/src/numpy_helper.h
index 844be9b292be3..5cfa51dc8a0be 100644
--- a/pandas/_libs/src/numpy_helper.h
+++ b/pandas/_libs/src/numpy_helper.h
@@ -32,7 +32,7 @@ PANDAS_INLINE PyObject* get_value_1d(PyArrayObject* ap, Py_ssize_t i) {
// returns ASCII or UTF8 (py3) view on python str
// python object owns memory, should not be freed
-PANDAS_INLINE char* get_c_string(PyObject* obj) {
+PANDAS_INLINE const char* get_c_string(PyObject* obj) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_AsUTF8(obj);
#else
@@ -40,7 +40,7 @@ PANDAS_INLINE char* get_c_string(PyObject* obj) {
#endif
}
-PANDAS_INLINE PyObject* char_to_string(char* data) {
+PANDAS_INLINE PyObject* char_to_string(const char* data) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(data);
#else
| In python 3.7 the return type of PyUnicode_AsUTF8 changed
from (char *) to (const char *).
PyUnicode_FromString also takes (const char *) as input, also be
explicit about that.
https://bugs.python.org/issue28769
commit 2a404b63d48d73bbaa007d89efb7a01048475acd in cpython
- [ ] 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/19749 | 2018-02-18T17:34:19Z | 2018-02-18T23:32:33Z | 2018-02-18T23:32:33Z | 2018-02-19T01:34:34Z |
DOC: Updated tutorials.rst, added 3 recent video tutorials | diff --git a/doc/source/tutorials.rst b/doc/source/tutorials.rst
index 710212bc237cd..db9385519bff2 100644
--- a/doc/source/tutorials.rst
+++ b/doc/source/tutorials.rst
@@ -9,52 +9,52 @@ This is a guide to many pandas tutorials, geared mainly for new users.
Internal Guides
---------------
-pandas own :ref:`10 Minutes to pandas<10min>`
+pandas' own :ref:`10 Minutes to pandas<10min>`.
-More complex recipes are in the :ref:`Cookbook<cookbook>`
+More complex recipes are in the :ref:`Cookbook<cookbook>`.
pandas Cookbook
---------------
-The goal of this cookbook (by `Julia Evans <http://jvns.ca>`_) is to
+The goal of this 2015 cookbook (by `Julia Evans <http://jvns.ca>`_) is to
give you some concrete examples for getting started with pandas. These
are examples with real-world data, and all the bugs and weirdness that
entails.
-Here are links to the v0.1 release. For an up-to-date table of contents, see the `pandas-cookbook GitHub
+Here are links to the v0.2 release. For an up-to-date table of contents, see the `pandas-cookbook GitHub
repository <http://github.com/jvns/pandas-cookbook>`_. To run the examples in this tutorial, you'll need to
clone the GitHub repository and get IPython Notebook running.
See `How to use this cookbook <https://github.com/jvns/pandas-cookbook#how-to-use-this-cookbook>`_.
-- `A quick tour of the IPython Notebook: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/A%20quick%20tour%20of%20IPython%20Notebook.ipynb>`_
+- `A quick tour of the IPython Notebook: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/A%20quick%20tour%20of%20IPython%20Notebook.ipynb>`_
Shows off IPython's awesome tab completion and magic functions.
-- `Chapter 1: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/Chapter%201%20-%20Reading%20from%20a%20CSV.ipynb>`_
+- `Chapter 1: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%201%20-%20Reading%20from%20a%20CSV.ipynb>`_
Reading your data into pandas is pretty much the easiest thing. Even
when the encoding is wrong!
-- `Chapter 2: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/Chapter%202%20-%20Selecting%20data%20&%20finding%20the%20most%20common%20complaint%20type.ipynb>`_
+- `Chapter 2: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%202%20-%20Selecting%20data%20&%20finding%20the%20most%20common%20complaint%20type.ipynb>`_
It's not totally obvious how to select data from a pandas dataframe.
Here we explain the basics (how to take slices and get columns)
-- `Chapter 3: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/Chapter%203%20-%20Which%20borough%20has%20the%20most%20noise%20complaints%3F%20%28or%2C%20more%20selecting%20data%29.ipynb>`_
+- `Chapter 3: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%203%20-%20Which%20borough%20has%20the%20most%20noise%20complaints%3F%20%28or%2C%20more%20selecting%20data%29.ipynb>`_
Here we get into serious slicing and dicing and learn how to filter
dataframes in complicated ways, really fast.
-- `Chapter 4: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/Chapter%204%20-%20Find%20out%20on%20which%20weekday%20people%20bike%20the%20most%20with%20groupby%20and%20aggregate.ipynb>`_
+- `Chapter 4: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%204%20-%20Find%20out%20on%20which%20weekday%20people%20bike%20the%20most%20with%20groupby%20and%20aggregate.ipynb>`_
Groupby/aggregate is seriously my favorite thing about pandas
and I use it all the time. You should probably read this.
-- `Chapter 5: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/Chapter%205%20-%20Combining%20dataframes%20and%20scraping%20Canadian%20weather%20data.ipynb>`_
+- `Chapter 5: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%205%20-%20Combining%20dataframes%20and%20scraping%20Canadian%20weather%20data.ipynb>`_
Here you get to find out if it's cold in Montreal in the winter
(spoiler: yes). Web scraping with pandas is fun! Here we combine dataframes.
-- `Chapter 6: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/Chapter%206%20-%20String%20operations%21%20Which%20month%20was%20the%20snowiest%3F.ipynb>`_
+- `Chapter 6: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%206%20-%20String%20operations%21%20Which%20month%20was%20the%20snowiest%3F.ipynb>`_
Strings with pandas are great. It has all these vectorized string
operations and they're the best. We will turn a bunch of strings
containing "Snow" into vectors of numbers in a trice.
-- `Chapter 7: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/Chapter%207%20-%20Cleaning%20up%20messy%20data.ipynb>`_
+- `Chapter 7: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%207%20-%20Cleaning%20up%20messy%20data.ipynb>`_
Cleaning up messy data is never a joy, but with pandas it's easier.
-- `Chapter 8: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/Chapter%208%20-%20How%20to%20deal%20with%20timestamps.ipynb>`_
+- `Chapter 8: <http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.2/cookbook/Chapter%208%20-%20How%20to%20deal%20with%20timestamps.ipynb>`_
Parsing Unix timestamps is confusing at first but it turns out
to be really easy.
-Lessons for New pandas Users
+Lessons for new pandas users
----------------------------
For more resources, please visit the main `repository <https://bitbucket.org/hrojas/learn-pandas>`__.
@@ -125,7 +125,7 @@ There are four sections covering selected topics as follows:
.. _tutorial-exercises-new-users:
-Exercises for New Users
+Exercises for new users
-----------------------
Practice your skills with real data sets and exercises.
For more resources, please visit the main `repository <https://github.com/guipsamora/pandas_exercises>`__.
@@ -152,9 +152,14 @@ For more resources, please visit the main `repository <https://github.com/guipsa
.. _tutorial-modern:
-Modern Pandas
+Modern pandas
-------------
+Tutorial series written in 2016 by
+`Tom Augspurger <https://github.com/TomAugspurger>`_.
+The source may be found in the GitHub repository
+`TomAugspurger/effective-pandas <https://github.com/TomAugspurger/effective-pandas>`_.
+
- `Modern Pandas <http://tomaugspurger.github.io/modern-1-intro.html>`_
- `Method Chaining <http://tomaugspurger.github.io/method-chaining.html>`_
- `Indexes <http://tomaugspurger.github.io/modern-3-indexes.html>`_
@@ -168,6 +173,20 @@ Excel charts with pandas, vincent and xlsxwriter
- `Using Pandas and XlsxWriter to create Excel charts <https://pandas-xlsxwriter-charts.readthedocs.io/>`_
+Video Tutorials
+---------------
+
+- `Pandas From The Ground Up <https://www.youtube.com/watch?v=5JnMutdy6Fw>`_
+ (2015) (2:24)
+ `GitHub repo <https://github.com/brandon-rhodes/pycon-pandas-tutorial>`_
+- `Introduction Into Pandas <https://www.youtube.com/watch?v=-NR-ynQg0YM>`_
+ (2016) (1:28)
+ `GitHub repo <https://github.com/chendaniely/2016-pydata-carolinas-pandas>`_
+- `Pandas: .head() to .tail() <https://www.youtube.com/watch?v=7vuO9QXDN50>`_
+ (2016) (1:26)
+ `GitHub repo <https://github.com/TomAugspurger/pydata-chi-h2t>`_
+
+
Various Tutorials
-----------------
| I have made the following changes to `tutorials.rst` (found [here](http://pandas-docs.github.io/pandas-docs-travis/tutorials.html)):
- Updated the version of the [pandas-cookbook](https://github.com/jvns/pandas-cookbook) from `v0.1` to `v0.2`.
- Added an introductory paragraph to the tutorial series by @TomAugspurger.
- Added 3 recent, high-quality video tutorials (Youtube).
| https://api.github.com/repos/pandas-dev/pandas/pulls/19748 | 2018-02-18T11:39:47Z | 2018-02-18T13:38:17Z | 2018-02-18T13:38:17Z | 2018-02-18T13:38:18Z |
DOC: Spellcheck of gotchas.rst (FAQ page) | diff --git a/ci/lint.sh b/ci/lint.sh
index e3a39668885f0..fcd65fc5aba5e 100755
--- a/ci/lint.sh
+++ b/ci/lint.sh
@@ -156,6 +156,7 @@ if [ "$LINT" ]; then
RET=1
fi
echo "Check for deprecated messages without sphinx directive DONE"
+
else
echo "NOT Linting"
fi
diff --git a/doc/source/gotchas.rst b/doc/source/gotchas.rst
index bc490877e190d..b7042ef390018 100644
--- a/doc/source/gotchas.rst
+++ b/doc/source/gotchas.rst
@@ -22,22 +22,22 @@ Frequently Asked Questions (FAQ)
DataFrame memory usage
----------------------
-The memory usage of a dataframe (including the index)
-is shown when accessing the ``info`` method of a dataframe. A
-configuration option, ``display.memory_usage`` (see :ref:`options`),
-specifies if the dataframe's memory usage will be displayed when
-invoking the ``df.info()`` method.
+The memory usage of a ``DataFrame`` (including the index) is shown when calling
+the :meth:`~DataFrame.info`. A configuration option, ``display.memory_usage``
+(see :ref:`the list of options <options.available>`), specifies if the
+``DataFrame``'s memory usage will be displayed when invoking the ``df.info()``
+method.
-For example, the memory usage of the dataframe below is shown
-when calling ``df.info()``:
+For example, the memory usage of the ``DataFrame`` below is shown
+when calling :meth:`~DataFrame.info`:
.. ipython:: python
dtypes = ['int64', 'float64', 'datetime64[ns]', 'timedelta64[ns]',
'complex128', 'object', 'bool']
n = 5000
- data = dict([ (t, np.random.randint(100, size=n).astype(t))
- for t in dtypes])
+ data = dict([(t, np.random.randint(100, size=n).astype(t))
+ for t in dtypes])
df = pd.DataFrame(data)
df['categorical'] = df['object'].astype('category')
@@ -48,7 +48,7 @@ pandas does not count the memory used by values in columns with
``dtype=object``.
Passing ``memory_usage='deep'`` will enable a more accurate memory usage report,
-that accounts for the full usage of the contained objects. This is optional
+accounting for the full usage of the contained objects. This is optional
as it can be expensive to do this deeper introspection.
.. ipython:: python
@@ -58,11 +58,11 @@ as it can be expensive to do this deeper introspection.
By default the display option is set to ``True`` but can be explicitly
overridden by passing the ``memory_usage`` argument when invoking ``df.info()``.
-The memory usage of each column can be found by calling the ``memory_usage``
-method. This returns a Series with an index represented by column names
-and memory usage of each column shown in bytes. For the dataframe above,
-the memory usage of each column and the total memory usage of the
-dataframe can be found with the memory_usage method:
+The memory usage of each column can be found by calling the
+:meth:`~DataFrame.memory_usage` method. This returns a ``Series`` with an index
+represented by column names and memory usage of each column shown in bytes. For
+the ``DataFrame`` above, the memory usage of each column and the total memory
+usage can be found with the ``memory_usage`` method:
.. ipython:: python
@@ -71,18 +71,18 @@ dataframe can be found with the memory_usage method:
# total memory usage of dataframe
df.memory_usage().sum()
-By default the memory usage of the dataframe's index is shown in the
-returned Series, the memory usage of the index can be suppressed by passing
+By default the memory usage of the ``DataFrame``'s index is shown in the
+returned ``Series``, the memory usage of the index can be suppressed by passing
the ``index=False`` argument:
.. ipython:: python
df.memory_usage(index=False)
-The memory usage displayed by the ``info`` method utilizes the
-``memory_usage`` method to determine the memory usage of a dataframe
-while also formatting the output in human-readable units (base-2
-representation; i.e., 1KB = 1024 bytes).
+The memory usage displayed by the :meth:`~DataFrame.info` method utilizes the
+:meth:`~DataFrame.memory_usage` method to determine the memory usage of a
+``DataFrame`` while also formatting the output in human-readable units (base-2
+representation; i.e. 1KB = 1024 bytes).
See also :ref:`Categorical Memory Usage <categorical.memory>`.
@@ -91,17 +91,18 @@ See also :ref:`Categorical Memory Usage <categorical.memory>`.
Using If/Truth Statements with pandas
-------------------------------------
-pandas follows the NumPy convention of raising an error when you try to convert something to a ``bool``.
-This happens in a ``if`` or when using the boolean operations, ``and``, ``or``, or ``not``. It is not clear
-what the result of
+pandas follows the NumPy convention of raising an error when you try to convert
+something to a ``bool``. This happens in an ``if``-statement or when using the
+boolean operations: ``and``, ``or``, and ``not``. It is not clear what the result
+of the following code should be:
.. code-block:: python
>>> if pd.Series([False, True, False]):
...
-should be. Should it be ``True`` because it's not zero-length? ``False`` because there are ``False`` values?
-It is unclear, so instead, pandas raises a ``ValueError``:
+Should it be ``True`` because it's not zero-length, or ``False`` because there
+are ``False`` values? It is unclear, so instead, pandas raises a ``ValueError``:
.. code-block:: python
@@ -111,9 +112,9 @@ It is unclear, so instead, pandas raises a ``ValueError``:
...
ValueError: The truth value of an array is ambiguous. Use a.empty, a.any() or a.all().
-
-If you see that, you need to explicitly choose what you want to do with it (e.g., use `any()`, `all()` or `empty`).
-or, you might want to compare if the pandas object is ``None``
+You need to explicitly choose what you want to do with the ``DataFrame``, e.g.
+use :meth:`~DataFrame.any`, :meth:`~DataFrame.all` or :meth:`~DataFrame.empty`.
+Alternatively, you might want to compare if the pandas object is ``None``:
.. code-block:: python
@@ -122,7 +123,7 @@ or, you might want to compare if the pandas object is ``None``
>>> I was not None
-or return if ``any`` value is ``True``.
+Below is how to check if any of the values are ``True``:
.. code-block:: python
@@ -130,7 +131,8 @@ or return if ``any`` value is ``True``.
print("I am any")
>>> I am any
-To evaluate single-element pandas objects in a boolean context, use the method ``.bool()``:
+To evaluate single-element pandas objects in a boolean context, use the method
+:meth:`~DataFrame.bool`:
.. ipython:: python
@@ -161,25 +163,25 @@ See :ref:`boolean comparisons<basics.compare>` for more examples.
Using the ``in`` operator
~~~~~~~~~~~~~~~~~~~~~~~~~
-Using the Python ``in`` operator on a Series tests for membership in the
+Using the Python ``in`` operator on a ``Series`` tests for membership in the
index, not membership among the values.
-.. ipython::
+.. ipython:: python
s = pd.Series(range(5), index=list('abcde'))
2 in s
'b' in s
If this behavior is surprising, keep in mind that using ``in`` on a Python
-dictionary tests keys, not values, and Series are dict-like.
-To test for membership in the values, use the method :func:`~pandas.Series.isin`:
+dictionary tests keys, not values, and ``Series`` are dict-like.
+To test for membership in the values, use the method :meth:`~pandas.Series.isin`:
-.. ipython::
+.. ipython:: python
s.isin([2])
s.isin([2]).any()
-For DataFrames, likewise, ``in`` applies to the column axis,
+For ``DataFrames``, likewise, ``in`` applies to the column axis,
testing for membership in the list of column names.
``NaN``, Integer ``NA`` values and ``NA`` type promotions
@@ -189,12 +191,12 @@ Choice of ``NA`` representation
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For lack of ``NA`` (missing) support from the ground up in NumPy and Python in
-general, we were given the difficult choice between either
+general, we were given the difficult choice between either:
- A *masked array* solution: an array of data and an array of boolean values
- indicating whether a value is there or is missing
+ indicating whether a value is there or is missing.
- Using a special sentinel value, bit pattern, or set of sentinel values to
- denote ``NA`` across the dtypes
+ denote ``NA`` across the dtypes.
For many reasons we chose the latter. After years of production use it has
proven, at least in my opinion, to be the best decision given the state of
@@ -226,15 +228,16 @@ arrays. For example:
s2.dtype
This trade-off is made largely for memory and performance reasons, and also so
-that the resulting Series continues to be "numeric". One possibility is to use
-``dtype=object`` arrays instead.
+that the resulting ``Series`` continues to be "numeric". One possibility is to
+use ``dtype=object`` arrays instead.
``NA`` type promotions
~~~~~~~~~~~~~~~~~~~~~~
-When introducing NAs into an existing Series or DataFrame via ``reindex`` or
-some other means, boolean and integer types will be promoted to a different
-dtype in order to store the NAs. These are summarized by this table:
+When introducing NAs into an existing ``Series`` or ``DataFrame`` via
+:meth:`~Series.reindex` or some other means, boolean and integer types will be
+promoted to a different dtype in order to store the NAs. The promotions are
+summarized in this table:
.. csv-table::
:header: "Typeclass","Promotion dtype for storing NAs"
@@ -289,19 +292,19 @@ integer arrays to floating when NAs must be introduced.
Differences with NumPy
----------------------
-For Series and DataFrame objects, ``var`` normalizes by ``N-1`` to produce
-unbiased estimates of the sample variance, while NumPy's ``var`` normalizes
-by N, which measures the variance of the sample. Note that ``cov``
-normalizes by ``N-1`` in both pandas and NumPy.
+For ``Series`` and ``DataFrame`` objects, :meth:`~DataFrame.var` normalizes by
+``N-1`` to produce unbiased estimates of the sample variance, while NumPy's
+``var`` normalizes by N, which measures the variance of the sample. Note that
+:meth:`~DataFrame.cov` normalizes by ``N-1`` in both pandas and NumPy.
Thread-safety
-------------
As of pandas 0.11, pandas is not 100% thread safe. The known issues relate to
-the ``DataFrame.copy`` method. If you are doing a lot of copying of DataFrame
-objects shared among threads, we recommend holding locks inside the threads
-where the data copying occurs.
+the :meth:`~DataFrame.copy` method. If you are doing a lot of copying of
+``DataFrame`` objects shared among threads, we recommend holding locks inside
+the threads where the data copying occurs.
See `this link <https://stackoverflow.com/questions/13592618/python-pandas-dataframe-thread-safe>`__
for more information.
@@ -310,7 +313,8 @@ for more information.
Byte-Ordering Issues
--------------------
Occasionally you may have to deal with data that were created on a machine with
-a different byte order than the one on which you are running Python. A common symptom of this issue is an error like
+a different byte order than the one on which you are running Python. A common
+symptom of this issue is an error like:
.. code-block:: python
@@ -320,8 +324,8 @@ a different byte order than the one on which you are running Python. A common sy
To deal
with this issue you should convert the underlying NumPy array to the native
-system byte order *before* passing it to Series/DataFrame/Panel constructors
-using something similar to the following:
+system byte order *before* passing it to ``Series`` or ``DataFrame``
+constructors using something similar to the following:
.. ipython:: python
| Minor changes to the documentation, specifically `gotchas.rst`, i.e. the FAQ page.
* Function/method references as links.
* Consistent double backticks ` `` ` around Series, DataFrame.
* Minor rephrasing of a sentence or two, added some missing punctuation.
* Replaced `.. ipython::` with `ipython:: python` twice, as the former is not sufficient to make the iPython code render in the docs.
Reviews/comments very welcome.
| https://api.github.com/repos/pandas-dev/pandas/pulls/19747 | 2018-02-18T09:59:15Z | 2018-02-23T11:46:12Z | 2018-02-23T11:46:12Z | 2018-02-23T11:46:12Z |
[DOCS] Add example of how to preserve order of columns with usecols. | diff --git a/doc/source/io.rst b/doc/source/io.rst
index 7bb34e4d232dd..b7f8792b42fd6 100644
--- a/doc/source/io.rst
+++ b/doc/source/io.rst
@@ -135,8 +135,14 @@ usecols : array-like or callable, default ``None``
be positional (i.e. integer indices into the document columns) or strings
that correspond to column names provided either by the user in `names` or
inferred from the document header row(s). For example, a valid array-like
- `usecols` parameter would be ``[0, 1, 2]`` or ``['foo', 'bar', 'baz']``.
- Element order is ignored, so ``usecols=[0, 1]`` is the same as ``[1, 0]``.
+ `usecols` parameter would be ``[0, 1, 2]`` or ``['foo', 'bar', 'baz']``.
+
+ Element order is ignored, so ``usecols=[0, 1]`` is the same as ``[1, 0]``. To
+ instantiate a DataFrame from ``data`` with element order preserved use
+ ``pd.read_csv(data, usecols=['foo', 'bar'])[['foo', 'bar']]`` for columns
+ in ``['foo', 'bar']`` order or
+ ``pd.read_csv(data, usecols=['foo', 'bar'])[['bar', 'foo']]`` for
+ ``['bar', 'foo']`` order.
If callable, the callable function will be evaluated against the column names,
returning names where the callable function evaluates to True:
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index 7ea6d321e0fdd..4b1385514a0c4 100755
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -102,7 +102,12 @@
that correspond to column names provided either by the user in `names` or
inferred from the document header row(s). For example, a valid array-like
`usecols` parameter would be [0, 1, 2] or ['foo', 'bar', 'baz']. Element
- order is ignored, so usecols=[1,0] is the same as [0,1].
+ order is ignored, so ``usecols=[0, 1]`` is the same as ``[1, 0]``.
+ To instantiate a DataFrame from ``data`` with element order preserved use
+ ``pd.read_csv(data, usecols=['foo', 'bar'])[['foo', 'bar']]`` for columns
+ in ``['foo', 'bar']`` order or
+ ``pd.read_csv(data, usecols=['foo', 'bar'])[['bar', 'foo']]``
+ for ``['bar', 'foo']`` order.
If callable, the callable function will be evaluated against the column
names, returning names where the callable function evaluates to True. An
| #### What's this PR do?
Adding an example of how to preserve order when using the ``usecols`` parameter. I've noticed that some folks are still unaware that the columns will not necessarily be returned in the specified order passed to ``usecols``.
| https://api.github.com/repos/pandas-dev/pandas/pulls/19746 | 2018-02-18T07:00:57Z | 2018-02-21T19:53:08Z | 2018-02-21T19:53:08Z | 2018-02-22T05:21:23Z |
Fix name setting in DTI/TDI __add__ and __sub__ | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 879b245af49cd..fdcec41110363 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -730,6 +730,8 @@ Datetimelike
- Bug in :class:`Timestamp` and :func:`to_datetime` where a string representing a barely out-of-bounds timestamp would be incorrectly rounded down instead of raising ``OutOfBoundsDatetime`` (:issue:`19382`)
- Bug in :func:`Timestamp.floor` :func:`DatetimeIndex.floor` where time stamps far in the future and past were not rounded correctly (:issue:`19206`)
- Bug in :func:`to_datetime` where passing an out-of-bounds datetime with ``errors='coerce'`` and ``utc=True`` would raise ``OutOfBoundsDatetime`` instead of parsing to ``NaT`` (:issue:`19612`)
+- Bug in :class:`DatetimeIndex` and :class:`TimedeltaIndex` addition and subtraction where name of the returned object was not always set consistently. (:issue:`19744`)
+-
Timedelta
^^^^^^^^^
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 6748db825acf0..77dc1522052d4 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -121,21 +121,6 @@ def _consensus_name_attr(objs):
return name
-def _maybe_match_name(a, b):
- a_has = hasattr(a, 'name')
- b_has = hasattr(b, 'name')
- if a_has and b_has:
- if a.name == b.name:
- return a.name
- else:
- return None
- elif a_has:
- return a.name
- elif b_has:
- return b.name
- return None
-
-
def _get_info_slice(obj, indexer):
"""Slice the info axis of `obj` with `indexer`."""
if not hasattr(obj, '_info_axis_number'):
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index c98f8ceea0ffa..187f9fcf52dd4 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -29,7 +29,7 @@
from pandas.core.dtypes.generic import (
ABCIndex, ABCSeries, ABCPeriodIndex, ABCIndexClass)
from pandas.core.dtypes.missing import isna
-from pandas.core import common as com, algorithms
+from pandas.core import common as com, algorithms, ops
from pandas.core.algorithms import checked_add_with_arr
from pandas.errors import NullFrequencyError
import pandas.io.formats.printing as printing
@@ -661,29 +661,37 @@ def __add__(self, other):
if isinstance(other, ABCSeries):
return NotImplemented
elif is_timedelta64_dtype(other):
- return self._add_delta(other)
+ result = self._add_delta(other)
elif isinstance(other, (DateOffset, timedelta)):
- return self._add_delta(other)
+ result = self._add_delta(other)
elif is_offsetlike(other):
# Array/Index of DateOffset objects
- return self._add_offset_array(other)
+ result = self._add_offset_array(other)
elif isinstance(self, TimedeltaIndex) and isinstance(other, Index):
if hasattr(other, '_add_delta'):
- return other._add_delta(self)
- raise TypeError("cannot add TimedeltaIndex and {typ}"
- .format(typ=type(other)))
+ result = other._add_delta(self)
+ else:
+ raise TypeError("cannot add TimedeltaIndex and {typ}"
+ .format(typ=type(other)))
elif is_integer(other):
- return self.shift(other)
+ # This check must come after the check for timedelta64_dtype
+ # or else it will incorrectly catch np.timedelta64 objects
+ result = self.shift(other)
elif isinstance(other, (datetime, np.datetime64)):
- return self._add_datelike(other)
+ result = self._add_datelike(other)
elif isinstance(other, Index):
- return self._add_datelike(other)
+ result = self._add_datelike(other)
elif is_integer_dtype(other) and self.freq is None:
# GH#19123
raise NullFrequencyError("Cannot shift with no freq")
else: # pragma: no cover
return NotImplemented
+ if result is not NotImplemented:
+ res_name = ops.get_op_result_name(self, other)
+ result.name = res_name
+ return result
+
cls.__add__ = __add__
cls.__radd__ = __add__
@@ -697,25 +705,27 @@ def __sub__(self, other):
if isinstance(other, ABCSeries):
return NotImplemented
elif is_timedelta64_dtype(other):
- return self._add_delta(-other)
+ result = self._add_delta(-other)
elif isinstance(other, (DateOffset, timedelta)):
- return self._add_delta(-other)
+ result = self._add_delta(-other)
elif is_offsetlike(other):
# Array/Index of DateOffset objects
- return self._sub_offset_array(other)
+ result = self._sub_offset_array(other)
elif isinstance(self, TimedeltaIndex) and isinstance(other, Index):
if not isinstance(other, TimedeltaIndex):
raise TypeError("cannot subtract TimedeltaIndex and {typ}"
.format(typ=type(other).__name__))
- return self._add_delta(-other)
+ result = self._add_delta(-other)
elif isinstance(other, DatetimeIndex):
- return self._sub_datelike(other)
+ result = self._sub_datelike(other)
elif is_integer(other):
- return self.shift(-other)
+ # This check must come after the check for timedelta64_dtype
+ # or else it will incorrectly catch np.timedelta64 objects
+ result = self.shift(-other)
elif isinstance(other, (datetime, np.datetime64)):
- return self._sub_datelike(other)
+ result = self._sub_datelike(other)
elif isinstance(other, Period):
- return self._sub_period(other)
+ result = self._sub_period(other)
elif isinstance(other, Index):
raise TypeError("cannot subtract {typ1} and {typ2}"
.format(typ1=type(self).__name__,
@@ -726,6 +736,11 @@ def __sub__(self, other):
else: # pragma: no cover
return NotImplemented
+ if result is not NotImplemented:
+ res_name = ops.get_op_result_name(self, other)
+ result.name = res_name
+ return result
+
cls.__sub__ = __sub__
def __rsub__(self, other):
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index cc9ce1f3fd5eb..debeabf9bae23 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -886,7 +886,7 @@ def _sub_datelike(self, other):
else:
raise TypeError("cannot subtract DatetimeIndex and {typ}"
.format(typ=type(other).__name__))
- return TimedeltaIndex(result, name=self.name, copy=False)
+ return TimedeltaIndex(result)
def _sub_datelike_dti(self, other):
"""subtraction of two DatetimeIndexes"""
@@ -910,20 +910,31 @@ def _maybe_update_attributes(self, attrs):
return attrs
def _add_delta(self, delta):
- if isinstance(delta, ABCSeries):
- return NotImplemented
+ """
+ Add a timedelta-like, DateOffset, or TimedeltaIndex-like object
+ to self.
+
+ Parameters
+ ----------
+ delta : {timedelta, np.timedelta64, DateOffset,
+ TimedelaIndex, ndarray[timedelta64]}
+ Returns
+ -------
+ result : DatetimeIndex
+
+ Notes
+ -----
+ The result's name is set outside of _add_delta by the calling
+ method (__add__ or __sub__)
+ """
from pandas import TimedeltaIndex
- name = self.name
if isinstance(delta, (Tick, timedelta, np.timedelta64)):
new_values = self._add_delta_td(delta)
elif is_timedelta64_dtype(delta):
if not isinstance(delta, TimedeltaIndex):
delta = TimedeltaIndex(delta)
- else:
- # update name when delta is Index
- name = com._maybe_match_name(self, delta)
new_values = self._add_delta_tdi(delta)
elif isinstance(delta, DateOffset):
new_values = self._add_offset(delta).asi8
@@ -931,7 +942,7 @@ def _add_delta(self, delta):
new_values = self.astype('O') + delta
tz = 'UTC' if self.tz is not None else None
- result = DatetimeIndex(new_values, tz=tz, name=name, freq='infer')
+ result = DatetimeIndex(new_values, tz=tz, freq='infer')
if self.tz is not None and self.tz is not utc:
result = result.tz_convert(self.tz)
return result
@@ -954,22 +965,19 @@ def _add_offset(self, offset):
def _add_offset_array(self, other):
# Array/Index of DateOffset objects
- if isinstance(other, ABCSeries):
- return NotImplemented
- elif len(other) == 1:
+ if len(other) == 1:
return self + other[0]
else:
warnings.warn("Adding/subtracting array of DateOffsets to "
"{} not vectorized".format(type(self)),
PerformanceWarning)
return self.astype('O') + np.array(other)
+ # TODO: pass freq='infer' like we do in _sub_offset_array?
# TODO: This works for __add__ but loses dtype in __sub__
def _sub_offset_array(self, other):
# Array/Index of DateOffset objects
- if isinstance(other, ABCSeries):
- return NotImplemented
- elif len(other) == 1:
+ if len(other) == 1:
return self - other[0]
else:
warnings.warn("Adding/subtracting array of DateOffsets to "
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 8f2d7d382a16e..60798e6d77e37 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -729,7 +729,7 @@ def _sub_datelike(self, other):
if other is tslib.NaT:
new_data = np.empty(len(self), dtype=np.int64)
new_data.fill(tslib.iNaT)
- return TimedeltaIndex(new_data, name=self.name)
+ return TimedeltaIndex(new_data)
return NotImplemented
def _sub_period(self, other):
@@ -744,7 +744,7 @@ def _sub_period(self, other):
new_data = new_data.astype(np.float64)
new_data[self._isnan] = np.nan
# result must be Int64Index or Float64Index
- return Index(new_data, name=self.name)
+ return Index(new_data)
def shift(self, n):
"""
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 4b543262fc485..af1c2f131fd60 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -356,19 +356,32 @@ def _maybe_update_attributes(self, attrs):
return attrs
def _add_delta(self, delta):
+ """
+ Add a timedelta-like, Tick, or TimedeltaIndex-like object
+ to self.
+
+ Parameters
+ ----------
+ delta : {timedelta, np.timedelta64, Tick, TimedeltaIndex}
+
+ Returns
+ -------
+ result : TimedeltaIndex
+
+ Notes
+ -----
+ The result's name is set outside of _add_delta by the calling
+ method (__add__ or __sub__)
+ """
if isinstance(delta, (Tick, timedelta, np.timedelta64)):
new_values = self._add_delta_td(delta)
- name = self.name
elif isinstance(delta, TimedeltaIndex):
new_values = self._add_delta_tdi(delta)
- # update name when delta is index
- name = com._maybe_match_name(self, delta)
else:
raise TypeError("cannot add the type {0} to a TimedeltaIndex"
.format(type(delta)))
- result = TimedeltaIndex(new_values, freq='infer', name=name)
- return result
+ return TimedeltaIndex(new_values, freq='infer')
def _evaluate_with_timedelta_like(self, other, op, opstr, reversed=False):
if isinstance(other, ABCSeries):
@@ -409,7 +422,7 @@ def _add_datelike(self, other):
result = checked_add_with_arr(i8, other.value,
arr_mask=self._isnan)
result = self._maybe_mask_results(result, fill_value=iNaT)
- return DatetimeIndex(result, name=self.name, copy=False)
+ return DatetimeIndex(result)
def _sub_datelike(self, other):
# GH#19124 Timedelta - datetime is not in general well-defined.
@@ -426,9 +439,7 @@ def _add_offset_array(self, other):
# TimedeltaIndex can only operate with a subset of DateOffset
# subclasses. Incompatible classes will raise AttributeError,
# which we re-raise as TypeError
- if isinstance(other, ABCSeries):
- return NotImplemented
- elif len(other) == 1:
+ if len(other) == 1:
return self + other[0]
else:
from pandas.errors import PerformanceWarning
@@ -436,6 +447,7 @@ def _add_offset_array(self, other):
"{} not vectorized".format(type(self)),
PerformanceWarning)
return self.astype('O') + np.array(other)
+ # TODO: pass freq='infer' like we do in _sub_offset_array?
# TODO: This works for __add__ but loses dtype in __sub__
except AttributeError:
raise TypeError("Cannot add non-tick DateOffset to TimedeltaIndex")
@@ -446,9 +458,7 @@ def _sub_offset_array(self, other):
# TimedeltaIndex can only operate with a subset of DateOffset
# subclasses. Incompatible classes will raise AttributeError,
# which we re-raise as TypeError
- if isinstance(other, ABCSeries):
- return NotImplemented
- elif len(other) == 1:
+ if len(other) == 1:
return self - other[0]
else:
from pandas.errors import PerformanceWarning
diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index da65f1f31ed2a..bdce611f58f06 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -42,6 +42,67 @@
ABCSparseSeries, ABCSparseArray)
+# -----------------------------------------------------------------------------
+# Ops Wrapping Utilities
+
+def get_op_result_name(left, right):
+ """
+ Find the appropriate name to pin to an operation result. This result
+ should always be either an Index or a Series.
+
+ Parameters
+ ----------
+ left : {Series, Index}
+ right : object
+
+ Returns
+ -------
+ name : object
+ Usually a string
+ """
+ # `left` is always a pd.Series when called from within ops
+ if isinstance(right, (ABCSeries, pd.Index)):
+ name = _maybe_match_name(left, right)
+ else:
+ name = left.name
+ return name
+
+
+def _maybe_match_name(a, b):
+ """
+ Try to find a name to attach to the result of an operation between
+ a and b. If only one of these has a `name` attribute, return that
+ name. Otherwise return a consensus name if they match of None if
+ they have different names.
+
+ Parameters
+ ----------
+ a : object
+ b : object
+
+ Returns
+ -------
+ name : str or None
+
+ See also
+ --------
+ pandas.core.common._consensus_name_attr
+ """
+ a_has = hasattr(a, 'name')
+ b_has = hasattr(b, 'name')
+ if a_has and b_has:
+ if a.name == b.name:
+ return a.name
+ else:
+ # TODO: what if they both have np.nan for their names?
+ return None
+ elif a_has:
+ return a.name
+ elif b_has:
+ return b.name
+ return None
+
+
# -----------------------------------------------------------------------------
# Reversed Operations not available in the stdlib operator module.
# Defining these instead of using lambdas allows us to reference them by name.
@@ -824,7 +885,7 @@ def wrapper(left, right, name=name, na_op=na_op):
return NotImplemented
left, right = _align_method_SERIES(left, right)
- res_name = _get_series_op_result_name(left, right)
+ res_name = get_op_result_name(left, right)
if is_datetime64_dtype(left) or is_datetime64tz_dtype(left):
result = dispatch_to_index_op(op, left, right, pd.DatetimeIndex)
@@ -888,15 +949,6 @@ def dispatch_to_index_op(op, left, right, index_class):
return result
-def _get_series_op_result_name(left, right):
- # `left` is always a pd.Series
- if isinstance(right, (ABCSeries, pd.Index)):
- name = com._maybe_match_name(left, right)
- else:
- name = left.name
- return name
-
-
def _comp_method_OBJECT_ARRAY(op, x, y):
if isinstance(y, list):
y = construct_1d_object_array_from_listlike(y)
@@ -974,7 +1026,7 @@ def wrapper(self, other, axis=None):
if axis is not None:
self._get_axis_number(axis)
- res_name = _get_series_op_result_name(self, other)
+ res_name = get_op_result_name(self, other)
if isinstance(other, ABCDataFrame): # pragma: no cover
# Defer to DataFrame implementation; fail early
@@ -1100,7 +1152,7 @@ def wrapper(self, other):
return NotImplemented
elif isinstance(other, ABCSeries):
- name = com._maybe_match_name(self, other)
+ name = get_op_result_name(self, other)
is_other_int_dtype = is_integer_dtype(other.dtype)
other = fill_int(other) if is_other_int_dtype else fill_bool(other)
@@ -1542,7 +1594,7 @@ def wrapper(self, other):
def _sparse_series_op(left, right, op, name):
left, right = left.align(right, join='outer', copy=False)
new_index = left.index
- new_name = com._maybe_match_name(left, right)
+ new_name = get_op_result_name(left, right)
from pandas.core.sparse.array import _sparse_array_op
result = _sparse_array_op(left.values, right.values, op, name,
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 90dc14836ab55..79ffb8be65838 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1728,7 +1728,7 @@ def _binop(self, other, func, level=None, fill_value=None):
with np.errstate(all='ignore'):
result = func(this_vals, other_vals)
- name = com._maybe_match_name(self, other)
+ name = ops.get_op_result_name(self, other)
result = self._constructor(result, index=new_index, name=name)
result = result.__finalize__(self)
if name is None:
@@ -1769,7 +1769,7 @@ def combine(self, other, func, fill_value=np.nan):
"""
if isinstance(other, Series):
new_index = self.index.union(other.index)
- new_name = com._maybe_match_name(self, other)
+ new_name = ops.get_op_result_name(self, other)
new_values = np.empty(len(new_index), dtype=self.dtype)
for i, idx in enumerate(new_index):
lv = self.get(idx, fill_value)
@@ -1814,7 +1814,7 @@ def combine_first(self, other):
this = self.reindex(new_index, copy=False)
other = other.reindex(new_index, copy=False)
# TODO: do we need name?
- name = com._maybe_match_name(self, other) # noqa
+ name = ops.get_op_result_name(self, other) # noqa
rs_vals = com._where_compat(isna(this), other._values, this._values)
return self._constructor(rs_vals, index=new_index).__finalize__(self)
diff --git a/pandas/tests/indexes/datetimes/test_arithmetic.py b/pandas/tests/indexes/datetimes/test_arithmetic.py
index ddc97636ae0a8..f252d6ec31f89 100644
--- a/pandas/tests/indexes/datetimes/test_arithmetic.py
+++ b/pandas/tests/indexes/datetimes/test_arithmetic.py
@@ -721,11 +721,10 @@ def test_dti_add_series(self, tz, names):
result4 = index + ser.values
tm.assert_index_equal(result4, expected)
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_dti_add_offset_array(self, tz, box):
+ def test_dti_add_offset_array(self, tz):
# GH#18849
dti = pd.date_range('2017-01-01', periods=2, tz=tz)
- other = box([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
+ other = np.array([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
with tm.assert_produces_warning(PerformanceWarning):
res = dti + other
@@ -737,11 +736,29 @@ def test_dti_add_offset_array(self, tz, box):
res2 = other + dti
tm.assert_index_equal(res2, expected)
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_dti_sub_offset_array(self, tz, box):
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('foo', 'bar', None),
+ ('foo', 'foo', 'foo')])
+ def test_dti_add_offset_index(self, tz, names):
+ # GH#18849, GH#19744
+ dti = pd.date_range('2017-01-01', periods=2, tz=tz, name=names[0])
+ other = pd.Index([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)],
+ name=names[1])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = dti + other
+ expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))],
+ name=names[2], freq='infer')
+ tm.assert_index_equal(res, expected)
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res2 = other + dti
+ tm.assert_index_equal(res2, expected)
+
+ def test_dti_sub_offset_array(self, tz):
# GH#18824
dti = pd.date_range('2017-01-01', periods=2, tz=tz)
- other = box([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
+ other = np.array([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
with tm.assert_produces_warning(PerformanceWarning):
res = dti - other
@@ -749,6 +766,21 @@ def test_dti_sub_offset_array(self, tz, box):
name=dti.name, freq='infer')
tm.assert_index_equal(res, expected)
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('foo', 'bar', None),
+ ('foo', 'foo', 'foo')])
+ def test_dti_sub_offset_index(self, tz, names):
+ # GH#18824, GH#19744
+ dti = pd.date_range('2017-01-01', periods=2, tz=tz, name=names[0])
+ other = pd.Index([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)],
+ name=names[1])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = dti - other
+ expected = DatetimeIndex([dti[n] - other[n] for n in range(len(dti))],
+ name=names[2], freq='infer')
+ tm.assert_index_equal(res, expected)
+
@pytest.mark.parametrize('names', [(None, None, None),
('foo', 'bar', None),
('foo', 'foo', 'foo')])
diff --git a/pandas/tests/indexes/timedeltas/test_arithmetic.py b/pandas/tests/indexes/timedeltas/test_arithmetic.py
index 3dc60ed33b958..029fdfcefc299 100644
--- a/pandas/tests/indexes/timedeltas/test_arithmetic.py
+++ b/pandas/tests/indexes/timedeltas/test_arithmetic.py
@@ -194,11 +194,31 @@ def test_shift_no_freq(self):
# -------------------------------------------------------------
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_tdi_add_offset_array(self, box):
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('foo', 'bar', None),
+ ('foo', 'foo', 'foo')])
+ def test_tdi_add_offset_index(self, names):
+ # GH#18849, GH#19744
+ tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00'],
+ name=names[0])
+ other = pd.Index([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)],
+ name=names[1])
+
+ expected = TimedeltaIndex([tdi[n] + other[n] for n in range(len(tdi))],
+ freq='infer', name=names[2])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = tdi + other
+ tm.assert_index_equal(res, expected)
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res2 = other + tdi
+ tm.assert_index_equal(res2, expected)
+
+ def test_tdi_add_offset_array(self):
# GH#18849
tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00'])
- other = box([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)])
+ other = np.array([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)])
expected = TimedeltaIndex([tdi[n] + other[n] for n in range(len(tdi))],
freq='infer')
@@ -211,23 +231,27 @@ def test_tdi_add_offset_array(self, box):
res2 = other + tdi
tm.assert_index_equal(res2, expected)
- anchored = box([pd.offsets.QuarterEnd(),
- pd.offsets.Week(weekday=2)])
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('foo', 'bar', None),
+ ('foo', 'foo', 'foo')])
+ def test_tdi_sub_offset_index(self, names):
+ # GH#18824, GH#19744
+ tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00'],
+ name=names[0])
+ other = pd.Index([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)],
+ name=names[1])
- # addition/subtraction ops with anchored offsets should issue
- # a PerformanceWarning and _then_ raise a TypeError.
- with pytest.raises(TypeError):
- with tm.assert_produces_warning(PerformanceWarning):
- tdi + anchored
- with pytest.raises(TypeError):
- with tm.assert_produces_warning(PerformanceWarning):
- anchored + tdi
+ expected = TimedeltaIndex([tdi[n] - other[n] for n in range(len(tdi))],
+ freq='infer', name=names[2])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = tdi - other
+ tm.assert_index_equal(res, expected)
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_tdi_sub_offset_array(self, box):
+ def test_tdi_sub_offset_array(self):
# GH#18824
tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00'])
- other = box([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)])
+ other = np.array([pd.offsets.Hour(n=1), pd.offsets.Minute(n=-2)])
expected = TimedeltaIndex([tdi[n] - other[n] for n in range(len(tdi))],
freq='infer')
@@ -236,17 +260,6 @@ def test_tdi_sub_offset_array(self, box):
res = tdi - other
tm.assert_index_equal(res, expected)
- anchored = box([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
-
- # addition/subtraction ops with anchored offsets should issue
- # a PerformanceWarning and _then_ raise a TypeError.
- with pytest.raises(TypeError):
- with tm.assert_produces_warning(PerformanceWarning):
- tdi - anchored
- with pytest.raises(TypeError):
- with tm.assert_produces_warning(PerformanceWarning):
- anchored - tdi
-
@pytest.mark.parametrize('names', [(None, None, None),
('foo', 'bar', None),
('foo', 'foo', 'foo')])
@@ -275,8 +288,12 @@ def test_tdi_with_offset_series(self, names):
res3 = tdi - other
tm.assert_series_equal(res3, expected_sub)
- anchored = Series([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)],
- name=names[1])
+ @pytest.mark.parametrize('box', [np.array, pd.Index, pd.Series])
+ def test_tdi_add_sub_anchored_offset_arraylike(self, box):
+ # GH#18824
+ tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00'])
+
+ anchored = box([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
# addition/subtraction ops with anchored offsets should issue
# a PerformanceWarning and _then_ raise a TypeError.
diff --git a/pandas/tests/test_common.py b/pandas/tests/test_common.py
index 57479be4d989f..0b329f64dafa3 100644
--- a/pandas/tests/test_common.py
+++ b/pandas/tests/test_common.py
@@ -9,6 +9,7 @@
from pandas import Series, Timestamp
from pandas.compat import range, lmap
import pandas.core.common as com
+from pandas.core import ops
import pandas.util.testing as tm
@@ -167,26 +168,26 @@ def test_random_state():
def test_maybe_match_name():
- matched = com._maybe_match_name(
+ matched = ops._maybe_match_name(
Series([1], name='x'), Series(
[2], name='x'))
assert (matched == 'x')
- matched = com._maybe_match_name(
+ matched = ops._maybe_match_name(
Series([1], name='x'), Series(
[2], name='y'))
assert (matched is None)
- matched = com._maybe_match_name(Series([1]), Series([2], name='x'))
+ matched = ops._maybe_match_name(Series([1]), Series([2], name='x'))
assert (matched is None)
- matched = com._maybe_match_name(Series([1], name='x'), Series([2]))
+ matched = ops._maybe_match_name(Series([1], name='x'), Series([2]))
assert (matched is None)
- matched = com._maybe_match_name(Series([1], name='x'), [2])
+ matched = ops._maybe_match_name(Series([1], name='x'), [2])
assert (matched == 'x')
- matched = com._maybe_match_name([1], Series([2], name='y'))
+ matched = ops._maybe_match_name([1], Series([2], name='y'))
assert (matched == 'y')
| - [ ] closes #xxxx
- [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/19744 | 2018-02-17T23:01:13Z | 2018-02-21T23:55:22Z | 2018-02-21T23:55:22Z | 2018-06-22T03:31:07Z |
DOC/BLD: Pinning sphinx to 1.5, as 1.7 has been released and it's incompatible with vendored numpydoc | diff --git a/ci/requirements_dev.txt b/ci/requirements_dev.txt
index 82f8de277c57b..a474658fa2922 100644
--- a/ci/requirements_dev.txt
+++ b/ci/requirements_dev.txt
@@ -7,4 +7,4 @@ pytest>=3.1
python-dateutil>=2.5.0
pytz
setuptools>=3.3
-sphinx
+sphinx=1.5*
| - [X] closes #19742
- [ ] tests added / passed
- [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/19743 | 2018-02-17T22:00:32Z | 2018-02-18T17:14:39Z | 2018-02-18T17:14:39Z | 2018-02-19T08:14:57Z |
finish off tests.tseries.test_timezones | diff --git a/pandas/tests/scalar/timestamp/test_unary_ops.py b/pandas/tests/scalar/timestamp/test_unary_ops.py
index 8a6989c909cb2..994ff86e6fdf9 100644
--- a/pandas/tests/scalar/timestamp/test_unary_ops.py
+++ b/pandas/tests/scalar/timestamp/test_unary_ops.py
@@ -4,11 +4,13 @@
import pytest
import pytz
from pytz import utc
+from dateutil.tz import gettz
import pandas.util.testing as tm
import pandas.util._test_decorators as td
from pandas.compat import PY3
+from pandas._libs import tslib
from pandas._libs.tslibs.frequencies import _INVALID_FREQ_ERROR
from pandas import Timestamp, NaT
@@ -215,6 +217,28 @@ def test_replace_tzinfo(self):
assert result_dt == result_pd
assert result_dt == result_pd.to_pydatetime()
+ @pytest.mark.parametrize('tz, normalize', [
+ (pytz.timezone('US/Eastern'), lambda x: x.tzinfo.normalize(x)),
+ (gettz('US/Eastern'), lambda x: x)])
+ def test_replace_across_dst(self, tz, normalize):
+ # GH#18319 check that 1) timezone is correctly normalized and
+ # 2) that hour is not incorrectly changed by this normalization
+ ts_naive = Timestamp('2017-12-03 16:03:30')
+ ts_aware = tslib._localize_pydatetime(ts_naive, tz)
+
+ # Preliminary sanity-check
+ assert ts_aware == normalize(ts_aware)
+
+ # Replace across DST boundary
+ ts2 = ts_aware.replace(month=6)
+
+ # Check that `replace` preserves hour literal
+ assert (ts2.hour, ts2.minute) == (ts_aware.hour, ts_aware.minute)
+
+ # Check that post-replace object is appropriately normalized
+ ts2b = normalize(ts2)
+ assert ts2 == ts2b
+
# --------------------------------------------------------------
@td.skip_if_windows
diff --git a/pandas/tests/tseries/test_timezones.py b/pandas/tests/tseries/test_timezones.py
deleted file mode 100644
index 97326dc04a522..0000000000000
--- a/pandas/tests/tseries/test_timezones.py
+++ /dev/null
@@ -1,108 +0,0 @@
-# pylint: disable-msg=E1101,W0612
-import pytest
-
-import pytz
-
-from datetime import datetime
-
-from pandas._libs.tslibs import timezones
-from pandas import Timestamp
-
-
-class TestTimeZoneSupportPytz(object):
-
- def tz(self, tz):
- # Construct a timezone object from a string. Overridden in subclass to
- # parameterize tests.
- return pytz.timezone(tz)
-
- def tzstr(self, tz):
- # Construct a timezone string from a string. Overridden in subclass to
- # parameterize tests.
- return tz
-
- def localize(self, tz, x):
- return tz.localize(x)
-
- def normalize(self, ts):
- tzinfo = ts.tzinfo
- return tzinfo.normalize(ts)
-
- def cmptz(self, tz1, tz2):
- # Compare two timezones. Overridden in subclass to parameterize
- # tests.
- return tz1.zone == tz2.zone
-
- # test utility methods
- def test_infer_tz(self):
- eastern = self.tz('US/Eastern')
- utc = pytz.utc
-
- _start = datetime(2001, 1, 1)
- _end = datetime(2009, 1, 1)
-
- start = self.localize(eastern, _start)
- end = self.localize(eastern, _end)
- assert (timezones.infer_tzinfo(start, end) is
- self.localize(eastern, _start).tzinfo)
- assert (timezones.infer_tzinfo(start, None) is
- self.localize(eastern, _start).tzinfo)
- assert (timezones.infer_tzinfo(None, end) is
- self.localize(eastern, _end).tzinfo)
-
- start = utc.localize(_start)
- end = utc.localize(_end)
- assert (timezones.infer_tzinfo(start, end) is utc)
-
- end = self.localize(eastern, _end)
- pytest.raises(Exception, timezones.infer_tzinfo, start, end)
- pytest.raises(Exception, timezones.infer_tzinfo, end, start)
-
- def test_replace_across_dst(self):
- # GH#18319 check that 1) timezone is correctly normalized and
- # 2) that hour is not incorrectly changed by this normalization
- tz = self.tz('US/Eastern')
-
- ts_naive = Timestamp('2017-12-03 16:03:30')
- ts_aware = self.localize(tz, ts_naive)
-
- # Preliminary sanity-check
- assert ts_aware == self.normalize(ts_aware)
-
- # Replace across DST boundary
- ts2 = ts_aware.replace(month=6)
-
- # Check that `replace` preserves hour literal
- assert (ts2.hour, ts2.minute) == (ts_aware.hour, ts_aware.minute)
-
- # Check that post-replace object is appropriately normalized
- ts2b = self.normalize(ts2)
- assert ts2 == ts2b
-
-
-class TestTimeZoneSupportDateutil(TestTimeZoneSupportPytz):
-
- def tz(self, tz):
- """
- Construct a dateutil timezone.
- Use tslib.maybe_get_tz so that we get the filename on the tz right
- on windows. See #7337.
- """
- return timezones.maybe_get_tz('dateutil/' + tz)
-
- def tzstr(self, tz):
- """ Construct a timezone string from a string. Overridden in subclass
- to parameterize tests. """
- return 'dateutil/' + tz
-
- def cmptz(self, tz1, tz2):
- """ Compare two timezones. Overridden in subclass to parameterize
- tests. """
- return tz1 == tz2
-
- def localize(self, tz, x):
- return x.replace(tzinfo=tz)
-
- def normalize(self, ts):
- # no-op for dateutil
- return ts
diff --git a/pandas/tests/tslibs/test_timezones.py b/pandas/tests/tslibs/test_timezones.py
index 603c5e3fea26f..1bb355f267938 100644
--- a/pandas/tests/tslibs/test_timezones.py
+++ b/pandas/tests/tslibs/test_timezones.py
@@ -5,6 +5,7 @@
import pytz
import dateutil.tz
+from pandas._libs import tslib
from pandas._libs.tslibs import timezones
from pandas import Timestamp
@@ -35,3 +36,33 @@ def test_tzlocal():
offset = dateutil.tz.tzlocal().utcoffset(datetime(2011, 1, 1))
offset = offset.total_seconds() * 1000000000
assert ts.value + offset == Timestamp('2011-01-01').value
+
+
+@pytest.mark.parametrize('eastern, localize', [
+ (pytz.timezone('US/Eastern'), lambda tz, x: tz.localize(x)),
+ (dateutil.tz.gettz('US/Eastern'), lambda tz, x: x.replace(tzinfo=tz))])
+def test_infer_tz(eastern, localize):
+ utc = pytz.utc
+
+ start_naive = datetime(2001, 1, 1)
+ end_naive = datetime(2009, 1, 1)
+
+ start = localize(eastern, start_naive)
+ end = localize(eastern, end_naive)
+
+ assert (timezones.infer_tzinfo(start, end) is
+ tslib._localize_pydatetime(start_naive, eastern).tzinfo)
+ assert (timezones.infer_tzinfo(start, None) is
+ tslib._localize_pydatetime(start_naive, eastern).tzinfo)
+ assert (timezones.infer_tzinfo(None, end) is
+ tslib._localize_pydatetime(end_naive, eastern).tzinfo)
+
+ start = utc.localize(start_naive)
+ end = utc.localize(end_naive)
+ assert timezones.infer_tzinfo(start, end) is utc
+
+ end = tslib._localize_pydatetime(end_naive, eastern)
+ with pytest.raises(Exception):
+ timezones.infer_tzinfo(start, end)
+ with pytest.raises(Exception):
+ timezones.infer_tzinfo(end, start)
| - [ ] 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/19739 | 2018-02-17T04:58:44Z | 2018-02-18T16:22:16Z | 2018-02-18T16:22:16Z | 2018-02-18T18:22:13Z |
DOC: correct merge_asof example | diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 4b99b0407cfcc..7b1a0875bba59 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -457,8 +457,8 @@ def merge_asof(left, right, on=None,
time ticker price quantity bid ask
0 2016-05-25 13:30:00.023 MSFT 51.95 75 NaN NaN
1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98
- 2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93
- 3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93
+ 2 2016-05-25 13:30:00.048 GOOG 720.77 100 NaN NaN
+ 3 2016-05-25 13:30:00.048 GOOG 720.92 100 NaN NaN
4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN
See also
diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py
index 2f48aef1894a9..cebbcc41c3e17 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -92,11 +92,30 @@ def test_examples2(self):
by='ticker',
tolerance=pd.Timedelta('2ms'))
- pd.merge_asof(trades, quotes,
- on='time',
- by='ticker',
- tolerance=pd.Timedelta('10ms'),
- allow_exact_matches=False)
+ expected = pd.DataFrame({
+ 'time': pd.to_datetime(['20160525 13:30:00.023',
+ '20160525 13:30:00.038',
+ '20160525 13:30:00.048',
+ '20160525 13:30:00.048',
+ '20160525 13:30:00.048']),
+ 'ticker': ['MSFT', 'MSFT', 'GOOG', 'GOOG', 'AAPL'],
+ 'price': [51.95, 51.95,
+ 720.77, 720.92, 98.00],
+ 'quantity': [75, 155,
+ 100, 100, 100],
+ 'bid': [np.nan, 51.97, np.nan,
+ np.nan, np.nan],
+ 'ask': [np.nan, 51.98, np.nan,
+ np.nan, np.nan]},
+ columns=['time', 'ticker', 'price', 'quantity',
+ 'bid', 'ask'])
+
+ result = pd.merge_asof(trades, quotes,
+ on='time',
+ by='ticker',
+ tolerance=pd.Timedelta('10ms'),
+ allow_exact_matches=False)
+ assert_frame_equal(result, expected)
def test_examples3(self):
""" doc-string examples """
| - [ ] closes #19489
- [x] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
- update of incorrect documentation example for merge_asof.
- add a test corresponding to this example. | https://api.github.com/repos/pandas-dev/pandas/pulls/19737 | 2018-02-17T02:18:03Z | 2018-02-18T17:46:54Z | 2018-02-18T17:46:53Z | 2018-02-19T00:06:21Z |
Split+Parametrize Timedelta tests | diff --git a/pandas/tests/scalar/timedelta/test_construction.py b/pandas/tests/scalar/timedelta/test_construction.py
new file mode 100644
index 0000000000000..5ccad9e6b4e3c
--- /dev/null
+++ b/pandas/tests/scalar/timedelta/test_construction.py
@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+from datetime import timedelta
+
+import pytest
+import numpy as np
+
+import pandas as pd
+import pandas.util.testing as tm
+from pandas import Timedelta
+
+
+def test_construction():
+ expected = np.timedelta64(10, 'D').astype('m8[ns]').view('i8')
+ assert Timedelta(10, unit='d').value == expected
+ assert Timedelta(10.0, unit='d').value == expected
+ assert Timedelta('10 days').value == expected
+ assert Timedelta(days=10).value == expected
+ assert Timedelta(days=10.0).value == expected
+
+ expected += np.timedelta64(10, 's').astype('m8[ns]').view('i8')
+ assert Timedelta('10 days 00:00:10').value == expected
+ assert Timedelta(days=10, seconds=10).value == expected
+ assert Timedelta(days=10, milliseconds=10 * 1000).value == expected
+ assert Timedelta(days=10,
+ microseconds=10 * 1000 * 1000).value == expected
+
+ # rounding cases
+ assert Timedelta(82739999850000).value == 82739999850000
+ assert ('0 days 22:58:59.999850' in str(Timedelta(82739999850000)))
+ assert Timedelta(123072001000000).value == 123072001000000
+ assert ('1 days 10:11:12.001' in str(Timedelta(123072001000000)))
+
+ # string conversion with/without leading zero
+ # GH#9570
+ assert Timedelta('0:00:00') == timedelta(hours=0)
+ assert Timedelta('00:00:00') == timedelta(hours=0)
+ assert Timedelta('-1:00:00') == -timedelta(hours=1)
+ assert Timedelta('-01:00:00') == -timedelta(hours=1)
+
+ # more strings & abbrevs
+ # GH#8190
+ assert Timedelta('1 h') == timedelta(hours=1)
+ assert Timedelta('1 hour') == timedelta(hours=1)
+ assert Timedelta('1 hr') == timedelta(hours=1)
+ assert Timedelta('1 hours') == timedelta(hours=1)
+ assert Timedelta('-1 hours') == -timedelta(hours=1)
+ assert Timedelta('1 m') == timedelta(minutes=1)
+ assert Timedelta('1.5 m') == timedelta(seconds=90)
+ assert Timedelta('1 minute') == timedelta(minutes=1)
+ assert Timedelta('1 minutes') == timedelta(minutes=1)
+ assert Timedelta('1 s') == timedelta(seconds=1)
+ assert Timedelta('1 second') == timedelta(seconds=1)
+ assert Timedelta('1 seconds') == timedelta(seconds=1)
+ assert Timedelta('1 ms') == timedelta(milliseconds=1)
+ assert Timedelta('1 milli') == timedelta(milliseconds=1)
+ assert Timedelta('1 millisecond') == timedelta(milliseconds=1)
+ assert Timedelta('1 us') == timedelta(microseconds=1)
+ assert Timedelta('1 micros') == timedelta(microseconds=1)
+ assert Timedelta('1 microsecond') == timedelta(microseconds=1)
+ assert Timedelta('1.5 microsecond') == Timedelta('00:00:00.000001500')
+ assert Timedelta('1 ns') == Timedelta('00:00:00.000000001')
+ assert Timedelta('1 nano') == Timedelta('00:00:00.000000001')
+ assert Timedelta('1 nanosecond') == Timedelta('00:00:00.000000001')
+
+ # combos
+ assert Timedelta('10 days 1 hour') == timedelta(days=10, hours=1)
+ assert Timedelta('10 days 1 h') == timedelta(days=10, hours=1)
+ assert Timedelta('10 days 1 h 1m 1s') == timedelta(
+ days=10, hours=1, minutes=1, seconds=1)
+ assert Timedelta('-10 days 1 h 1m 1s') == -timedelta(
+ days=10, hours=1, minutes=1, seconds=1)
+ assert Timedelta('-10 days 1 h 1m 1s') == -timedelta(
+ days=10, hours=1, minutes=1, seconds=1)
+ assert Timedelta('-10 days 1 h 1m 1s 3us') == -timedelta(
+ days=10, hours=1, minutes=1, seconds=1, microseconds=3)
+ assert Timedelta('-10 days 1 h 1.5m 1s 3us') == -timedelta(
+ days=10, hours=1, minutes=1, seconds=31, microseconds=3)
+
+ # Currently invalid as it has a - on the hh:mm:dd part
+ # (only allowed on the days)
+ with pytest.raises(ValueError):
+ Timedelta('-10 days -1 h 1.5m 1s 3us')
+
+ # only leading neg signs are allowed
+ with pytest.raises(ValueError):
+ Timedelta('10 days -1 h 1.5m 1s 3us')
+
+ # no units specified
+ with pytest.raises(ValueError):
+ Timedelta('3.1415')
+
+ # invalid construction
+ tm.assert_raises_regex(ValueError, "cannot construct a Timedelta",
+ lambda: Timedelta())
+ tm.assert_raises_regex(ValueError,
+ "unit abbreviation w/o a number",
+ lambda: Timedelta('foo'))
+ tm.assert_raises_regex(ValueError,
+ "cannot construct a Timedelta from the "
+ "passed arguments, allowed keywords are ",
+ lambda: Timedelta(day=10))
+
+ # floats
+ expected = np.timedelta64(
+ 10, 's').astype('m8[ns]').view('i8') + np.timedelta64(
+ 500, 'ms').astype('m8[ns]').view('i8')
+ assert Timedelta(10.5, unit='s').value == expected
+
+ # offset
+ assert pd.to_timedelta(pd.offsets.Hour(2)) == Timedelta(hours=2)
+ assert Timedelta(pd.offsets.Hour(2)) == Timedelta(hours=2)
+ assert Timedelta(pd.offsets.Second(2)) == Timedelta(seconds=2)
+
+ # GH#11995: unicode
+ expected = Timedelta('1H')
+ result = pd.Timedelta(u'1H')
+ assert result == expected
+ assert (pd.to_timedelta(pd.offsets.Hour(2)) ==
+ Timedelta(u'0 days, 02:00:00'))
+
+ with pytest.raises(ValueError):
+ Timedelta(u'foo bar')
+
+
+@pytest.mark.parametrize('item', list({'days': 'D',
+ 'seconds': 's',
+ 'microseconds': 'us',
+ 'milliseconds': 'ms',
+ 'minutes': 'm',
+ 'hours': 'h',
+ 'weeks': 'W'}.items()))
+@pytest.mark.parametrize('npdtype', [np.int64, np.int32, np.int16,
+ np.float64, np.float32, np.float16])
+def test_td_construction_with_np_dtypes(npdtype, item):
+ # GH#8757: test construction with np dtypes
+ pykwarg, npkwarg = item
+ expected = np.timedelta64(1, npkwarg).astype('m8[ns]').view('i8')
+ assert Timedelta(**{pykwarg: npdtype(1)}).value == expected
+
+
+@pytest.mark.parametrize('val', [
+ '1s', '-1s', '1us', '-1us', '1 day', '-1 day',
+ '-23:59:59.999999', '-1 days +23:59:59.999999', '-1ns',
+ '1ns', '-23:59:59.999999999'])
+def test_td_from_repr_roundtrip(val):
+ # round-trip both for string and value
+ td = Timedelta(val)
+ assert Timedelta(td.value) == td
+
+ # str does not normally display nanos
+ if not td.nanoseconds:
+ assert Timedelta(str(td)) == td
+ assert Timedelta(td._repr_base(format='all')) == td
+
+
+def test_overflow_on_construction():
+ # xref https://github.com/statsmodels/statsmodels/issues/3374
+ value = pd.Timedelta('1day').value * 20169940
+ with pytest.raises(OverflowError):
+ pd.Timedelta(value)
+
+ # xref GH#17637
+ with pytest.raises(OverflowError):
+ pd.Timedelta(7 * 19999, unit='D')
+
+ with pytest.raises(OverflowError):
+ pd.Timedelta(timedelta(days=13 * 19999))
+
+
+@pytest.mark.parametrize('fmt,exp', [
+ ('P6DT0H50M3.010010012S', Timedelta(days=6, minutes=50, seconds=3,
+ milliseconds=10, microseconds=10,
+ nanoseconds=12)),
+ ('P-6DT0H50M3.010010012S', Timedelta(days=-6, minutes=50, seconds=3,
+ milliseconds=10, microseconds=10,
+ nanoseconds=12)),
+ ('P4DT12H30M5S', Timedelta(days=4, hours=12, minutes=30, seconds=5)),
+ ('P0DT0H0M0.000000123S', Timedelta(nanoseconds=123)),
+ ('P0DT0H0M0.00001S', Timedelta(microseconds=10)),
+ ('P0DT0H0M0.001S', Timedelta(milliseconds=1)),
+ ('P0DT0H1M0S', Timedelta(minutes=1)),
+ ('P1DT25H61M61S', Timedelta(days=1, hours=25, minutes=61, seconds=61))
+])
+def test_iso_constructor(fmt, exp):
+ assert Timedelta(fmt) == exp
+
+
+@pytest.mark.parametrize('fmt', [
+ 'PPPPPPPPPPPP', 'PDTHMS', 'P0DT999H999M999S',
+ 'P1DT0H0M0.0000000000000S', 'P1DT0H0M00000000000S',
+ 'P1DT0H0M0.S'])
+def test_iso_constructor_raises(fmt):
+ with tm.assert_raises_regex(ValueError, 'Invalid ISO 8601 Duration '
+ 'format - {}'.format(fmt)):
+ Timedelta(fmt)
+
+
+def test_td_constructor_on_nanoseconds():
+ # GH#9273
+ result = Timedelta(nanoseconds=100)
+ expected = Timedelta('100ns')
+ assert result == expected
+
+ result = Timedelta(days=1, hours=1, minutes=1, weeks=1, seconds=1,
+ milliseconds=1, microseconds=1, nanoseconds=1)
+ expected = Timedelta(694861001001001)
+ assert result == expected
+
+ result = Timedelta(microseconds=1) + Timedelta(nanoseconds=1)
+ expected = Timedelta('1us1ns')
+ assert result == expected
+
+ result = Timedelta(microseconds=1) - Timedelta(nanoseconds=1)
+ expected = Timedelta('999ns')
+ assert result == expected
+
+ result = Timedelta(microseconds=1) + 5 * Timedelta(nanoseconds=-2)
+ expected = Timedelta('990ns')
+ assert result == expected
+
+ with pytest.raises(TypeError):
+ Timedelta(nanoseconds='abc')
diff --git a/pandas/tests/scalar/timedelta/test_formats.py b/pandas/tests/scalar/timedelta/test_formats.py
new file mode 100644
index 0000000000000..8a877c7d1c0fa
--- /dev/null
+++ b/pandas/tests/scalar/timedelta/test_formats.py
@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+from pandas import Timedelta
+
+
+def test_repr():
+ assert (repr(Timedelta(10, unit='d')) ==
+ "Timedelta('10 days 00:00:00')")
+ assert (repr(Timedelta(10, unit='s')) ==
+ "Timedelta('0 days 00:00:10')")
+ assert (repr(Timedelta(10, unit='ms')) ==
+ "Timedelta('0 days 00:00:00.010000')")
+ assert (repr(Timedelta(-10, unit='ms')) ==
+ "Timedelta('-1 days +23:59:59.990000')")
+
+
+def test_isoformat():
+ td = Timedelta(days=6, minutes=50, seconds=3,
+ milliseconds=10, microseconds=10, nanoseconds=12)
+ expected = 'P6DT0H50M3.010010012S'
+ result = td.isoformat()
+ assert result == expected
+
+ td = Timedelta(days=4, hours=12, minutes=30, seconds=5)
+ result = td.isoformat()
+ expected = 'P4DT12H30M5S'
+ assert result == expected
+
+ td = Timedelta(nanoseconds=123)
+ result = td.isoformat()
+ expected = 'P0DT0H0M0.000000123S'
+ assert result == expected
+
+ # trim nano
+ td = Timedelta(microseconds=10)
+ result = td.isoformat()
+ expected = 'P0DT0H0M0.00001S'
+ assert result == expected
+
+ # trim micro
+ td = Timedelta(milliseconds=1)
+ result = td.isoformat()
+ expected = 'P0DT0H0M0.001S'
+ assert result == expected
+
+ # don't strip every 0
+ result = Timedelta(minutes=1).isoformat()
+ expected = 'P0DT0H1M0S'
+ assert result == expected
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 420b66b4ce0dc..0f7fb84c6520b 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -36,31 +36,6 @@ def test_ops_error_str(self):
assert not left == right
assert left != right
- def test_to_timedelta_on_nanoseconds(self):
- # GH 9273
- result = Timedelta(nanoseconds=100)
- expected = Timedelta('100ns')
- assert result == expected
-
- result = Timedelta(days=1, hours=1, minutes=1, weeks=1, seconds=1,
- milliseconds=1, microseconds=1, nanoseconds=1)
- expected = Timedelta(694861001001001)
- assert result == expected
-
- result = Timedelta(microseconds=1) + Timedelta(nanoseconds=1)
- expected = Timedelta('1us1ns')
- assert result == expected
-
- result = Timedelta(microseconds=1) - Timedelta(nanoseconds=1)
- expected = Timedelta('999ns')
- assert result == expected
-
- result = Timedelta(microseconds=1) + 5 * Timedelta(nanoseconds=-2)
- expected = Timedelta('990ns')
- assert result == expected
-
- pytest.raises(TypeError, lambda: Timedelta(nanoseconds='abc'))
-
def test_ops_notimplemented(self):
class Other:
pass
@@ -124,164 +99,6 @@ def test_compare_timedelta_ndarray(self):
class TestTimedeltas(object):
- def setup_method(self, method):
- pass
-
- def test_construction(self):
-
- expected = np.timedelta64(10, 'D').astype('m8[ns]').view('i8')
- assert Timedelta(10, unit='d').value == expected
- assert Timedelta(10.0, unit='d').value == expected
- assert Timedelta('10 days').value == expected
- assert Timedelta(days=10).value == expected
- assert Timedelta(days=10.0).value == expected
-
- expected += np.timedelta64(10, 's').astype('m8[ns]').view('i8')
- assert Timedelta('10 days 00:00:10').value == expected
- assert Timedelta(days=10, seconds=10).value == expected
- assert Timedelta(days=10, milliseconds=10 * 1000).value == expected
- assert (Timedelta(days=10, microseconds=10 * 1000 * 1000)
- .value == expected)
-
- # gh-8757: test construction with np dtypes
- timedelta_kwargs = {'days': 'D',
- 'seconds': 's',
- 'microseconds': 'us',
- 'milliseconds': 'ms',
- 'minutes': 'm',
- 'hours': 'h',
- 'weeks': 'W'}
- npdtypes = [np.int64, np.int32, np.int16, np.float64, np.float32,
- np.float16]
- for npdtype in npdtypes:
- for pykwarg, npkwarg in timedelta_kwargs.items():
- expected = np.timedelta64(1, npkwarg).astype(
- 'm8[ns]').view('i8')
- assert Timedelta(**{pykwarg: npdtype(1)}).value == expected
-
- # rounding cases
- assert Timedelta(82739999850000).value == 82739999850000
- assert ('0 days 22:58:59.999850' in str(Timedelta(82739999850000)))
- assert Timedelta(123072001000000).value == 123072001000000
- assert ('1 days 10:11:12.001' in str(Timedelta(123072001000000)))
-
- # string conversion with/without leading zero
- # GH 9570
- assert Timedelta('0:00:00') == timedelta(hours=0)
- assert Timedelta('00:00:00') == timedelta(hours=0)
- assert Timedelta('-1:00:00') == -timedelta(hours=1)
- assert Timedelta('-01:00:00') == -timedelta(hours=1)
-
- # more strings & abbrevs
- # GH 8190
- assert Timedelta('1 h') == timedelta(hours=1)
- assert Timedelta('1 hour') == timedelta(hours=1)
- assert Timedelta('1 hr') == timedelta(hours=1)
- assert Timedelta('1 hours') == timedelta(hours=1)
- assert Timedelta('-1 hours') == -timedelta(hours=1)
- assert Timedelta('1 m') == timedelta(minutes=1)
- assert Timedelta('1.5 m') == timedelta(seconds=90)
- assert Timedelta('1 minute') == timedelta(minutes=1)
- assert Timedelta('1 minutes') == timedelta(minutes=1)
- assert Timedelta('1 s') == timedelta(seconds=1)
- assert Timedelta('1 second') == timedelta(seconds=1)
- assert Timedelta('1 seconds') == timedelta(seconds=1)
- assert Timedelta('1 ms') == timedelta(milliseconds=1)
- assert Timedelta('1 milli') == timedelta(milliseconds=1)
- assert Timedelta('1 millisecond') == timedelta(milliseconds=1)
- assert Timedelta('1 us') == timedelta(microseconds=1)
- assert Timedelta('1 micros') == timedelta(microseconds=1)
- assert Timedelta('1 microsecond') == timedelta(microseconds=1)
- assert Timedelta('1.5 microsecond') == Timedelta('00:00:00.000001500')
- assert Timedelta('1 ns') == Timedelta('00:00:00.000000001')
- assert Timedelta('1 nano') == Timedelta('00:00:00.000000001')
- assert Timedelta('1 nanosecond') == Timedelta('00:00:00.000000001')
-
- # combos
- assert Timedelta('10 days 1 hour') == timedelta(days=10, hours=1)
- assert Timedelta('10 days 1 h') == timedelta(days=10, hours=1)
- assert Timedelta('10 days 1 h 1m 1s') == timedelta(
- days=10, hours=1, minutes=1, seconds=1)
- assert Timedelta('-10 days 1 h 1m 1s') == -timedelta(
- days=10, hours=1, minutes=1, seconds=1)
- assert Timedelta('-10 days 1 h 1m 1s') == -timedelta(
- days=10, hours=1, minutes=1, seconds=1)
- assert Timedelta('-10 days 1 h 1m 1s 3us') == -timedelta(
- days=10, hours=1, minutes=1, seconds=1, microseconds=3)
- assert Timedelta('-10 days 1 h 1.5m 1s 3us'), -timedelta(
- days=10, hours=1, minutes=1, seconds=31, microseconds=3)
-
- # Currently invalid as it has a - on the hh:mm:dd part
- # (only allowed on the days)
- pytest.raises(ValueError,
- lambda: Timedelta('-10 days -1 h 1.5m 1s 3us'))
-
- # only leading neg signs are allowed
- pytest.raises(ValueError,
- lambda: Timedelta('10 days -1 h 1.5m 1s 3us'))
-
- # no units specified
- pytest.raises(ValueError, lambda: Timedelta('3.1415'))
-
- # invalid construction
- tm.assert_raises_regex(ValueError, "cannot construct a Timedelta",
- lambda: Timedelta())
- tm.assert_raises_regex(ValueError,
- "unit abbreviation w/o a number",
- lambda: Timedelta('foo'))
- tm.assert_raises_regex(ValueError,
- "cannot construct a Timedelta from the "
- "passed arguments, allowed keywords are ",
- lambda: Timedelta(day=10))
-
- # round-trip both for string and value
- for v in ['1s', '-1s', '1us', '-1us', '1 day', '-1 day',
- '-23:59:59.999999', '-1 days +23:59:59.999999', '-1ns',
- '1ns', '-23:59:59.999999999']:
-
- td = Timedelta(v)
- assert Timedelta(td.value) == td
-
- # str does not normally display nanos
- if not td.nanoseconds:
- assert Timedelta(str(td)) == td
- assert Timedelta(td._repr_base(format='all')) == td
-
- # floats
- expected = np.timedelta64(
- 10, 's').astype('m8[ns]').view('i8') + np.timedelta64(
- 500, 'ms').astype('m8[ns]').view('i8')
- assert Timedelta(10.5, unit='s').value == expected
-
- # offset
- assert (to_timedelta(pd.offsets.Hour(2)) ==
- Timedelta('0 days, 02:00:00'))
- assert (Timedelta(pd.offsets.Hour(2)) ==
- Timedelta('0 days, 02:00:00'))
- assert (Timedelta(pd.offsets.Second(2)) ==
- Timedelta('0 days, 00:00:02'))
-
- # gh-11995: unicode
- expected = Timedelta('1H')
- result = pd.Timedelta(u'1H')
- assert result == expected
- assert (to_timedelta(pd.offsets.Hour(2)) ==
- Timedelta(u'0 days, 02:00:00'))
-
- pytest.raises(ValueError, lambda: Timedelta(u'foo bar'))
-
- def test_overflow_on_construction(self):
- # xref https://github.com/statsmodels/statsmodels/issues/3374
- value = pd.Timedelta('1day').value * 20169940
- pytest.raises(OverflowError, pd.Timedelta, value)
-
- # xref gh-17637
- with pytest.raises(OverflowError):
- pd.Timedelta(7 * 19999, unit='D')
-
- with pytest.raises(OverflowError):
- pd.Timedelta(timedelta(days=13 * 19999))
-
def test_total_seconds_scalar(self):
# see gh-10939
rng = Timedelta('1 days, 10:11:12.100123456')
@@ -291,17 +108,6 @@ def test_total_seconds_scalar(self):
rng = Timedelta(np.nan)
assert np.isnan(rng.total_seconds())
- def test_repr(self):
-
- assert (repr(Timedelta(10, unit='d')) ==
- "Timedelta('10 days 00:00:00')")
- assert (repr(Timedelta(10, unit='s')) ==
- "Timedelta('0 days 00:00:10')")
- assert (repr(Timedelta(10, unit='ms')) ==
- "Timedelta('0 days 00:00:00.010000')")
- assert (repr(Timedelta(-10, unit='ms')) ==
- "Timedelta('-1 days +23:59:59.990000')")
-
def test_conversion(self):
for td in [Timedelta(10, unit='d'),
@@ -756,63 +562,3 @@ def test_components(self):
result = s.dt.components
assert not result.iloc[0].isna().all()
assert result.iloc[1].isna().all()
-
- def test_isoformat(self):
- td = Timedelta(days=6, minutes=50, seconds=3,
- milliseconds=10, microseconds=10, nanoseconds=12)
- expected = 'P6DT0H50M3.010010012S'
- result = td.isoformat()
- assert result == expected
-
- td = Timedelta(days=4, hours=12, minutes=30, seconds=5)
- result = td.isoformat()
- expected = 'P4DT12H30M5S'
- assert result == expected
-
- td = Timedelta(nanoseconds=123)
- result = td.isoformat()
- expected = 'P0DT0H0M0.000000123S'
- assert result == expected
-
- # trim nano
- td = Timedelta(microseconds=10)
- result = td.isoformat()
- expected = 'P0DT0H0M0.00001S'
- assert result == expected
-
- # trim micro
- td = Timedelta(milliseconds=1)
- result = td.isoformat()
- expected = 'P0DT0H0M0.001S'
- assert result == expected
-
- # don't strip every 0
- result = Timedelta(minutes=1).isoformat()
- expected = 'P0DT0H1M0S'
- assert result == expected
-
- @pytest.mark.parametrize('fmt,exp', [
- ('P6DT0H50M3.010010012S', Timedelta(days=6, minutes=50, seconds=3,
- milliseconds=10, microseconds=10,
- nanoseconds=12)),
- ('P-6DT0H50M3.010010012S', Timedelta(days=-6, minutes=50, seconds=3,
- milliseconds=10, microseconds=10,
- nanoseconds=12)),
- ('P4DT12H30M5S', Timedelta(days=4, hours=12, minutes=30, seconds=5)),
- ('P0DT0H0M0.000000123S', Timedelta(nanoseconds=123)),
- ('P0DT0H0M0.00001S', Timedelta(microseconds=10)),
- ('P0DT0H0M0.001S', Timedelta(milliseconds=1)),
- ('P0DT0H1M0S', Timedelta(minutes=1)),
- ('P1DT25H61M61S', Timedelta(days=1, hours=25, minutes=61, seconds=61))
- ])
- def test_iso_constructor(self, fmt, exp):
- assert Timedelta(fmt) == exp
-
- @pytest.mark.parametrize('fmt', [
- 'PPPPPPPPPPPP', 'PDTHMS', 'P0DT999H999M999S',
- 'P1DT0H0M0.0000000000000S', 'P1DT0H0M00000000000S',
- 'P1DT0H0M0.S'])
- def test_iso_constructor_raises(self, fmt):
- with tm.assert_raises_regex(ValueError, 'Invalid ISO 8601 Duration '
- 'format - {}'.format(fmt)):
- Timedelta(fmt)
| Started splitting non-contentious parts off of #19365. This even-easier bit got split off of that. Just organizing+splitting+parametrizing tests. | https://api.github.com/repos/pandas-dev/pandas/pulls/19736 | 2018-02-17T01:54:34Z | 2018-02-20T11:16:30Z | 2018-02-20T11:16:30Z | 2018-06-22T03:31:07Z |
CLN: Removed Unnecessary Conditionals in groupby_helper | diff --git a/pandas/_libs/groupby_helper.pxi.in b/pandas/_libs/groupby_helper.pxi.in
index fe4d31516d839..93fbb4477e2d0 100644
--- a/pandas/_libs/groupby_helper.pxi.in
+++ b/pandas/_libs/groupby_helper.pxi.in
@@ -56,36 +56,19 @@ def group_add_{{name}}(ndarray[{{dest_type2}}, ndim=2] out,
with nogil:
- if K > 1:
-
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
-
- counts[lab] += 1
- for j in range(K):
- val = values[i, j]
-
- # not nan
- if val == val:
- nobs[lab, j] += 1
- sumx[lab, j] += val
-
- else:
-
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
+ for i in range(N):
+ lab = labels[i]
+ if lab < 0:
+ continue
- counts[lab] += 1
- val = values[i, 0]
+ counts[lab] += 1
+ for j in range(K):
+ val = values[i, j]
# not nan
if val == val:
- nobs[lab, 0] += 1
- sumx[lab, 0] += val
+ nobs[lab, j] += 1
+ sumx[lab, j] += val
for i in range(ncounts):
for j in range(K):
@@ -119,33 +102,19 @@ def group_prod_{{name}}(ndarray[{{dest_type2}}, ndim=2] out,
N, K = (<object> values).shape
with nogil:
- if K > 1:
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
-
- counts[lab] += 1
- for j in range(K):
- val = values[i, j]
-
- # not nan
- if val == val:
- nobs[lab, j] += 1
- prodx[lab, j] *= val
- else:
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
+ for i in range(N):
+ lab = labels[i]
+ if lab < 0:
+ continue
- counts[lab] += 1
- val = values[i, 0]
+ counts[lab] += 1
+ for j in range(K):
+ val = values[i, j]
# not nan
if val == val:
- nobs[lab, 0] += 1
- prodx[lab, 0] *= val
+ nobs[lab, j] += 1
+ prodx[lab, j] *= val
for i in range(ncounts):
for j in range(K):
@@ -231,31 +200,18 @@ def group_mean_{{name}}(ndarray[{{dest_type2}}, ndim=2] out,
N, K = (<object> values).shape
with nogil:
- if K > 1:
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
-
- counts[lab] += 1
- for j in range(K):
- val = values[i, j]
- # not nan
- if val == val:
- nobs[lab, j] += 1
- sumx[lab, j] += val
- else:
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
+ for i in range(N):
+ lab = labels[i]
+ if lab < 0:
+ continue
- counts[lab] += 1
- val = values[i, 0]
+ counts[lab] += 1
+ for j in range(K):
+ val = values[i, j]
# not nan
if val == val:
- nobs[lab, 0] += 1
- sumx[lab, 0] += val
+ nobs[lab, j] += 1
+ sumx[lab, j] += val
for i in range(ncounts):
for j in range(K):
@@ -670,33 +626,14 @@ def group_max_{{name}}(ndarray[{{dest_type2}}, ndim=2] out,
N, K = (<object> values).shape
with nogil:
- if K > 1:
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
-
- counts[lab] += 1
- for j in range(K):
- val = values[i, j]
-
- # not nan
- {{if name == 'int64'}}
- if val != {{nan_val}}:
- {{else}}
- if val == val and val != {{nan_val}}:
- {{endif}}
- nobs[lab, j] += 1
- if val > maxx[lab, j]:
- maxx[lab, j] = val
- else:
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
+ for i in range(N):
+ lab = labels[i]
+ if lab < 0:
+ continue
- counts[lab] += 1
- val = values[i, 0]
+ counts[lab] += 1
+ for j in range(K):
+ val = values[i, j]
# not nan
{{if name == 'int64'}}
@@ -704,9 +641,9 @@ def group_max_{{name}}(ndarray[{{dest_type2}}, ndim=2] out,
{{else}}
if val == val and val != {{nan_val}}:
{{endif}}
- nobs[lab, 0] += 1
- if val > maxx[lab, 0]:
- maxx[lab, 0] = val
+ nobs[lab, j] += 1
+ if val > maxx[lab, j]:
+ maxx[lab, j] = val
for i in range(ncounts):
for j in range(K):
@@ -744,33 +681,14 @@ def group_min_{{name}}(ndarray[{{dest_type2}}, ndim=2] out,
N, K = (<object> values).shape
with nogil:
- if K > 1:
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
-
- counts[lab] += 1
- for j in range(K):
- val = values[i, j]
-
- # not nan
- {{if name == 'int64'}}
- if val != {{nan_val}}:
- {{else}}
- if val == val and val != {{nan_val}}:
- {{endif}}
- nobs[lab, j] += 1
- if val < minx[lab, j]:
- minx[lab, j] = val
- else:
- for i in range(N):
- lab = labels[i]
- if lab < 0:
- continue
+ for i in range(N):
+ lab = labels[i]
+ if lab < 0:
+ continue
- counts[lab] += 1
- val = values[i, 0]
+ counts[lab] += 1
+ for j in range(K):
+ val = values[i, j]
# not nan
{{if name == 'int64'}}
@@ -778,9 +696,9 @@ def group_min_{{name}}(ndarray[{{dest_type2}}, ndim=2] out,
{{else}}
if val == val and val != {{nan_val}}:
{{endif}}
- nobs[lab, 0] += 1
- if val < minx[lab, 0]:
- minx[lab, 0] = val
+ nobs[lab, j] += 1
+ if val < minx[lab, j]:
+ minx[lab, j] = val
for i in range(ncounts):
for j in range(K):
| - [X] closes #19724
- [X] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
ASV results are pretty inconsistent but I couldn't find anything directly related from this change. Of the marks below, only `max` was touched by this change, and that doesn't appear consistently in the results
```bash
before after ratio
[2fdf1e25] [458210c1]
+ 155±1μs 173±4μs 1.12 groupby.GroupByMethods.time_method('float', 'max')
+ 324±1μs 361±5μs 1.12 groupby.GroupByMethods.time_method('float', 'median')
- 722±5μs 638±8μs 0.88 groupby.GroupByMethods.time_method('int', 'cumprod')
- 540±10μs 463±1μs 0.86 groupby.GroupByMethods.time_method('int', 'cummax')
- 551±20μs 459±1μs 0.83 groupby.GroupByMethods.time_method('int', 'cummin')
- 1.17±0.1ms 475±7μs 0.40 groupby.GroupByMethods.time_method('float', 'sem')
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/19734 | 2018-02-17T00:48:42Z | 2018-02-18T16:39:50Z | 2018-02-18T16:39:49Z | 2018-02-18T18:40:56Z |
BUG: Avoid Timedelta rounding when specifying unit and integer (#12690) | diff --git a/doc/source/whatsnew/v0.23.1.txt b/doc/source/whatsnew/v0.23.1.txt
index 5a553264e828b..5e26c0ac4433a 100644
--- a/doc/source/whatsnew/v0.23.1.txt
+++ b/doc/source/whatsnew/v0.23.1.txt
@@ -53,7 +53,10 @@ Strings
^^^^^^^
- Bug in :meth:`Series.str.replace()` where the method throws `TypeError` on Python 3.5.2 (:issue: `21078`)
--
+
+Timedelta
+^^^^^^^^^
+- Bug in :class:`Timedelta`: where passing a float with a unit would prematurely round the float precision (:issue: `14156`)
Categorical
^^^^^^^^^^^
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index f7bb6c1dbb304..22f9d3327f575 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -202,22 +202,22 @@ cpdef inline int64_t cast_from_unit(object ts, object unit) except? -1:
if unit == 'D' or unit == 'd':
m = 1000000000L * 86400
- p = 6
+ p = 9
elif unit == 'h':
m = 1000000000L * 3600
- p = 6
+ p = 9
elif unit == 'm':
m = 1000000000L * 60
- p = 6
+ p = 9
elif unit == 's':
m = 1000000000L
- p = 6
+ p = 9
elif unit == 'ms':
m = 1000000L
- p = 3
+ p = 6
elif unit == 'us':
m = 1000L
- p = 0
+ p = 3
elif unit == 'ns' or unit is None:
m = 1L
p = 0
@@ -231,10 +231,10 @@ cpdef inline int64_t cast_from_unit(object ts, object unit) except? -1:
# cast the unit, multiply base/frace separately
# to avoid precision issues from float -> int
base = <int64_t> ts
- frac = ts -base
+ frac = ts - base
if p:
frac = round(frac, p)
- return <int64_t> (base *m) + <int64_t> (frac *m)
+ return <int64_t> (base * m) + <int64_t> (frac * m)
cdef inline _decode_if_necessary(object ts):
diff --git a/pandas/tests/indexes/datetimes/test_tools.py b/pandas/tests/indexes/datetimes/test_tools.py
index 45be3974dad63..8b0514764b0c0 100644
--- a/pandas/tests/indexes/datetimes/test_tools.py
+++ b/pandas/tests/indexes/datetimes/test_tools.py
@@ -650,6 +650,14 @@ def test_unit_mixed(self, cache):
with pytest.raises(ValueError):
pd.to_datetime(arr, errors='raise', cache=cache)
+ @pytest.mark.parametrize('cache', [True, False])
+ def test_unit_rounding(self, cache):
+ # GH 14156: argument will incur floating point errors but no
+ # premature rounding
+ result = pd.to_datetime(1434743731.8770001, unit='s', cache=cache)
+ expected = pd.Timestamp('2015-06-19 19:55:31.877000093')
+ assert result == expected
+
@pytest.mark.parametrize('cache', [True, False])
def test_dataframe(self, cache):
diff --git a/pandas/tests/io/sas/test_sas7bdat.py b/pandas/tests/io/sas/test_sas7bdat.py
index 5da347e47957c..b80263021c269 100644
--- a/pandas/tests/io/sas/test_sas7bdat.py
+++ b/pandas/tests/io/sas/test_sas7bdat.py
@@ -182,6 +182,8 @@ def test_date_time():
fname = os.path.join(dirpath, "datetime.csv")
df0 = pd.read_csv(fname, parse_dates=['Date1', 'Date2', 'DateTime',
'DateTimeHi', 'Taiw'])
+ # GH 19732: Timestamps imported from sas will incur floating point errors
+ df.iloc[:, 3] = df.iloc[:, 3].dt.round('us')
tm.assert_frame_equal(df, df0)
diff --git a/pandas/tests/scalar/timedelta/test_timedelta.py b/pandas/tests/scalar/timedelta/test_timedelta.py
index 3fdc2aa71bfc0..205fdf49d3e91 100644
--- a/pandas/tests/scalar/timedelta/test_timedelta.py
+++ b/pandas/tests/scalar/timedelta/test_timedelta.py
@@ -106,6 +106,16 @@ def test_compare_timedelta_ndarray(self):
class TestTimedeltas(object):
+ @pytest.mark.parametrize("unit, value, expected", [
+ ('us', 9.999, 9999), ('ms', 9.999999, 9999999),
+ ('s', 9.999999999, 9999999999)])
+ def test_rounding_on_int_unit_construction(self, unit, value, expected):
+ # GH 12690
+ result = Timedelta(value, unit=unit)
+ assert result.value == expected
+ result = Timedelta(str(value) + unit)
+ assert result.value == expected
+
def test_total_seconds_scalar(self):
# see gh-10939
rng = Timedelta('1 days, 10:11:12.100123456')
diff --git a/pandas/tests/scalar/timestamp/test_timestamp.py b/pandas/tests/scalar/timestamp/test_timestamp.py
index b022b327de57c..ab87d98fca8eb 100644
--- a/pandas/tests/scalar/timestamp/test_timestamp.py
+++ b/pandas/tests/scalar/timestamp/test_timestamp.py
@@ -621,10 +621,51 @@ def test_basics_nanos(self):
assert stamp.microsecond == 145224
assert stamp.nanosecond == 192
- def test_unit(self):
-
- def check(val, unit=None, h=1, s=1, us=0):
- stamp = Timestamp(val, unit=unit)
+ @pytest.mark.parametrize('value, check_kwargs', [
+ [946688461000000000, {}],
+ [946688461000000000 / long(1000), dict(unit='us')],
+ [946688461000000000 / long(1000000), dict(unit='ms')],
+ [946688461000000000 / long(1000000000), dict(unit='s')],
+ [10957, dict(unit='D', h=0)],
+ pytest.param((946688461000000000 + 500000) / long(1000000000),
+ dict(unit='s', us=499, ns=964),
+ marks=pytest.mark.skipif(not PY3,
+ reason='using truediv, so these'
+ ' are like floats')),
+ pytest.param((946688461000000000 + 500000000) / long(1000000000),
+ dict(unit='s', us=500000),
+ marks=pytest.mark.skipif(not PY3,
+ reason='using truediv, so these'
+ ' are like floats')),
+ pytest.param((946688461000000000 + 500000) / long(1000000),
+ dict(unit='ms', us=500),
+ marks=pytest.mark.skipif(not PY3,
+ reason='using truediv, so these'
+ ' are like floats')),
+ pytest.param((946688461000000000 + 500000) / long(1000000000),
+ dict(unit='s'),
+ marks=pytest.mark.skipif(PY3,
+ reason='get chopped in py2')),
+ pytest.param((946688461000000000 + 500000000) / long(1000000000),
+ dict(unit='s'),
+ marks=pytest.mark.skipif(PY3,
+ reason='get chopped in py2')),
+ pytest.param((946688461000000000 + 500000) / long(1000000),
+ dict(unit='ms'),
+ marks=pytest.mark.skipif(PY3,
+ reason='get chopped in py2')),
+ [(946688461000000000 + 500000) / long(1000), dict(unit='us', us=500)],
+ [(946688461000000000 + 500000000) / long(1000000),
+ dict(unit='ms', us=500000)],
+ [946688461000000000 / 1000.0 + 5, dict(unit='us', us=5)],
+ [946688461000000000 / 1000.0 + 5000, dict(unit='us', us=5000)],
+ [946688461000000000 / 1000000.0 + 0.5, dict(unit='ms', us=500)],
+ [946688461000000000 / 1000000.0 + 0.005, dict(unit='ms', us=5, ns=5)],
+ [946688461000000000 / 1000000000.0 + 0.5, dict(unit='s', us=500000)],
+ [10957 + 0.5, dict(unit='D', h=12)]])
+ def test_unit(self, value, check_kwargs):
+ def check(value, unit=None, h=1, s=1, us=0, ns=0):
+ stamp = Timestamp(value, unit=unit)
assert stamp.year == 2000
assert stamp.month == 1
assert stamp.day == 1
@@ -637,41 +678,9 @@ def check(val, unit=None, h=1, s=1, us=0):
assert stamp.minute == 0
assert stamp.second == 0
assert stamp.microsecond == 0
- assert stamp.nanosecond == 0
-
- ts = Timestamp('20000101 01:01:01')
- val = ts.value
- days = (ts - Timestamp('1970-01-01')).days
-
- check(val)
- check(val / long(1000), unit='us')
- check(val / long(1000000), unit='ms')
- check(val / long(1000000000), unit='s')
- check(days, unit='D', h=0)
+ assert stamp.nanosecond == ns
- # using truediv, so these are like floats
- if PY3:
- check((val + 500000) / long(1000000000), unit='s', us=500)
- check((val + 500000000) / long(1000000000), unit='s', us=500000)
- check((val + 500000) / long(1000000), unit='ms', us=500)
-
- # get chopped in py2
- else:
- check((val + 500000) / long(1000000000), unit='s')
- check((val + 500000000) / long(1000000000), unit='s')
- check((val + 500000) / long(1000000), unit='ms')
-
- # ok
- check((val + 500000) / long(1000), unit='us', us=500)
- check((val + 500000000) / long(1000000), unit='ms', us=500000)
-
- # floats
- check(val / 1000.0 + 5, unit='us', us=5)
- check(val / 1000.0 + 5000, unit='us', us=5000)
- check(val / 1000000.0 + 0.5, unit='ms', us=500)
- check(val / 1000000.0 + 0.005, unit='ms', us=5)
- check(val / 1000000000.0 + 0.5, unit='s', us=500000)
- check(days + 0.5, unit='D', h=12)
+ check(value, **check_kwargs)
def test_roundtrip(self):
| - [x] closes #14156
- [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/19732 | 2018-02-16T20:28:14Z | 2018-05-21T11:06:04Z | 2018-05-21T11:06:04Z | 2018-06-08T17:12:29Z |
BUG: drop_duplicates not raising KeyError on missing key | diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index a2198d9103528..a4924417ff2b7 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -767,6 +767,8 @@ Indexing
- Bug in :class:`IntervalIndex` where empty and purely NA data was constructed inconsistently depending on the construction method (:issue:`18421`)
- Bug in :func:`IntervalIndex.symmetric_difference` where the symmetric difference with a non-``IntervalIndex`` did not raise (:issue:`18475`)
- Bug in :class:`IntervalIndex` where set operations that returned an empty ``IntervalIndex`` had the wrong dtype (:issue:`19101`)
+- Bug in :meth:`DataFrame.drop_duplicates` where no ``KeyError`` is raised when passing in columns that don't exist on the ``DataFrame`` (issue:`19726`)
+
MultiIndex
^^^^^^^^^^
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index a001037b573d4..b4db770e6bb74 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3655,6 +3655,13 @@ def f(vals):
isinstance(subset, tuple) and subset in self.columns):
subset = subset,
+ # Verify all columns in subset exist in the queried dataframe
+ # Otherwise, raise a KeyError, same as if you try to __getitem__ with a
+ # key that doesn't exist.
+ diff = Index(subset).difference(self.columns)
+ if not diff.empty:
+ raise KeyError(diff)
+
vals = (col.values for name, col in self.iteritems()
if name in subset)
labels, shape = map(list, zip(*map(f, vals)))
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index b9275fc69e7ff..f2b8387072c8d 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -1492,6 +1492,19 @@ def test_drop_duplicates(self):
for keep in ['first', 'last', False]:
assert df.duplicated(keep=keep).sum() == 0
+ @pytest.mark.parametrize('subset', ['a', ['a'], ['a', 'B']])
+ def test_duplicated_with_misspelled_column_name(self, subset):
+ # GH 19730
+ df = pd.DataFrame({'A': [0, 0, 1],
+ 'B': [0, 0, 1],
+ 'C': [0, 0, 1]})
+
+ with pytest.raises(KeyError):
+ df.duplicated(subset)
+
+ with pytest.raises(KeyError):
+ df.drop_duplicates(subset)
+
def test_drop_duplicates_with_duplicate_column_names(self):
# GH17836
df = DataFrame([
| Fix #17879 introduced an error by iterating over the columns in the dataframe, not the columns in the subset. This meant that passing in a column name missing from the dataframe would no longer raise a `KeyError` like it had previously.
This fix checks the subset first before pulling necessary columns from the dataframe, and raises the necessary `KeyError` when a given column doesn't exist.
- [x] closes #19726
- [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/19730 | 2018-02-16T18:14:12Z | 2018-02-21T11:40:22Z | 2018-02-21T11:40:21Z | 2018-02-21T14:16:45Z |
BUG: fix index op names and pinning | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 59fe4bba649d3..c343126db0ea1 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1,11 +1,11 @@
-import datetime
+from datetime import datetime, timedelta
import warnings
import operator
import numpy as np
from pandas._libs import (lib, index as libindex, tslib as libts,
algos as libalgos, join as libjoin,
- Timestamp, Timedelta)
+ Timedelta)
from pandas._libs.lib import is_datetime_array
from pandas.compat import range, u, set_function_name
@@ -47,6 +47,7 @@
from pandas.core.base import PandasObject, IndexOpsMixin
import pandas.core.common as com
import pandas.core.base as base
+from pandas.core import ops
from pandas.util._decorators import (
Appender, Substitution, cache_readonly, deprecate_kwarg)
from pandas.core.indexes.frozen import FrozenList
@@ -55,7 +56,7 @@
import pandas.core.algorithms as algos
import pandas.core.sorting as sorting
from pandas.io.formats.printing import pprint_thing
-from pandas.core.ops import _comp_method_OBJECT_ARRAY, make_invalid_op
+from pandas.core.ops import make_invalid_op
from pandas.core.config import get_option
from pandas.core.strings import StringMethods
@@ -82,6 +83,74 @@ def _try_get_item(x):
return x
+def _make_comparison_op(op, cls):
+ def cmp_method(self, other):
+ if isinstance(other, (np.ndarray, Index, ABCSeries)):
+ if other.ndim > 0 and len(self) != len(other):
+ raise ValueError('Lengths must match to compare')
+
+ # we may need to directly compare underlying
+ # representations
+ if needs_i8_conversion(self) and needs_i8_conversion(other):
+ return self._evaluate_compare(other, op)
+
+ if is_object_dtype(self) and self.nlevels == 1:
+ # don't pass MultiIndex
+ with np.errstate(all='ignore'):
+ result = ops._comp_method_OBJECT_ARRAY(op, self.values, other)
+ else:
+ with np.errstate(all='ignore'):
+ result = op(self.values, np.asarray(other))
+
+ # technically we could support bool dtyped Index
+ # for now just return the indexing array directly
+ if is_bool_dtype(result):
+ return result
+ try:
+ return Index(result)
+ except TypeError:
+ return result
+
+ name = '__{name}__'.format(name=op.__name__)
+ # TODO: docstring?
+ return set_function_name(cmp_method, name, cls)
+
+
+def _make_arithmetic_op(op, cls):
+ def index_arithmetic_method(self, other):
+ if isinstance(other, (ABCSeries, ABCDataFrame)):
+ return NotImplemented
+ elif isinstance(other, ABCTimedeltaIndex):
+ # Defer to subclass implementation
+ return NotImplemented
+
+ other = self._validate_for_numeric_binop(other, op)
+
+ # handle time-based others
+ if isinstance(other, (ABCDateOffset, np.timedelta64, timedelta)):
+ return self._evaluate_with_timedelta_like(other, op)
+ elif isinstance(other, (datetime, np.datetime64)):
+ return self._evaluate_with_datetime_like(other, op)
+
+ values = self.values
+ with np.errstate(all='ignore'):
+ result = op(values, other)
+
+ result = missing.dispatch_missing(op, values, other, result)
+
+ attrs = self._get_attributes_dict()
+ attrs = self._maybe_update_attributes(attrs)
+ if op is divmod:
+ result = (Index(result[0], **attrs), Index(result[1], **attrs))
+ else:
+ result = Index(result, **attrs)
+ return result
+
+ name = '__{name}__'.format(name=op.__name__)
+ # TODO: docstring?
+ return set_function_name(index_arithmetic_method, name, cls)
+
+
class InvalidIndexError(Exception):
pass
@@ -2175,11 +2244,13 @@ def __add__(self, other):
def __radd__(self, other):
return Index(other + np.array(self))
- __iadd__ = __add__
+ def __iadd__(self, other):
+ # alias for __add__
+ return self + other
def __sub__(self, other):
raise TypeError("cannot perform __sub__ with this index type: "
- "{typ}".format(typ=type(self)))
+ "{typ}".format(typ=type(self).__name__))
def __and__(self, other):
return self.intersection(other)
@@ -3917,13 +3988,11 @@ def dropna(self, how='any'):
return self._shallow_copy(self.values[~self._isnan])
return self._shallow_copy()
- def _evaluate_with_timedelta_like(self, other, op, opstr, reversed=False):
+ def _evaluate_with_timedelta_like(self, other, op):
# Timedelta knows how to operate with np.array, so dispatch to that
# operation and then wrap the results
other = Timedelta(other)
values = self.values
- if reversed:
- values, other = other, values
with np.errstate(all='ignore'):
result = op(values, other)
@@ -3934,7 +4003,7 @@ def _evaluate_with_timedelta_like(self, other, op, opstr, reversed=False):
return Index(result[0], **attrs), Index(result[1], **attrs)
return Index(result, **attrs)
- def _evaluate_with_datetime_like(self, other, op, opstr):
+ def _evaluate_with_datetime_like(self, other, op):
raise TypeError("can only perform ops with datetime like values")
def _evaluate_compare(self, other, op):
@@ -3943,64 +4012,39 @@ def _evaluate_compare(self, other, op):
@classmethod
def _add_comparison_methods(cls):
""" add in comparison methods """
-
- def _make_compare(op):
- def _evaluate_compare(self, other):
- if isinstance(other, (np.ndarray, Index, ABCSeries)):
- if other.ndim > 0 and len(self) != len(other):
- raise ValueError('Lengths must match to compare')
-
- # we may need to directly compare underlying
- # representations
- if needs_i8_conversion(self) and needs_i8_conversion(other):
- return self._evaluate_compare(other, op)
-
- if (is_object_dtype(self) and
- self.nlevels == 1):
-
- # don't pass MultiIndex
- with np.errstate(all='ignore'):
- result = _comp_method_OBJECT_ARRAY(
- op, self.values, other)
- else:
- with np.errstate(all='ignore'):
- result = op(self.values, np.asarray(other))
-
- # technically we could support bool dtyped Index
- # for now just return the indexing array directly
- if is_bool_dtype(result):
- return result
- try:
- return Index(result)
- except TypeError:
- return result
-
- name = '__{name}__'.format(name=op.__name__)
- return set_function_name(_evaluate_compare, name, cls)
-
- cls.__eq__ = _make_compare(operator.eq)
- cls.__ne__ = _make_compare(operator.ne)
- cls.__lt__ = _make_compare(operator.lt)
- cls.__gt__ = _make_compare(operator.gt)
- cls.__le__ = _make_compare(operator.le)
- cls.__ge__ = _make_compare(operator.ge)
+ cls.__eq__ = _make_comparison_op(operator.eq, cls)
+ cls.__ne__ = _make_comparison_op(operator.ne, cls)
+ cls.__lt__ = _make_comparison_op(operator.lt, cls)
+ cls.__gt__ = _make_comparison_op(operator.gt, cls)
+ cls.__le__ = _make_comparison_op(operator.le, cls)
+ cls.__ge__ = _make_comparison_op(operator.ge, cls)
@classmethod
def _add_numeric_methods_add_sub_disabled(cls):
""" add in the numeric add/sub methods to disable """
- cls.__add__ = cls.__radd__ = __iadd__ = make_invalid_op('__add__') # noqa
- cls.__sub__ = __isub__ = make_invalid_op('__sub__') # noqa
+ cls.__add__ = make_invalid_op('__add__')
+ cls.__radd__ = make_invalid_op('__radd__')
+ cls.__iadd__ = make_invalid_op('__iadd__')
+ cls.__sub__ = make_invalid_op('__sub__')
+ cls.__rsub__ = make_invalid_op('__rsub__')
+ cls.__isub__ = make_invalid_op('__isub__')
@classmethod
def _add_numeric_methods_disabled(cls):
""" add in numeric methods to disable other than add/sub """
cls.__pow__ = make_invalid_op('__pow__')
cls.__rpow__ = make_invalid_op('__rpow__')
- cls.__mul__ = cls.__rmul__ = make_invalid_op('__mul__')
- cls.__floordiv__ = cls.__rfloordiv__ = make_invalid_op('__floordiv__')
- cls.__truediv__ = cls.__rtruediv__ = make_invalid_op('__truediv__')
+ cls.__mul__ = make_invalid_op('__mul__')
+ cls.__rmul__ = make_invalid_op('__rmul__')
+ cls.__floordiv__ = make_invalid_op('__floordiv__')
+ cls.__rfloordiv__ = make_invalid_op('__rfloordiv__')
+ cls.__truediv__ = make_invalid_op('__truediv__')
+ cls.__rtruediv__ = make_invalid_op('__rtruediv__')
if not compat.PY3:
- cls.__div__ = cls.__rdiv__ = make_invalid_op('__div__')
+ cls.__div__ = make_invalid_op('__div__')
+ cls.__rdiv__ = make_invalid_op('__rdiv__')
+ cls.__mod__ = make_invalid_op('__mod__')
+ cls.__divmod__ = make_invalid_op('__divmod__')
cls.__neg__ = make_invalid_op('__neg__')
cls.__pos__ = make_invalid_op('__pos__')
cls.__abs__ = make_invalid_op('__abs__')
@@ -4015,34 +4059,29 @@ def _validate_for_numeric_unaryop(self, op, opstr):
if not self._is_numeric_dtype:
raise TypeError("cannot evaluate a numeric op "
- "{opstr} for type: {typ}".format(
- opstr=opstr,
- typ=type(self))
- )
+ "{opstr} for type: {typ}"
+ .format(opstr=opstr, typ=type(self).__name__))
- def _validate_for_numeric_binop(self, other, op, opstr):
+ def _validate_for_numeric_binop(self, other, op):
"""
return valid other, evaluate or raise TypeError
if we are not of the appropriate type
internal method called by ops
"""
+ opstr = '__{opname}__'.format(opname=op.__name__)
# if we are an inheritor of numeric,
# but not actually numeric (e.g. DatetimeIndex/PeriodIndex)
if not self._is_numeric_dtype:
raise TypeError("cannot evaluate a numeric op {opstr} "
- "for type: {typ}".format(
- opstr=opstr,
- typ=type(self))
- )
+ "for type: {typ}"
+ .format(opstr=opstr, typ=type(self).__name__))
if isinstance(other, Index):
if not other._is_numeric_dtype:
raise TypeError("cannot evaluate a numeric op "
- "{opstr} with type: {typ}".format(
- opstr=type(self),
- typ=type(other))
- )
+ "{opstr} with type: {typ}"
+ .format(opstr=opstr, typ=type(other)))
elif isinstance(other, np.ndarray) and not other.ndim:
other = other.item()
@@ -4054,11 +4093,10 @@ def _validate_for_numeric_binop(self, other, op, opstr):
if other.dtype.kind not in ['f', 'i', 'u']:
raise TypeError("cannot evaluate a numeric op "
"with a non-numeric dtype")
- elif isinstance(other, (ABCDateOffset, np.timedelta64,
- datetime.timedelta)):
+ elif isinstance(other, (ABCDateOffset, np.timedelta64, timedelta)):
# higher up to handle
pass
- elif isinstance(other, (Timestamp, np.datetime64)):
+ elif isinstance(other, (datetime, np.datetime64)):
# higher up to handle
pass
else:
@@ -4070,73 +4108,24 @@ def _validate_for_numeric_binop(self, other, op, opstr):
@classmethod
def _add_numeric_methods_binary(cls):
""" add in numeric methods """
-
- def _make_evaluate_binop(op, opstr, reversed=False, constructor=Index):
- def _evaluate_numeric_binop(self, other):
- if isinstance(other, (ABCSeries, ABCDataFrame)):
- return NotImplemented
- elif isinstance(other, ABCTimedeltaIndex):
- # Defer to subclass implementation
- return NotImplemented
-
- other = self._validate_for_numeric_binop(other, op, opstr)
-
- # handle time-based others
- if isinstance(other, (ABCDateOffset, np.timedelta64,
- datetime.timedelta)):
- return self._evaluate_with_timedelta_like(other, op, opstr,
- reversed)
- elif isinstance(other, (Timestamp, np.datetime64)):
- return self._evaluate_with_datetime_like(other, op, opstr)
-
- # if we are a reversed non-commutative op
- values = self.values
- if reversed:
- values, other = other, values
-
- attrs = self._get_attributes_dict()
- attrs = self._maybe_update_attributes(attrs)
- with np.errstate(all='ignore'):
- result = op(values, other)
-
- result = missing.dispatch_missing(op, values, other, result)
- return constructor(result, **attrs)
-
- return _evaluate_numeric_binop
-
- cls.__add__ = cls.__radd__ = _make_evaluate_binop(
- operator.add, '__add__')
- cls.__sub__ = _make_evaluate_binop(
- operator.sub, '__sub__')
- cls.__rsub__ = _make_evaluate_binop(
- operator.sub, '__sub__', reversed=True)
- cls.__mul__ = cls.__rmul__ = _make_evaluate_binop(
- operator.mul, '__mul__')
- cls.__rpow__ = _make_evaluate_binop(
- operator.pow, '__pow__', reversed=True)
- cls.__pow__ = _make_evaluate_binop(
- operator.pow, '__pow__')
- cls.__mod__ = _make_evaluate_binop(
- operator.mod, '__mod__')
- cls.__floordiv__ = _make_evaluate_binop(
- operator.floordiv, '__floordiv__')
- cls.__rfloordiv__ = _make_evaluate_binop(
- operator.floordiv, '__floordiv__', reversed=True)
- cls.__truediv__ = _make_evaluate_binop(
- operator.truediv, '__truediv__')
- cls.__rtruediv__ = _make_evaluate_binop(
- operator.truediv, '__truediv__', reversed=True)
+ cls.__add__ = _make_arithmetic_op(operator.add, cls)
+ cls.__radd__ = _make_arithmetic_op(ops.radd, cls)
+ cls.__sub__ = _make_arithmetic_op(operator.sub, cls)
+ cls.__rsub__ = _make_arithmetic_op(ops.rsub, cls)
+ cls.__mul__ = _make_arithmetic_op(operator.mul, cls)
+ cls.__rmul__ = _make_arithmetic_op(ops.rmul, cls)
+ cls.__rpow__ = _make_arithmetic_op(ops.rpow, cls)
+ cls.__pow__ = _make_arithmetic_op(operator.pow, cls)
+ cls.__mod__ = _make_arithmetic_op(operator.mod, cls)
+ cls.__floordiv__ = _make_arithmetic_op(operator.floordiv, cls)
+ cls.__rfloordiv__ = _make_arithmetic_op(ops.rfloordiv, cls)
+ cls.__truediv__ = _make_arithmetic_op(operator.truediv, cls)
+ cls.__rtruediv__ = _make_arithmetic_op(ops.rtruediv, cls)
if not compat.PY3:
- cls.__div__ = _make_evaluate_binop(
- operator.div, '__div__')
- cls.__rdiv__ = _make_evaluate_binop(
- operator.div, '__div__', reversed=True)
+ cls.__div__ = _make_arithmetic_op(operator.div, cls)
+ cls.__rdiv__ = _make_arithmetic_op(ops.rdiv, cls)
- cls.__divmod__ = _make_evaluate_binop(
- divmod,
- '__divmod__',
- constructor=lambda result, **attrs: (Index(result[0], **attrs),
- Index(result[1], **attrs)))
+ cls.__divmod__ = _make_arithmetic_op(divmod, cls)
@classmethod
def _add_numeric_methods_unary(cls):
@@ -4153,8 +4142,8 @@ def _evaluate_numeric_unary(self):
return _evaluate_numeric_unary
- cls.__neg__ = _make_evaluate_unary(lambda x: -x, '__neg__')
- cls.__pos__ = _make_evaluate_unary(lambda x: x, '__pos__')
+ cls.__neg__ = _make_evaluate_unary(operator.neg, '__neg__')
+ cls.__pos__ = _make_evaluate_unary(operator.pos, '__pos__')
cls.__abs__ = _make_evaluate_unary(np.abs, '__abs__')
cls.__inv__ = _make_evaluate_unary(lambda x: -x, '__inv__')
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 187f9fcf52dd4..ac75e5ae5e2a0 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -669,6 +669,7 @@ def __add__(self, other):
result = self._add_offset_array(other)
elif isinstance(self, TimedeltaIndex) and isinstance(other, Index):
if hasattr(other, '_add_delta'):
+ # i.e. DatetimeIndex, TimedeltaIndex, or PeriodIndex
result = other._add_delta(self)
else:
raise TypeError("cannot add TimedeltaIndex and {typ}"
@@ -693,7 +694,11 @@ def __add__(self, other):
return result
cls.__add__ = __add__
- cls.__radd__ = __add__
+
+ def __radd__(self, other):
+ # alias for __add__
+ return self.__add__(other)
+ cls.__radd__ = __radd__
def __sub__(self, other):
from pandas.core.index import Index
@@ -712,10 +717,10 @@ def __sub__(self, other):
# Array/Index of DateOffset objects
result = self._sub_offset_array(other)
elif isinstance(self, TimedeltaIndex) and isinstance(other, Index):
- if not isinstance(other, TimedeltaIndex):
- raise TypeError("cannot subtract TimedeltaIndex and {typ}"
- .format(typ=type(other).__name__))
- result = self._add_delta(-other)
+ # We checked above for timedelta64_dtype(other) so this
+ # must be invalid.
+ raise TypeError("cannot subtract TimedeltaIndex and {typ}"
+ .format(typ=type(other).__name__))
elif isinstance(other, DatetimeIndex):
result = self._sub_datelike(other)
elif is_integer(other):
@@ -747,8 +752,15 @@ def __rsub__(self, other):
return -(self - other)
cls.__rsub__ = __rsub__
- cls.__iadd__ = __add__
- cls.__isub__ = __sub__
+ def __iadd__(self, other):
+ # alias for __add__
+ return self.__add__(other)
+ cls.__iadd__ = __iadd__
+
+ def __isub__(self, other):
+ # alias for __sub__
+ return self.__sub__(other)
+ cls.__isub__ = __isub__
def _add_delta(self, other):
return NotImplemented
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index debeabf9bae23..17f92339e4205 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -100,10 +100,11 @@ def f(self):
return property(f)
-def _dt_index_cmp(opname, cls, nat_result=False):
+def _dt_index_cmp(opname, cls):
"""
Wrap comparison operations to convert datetime-like to datetime64
"""
+ nat_result = True if opname == '__ne__' else False
def wrapper(self, other):
func = getattr(super(DatetimeIndex, self), opname)
@@ -291,7 +292,7 @@ def _join_i8_wrapper(joinf, **kwargs):
def _add_comparison_methods(cls):
""" add in comparison methods """
cls.__eq__ = _dt_index_cmp('__eq__', cls)
- cls.__ne__ = _dt_index_cmp('__ne__', cls, nat_result=True)
+ cls.__ne__ = _dt_index_cmp('__ne__', cls)
cls.__lt__ = _dt_index_cmp('__lt__', cls)
cls.__gt__ = _dt_index_cmp('__gt__', cls)
cls.__le__ = _dt_index_cmp('__le__', cls)
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 88f9297652ebf..4c14cbffcd813 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -76,26 +76,25 @@ def dt64arr_to_periodarr(data, freq, tz):
_DIFFERENT_FREQ_INDEX = period._DIFFERENT_FREQ_INDEX
-def _period_index_cmp(opname, cls, nat_result=False):
+def _period_index_cmp(opname, cls):
"""
- Wrap comparison operations to convert datetime-like to datetime64
+ Wrap comparison operations to convert Period-like to PeriodDtype
"""
+ nat_result = True if opname == '__ne__' else False
def wrapper(self, other):
+ op = getattr(self._ndarray_values, opname)
if isinstance(other, Period):
- func = getattr(self._ndarray_values, opname)
- other_base, _ = _gfc(other.freq)
if other.freq != self.freq:
msg = _DIFFERENT_FREQ_INDEX.format(self.freqstr, other.freqstr)
raise IncompatibleFrequency(msg)
- result = func(other.ordinal)
+ result = op(other.ordinal)
elif isinstance(other, PeriodIndex):
if other.freq != self.freq:
msg = _DIFFERENT_FREQ_INDEX.format(self.freqstr, other.freqstr)
raise IncompatibleFrequency(msg)
- op = getattr(self._ndarray_values, opname)
result = op(other._ndarray_values)
mask = self._isnan | other._isnan
@@ -108,8 +107,7 @@ def wrapper(self, other):
result.fill(nat_result)
else:
other = Period(other, freq=self.freq)
- func = getattr(self._ndarray_values, opname)
- result = func(other.ordinal)
+ result = op(other.ordinal)
if self.hasnans:
result[self._isnan] = nat_result
@@ -231,7 +229,7 @@ class PeriodIndex(DatelikeOps, DatetimeIndexOpsMixin, Int64Index):
def _add_comparison_methods(cls):
""" add in comparison methods """
cls.__eq__ = _period_index_cmp('__eq__', cls)
- cls.__ne__ = _period_index_cmp('__ne__', cls, nat_result=True)
+ cls.__ne__ = _period_index_cmp('__ne__', cls)
cls.__lt__ = _period_index_cmp('__lt__', cls)
cls.__gt__ = _period_index_cmp('__gt__', cls)
cls.__le__ = _period_index_cmp('__le__', cls)
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 0ac415ee0b701..9d770cffb0059 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -16,6 +16,7 @@
from pandas.compat.numpy import function as nv
import pandas.core.common as com
+from pandas.core import ops
from pandas.core.indexes.base import Index, _index_shared_docs
from pandas.util._decorators import Appender, cache_readonly
import pandas.core.dtypes.concat as _concat
@@ -570,16 +571,12 @@ def __floordiv__(self, other):
def _add_numeric_methods_binary(cls):
""" add in numeric methods, specialized to RangeIndex """
- def _make_evaluate_binop(op, opstr, reversed=False, step=False):
+ def _make_evaluate_binop(op, step=False):
"""
Parameters
----------
op : callable that accepts 2 parms
perform the binary op
- opstr : string
- string name of ops
- reversed : boolean, default False
- if this is a reversed op, e.g. radd
step : callable, optional, default to False
op to apply to the step parm if not None
if False, use the existing step
@@ -594,17 +591,13 @@ def _evaluate_numeric_binop(self, other):
elif isinstance(other, (timedelta, np.timedelta64)):
# GH#19333 is_integer evaluated True on timedelta64,
# so we need to catch these explicitly
- if reversed:
- return op(other, self._int64index)
return op(self._int64index, other)
- other = self._validate_for_numeric_binop(other, op, opstr)
+ other = self._validate_for_numeric_binop(other, op)
attrs = self._get_attributes_dict()
attrs = self._maybe_update_attributes(attrs)
left, right = self, other
- if reversed:
- left, right = right, left
try:
# apply if we have an override
@@ -638,43 +631,26 @@ def _evaluate_numeric_binop(self, other):
return result
- except (ValueError, TypeError, AttributeError,
- ZeroDivisionError):
+ except (ValueError, TypeError, ZeroDivisionError):
# Defer to Int64Index implementation
- if reversed:
- return op(other, self._int64index)
return op(self._int64index, other)
+ # TODO: Do attrs get handled reliably?
return _evaluate_numeric_binop
- cls.__add__ = cls.__radd__ = _make_evaluate_binop(
- operator.add, '__add__')
- cls.__sub__ = _make_evaluate_binop(operator.sub, '__sub__')
- cls.__rsub__ = _make_evaluate_binop(
- operator.sub, '__sub__', reversed=True)
- cls.__mul__ = cls.__rmul__ = _make_evaluate_binop(
- operator.mul,
- '__mul__',
- step=operator.mul)
- cls.__truediv__ = _make_evaluate_binop(
- operator.truediv,
- '__truediv__',
- step=operator.truediv)
- cls.__rtruediv__ = _make_evaluate_binop(
- operator.truediv,
- '__truediv__',
- reversed=True,
- step=operator.truediv)
+ cls.__add__ = _make_evaluate_binop(operator.add)
+ cls.__radd__ = _make_evaluate_binop(ops.radd)
+ cls.__sub__ = _make_evaluate_binop(operator.sub)
+ cls.__rsub__ = _make_evaluate_binop(ops.rsub)
+ cls.__mul__ = _make_evaluate_binop(operator.mul, step=operator.mul)
+ cls.__rmul__ = _make_evaluate_binop(ops.rmul, step=ops.rmul)
+ cls.__truediv__ = _make_evaluate_binop(operator.truediv,
+ step=operator.truediv)
+ cls.__rtruediv__ = _make_evaluate_binop(ops.rtruediv,
+ step=ops.rtruediv)
if not compat.PY3:
- cls.__div__ = _make_evaluate_binop(
- operator.div,
- '__div__',
- step=operator.div)
- cls.__rdiv__ = _make_evaluate_binop(
- operator.div,
- '__div__',
- reversed=True,
- step=operator.div)
+ cls.__div__ = _make_evaluate_binop(operator.div, step=operator.div)
+ cls.__rdiv__ = _make_evaluate_binop(ops.rdiv, step=ops.rdiv)
RangeIndex._add_numeric_methods()
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 6b61db53d9a11..3542a24290f89 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -53,10 +53,11 @@ def f(self):
return property(f)
-def _td_index_cmp(opname, cls, nat_result=False):
+def _td_index_cmp(opname, cls):
"""
Wrap comparison operations to convert timedelta-like to timedelta64
"""
+ nat_result = True if opname == '__ne__' else False
def wrapper(self, other):
msg = "cannot compare a TimedeltaIndex with type {0}"
@@ -184,7 +185,7 @@ def _join_i8_wrapper(joinf, **kwargs):
def _add_comparison_methods(cls):
""" add in comparison methods """
cls.__eq__ = _td_index_cmp('__eq__', cls)
- cls.__ne__ = _td_index_cmp('__ne__', cls, nat_result=True)
+ cls.__ne__ = _td_index_cmp('__ne__', cls)
cls.__lt__ = _td_index_cmp('__lt__', cls)
cls.__gt__ = _td_index_cmp('__gt__', cls)
cls.__le__ = _td_index_cmp('__le__', cls)
@@ -383,11 +384,12 @@ def _add_delta(self, delta):
return TimedeltaIndex(new_values, freq='infer')
- def _evaluate_with_timedelta_like(self, other, op, opstr, reversed=False):
+ def _evaluate_with_timedelta_like(self, other, op):
if isinstance(other, ABCSeries):
# GH#19042
return NotImplemented
+ opstr = '__{opname}__'.format(opname=op.__name__).replace('__r', '__')
# allow division by a timedelta
if opstr in ['__div__', '__truediv__', '__floordiv__']:
if _is_convertible_to_td(other):
@@ -398,11 +400,9 @@ def _evaluate_with_timedelta_like(self, other, op, opstr, reversed=False):
i8 = self.asi8
left, right = i8, other.value
- if reversed:
- left, right = right, left
if opstr in ['__floordiv__']:
- result = left // right
+ result = op(left, right)
else:
result = op(left, np.float64(right))
result = self._maybe_mask_results(result, convert='float64')
diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py
index 1162662bf9a08..8f51dbabd5b71 100644
--- a/pandas/tests/indexes/common.py
+++ b/pandas/tests/indexes/common.py
@@ -127,16 +127,17 @@ def test_numeric_compat(self):
idx = self.create_index()
tm.assert_raises_regex(TypeError, "cannot perform __mul__",
lambda: idx * 1)
- tm.assert_raises_regex(TypeError, "cannot perform __mul__",
+ tm.assert_raises_regex(TypeError, "cannot perform __rmul__",
lambda: 1 * idx)
div_err = "cannot perform __truediv__" if PY3 \
else "cannot perform __div__"
tm.assert_raises_regex(TypeError, div_err, lambda: idx / 1)
+ div_err = div_err.replace(' __', ' __r')
tm.assert_raises_regex(TypeError, div_err, lambda: 1 / idx)
tm.assert_raises_regex(TypeError, "cannot perform __floordiv__",
lambda: idx // 1)
- tm.assert_raises_regex(TypeError, "cannot perform __floordiv__",
+ tm.assert_raises_regex(TypeError, "cannot perform __rfloordiv__",
lambda: 1 // idx)
def test_logical_compat(self):
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 90edcb526bb2e..d7f185853ca45 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -7,6 +7,7 @@
from collections import defaultdict
import pandas.util.testing as tm
+from pandas.core.dtypes.generic import ABCIndex
from pandas.core.dtypes.common import is_unsigned_integer_dtype
from pandas.core.indexes.api import Index, MultiIndex
from pandas.tests.indexes.common import Base
@@ -1988,6 +1989,17 @@ def test_addsub_arithmetic(self, dtype, delta):
tm.assert_index_equal(idx - idx, 0 * idx)
assert not (idx - idx).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"
+
class TestMixedIntIndex(Base):
# Mostly the tests from common.py for which the results differ
@@ -2301,9 +2313,17 @@ def test_ensure_index_from_sequences(self, data, names, expected):
tm.assert_index_equal(result, expected)
-@pytest.mark.parametrize('opname', ['eq', 'ne', 'le', 'lt', 'ge', 'gt'])
+@pytest.mark.parametrize('opname', ['eq', 'ne', 'le', 'lt', 'ge', 'gt',
+ 'add', 'radd', 'sub', 'rsub',
+ 'mul', 'rmul', 'truediv', 'rtruediv',
+ 'floordiv', 'rfloordiv',
+ 'pow', 'rpow', 'mod', 'divmod'])
def test_generated_op_names(opname, indices):
index = indices
+ if isinstance(index, ABCIndex) and opname == 'rsub':
+ # pd.Index.__rsub__ does not exist; though the method does exist
+ # for subclasses. see GH#19723
+ return
opname = '__{name}__'.format(name=opname)
method = getattr(index, opname)
assert method.__name__ == opname
| This is a moderately big one, but changes very little.
Fixes incorrect Index ops names and several methods that are defined but not pinned to the class (#19716).
Avoids the need to pass `reversed` and `str_rep` in a bunch of places, cleans up some of the Index classmethods.
Removes the no-longer-needed catching of AttributeError in RangeIndex ops.
The part that may be controversial (and almost certainly needs new tests) is that `Index.__rsub__` is implemented, since it doesn't currently exist. This implements it in "the obvious way", but the fact that `Index.__sub__` isn't defined in the obvious way suggests this _might_ not be desired. Comments welcome.
- [x] closes #19716
- [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/19723 | 2018-02-16T02:09:12Z | 2018-02-23T11:36:43Z | 2018-02-23T11:36:42Z | 2018-06-22T03:31:15Z |
Cythonized GroupBy any | diff --git a/asv_bench/benchmarks/groupby.py b/asv_bench/benchmarks/groupby.py
index c347442784d41..3e7e5c821b14c 100644
--- a/asv_bench/benchmarks/groupby.py
+++ b/asv_bench/benchmarks/groupby.py
@@ -11,6 +11,13 @@
from .pandas_vb_common import setup # noqa
+method_blacklist = {
+ 'object': {'median', 'prod', 'sem', 'cumsum', 'sum', 'cummin', 'mean',
+ 'max', 'skew', 'cumprod', 'cummax', 'rank', 'pct_change', 'min',
+ 'var', 'mad', 'describe', 'std'}
+}
+
+
class ApplyDictReturn(object):
goal_time = 0.2
@@ -153,6 +160,7 @@ def time_frame_nth_any(self, df):
def time_frame_nth(self, df):
df.groupby(0).nth(0)
+
def time_series_nth_any(self, df):
df[1].groupby(df[0]).nth(0, dropna='any')
@@ -369,7 +377,7 @@ class GroupByMethods(object):
goal_time = 0.2
param_names = ['dtype', 'method']
- params = [['int', 'float'],
+ params = [['int', 'float', 'object'],
['all', 'any', 'bfill', 'count', 'cumcount', 'cummax', 'cummin',
'cumprod', 'cumsum', 'describe', 'ffill', 'first', 'head',
'last', 'mad', 'max', 'min', 'median', 'mean', 'nunique',
@@ -377,15 +385,19 @@ class GroupByMethods(object):
'std', 'sum', 'tail', 'unique', 'value_counts', 'var']]
def setup(self, dtype, method):
+ if method in method_blacklist.get(dtype, {}):
+ raise NotImplementedError # skip benchmark
ngroups = 1000
size = ngroups * 2
rng = np.arange(ngroups)
values = rng.take(np.random.randint(0, ngroups, size=size))
if dtype == 'int':
key = np.random.randint(0, size, size=size)
- else:
+ elif dtype == 'float':
key = np.concatenate([np.random.random(ngroups) * 0.1,
np.random.random(ngroups) * 10.0])
+ elif dtype == 'object':
+ key = ['foo'] * size
df = DataFrame({'values': values, 'key': key})
self.df_groupby_method = getattr(df.groupby('key')['values'], method)
diff --git a/doc/source/api.rst b/doc/source/api.rst
index 0e47499a03f3a..a5e26bc948a70 100644
--- a/doc/source/api.rst
+++ b/doc/source/api.rst
@@ -2179,8 +2179,12 @@ Computations / Descriptive Stats
.. autosummary::
:toctree: generated/
+ GroupBy.all
+ GroupBy.any
+ GroupBy.bfill
GroupBy.count
GroupBy.cumcount
+ GroupBy.ffill
GroupBy.first
GroupBy.head
GroupBy.last
@@ -2192,6 +2196,7 @@ Computations / Descriptive Stats
GroupBy.nth
GroupBy.ohlc
GroupBy.prod
+ GroupBy.rank
GroupBy.size
GroupBy.sem
GroupBy.std
diff --git a/doc/source/whatsnew/v0.23.0.txt b/doc/source/whatsnew/v0.23.0.txt
index 6865428c352c1..887063d526d16 100644
--- a/doc/source/whatsnew/v0.23.0.txt
+++ b/doc/source/whatsnew/v0.23.0.txt
@@ -697,9 +697,10 @@ Performance Improvements
- Improved performance of :func:`DataFrame.median` with ``axis=1`` when bottleneck is not installed (:issue:`16468`)
- Improved performance of :func:`MultiIndex.get_loc` for large indexes, at the cost of a reduction in performance for small ones (:issue:`18519`)
- Improved performance of pairwise ``.rolling()`` and ``.expanding()`` with ``.cov()`` and ``.corr()`` operations (:issue:`17917`)
-- Improved performance of :func:`DataFrameGroupBy.rank` (:issue:`15779`)
+- Improved performance of :func:`pandas.core.groupby.GroupBy.rank` (:issue:`15779`)
- Improved performance of variable ``.rolling()`` on ``.min()`` and ``.max()`` (:issue:`19521`)
-- Improved performance of ``GroupBy.ffill`` and ``GroupBy.bfill`` (:issue:`11296`)
+- Improved performance of :func:`pandas.core.groupby.GroupBy.ffill` and :func:`pandas.core.groupby.GroupBy.bfill` (:issue:`11296`)
+- Improved performance of :func:`pandas.core.groupby.GroupBy.any` and :func:`pandas.core.groupby.GroupBy.all` (:issue:`15435`)
.. _whatsnew_0230.docs:
diff --git a/pandas/_libs/groupby.pyx b/pandas/_libs/groupby.pyx
index e3d208a915225..d3fcd84e5f38d 100644
--- a/pandas/_libs/groupby.pyx
+++ b/pandas/_libs/groupby.pyx
@@ -310,5 +310,62 @@ def group_fillna_indexer(ndarray[int64_t] out, ndarray[int64_t] labels,
filled_vals = 0
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def group_any_all(ndarray[uint8_t] out,
+ ndarray[int64_t] labels,
+ ndarray[uint8_t] values,
+ ndarray[uint8_t] mask,
+ object val_test,
+ bint skipna):
+ """Aggregated boolean values to show truthfulness of group elements
+
+ Parameters
+ ----------
+ out : array of values which this method will write its results to
+ labels : array containing unique label for each group, with its
+ ordering matching up to the corresponding record in `values`
+ values : array containing the truth value of each element
+ mask : array indicating whether a value is na or not
+ val_test : str {'any', 'all'}
+ String object dictating whether to use any or all truth testing
+ skipna : boolean
+ Flag to ignore nan values during truth testing
+
+ Notes
+ -----
+ This method modifies the `out` parameter rather than returning an object.
+ The returned values will either be 0 or 1 (False or True, respectively).
+ """
+ cdef:
+ Py_ssize_t i, N=len(labels)
+ int64_t lab
+ uint8_t flag_val
+
+ if val_test == 'all':
+ # Because the 'all' value of an empty iterable in Python is True we can
+ # start with an array full of ones and set to zero when a False value
+ # is encountered
+ flag_val = 0
+ elif val_test == 'any':
+ # Because the 'any' value of an empty iterable in Python is False we
+ # can start with an array full of zeros and set to one only if any
+ # value encountered is True
+ flag_val = 1
+ else:
+ raise ValueError("'bool_func' must be either 'any' or 'all'!")
+
+ out.fill(1 - flag_val)
+
+ with nogil:
+ for i in range(N):
+ lab = labels[i]
+ if lab < 0 or (skipna and mask[i]):
+ continue
+
+ if values[i] == flag_val:
+ out[lab] = flag_val
+
+
# generated from template
include "groupby_helper.pxi"
diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py
index 00643614e8803..b8ca104c4b2c7 100644
--- a/pandas/core/groupby.py
+++ b/pandas/core/groupby.py
@@ -1219,6 +1219,53 @@ class GroupBy(_GroupBy):
"""
_apply_whitelist = _common_apply_whitelist
+ def _bool_agg(self, val_test, skipna):
+ """Shared func to call any / all Cython GroupBy implementations"""
+
+ def objs_to_bool(vals):
+ try:
+ vals = vals.astype(np.bool)
+ except ValueError: # for objects
+ vals = np.array([bool(x) for x in vals])
+
+ return vals.view(np.uint8)
+
+ def result_to_bool(result):
+ return result.astype(np.bool, copy=False)
+
+ return self._get_cythonized_result('group_any_all', self.grouper,
+ aggregate=True,
+ cython_dtype=np.uint8,
+ needs_values=True,
+ needs_mask=True,
+ pre_processing=objs_to_bool,
+ post_processing=result_to_bool,
+ val_test=val_test, skipna=skipna)
+
+ @Substitution(name='groupby')
+ @Appender(_doc_template)
+ def any(self, skipna=True):
+ """Returns True if any value in the group is truthful, else False
+
+ Parameters
+ ----------
+ skipna : bool, default True
+ Flag to ignore nan values during truth testing
+ """
+ return self._bool_agg('any', skipna)
+
+ @Substitution(name='groupby')
+ @Appender(_doc_template)
+ def all(self, skipna=True):
+ """Returns True if all values in the group are truthful, else False
+
+ Parameters
+ ----------
+ skipna : bool, default True
+ Flag to ignore nan values during truth testing
+ """
+ return self._bool_agg('all', skipna)
+
@Substitution(name='groupby')
@Appender(_doc_template)
def count(self):
@@ -1485,6 +1532,8 @@ def _fill(self, direction, limit=None):
return self._get_cythonized_result('group_fillna_indexer',
self.grouper, needs_mask=True,
+ cython_dtype=np.int64,
+ result_is_index=True,
direction=direction, limit=limit)
@Substitution(name='groupby')
@@ -1873,18 +1922,40 @@ def cummax(self, axis=0, **kwargs):
return self._cython_transform('cummax', numeric_only=False)
- def _get_cythonized_result(self, how, grouper, needs_mask=False,
- needs_ngroups=False, **kwargs):
+ def _get_cythonized_result(self, how, grouper, aggregate=False,
+ cython_dtype=None, needs_values=False,
+ needs_mask=False, needs_ngroups=False,
+ result_is_index=False,
+ pre_processing=None, post_processing=None,
+ **kwargs):
"""Get result for Cythonized functions
Parameters
----------
how : str, Cythonized function name to be called
grouper : Grouper object containing pertinent group info
+ aggregate : bool, default False
+ Whether the result should be aggregated to match the number of
+ groups
+ cython_dtype : default None
+ Type of the array that will be modified by the Cython call. If
+ `None`, the type will be inferred from the values of each slice
+ needs_values : bool, default False
+ Whether the values should be a part of the Cython call
+ signature
needs_mask : bool, default False
- Whether boolean mask needs to be part of the Cython call signature
+ Whether boolean mask needs to be part of the Cython call
+ signature
needs_ngroups : bool, default False
- Whether number of groups part of the Cython call signature
+ Whether number of groups is part of the Cython call signature
+ result_is_index : bool, default False
+ Whether the result of the Cython operation is an index of
+ values to be retrieved, instead of the actual values themselves
+ pre_processing : function, default None
+ Function to be applied to `values` prior to passing to Cython
+ Raises if `needs_values` is False
+ post_processing : function, default None
+ Function to be applied to result of Cython function
**kwargs : dict
Extra arguments to be passed back to Cython funcs
@@ -1892,14 +1963,40 @@ def _get_cythonized_result(self, how, grouper, needs_mask=False,
-------
`Series` or `DataFrame` with filled values
"""
+ if result_is_index and aggregate:
+ raise ValueError("'result_is_index' and 'aggregate' cannot both "
+ "be True!")
+ if post_processing:
+ if not callable(pre_processing):
+ raise ValueError("'post_processing' must be a callable!")
+ if pre_processing:
+ if not callable(pre_processing):
+ raise ValueError("'pre_processing' must be a callable!")
+ if not needs_values:
+ raise ValueError("Cannot use 'pre_processing' without "
+ "specifying 'needs_values'!")
labels, _, ngroups = grouper.group_info
output = collections.OrderedDict()
base_func = getattr(libgroupby, how)
for name, obj in self._iterate_slices():
- indexer = np.zeros_like(labels, dtype=np.int64)
- func = partial(base_func, indexer, labels)
+ if aggregate:
+ result_sz = ngroups
+ else:
+ result_sz = len(obj.values)
+
+ if not cython_dtype:
+ cython_dtype = obj.values.dtype
+
+ result = np.zeros(result_sz, dtype=cython_dtype)
+ func = partial(base_func, result, labels)
+ if needs_values:
+ vals = obj.values
+ if pre_processing:
+ vals = pre_processing(vals)
+ func = partial(func, vals)
+
if needs_mask:
mask = isnull(obj.values).view(np.uint8)
func = partial(func, mask)
@@ -1908,9 +2005,19 @@ def _get_cythonized_result(self, how, grouper, needs_mask=False,
func = partial(func, ngroups)
func(**kwargs) # Call func to modify indexer values in place
- output[name] = algorithms.take_nd(obj.values, indexer)
- return self._wrap_transformed_output(output)
+ if result_is_index:
+ result = algorithms.take_nd(obj.values, result)
+
+ if post_processing:
+ result = post_processing(result)
+
+ output[name] = result
+
+ if aggregate:
+ return self._wrap_aggregated_output(output)
+ else:
+ return self._wrap_transformed_output(output)
@Substitution(name='groupby')
@Appender(_doc_template)
@@ -1930,7 +2037,9 @@ def shift(self, periods=1, freq=None, axis=0):
return self.apply(lambda x: x.shift(periods, freq, axis))
return self._get_cythonized_result('group_shift_indexer',
- self.grouper, needs_ngroups=True,
+ self.grouper, cython_dtype=np.int64,
+ needs_ngroups=True,
+ result_is_index=True,
periods=periods)
@Substitution(name='groupby')
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 2429e9975fc8e..0561b3a1d8592 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -9,6 +9,7 @@
from pandas import (date_range, bdate_range, Timestamp,
Index, MultiIndex, DataFrame, Series,
concat, Panel, DatetimeIndex, read_csv)
+from pandas.core.dtypes.missing import isna
from pandas.errors import UnsupportedFunctionCall, PerformanceWarning
from pandas.util.testing import (assert_frame_equal, assert_index_equal,
assert_series_equal, assert_almost_equal)
@@ -2116,6 +2117,30 @@ def interweave(list_obj):
exp = DataFrame({'key': keys, 'val': _exp_vals})
assert_frame_equal(result, exp)
+ @pytest.mark.parametrize("agg_func", ['any', 'all'])
+ @pytest.mark.parametrize("skipna", [True, False])
+ @pytest.mark.parametrize("vals", [
+ ['foo', 'bar', 'baz'], ['foo', '', ''], ['', '', ''],
+ [1, 2, 3], [1, 0, 0], [0, 0, 0],
+ [1., 2., 3.], [1., 0., 0.], [0., 0., 0.],
+ [True, True, True], [True, False, False], [False, False, False],
+ [np.nan, np.nan, np.nan]
+ ])
+ def test_groupby_bool_aggs(self, agg_func, skipna, vals):
+ df = DataFrame({'key': ['a'] * 3 + ['b'] * 3, 'val': vals * 2})
+
+ # Figure out expectation using Python builtin
+ exp = getattr(compat.builtins, agg_func)(vals)
+
+ # edge case for missing data with skipna and 'any'
+ if skipna and all(isna(vals)) and agg_func == 'any':
+ exp = False
+
+ exp_df = DataFrame([exp] * 2, columns=['val'], index=pd.Index(
+ ['a', 'b'], name='key'))
+ result = getattr(df.groupby('key'), agg_func)(skipna=skipna)
+ assert_frame_equal(result, exp_df)
+
def test_dont_clobber_name_column(self):
df = DataFrame({'key': ['a', 'a', 'a', 'b', 'b', 'b'],
'name': ['foo', 'bar', 'baz'] * 2})
|
- [X] closes #15435
- [X] tests added / passed
- [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [X] whatsnew entry
```bash
before after ratio
[2fdf1e25] [a2223dbf]
- 1.21s 956±3ms 0.79 groupby.GroupByMethods.time_method('float', 'mad')
- 141±2ms 57.8±0.9μs 0.00 groupby.GroupByMethods.time_method('int', 'any')
- 213±7ms 56.6±1μs 0.00 groupby.GroupByMethods.time_method('float', 'any')
SOME BENCHMARKS HAVE CHANGED SIGNIFICANTLY.
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/19722 | 2018-02-16T02:06:07Z | 2018-03-01T01:30:19Z | 2018-03-01T01:30:19Z | 2018-03-01T03:40:46Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.