fix: compute %s (seconds since epoch) explicitly in pandas-like dt.to_string

src/narwhals/_pandas_like/series_dt.py

@@ -30,6 +30,32 @@
     from narwhals.typing import TimeUnit
 
 
+def _split_unescaped_percent_s(format: str) -> list[str] | None:
+    """Split `format` on `%s` directives, ignoring escaped `%%`.
+
+    Returns `None` when there is no unescaped `%s` directive.
+    """
+    parts: list[str] = []
+    current: list[str] = []
+    i, n = 0, len(format)
+    while i < n:
+        char, nxt = format[i], format[i + 1] if i + 1 < n else ""
+        if char == "%" and nxt in {"%", "s"}:
+            if nxt == "s":
+                parts.append("".join(current))
+                current = []
+            else:
+                current.append("%%")
+            i += 2
+        else:
+            current.append(char)
+            i += 1
+    if not parts:
+        return None
+    parts.append("".join(current))
+    return parts
+
+
 class PandasLikeSeriesDateTimeNamespace(
     PandasLikeSeriesNamespace, DateTimeNamespace["PandasLikeSeries"]
 ):
@@ -167,6 +193,16 @@ def to_string(self, format: str) -> PandasLikeSeries:
             format = format.replace("%S%.f", "%S.%f")
         else:
             format = format.replace("%S.%f", "%S").replace("%S%.f", "%S")
+        if self._is_pyarrow() and (parts := _split_unescaped_percent_s(format)):
+            # `%s` (seconds since the epoch) isn't supported by `pc.strftime`,
+            # which passes it through as literal text - splice the epoch values
+            # in explicitly so the output matches the other backends.
+            strftimed = [self.native.dt.strftime(part) for part in parts]
+            epoch = self.timestamp("s").native.astype(strftimed[0].dtype)
+            result: Any = strftimed[0]
+            for part in strftimed[1:]:
+                result = result + epoch + part
+            return self.with_native(result)
         return self.with_native(self.native.dt.strftime(format))
 
     def replace_time_zone(self, time_zone: str | None) -> PandasLikeSeries:

src/narwhals/_pandas_like/utils.py

@@ -582,6 +582,9 @@ def int_dtype_mapper(dtype: Any) -> str:
     ("s", "ns"): (operator.mul, NS_PER_SECOND),
     ("s", "us"): (operator.mul, US_PER_SECOND),
     ("s", "ms"): (operator.mul, MS_PER_SECOND),
+    ("ns", "s"): (operator.floordiv, NS_PER_SECOND),
+    ("us", "s"): (operator.floordiv, US_PER_SECOND),
+    ("ms", "s"): (operator.floordiv, MS_PER_SECOND),
 }
 
 

src/narwhals/expr_dt.py

@@ -501,6 +501,9 @@ def to_string(self, format: str) -> ExprT:
             Therefore, we make the following adjustments.
 
             - for pandas-like libraries, we replace `"%S.%f"` with `"%S%.f"`.
+            - for pandas-like libraries with a PyArrow-backed dtype, we compute
+              `"%s"` (seconds since the epoch) explicitly, as `pc.strftime`
+              doesn't support it and passes it through as literal text.
             - for PyArrow, we replace `"%S.%f"` with `"%S"`.
             ---
             Workarounds like these don't make us happy, and we try to avoid them as

src/narwhals/series_dt.py

@@ -448,6 +448,9 @@ def to_string(self, format: str) -> SeriesT:
             Therefore, we make the following adjustments.
 
             - for pandas-like libraries, we replace `"%S.%f"` with `"%S%.f"`.
+            - for pandas-like libraries with a PyArrow-backed dtype, we compute
+              `"%s"` (seconds since the epoch) explicitly, as `pc.strftime`
+              doesn't support it and passes it through as literal text.
             - for PyArrow, we replace `"%S.%f"` with `"%S"`.
             ---
             Workarounds like these don't make us happy, and we try to avoid them as

tests/expr_and_series/dt/to_string_test.py

@@ -144,3 +144,73 @@ def test_dt_to_string_iso_local_date_expr(
     df = constructor({"a": [data]})
     result = nw.from_native(df).select(b=nw.col("a").dt.to_string("%Y-%m-%d"))
     assert_equal_data(result, {"b": [expected]})
+
+
+@pytest.mark.parametrize(
+    ("fmt", "expected"),
+    [
+        ("%s", ["1773450123", None]),
+        ("%s|%s", ["1773450123|1773450123", None]),
+        ("epoch=%s", ["epoch=1773450123", None]),
+        ("%Y-%m-%d %s", ["2026-03-14 1773450123", None]),
+        ("%%s", ["%s", None]),
+    ],
+)
+@pytest.mark.skipif(is_windows(), reason="pyarrow breaking on windows")
+def test_dt_to_string_epoch_seconds_series(
+    constructor_eager: ConstructorEager,
+    fmt: str,
+    expected: list[str | None],
+    request: pytest.FixtureRequest,
+) -> None:
+    # https://github.com/narwhals-dev/narwhals/issues/3983
+    # `%s` (seconds since the epoch) isn't supported by `pc.strftime`, which
+    # passes it through as literal text - narwhals splices it in explicitly,
+    # including for pandas-like libraries with a PyArrow-backed dtype, which
+    # delegate to `pc.strftime`.
+    from narwhals._pandas_like.series_dt import _split_unescaped_percent_s
+
+    if _split_unescaped_percent_s(fmt) and any(
+        x in str(constructor_eager)
+        for x in ["duckdb", "sqlframe", "ibis", "pyarrow_table_constructor"]
+    ):
+        # These backends don't support `%s` in `strftime` at all
+        # (pure-PyArrow is handled separately in #4000).
+        request.applymarker(pytest.mark.xfail(reason="backend doesn't support %s"))
+    data = {"a": [datetime(2026, 3, 14, 1, 2, 3), None]}
+    result = nw.from_native(constructor_eager(data), eager_only=True)["a"].dt.to_string(
+        fmt
+    )
+    assert_equal_data({"a": result}, {"a": expected})
+
+
+@pytest.mark.parametrize(
+    ("fmt", "expected"),
+    [
+        ("%s", ["1773450123", None]),
+        ("%s|%s", ["1773450123|1773450123", None]),
+        ("epoch=%s", ["epoch=1773450123", None]),
+        ("%Y-%m-%d %s", ["2026-03-14 1773450123", None]),
+        ("%%s", ["%s", None]),
+    ],
+)
+@pytest.mark.skipif(is_windows(), reason="pyarrow breaking on windows")
+def test_dt_to_string_epoch_seconds_expr(
+    constructor: Constructor,
+    fmt: str,
+    expected: list[str | None],
+    request: pytest.FixtureRequest,
+) -> None:
+    # https://github.com/narwhals-dev/narwhals/issues/3983
+    from narwhals._pandas_like.series_dt import _split_unescaped_percent_s
+
+    if _split_unescaped_percent_s(fmt) and any(
+        x in str(constructor)
+        for x in ["duckdb", "sqlframe", "ibis", "pyarrow_table_constructor"]
+    ):
+        # These backends don't support `%s` in `strftime` at all
+        # (pure-PyArrow is handled separately in #4000).
+        request.applymarker(pytest.mark.xfail(reason="backend doesn't support %s"))
+    data = {"a": [datetime(2026, 3, 14, 1, 2, 3), None]}
+    result = nw.from_native(constructor(data)).select(b=nw.col("a").dt.to_string(fmt))
+    assert_equal_data(result, {"b": expected})