fix: use explicit None checks, widen numeric type hints, and add tests

Replace 7 fragile truthiness checks (x.expr if x else None) with
explicit is not None checks to prevent silent None when zero-valued
literals are passed. Widen log/power/pow type hints to Expr | int | float
with noqa: PYI041 for clarity. Add unit tests for coerce_to_expr helpers
and integration tests for pythonic calling conventions.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: timsaucer

python/datafusion/functions.py

@@ -1190,7 +1190,7 @@ def ln(arg: Expr) -> Expr:
     return Expr(f.ln(arg.expr))
 
 
-def log(base: Expr | float, num: Expr) -> Expr:
+def log(base: Expr | int | float, num: Expr) -> Expr:  # noqa: PYI041
     """Returns the logarithm of a number for a particular ``base``.
 
     Examples:
@@ -1416,7 +1416,7 @@ def position(string: Expr, substring: Expr | str) -> Expr:
     return strpos(string, substring)
 
 
-def power(base: Expr, exponent: Expr | float) -> Expr:
+def power(base: Expr, exponent: Expr | int | float) -> Expr:  # noqa: PYI041
     """Returns ``base`` raised to the power of ``exponent``.
 
     Examples:
@@ -1432,7 +1432,7 @@ def power(base: Expr, exponent: Expr | float) -> Expr:
     return Expr(f.power(base.expr, exponent.expr))
 
 
-def pow(base: Expr, exponent: Expr | float) -> Expr:
+def pow(base: Expr, exponent: Expr | int | float) -> Expr:  # noqa: PYI041
     """Returns ``base`` raised to the power of ``exponent``.
 
     See Also:
@@ -1486,7 +1486,11 @@ def regexp_like(
     """
     regex = coerce_to_expr(regex)
     flags = coerce_to_expr_or_none(flags)
