Merge branch 'main' into series-from-numpy

dangotbanned · web-flow · commit 82be657ada42 · 2025-03-13T18:22:25.000Z
diff --git a/narwhals/_arrow/series_dt.py b/narwhals/_arrow/series_dt.py
@@ -30,7 +30,7 @@ def unit(self) -> TimeUnit:  # NOTE: Unsafe (native).
     def time_zone(self) -> str | None:  # NOTE: Unsafe (narwhals).
         return cast("Datetime", self.compliant.dtype).time_zone
 
-    def to_string(self: Self, format: str) -> ArrowSeries:  # noqa: A002
+    def to_string(self: Self, format: str) -> ArrowSeries:
         # PyArrow differs from other libraries in that %S also prints out
         # the fractional part of the second...:'(
         # https://arrow.apache.org/docs/python/generated/pyarrow.compute.strftime.html
diff --git a/narwhals/_arrow/series_str.py b/narwhals/_arrow/series_str.py
@@ -61,7 +61,7 @@ def split(self: Self, by: str) -> ArrowSeries:
         split_series = pc.split_pattern(self.native, by)  # type: ignore[call-overload]
         return self.from_native(split_series)
 
-    def to_datetime(self: Self, format: str | None) -> ArrowSeries:  # noqa: A002
+    def to_datetime(self: Self, format: str | None) -> ArrowSeries:
         format = parse_datetime_format(self.native) if format is None else format
         strptime: Incomplete = pc.strptime
         timestamp_array: pa.Array[pa.TimestampScalar[Any, Any]] = strptime(
diff --git a/narwhals/_compliant/any_namespace.py b/narwhals/_compliant/any_namespace.py
@@ -28,7 +28,7 @@ def get_categories(self) -> CompliantT_co: ...
 
 
 class DateTimeNamespace(_StoresCompliant[CompliantT_co], Protocol[CompliantT_co]):
-    def to_string(self, format: str) -> CompliantT_co: ...  # noqa: A002
+    def to_string(self, format: str) -> CompliantT_co: ...
     def replace_time_zone(self, time_zone: str | None) -> CompliantT_co: ...
     def convert_time_zone(self, time_zone: str) -> CompliantT_co: ...
     def timestamp(self, time_unit: TimeUnit) -> CompliantT_co: ...
@@ -78,7 +78,7 @@ def ends_with(self, suffix: str) -> CompliantT_co: ...
     def contains(self, pattern: str, *, literal: bool) -> CompliantT_co: ...
     def slice(self, offset: int, length: int | None) -> CompliantT_co: ...
     def split(self, by: str) -> CompliantT_co: ...
-    def to_datetime(self, format: str | None) -> CompliantT_co: ...  # noqa: A002
+    def to_datetime(self, format: str | None) -> CompliantT_co: ...
     def to_lowercase(self) -> CompliantT_co: ...
     def to_uppercase(self) -> CompliantT_co: ...
 
diff --git a/narwhals/_compliant/expr.py b/narwhals/_compliant/expr.py
@@ -861,7 +861,7 @@ def get_categories(self) -> EagerExprT:
 class EagerExprDateTimeNamespace(
     EagerExprNamespace[EagerExprT], DateTimeNamespace[EagerExprT], Generic[EagerExprT]
 ):
-    def to_string(self, format: str) -> EagerExprT:  # noqa: A002
+    def to_string(self, format: str) -> EagerExprT:
         return self.compliant._reuse_series_namespace("dt", "to_string", format=format)
 
     def replace_time_zone(self, time_zone: str | None) -> EagerExprT:
@@ -1024,7 +1024,7 @@ def slice(self, offset: int, length: int | None) -> EagerExprT:
     def split(self, by: str) -> EagerExprT:
         return self.compliant._reuse_series_namespace("str", "split", by=by)
 
-    def to_datetime(self, format: str | None) -> EagerExprT:  # noqa: A002
+    def to_datetime(self, format: str | None) -> EagerExprT:
         return self.compliant._reuse_series_namespace("str", "to_datetime", format=format)
 
     def to_lowercase(self) -> EagerExprT:
diff --git a/narwhals/_dask/expr_dt.py b/narwhals/_dask/expr_dt.py
@@ -72,9 +72,9 @@ def weekday(self: Self) -> DaskExpr:
             "weekday",
         )
 
-    def to_string(self: Self, format: str) -> DaskExpr:  # noqa: A002
+    def to_string(self: Self, format: str) -> DaskExpr:
         return self._compliant_expr._from_call(
-            lambda _input, format: _input.dt.strftime(format.replace("%.f", ".%f")),  # noqa: A006
+            lambda _input, format: _input.dt.strftime(format.replace("%.f", ".%f")),
             "strftime",
             format=format,
         )
diff --git a/narwhals/_dask/expr_str.py b/narwhals/_dask/expr_str.py
@@ -88,9 +88,9 @@ def split(self: Self, by: str) -> DaskExpr:
             by=by,
         )
 
