Updating tests

Author: datapythonista

pandas/conftest.py

@@ -402,14 +402,6 @@ 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):
     """

pandas/core/frame.py

@@ -10644,7 +10644,7 @@ def map(
         self,
         func: PythonFuncType,
         skipna: bool = False,
-        na_action: Literal["ignore"] | None = None,
+        na_action: Literal["ignore"] | None = lib.no_default,
         **kwargs,
     ) -> DataFrame:
         """
@@ -10725,14 +10725,20 @@ def map(
         0   1.000000   4.494400
         1  11.262736  20.857489
         """
-        if na_action == "ignore":
+        if na_action != lib.no_default:
             warnings.warn(
                 "The ``na_action`` parameter has been deprecated and it will be "
                 "removed in a future version of pandas. Use ``skipna`` instead.",
                 FutureWarning,
                 stacklevel=find_stack_level(),
             )
-            skipna = True
+            if na_action == "ignore":
+                skipna = True
+            elif na_action not in (None, "ignore"):
+                raise ValueError(
+                    "na_action must either be 'ignore' or None, "
+                    f"{na_action!r} was passed"
+                )
 
         if self.empty:
             return self.copy()

pandas/core/indexes/base.py

@@ -6351,7 +6351,10 @@ def groupby(self, values) -> PrettyDict[Hashable, Index]:
         return PrettyDict(result)
 
     def map(
-        self, mapper, skipna: bool = False, na_action: Literal["ignore"] | None = None
+        self,
+        mapper,
+        skipna: bool = False,
+        na_action: Literal["ignore"] | None = lib.no_default,
     ):
         """
         Map values using an input mapping or function.
@@ -6399,14 +6402,20 @@ def map(
         """
         from pandas.core.indexes.multi import MultiIndex
 
-        if na_action == "ignore":
+        if na_action != lib.no_default:
             warnings.warn(
                 "The ``na_action`` parameter has been deprecated and it will be "
                 "removed in a future version of pandas. Use ``skipna`` instead.",
                 FutureWarning,
                 stacklevel=find_stack_level(),
             )
-            skipna = True
+            if na_action == "ignore":
+                skipna = True
+            elif na_action not in (None, "ignore"):
+                raise ValueError(
+                    "na_action must either be 'ignore' or None, "
+                    f"{na_action!r} was passed"
+                )
 
         new_values = self._map_values(mapper, skipna=skipna)
 

pandas/core/series.py

@@ -4328,7 +4328,7 @@ def map(
         self,
         func: Callable | Mapping | Series | None = None,
         skipna: bool = False,
-        na_action: Literal["ignore"] | None = None,
+        na_action: Literal["ignore"] | None = lib.no_default,
         engine: Callable | None = None,
         **kwargs,
     ) -> Series:
@@ -4437,14 +4437,20 @@ def map(
         3  I am a rabbit
         dtype: object
         """
-        if na_action == "ignore":
+        if na_action != lib.no_default:
             warnings.warn(
                 "The ``na_action`` parameter has been deprecated and it will be "
                 "removed in a future version of pandas. Use ``skipna`` instead.",
                 FutureWarning,
                 stacklevel=find_stack_level(),
             )
-            skipna = True
+            if na_action == "ignore":
+                skipna = True
+            elif na_action not in (None, "ignore"):
+                raise ValueError(
+                    "na_action must either be 'ignore' or None, "
+                    f"{na_action!r} was passed"
+                )
 
         if func is None:
             if "arg" in kwargs:

pandas/tests/apply/conftest.py

@@ -23,7 +23,7 @@ class MockExecutionEngine(BaseExecutionEngine):
 
     def map(data, func, args, kwargs, decorator, skip_na):
         kwargs_to_pass = kwargs if isinstance(data, DataFrame) else {}
-        return data.map(func, na_action="ignore" if skip_na else None, **kwargs_to_pass)
+        return data.map(func, skipna=skip_na, **kwargs_to_pass)
 
     def apply(data, func, args, kwargs, decorator, axis):
         if isinstance(data, Series):

pandas/tests/apply/test_invalid_arg.py

@@ -54,23 +54,6 @@ def test_agg_raises():
         df.agg()
 
 
-def test_map_with_invalid_na_action_raises():
-    # https://github.com/pandas-dev/pandas/issues/32815
-    s = Series([1, 2, 3])
-    msg = "na_action must either be 'ignore' or None"
-    with pytest.raises(ValueError, match=msg):
-        s.map(lambda x: x, na_action="____")
-
-
-@pytest.mark.parametrize("input_na_action", ["____", True])
-def test_map_arg_is_dict_with_invalid_na_action_raises(input_na_action):
-    # https://github.com/pandas-dev/pandas/issues/46588
-    s = Series([1, 2, 3])
-    msg = f"na_action must either be 'ignore' or None, {input_na_action} was passed"
-    with pytest.raises(ValueError, match=msg):
-        s.map({1: 2}, na_action=input_na_action)
-
-
 @pytest.mark.parametrize("method", ["apply", "agg", "transform"])
 @pytest.mark.parametrize("func", [{"A": {"B": "sum"}}, {"A": {"B": ["sum"]}}])
 def test_nested_renamer(frame_or_series, method, func):

pandas/tests/arrays/categorical/test_analytics.py

@@ -318,16 +318,16 @@ def test_memory_usage(self, using_infer_string):
 
     def test_map(self):
         c = Categorical(list("ABABC"), categories=list("CBA"), ordered=True)
-        result = c.map(lambda x: x.lower(), na_action=None)
+        result = c.map(lambda x: x.lower(), skipna=False)
         exp = Categorical(list("ababc"), categories=list("cba"), ordered=True)
         tm.assert_categorical_equal(result, exp)
 
         c = Categorical(list("ABABC"), categories=list("ABC"), ordered=False)
-        result = c.map(lambda x: x.lower(), na_action=None)
+        result = c.map(lambda x: x.lower(), skipna=False)
         exp = Categorical(list("ababc"), categories=list("abc"), ordered=False)
         tm.assert_categorical_equal(result, exp)
 
-        result = c.map(lambda x: 1, na_action=None)
+        result = c.map(lambda x: 1, skipna=False)
         # GH 12766: Return an index not an array
         tm.assert_index_equal(result, Index(np.array([1] * 5, dtype=np.int64)))
 

pandas/tests/arrays/categorical/test_map.py

@@ -18,29 +18,29 @@
     ],
     ids=["string", "interval"],
 )