-    return Expr(f.regexp_like(string.expr, regex.expr, flags.expr if flags else None))
+    return Expr(
+        f.regexp_like(
+            string.expr, regex.expr, flags.expr if flags is not None else None
+        )
+    )
 
 
 def regexp_match(
@@ -1518,7 +1522,11 @@ def regexp_match(
     """
     regex = coerce_to_expr(regex)
     flags = coerce_to_expr_or_none(flags)
-    return Expr(f.regexp_match(string.expr, regex.expr, flags.expr if flags else None))
+    return Expr(
+        f.regexp_match(
+            string.expr, regex.expr, flags.expr if flags is not None else None
+        )
+    )
 
 
 def regexp_replace(
@@ -1565,7 +1573,7 @@ def regexp_replace(
             string.expr,
             pattern.expr,
             replacement.expr,
-            flags.expr if flags else None,
+            flags.expr if flags is not None else None,
         )
     )
 
@@ -1606,8 +1614,8 @@ def regexp_count(
         f.regexp_count(
             string.expr,
             pattern.expr,
-            start.expr if start else None,
-            flags.expr if flags else None,
+            start.expr if start is not None else None,
+            flags.expr if flags is not None else None,
         )
     )
 
@@ -3587,7 +3595,12 @@ def array_slice(
     end = coerce_to_expr(end)
     stride = coerce_to_expr_or_none(stride)
     return Expr(
-        f.array_slice(array.expr, begin.expr, end.expr, stride.expr if stride else None)
+        f.array_slice(
+            array.expr,
+            begin.expr,
+            end.expr,
+            stride.expr if stride is not None else None,
+        )
     )
 
 
@@ -3886,7 +3899,7 @@ def string_to_array(
         f.string_to_array(
             string.expr,
             delimiter.expr,
-            null_string.expr if null_string else None,
+            null_string.expr if null_string is not None else None,
         )
     )
 

python/tests/test_expr.py

@@ -53,6 +53,8 @@
     TransactionEnd,
     TransactionStart,
     Values,
+    coerce_to_expr,
+    coerce_to_expr_or_none,
     ensure_expr,
     ensure_expr_list,
 )
@@ -1026,6 +1028,49 @@ def test_ensure_expr_list_bytearray():
         ensure_expr_list(bytearray(b"a"))
 
 
+def test_coerce_to_expr_passes_expr_through():
+    e = col("a")
+    result = coerce_to_expr(e)
+    assert isinstance(result, type(e))
+    assert str(result) == str(e)
+
+
+def test_coerce_to_expr_wraps_int():
+    result = coerce_to_expr(42)
+    assert isinstance(result, type(lit(42)))
+
+
+def test_coerce_to_expr_wraps_str():
+    result = coerce_to_expr("hello")
+    assert isinstance(result, type(lit("hello")))
+
+
+def test_coerce_to_expr_wraps_float():
+    result = coerce_to_expr(3.14)
+    assert isinstance(result, type(lit(3.14)))
+
+
+def test_coerce_to_expr_wraps_bool():
+    result = coerce_to_expr(True)  # noqa: FBT003
+    assert isinstance(result, type(lit(True)))
+
+
+def test_coerce_to_expr_or_none_returns_none():
+    assert coerce_to_expr_or_none(None) is None
+
+
+def test_coerce_to_expr_or_none_wraps_value():
+    result = coerce_to_expr_or_none(42)
+    assert isinstance(result, type(lit(42)))
+
+
+def test_coerce_to_expr_or_none_passes_expr_through():
+    e = col("a")
+    result = coerce_to_expr_or_none(e)
+    assert isinstance(result, type(e))
+    assert str(result) == str(e)
+
+
 @pytest.mark.parametrize(
     "value",
     [

python/tests/test_functions.py

@@ -2099,3 +2099,96 @@ def test_gen_series_with_step():
         f.gen_series(literal(1), literal(10), literal(3)).alias("v")
     ).collect()
     assert result[0].column(0)[0].as_py() == [1, 4, 7, 10]
+
+
+class TestPythonicNativeTypes:
+    """Tests for accepting native Python types instead of requiring lit()."""
+
+    def test_split_part_native(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": ["a,b,c"]})
+        result = df.select(f.split_part(column("a"), ",", 2).alias("s")).collect()
+        assert result[0].column(0)[0].as_py() == "b"
+
+    def test_encode_native_str(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": ["hello"]})
+        result = df.select(f.encode(column("a"), "base64").alias("e")).collect()
+        assert result[0].column(0)[0].as_py() == "aGVsbG8"
+
+    def test_date_part_native_str(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": ["2021-07-15T00:00:00"]})
+        df = df.select(f.to_timestamp(column("a")).alias("a"))
+        result = df.select(f.date_part("year", column("a")).alias("y")).collect()
+        assert result[0].column(0)[0].as_py() == 2021
+
+    def test_date_trunc_native_str(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": ["2021-07-15T12:34:56"]})
+        df = df.select(f.to_timestamp(column("a")).alias("a"))
+        result = df.select(f.date_trunc("month", column("a")).alias("t")).collect()
+        assert str(result[0].column(0)[0].as_py()) == "2021-07-01 00:00:00"
+
+    def test_left_native_int(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": ["the cat"]})
+        result = df.select(f.left(column("a"), 3).alias("l")).collect()
+        assert result[0].column(0)[0].as_py() == "the"
+
+    def test_round_native_int(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": [1.567]})
+        result = df.select(f.round(column("a"), 2).alias("r")).collect()
+        assert result[0].column(0)[0].as_py() == 1.57
+
+    def test_regexp_count_native(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": ["abcabc"]})
+        result = df.select(
+            f.regexp_count(column("a"), "abc", start=4, flags="i").alias("c")
+        ).collect()
+        assert result[0].column(0)[0].as_py() == 1
+
+    def test_log_native_int(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": [100.0]})
+        result = df.select(f.log(10, column("a")).alias("l")).collect()
+        assert result[0].column(0)[0].as_py() == 2.0
+
+    def test_power_native_int(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": [2.0]})
+        result = df.select(f.power(column("a"), 3).alias("p")).collect()
+        assert result[0].column(0)[0].as_py() == 8.0
+
+    def test_array_slice_native(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": [[1, 2, 3, 4]]})
+        result = df.select(f.array_slice(column("a"), 2, 3).alias("s")).collect()
+        assert result[0].column(0)[0].as_py() == [2, 3]
+
+    def test_string_to_array_native(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": ["hello,NA,world"]})
+        result = df.select(
+            f.string_to_array(column("a"), ",", null_string="NA").alias("v")
+        ).collect()
+        assert result[0].column(0)[0].as_py() == ["hello", None, "world"]
+
+    def test_regexp_replace_native(self):
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": ["a1 b2 c3"]})
+        result = df.select(
+            f.regexp_replace(column("a"), r"\d+", "X", flags="g").alias("r")
+        ).collect()
+        assert result[0].column(0)[0].as_py() == "aX bX cX"
+
+    def test_backward_compat_with_lit(self):
+        """Verify that existing code using lit() still works."""
+        ctx = SessionContext()
+        df = ctx.from_pydict({"a": ["a,b,c"]})
+        result = df.select(
+            f.split_part(column("a"), literal(","), literal(2)).alias("s")
+        ).collect()
+        assert result[0].column(0)[0].as_py() == "b"