engine with no function and tests

Author: datapythonista

pandas/core/series.py

@@ -4340,13 +4340,16 @@ def map(
             If 'ignore', propagate NaN values, without passing them to the
             mapping correspondence.
         engine : decorator, optional
-            Choose the execution engine to use. If not provided the function
-            will be executed by the regular Python interpreter.
+            Choose the execution engine to use to run the function. Only used for
+            functions. If ``map`` is called with a mapping or ``Series``, and
+            exception will be raised. If ``engine`` is not provided the function will
+            be executed by the regular Python interpreter.
 
-            Other options include JIT compilers such as Numba and Bodo, which in some
-            cases can speed up the execution. To use an executor you can provide
-            the decorators ``numba.jit``, ``numba.njit`` or ``bodo.jit``. You can
-            also provide the decorator with parameters, like ``numba.jit(nogit=True)``.
+            Options include JIT compilers such as Numba, Bodo or Blosc2, which in some
+            cases can speed up the execution. To use an executor you can provide the
+            decorators ``numba.jit``, ``numba.njit``, ``bodo.jit`` or ``blosc2.jit``.
+            You can also provide the decorator with parameters, like
+            ``numba.jit(nogit=True)``.
 
             Not all functions can be executed with all execution engines. In general,
             JIT compilers will require type stability in the function (no variable
@@ -4423,8 +4426,12 @@ def map(
         dtype: object
         """
         if engine is not None:
+            if not callable(arg):
+                raise ValueError(
+                    "The engine argument can only be specified when func is a function"
+                )
             if not hasattr(engine, "__pandas_udf__"):
-                raise ValueError(f"Not a valid engine: {engine}")
+                raise ValueError(f"Not a valid engine: {engine!r}")
             result = engine.__pandas_udf__.map(
                 data=self,
                 func=arg,

pandas/tests/series/methods/test_map.py

@@ -32,16 +32,20 @@ def f(x):
     ser.map(f)
 
 
-def test_map_callable(datetime_series):
+def test_map_callable(datetime_series, engine):
     with np.errstate(all="ignore"):
-        tm.assert_series_equal(datetime_series.map(np.sqrt), np.sqrt(datetime_series))
+        tm.assert_series_equal(
+            datetime_series.map(np.sqrt, engine=engine), np.sqrt(datetime_series)
+        )
 
     # map function element-wise
-    tm.assert_series_equal(datetime_series.map(math.exp), np.exp(datetime_series))
+    tm.assert_series_equal(
+        datetime_series.map(math.exp, engine=engine), np.exp(datetime_series)
+    )
 
     # empty series
     s = Series(dtype=object, name="foo", index=Index([], name="bar"))
-    rs = s.map(lambda x: x)
+    rs = s.map(lambda x: x, engine=engine)
     tm.assert_series_equal(s, rs)
 
     # check all metadata (GH 9322)
@@ -52,7 +56,7 @@ def test_map_callable(datetime_series):
 
     # index but no data
     s = Series(index=[1, 2, 3], dtype=np.float64)
-    rs = s.map(lambda x: x)
+    rs = s.map(lambda x: x, engine=engine)
     tm.assert_series_equal(s, rs)
 
 
@@ -269,10 +273,10 @@ def test_map_decimal(string_series):
     assert isinstance(result.iloc[0], Decimal)
 
 
-def test_map_na_exclusion():
+def test_map_na_exclusion(engine):
     s = Series([1.5, np.nan, 3, np.nan, 5])
 
-    result = s.map(lambda x: x * 2, na_action="ignore")
+    result = s.map(lambda x: x * 2, na_action="ignore", engine=engine)
     exp = s * 2
     tm.assert_series_equal(result, exp)
 
@@ -604,3 +608,23 @@ def test_map_kwargs():
     result = Series([2, 4, 5]).map(lambda x, y: x + y, y=2)
     expected = Series([4, 6, 7])
     tm.assert_series_equal(result, expected)
+
+
+def test_map_engine_no_function():
+    s = Series([1, 2])
+
+    with pytest.raises(ValueError, match="engine argument can only be specified"):
+        s.map({}, engine="something")
+
+    with pytest.raises(ValueError, match="engine argument can only be specified"):
+        s.map({1: 2}, engine="something")
+
+    with pytest.raises(ValueError, match="engine argument can only be specified"):
+        s.map(Series([3, 4]), engine="something")
+
+
+def test_map_engine_not_executor():
+    s = Series([1, 2])
+
+    with pytest.raises(ValueError, match="Not a valid engine: 'something'"):
+        s.map(lambda x: x, engine="something")