-def test_map_str(data, categories, ordered, na_action):
+def test_map_str(data, categories, ordered, skipna):
     # GH 31202 - override base class since we want to maintain categorical/ordered
     cat = Categorical(data, categories=categories, ordered=ordered)
-    result = cat.map(str, na_action=na_action)
+    result = cat.map(str, skipna=skipna)
     expected = Categorical(
         map(str, data), categories=map(str, categories), ordered=ordered
     )
     tm.assert_categorical_equal(result, expected)
 
 
-def test_map(na_action):
+def test_map(skipna):
     cat = Categorical(list("ABABC"), categories=list("CBA"), ordered=True)
-    result = cat.map(lambda x: x.lower(), na_action=na_action)
+    result = cat.map(lambda x: x.lower(), skipna=skipna)
     exp = Categorical(list("ababc"), categories=list("cba"), ordered=True)
     tm.assert_categorical_equal(result, exp)
 
     cat = Categorical(list("ABABC"), categories=list("BAC"), ordered=False)
-    result = cat.map(lambda x: x.lower(), na_action=na_action)
+    result = cat.map(lambda x: x.lower(), skipna=skipna)
     exp = Categorical(list("ababc"), categories=list("bac"), ordered=False)
     tm.assert_categorical_equal(result, exp)
 
     # GH 12766: Return an index not an array
-    result = cat.map(lambda x: 1, na_action=na_action)
+    result = cat.map(lambda x: 1, skipna=skipna)
     exp = Index(np.array([1] * 5, dtype=np.int64))
     tm.assert_index_equal(result, exp)
 
@@ -50,15 +50,15 @@ def test_map(na_action):
     def f(x):
         return {"A": 10, "B": 20, "C": 30}.get(x)
 
-    result = cat.map(f, na_action=na_action)
+    result = cat.map(f, skipna=skipna)
     exp = Categorical([10, 20, 10, 20, 30], categories=[20, 10, 30], ordered=False)
     tm.assert_categorical_equal(result, exp)
 
     mapper = Series([10, 20, 30], index=["A", "B", "C"])
-    result = cat.map(mapper, na_action=na_action)
+    result = cat.map(mapper, skipna=skipna)
     tm.assert_categorical_equal(result, exp)
 
-    result = cat.map({"A": 10, "B": 20, "C": 30}, na_action=na_action)
+    result = cat.map({"A": 10, "B": 20, "C": 30}, skipna=skipna)
     tm.assert_categorical_equal(result, exp)
 
 
@@ -83,7 +83,7 @@ def f(x):
 )
 def test_map_with_nan_none(data, f, expected):  # GH 24241
     values = Categorical(data)
-    result = values.map(f, na_action=None)
+    result = values.map(f, skipna=False)
     if isinstance(expected, Categorical):
         tm.assert_categorical_equal(result, expected)
     else:
@@ -111,26 +111,26 @@ def test_map_with_nan_none(data, f, expected):  # GH 24241
 )
 def test_map_with_nan_ignore(data, f, expected):  # GH 24241
     values = Categorical(data)
-    result = values.map(f, na_action="ignore")
+    result = values.map(f, skipna=True)
     if data[1] == 1:
         tm.assert_categorical_equal(result, expected)
     else:
         tm.assert_index_equal(result, expected)
 
 
-def test_map_with_dict_or_series(na_action):
+def test_map_with_dict_or_series(skipna):
     orig_values = ["a", "B", 1, "a"]
     new_values = ["one", 2, 3.0, "one"]
     cat = Categorical(orig_values)
 
     mapper = Series(new_values[:-1], index=orig_values[:-1])
-    result = cat.map(mapper, na_action=na_action)
+    result = cat.map(mapper, skipna=skipna)
 
     # Order of categories in result can be different
     expected = Categorical(new_values, categories=[3.0, 2, "one"])
     tm.assert_categorical_equal(result, expected)
 
     mapper = dict(zip(orig_values[:-1], new_values[:-1]))
-    result = cat.map(mapper, na_action=na_action)
+    result = cat.map(mapper, skipna=skipna)
     # Order of categories in result can be different
     tm.assert_categorical_equal(result, expected)

pandas/tests/arrays/categorical/test_subclass.py

@@ -20,7 +20,7 @@ def test_from_codes(self):
 
     def test_map(self):
         sc = SubclassedCategorical(["a", "b", "c"])
-        res = sc.map(lambda x: x.upper(), na_action=None)
+        res = sc.map(lambda x: x.upper(), skipna=False)
         assert isinstance(res, SubclassedCategorical)
         exp = Categorical(["A", "B", "C"])
         tm.assert_categorical_equal(res, exp)

pandas/tests/extension/base/methods.py

@@ -97,9 +97,9 @@ 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)
+    @pytest.mark.parametrize("skipna", [False, True])
+    def test_map(self, data_missing, skipna):
+        result = data_missing.map(lambda x: x, skipna=skipna)
         expected = data_missing.to_numpy()
         tm.assert_numpy_array_equal(result, expected)