-    def to_datetime(self: Self, format: str | None) -> DaskExpr:  # noqa: A002
+    def to_datetime(self: Self, format: str | None) -> DaskExpr:
         return self._compliant_expr._from_call(
-            lambda _input, format: dd.to_datetime(_input, format=format),  # noqa: A006
+            lambda _input, format: dd.to_datetime(_input, format=format),
             "to_datetime",
             format=format,
         )
diff --git a/narwhals/_duckdb/expr_dt.py b/narwhals/_duckdb/expr_dt.py
@@ -67,7 +67,7 @@ def nanosecond(self: Self) -> DuckDBExpr:
             "nanosecond",
         )
 
-    def to_string(self: Self, format: str) -> DuckDBExpr:  # noqa: A002
+    def to_string(self: Self, format: str) -> DuckDBExpr:
         return self._compliant_expr._from_call(
             lambda _input: FunctionExpression("strftime", _input, lit(format)),
             "to_string",
diff --git a/narwhals/_duckdb/expr_str.py b/narwhals/_duckdb/expr_str.py
@@ -106,7 +106,7 @@ def replace(self: Self, pattern: str, value: str, *, literal: bool, n: int) -> N
         msg = "`replace` is currently not supported for DuckDB"
         raise NotImplementedError(msg)
 
-    def to_datetime(self: Self, format: str | None) -> DuckDBExpr:  # noqa: A002
+    def to_datetime(self: Self, format: str | None) -> DuckDBExpr:
         if format is None:
             msg = "Cannot infer format with DuckDB backend, please specify `format` explicitly."
             raise NotImplementedError(msg)
diff --git a/narwhals/_pandas_like/series_dt.py b/narwhals/_pandas_like/series_dt.py
@@ -178,7 +178,7 @@ def total_nanoseconds(self: Self) -> PandasLikeSeries:
             s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
         return self._compliant_series._from_native_series(s_abs * s_sign)
 
-    def to_string(self: Self, format: str) -> PandasLikeSeries:  # noqa: A002
+    def to_string(self: Self, format: str) -> PandasLikeSeries:
         # Polars' parser treats `'%.f'` as pandas does `'.%f'`
         # PyArrow interprets `'%S'` as "seconds, plus fractional seconds"
         # and doesn't support `%f`
diff --git a/narwhals/_pandas_like/series_str.py b/narwhals/_pandas_like/series_str.py
@@ -84,7 +84,7 @@ def split(self: Self, by: str) -> PandasLikeSeries:
             self._compliant_series._native_series.str.split(pat=by),
         )
 
-    def to_datetime(self: Self, format: str | None) -> PandasLikeSeries:  # noqa: A002
+    def to_datetime(self: Self, format: str | None) -> PandasLikeSeries:
         if format is not None and any(x in format for x in ("%z", "Z")):
             # We know that the inputs are timezone-aware, so we can directly pass
             # `utc=True` for better performance.
diff --git a/narwhals/_spark_like/expr_str.py b/narwhals/_spark_like/expr_str.py
@@ -106,7 +106,7 @@ def to_lowercase(self: Self) -> SparkLikeExpr:
             self._compliant_expr._F.lower, "to_lowercase"
         )
 
-    def to_datetime(self: Self, format: str | None) -> SparkLikeExpr:  # noqa: A002
+    def to_datetime(self: Self, format: str | None) -> SparkLikeExpr:
         F = self._compliant_expr._F  # noqa: N806
         if not format:
             function = F.to_timestamp
@@ -123,11 +123,11 @@ def to_datetime(self: Self, format: str | None) -> SparkLikeExpr:  # noqa: A002
         )
 
 
-def is_naive_format(format: str) -> bool:  # noqa: A002
+def is_naive_format(format: str) -> bool:
     return not any(x in format for x in ("%s", "%z", "Z"))
 
 
-def strptime_to_pyspark_format(format: str) -> str:  # noqa: A002
+def strptime_to_pyspark_format(format: str) -> str:
     """Converts a Python strptime datetime format string to a PySpark datetime format string."""
     # Mapping from Python strptime format to PySpark format
 
diff --git a/narwhals/expr_dt.py b/narwhals/expr_dt.py
@@ -575,7 +575,7 @@ def total_nanoseconds(self: Self) -> ExprT:
             self._expr._metadata,
         )
 
-    def to_string(self: Self, format: str) -> ExprT:  # noqa: A002
+    def to_string(self: Self, format: str) -> ExprT:
         """Convert a Date/Time/Datetime column into a String column with the given format.
 
         Arguments:
diff --git a/narwhals/expr_str.py b/narwhals/expr_str.py
@@ -367,7 +367,7 @@ def tail(self: Self, n: int = 5) -> ExprT:
             self._expr._metadata,
         )
 
-    def to_datetime(self: Self, format: str | None = None) -> ExprT:  # noqa: A002
+    def to_datetime(self: Self, format: str | None = None) -> ExprT:
         """Convert to Datetime dtype.
 
         Notes:
diff --git a/narwhals/series_dt.py b/narwhals/series_dt.py
@@ -487,7 +487,7 @@ def total_nanoseconds(self: Self) -> SeriesT:
             self._narwhals_series._compliant_series.dt.total_nanoseconds()
         )
 
-    def to_string(self: Self, format: str) -> SeriesT:  # noqa: A002
+    def to_string(self: Self, format: str) -> SeriesT:
         """Convert a Date/Time/Datetime series into a String series with the given format.
 
         Arguments:
diff --git a/narwhals/series_str.py b/narwhals/series_str.py
@@ -369,7 +369,7 @@ def to_lowercase(self: Self) -> SeriesT:
             self._narwhals_series._compliant_series.str.to_lowercase()
         )
 
-    def to_datetime(self: Self, format: str | None = None) -> SeriesT:  # noqa: A002
+    def to_datetime(self: Self, format: str | None = None) -> SeriesT:
         """Parse Series with strings to a Series with Datetime dtype.
 
         Notes:
diff --git a/pyproject.toml b/pyproject.toml
@@ -158,6 +158,9 @@ ignore = [
   "TD004",   # missing-todo-colon
 ]
 
+[tool.ruff.lint.flake8-builtins]
+builtins-ignorelist = ["format"]
+
 [tool.ruff.lint.per-file-ignores]
 "narwhals/expr_dt.py" = ["RUF002"]
 "tests/*" = ["S101"]
diff --git a/tests/expr_and_series/str/to_datetime_test.py b/tests/expr_and_series/str/to_datetime_test.py
@@ -206,7 +206,7 @@ def test_pyarrow_infer_datetime_raise_inconsistent_date_fmt(
 def test_to_datetime_tz_aware(
     constructor: Constructor,
     request: pytest.FixtureRequest,
-    format: str | None,  # noqa: A002
+    format: str | None,
 ) -> None:
     if "pyarrow_table" in str(constructor) and PYARROW_VERSION < (13,):
         # bugged

Original file line number	Diff line number	Diff line change
`@@ -72,9 +72,9 @@ def weekday(self: Self) -> DaskExpr:`
`72`	`72`	`"weekday",`
`73`	`73`	`)`
`74`	`74`
`75`		`- def to_string(self: Self, format: str) -> DaskExpr: # noqa: A002`
	`75`	`+ def to_string(self: Self, format: str) -> DaskExpr:`
`76`	`76`	`return self._compliant_expr._from_call(`
`77`		`- lambda _input, format: _input.dt.strftime(format.replace("%.f", ".%f")), # noqa: A006`
	`77`	`+ lambda _input, format: _input.dt.strftime(format.replace("%.f", ".%f")),`
`78`	`78`	`"strftime",`
`79`	`79`	`format=format,`
`80`	`80`	`)`
Original file line number	Diff line number	Diff line change
`@@ -88,9 +88,9 @@ def split(self: Self, by: str) -> DaskExpr:`
`88`	`88`	`by=by,`
`89`	`89`	`)`
`90`	`90`
`91`		`- def to_datetime(self: Self, format: str \| None) -> DaskExpr: # noqa: A002`
	`91`	`+ def to_datetime(self: Self, format: str \| None) -> DaskExpr:`
`92`	`92`	`return self._compliant_expr._from_call(`
`93`		`- lambda _input, format: dd.to_datetime(_input, format=format), # noqa: A006`
	`93`	`+ lambda _input, format: dd.to_datetime(_input, format=format),`
`94`	`94`	`"to_datetime",`
`95`	`95`	`format=format,`
`96`	`96`	`)`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ def nanosecond(self: Self) -> DuckDBExpr:`
`67`	`67`	`"nanosecond",`
`68`	`68`	`)`
`69`	`69`
`70`		`- def to_string(self: Self, format: str) -> DuckDBExpr: # noqa: A002`
	`70`	`+ def to_string(self: Self, format: str) -> DuckDBExpr:`
`71`	`71`	`return self._compliant_expr._from_call(`
`72`	`72`	`lambda _input: FunctionExpression("strftime", _input, lit(format)),`
`73`	`73`	`"to_string",`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ def split(self: Self, by: str) -> PandasLikeSeries:`
`84`	`84`	`self._compliant_series._native_series.str.split(pat=by),`
`85`	`85`	`)`
`86`	`86`
`87`		`- def to_datetime(self: Self, format: str \| None) -> PandasLikeSeries: # noqa: A002`
	`87`	`+ def to_datetime(self: Self, format: str \| None) -> PandasLikeSeries:`
`88`	`88`	`if format is not None and any(x in format for x in ("%z", "Z")):`
`89`	`89`	`# We know that the inputs are timezone-aware, so we can directly pass`
`90`	`90`	# `utc=True` for better performance.