bigframes 2.48.0__tar.gz → 2.49.0__tar.gz

{bigframes-2.48.0/bigframes.egg-info → bigframes-2.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bigframes
-Version: 2.48.0
+Version: 2.49.0
 Summary: BigQuery DataFrames -- scalable analytics and machine learning with BigQuery
 Home-page: https://dataframes.bigquery.dev
 Download-URL: https://github.com/googleapis/google-cloud-python/tree/main/packages/bigframes/releases
@@ -64,7 +64,7 @@ Requires-Dist: google-cloud-bigtable>=2.30.0; extra == "tests"
 Requires-Dist: google-cloud-pubsub>=2.29.0; extra == "tests"
 Requires-Dist: tzdata; extra == "tests"
 Provides-Extra: polars
-Requires-Dist: polars>=1.21.0; extra == "polars"
+Requires-Dist: polars<2.0.0,>=1.21.0; extra == "polars"
 Provides-Extra: scikit-learn
 Requires-Dist: scikit-learn>=1.2.2; extra == "scikit-learn"
 Provides-Extra: dev
@@ -82,7 +82,7 @@ Requires-Dist: google-cloud-bigtable>=2.30.0; extra == "all"
 Requires-Dist: google-cloud-pubsub>=2.29.0; extra == "all"
 Requires-Dist: google-cloud-testutils; extra == "all"
 Requires-Dist: nox; extra == "all"
-Requires-Dist: polars>=1.21.0; extra == "all"
+Requires-Dist: polars<2.0.0,>=1.21.0; extra == "all"
 Requires-Dist: pre-commit; extra == "all"
 Requires-Dist: pytest; extra == "all"
 Requires-Dist: pytest-snapshot; extra == "all"

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/bigquery/__init__.py

@@ -134,9 +134,7 @@ from bigframes.operations.googlesql.global_namespace.date import (
     date_from_unix_date,
     date_sub,
     date_trunc,
-    extract,
     format_date,
-    generate_date_array,
     last_day,
     parse_date,
     unix_date,
@@ -179,9 +177,7 @@ _functions = [
     date_from_unix_date,
     date_sub,
     date_trunc,
-    extract,
     format_date,
-    generate_date_array,
     last_day,
     parse_date,
     unix_date,
@@ -277,9 +273,7 @@ __all__ = [
     "date_from_unix_date",
     "date_sub",
     "date_trunc",
-    "extract",
     "format_date",
-    "generate_date_array",
     "last_day",
     "parse_date",
     "unix_date",

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/core/col.py

@@ -157,6 +157,8 @@ class Expression:
 
     @property
     def dt(self) -> datetimes.DatetimeSimpleMethods:
+        # datetimes depends on bigframes.core.col, so import here to break the
+        # circular import.
         import bigframes.operations.datetimes as datetimes
 
         return datetimes.DatetimeSimpleMethods(self)
@@ -186,6 +188,8 @@ class Expression:
     # keep this last as str declaration can shadow builtins.str
     @property
     def str(self) -> strings.StringMethods:
+        # strings depends on bigframes.core.col, so import here to break the
+        # circular import.
         import bigframes.operations.strings as strings
 
         return strings.StringMethods(self)

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/core/compile/sqlglot/aggregations/unary_compiler.py

@@ -26,7 +26,7 @@ from bigframes import dtypes
 from bigframes.core import window_spec
 from bigframes.core.compile.sqlglot import sql
 from bigframes.core.compile.sqlglot.aggregations.windows import apply_window_if_present
-from bigframes.core.compile.sqlglot.expressions import constants
+from bigframes.core.compile.sqlglot.expressions import common, constants
 from bigframes.operations import aggregations as agg_ops
 
 UNARY_OP_REGISTRATION = reg.OpRegistration()
@@ -48,10 +48,9 @@ def _(
     column: typed_expr.TypedExpr,
     window: typing.Optional[window_spec.WindowSpec] = None,
 ) -> sge.Expression:
-    expr = column.expr
-    if column.dtype != dtypes.BOOL_DTYPE:
-        expr = sge.NEQ(this=expr, expression=sge.convert(0))
-    expr = apply_window_if_present(sge.func("LOGICAL_AND", expr), window)
+    expr = apply_window_if_present(
+        sge.func("LOGICAL_AND", common._to_nullable_bool(column)), window
+    )
 
     # BQ will return null for empty column, result would be true in pandas.
     return sge.func("COALESCE", expr, sge.convert(True))
@@ -63,10 +62,9 @@ def _(
     column: typed_expr.TypedExpr,
     window: typing.Optional[window_spec.WindowSpec] = None,
 ) -> sge.Expression:
-    expr = column.expr
-    if column.dtype != dtypes.BOOL_DTYPE:
-        expr = sge.NEQ(this=expr, expression=sge.convert(0))
-    expr = apply_window_if_present(sge.func("LOGICAL_OR", expr), window)
+    expr = apply_window_if_present(
+        sge.func("LOGICAL_OR", common._to_nullable_bool(column)), window
+    )
 
     # BQ will return null for empty column, result would be false in pandas.
     return sge.func("COALESCE", expr, sge.convert(False))

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/core/compile/sqlglot/expressions/common.py

@@ -14,8 +14,12 @@
 
 from __future__ import annotations
 
+import bigframes_vendored.sqlglot as sg
 import bigframes_vendored.sqlglot.expressions as sge
 
+from bigframes import dtypes
+from bigframes.core.compile.sqlglot.expressions import typed_expr
+
 
 def round_towards_zero(expr: sge.Expression):
     """
@@ -31,3 +35,25 @@ def round_towards_zero(expr: sge.Expression):
         ),
         to="INT64",
     )
+
+
+def _to_nullable_bool(expr: typed_expr.TypedExpr) -> sge.Expression:
+    """
+    Cast the value of an expression to bool based on its truthiness. If the value is null, the result is null.
+    """
+    from_type = expr.dtype
+    sg_expr = expr.expr
+
+    if from_type == dtypes.BOOL_DTYPE:
+        return sg_expr
+    elif dtypes.is_numeric(from_type):
+        return sge.NEQ(this=sg_expr, expression=sge.convert(0))
+    elif dtypes.is_string_like(from_type):
+        return sge.GT(this=sge.func("LENGTH", sg_expr), expression=sge.convert(0))
+    elif dtypes.is_array_like(from_type):
+        return sge.GT(this=sge.func("ARRAY_LENGTH", sg_expr), expression=sge.convert(0))
+
+    return sge.Is(
+        this=sge.paren(sg_expr, copy=False),
+        expression=sg.not_(sge.Null(), copy=False),
+    )

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/core/compile/sqlglot/expressions/generic_ops.py

@@ -21,6 +21,7 @@ import bigframes.core.compile.sqlglot.expression_compiler as expression_compiler
 from bigframes import dtypes
 from bigframes import operations as ops
 from bigframes.core.compile.sqlglot import sql, sqlglot_types
+from bigframes.core.compile.sqlglot.expressions import common
 from bigframes.core.compile.sqlglot.expressions.typed_expr import TypedExpr
 
 register_unary_op = expression_compiler.expression_compiler.register_unary_op
@@ -150,24 +151,9 @@ def _(expr: TypedExpr) -> sge.Expression:
 
 @register_unary_op(ops.coerce_to_bool_op)
 def _(expr: TypedExpr) -> sge.Expression:
-    from_type = expr.dtype
-    sg_expr = expr.expr
-
-    if from_type == dtypes.BOOL_DTYPE:
-        res = sg_expr
-    elif dtypes.is_numeric(from_type):
-        res = sge.NEQ(this=sg_expr, expression=sge.convert(0))
-    elif dtypes.is_string_like(from_type):
-        res = sge.GT(this=sge.func("LENGTH", sg_expr), expression=sge.convert(0))
-    elif dtypes.is_array_like(from_type):
-        res = sge.GT(this=sge.func("ARRAY_LENGTH", sg_expr), expression=sge.convert(0))
-    else:
-        res = sge.Is(
-            this=sge.paren(sg_expr, copy=False),
-            expression=sg.not_(sge.Null(), copy=False),
-        )
-
-    return sge.Coalesce(this=res, expressions=[sge.convert(False)])
+    return sge.Coalesce(
+        this=common._to_nullable_bool(expr), expressions=[sge.convert(False)]
+    )
 
 
 @register_ternary_op(ops.where_op)

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/core/compile/sqlglot/sql/base.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+import datetime
 import typing
 
 import bigframes_vendored.sqlglot as sg
@@ -57,6 +58,19 @@ def identifier(id: str) -> sge.Identifier:
     return sge.to_identifier(id, quoted=QUOTED)
 
 
+def _unwrap_scalar(value: typing.Any) -> typing.Any:
+    """Unwraps PyArrow scalars and NumPy generic types to native Python objects."""
+    if isinstance(value, pa.Scalar):
+        return value.as_py()
+    if isinstance(value, np.datetime64):
+        # Avoid calling .item() on np.datetime64 because sub-microsecond np.datetime64 objects
+        # are converted to integer epoch.
+        return pd.Timestamp(value).to_pydatetime()
+    if isinstance(value, np.generic):
+        return value.item()
+    return value
+
+
 def literal(value: typing.Any, dtype: dtypes.Dtype | None = None) -> sge.Expression:
     """Return a string representing column reference in a SQL."""
     if dtype is None:
@@ -101,10 +115,19 @@ def literal(value: typing.Any, dtype: dtypes.Dtype | None = None) -> sge.Express
     elif dtype == dtypes.BYTES_DTYPE:
         return cast(str(value), sqlglot_type)
     elif dtypes.is_time_like(dtype):
+        value = _unwrap_scalar(value)
+        if isinstance(value, str):
+            return cast(sge.convert(value), sqlglot_type)
+        elif isinstance(value, pd.Timestamp):
+            value = value.to_pydatetime()
+        return cast(sge.convert(value.isoformat()), sqlglot_type)
+    elif dtypes.is_date_like(dtype):
+        value = _unwrap_scalar(value)
         if isinstance(value, str):
             return cast(sge.convert(value), sqlglot_type)
-        if isinstance(value, np.generic):
-            value = value.item()
+        elif isinstance(value, datetime.datetime):
+            # pd.Timestamp is a subclass of datatime.datetime.
+            value = value.date()
         return cast(sge.convert(value.isoformat()), sqlglot_type)
     elif dtype in (dtypes.NUMERIC_DTYPE, dtypes.BIGNUMERIC_DTYPE):
         return cast(sge.convert(value), sqlglot_type)
@@ -113,12 +136,10 @@ def literal(value: typing.Any, dtype: dtypes.Dtype | None = None) -> sge.Express
         return sge.func("ST_GEOGFROMTEXT", sge.convert(wkt))
     elif dtype == dtypes.TIMEDELTA_DTYPE:
         return sge.convert(utils.timedelta_to_micros(value))
+    elif dtype == dtypes.STRING_DTYPE:
+        return sge.convert(str(_unwrap_scalar(value)))
     else:
-        if isinstance(value, np.generic):
-            value = value.item()
-        if isinstance(value, pa.Scalar):
-            value = value.as_py()
-        return sge.convert(value)
+        return sge.convert(_unwrap_scalar(value))
 
 
 def cast(arg: typing.Any, to: str, safe: bool = False) -> sge.Cast | sge.TryCast:

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/core/compile/sqlglot/sql/ddl.py

@@ -149,8 +149,10 @@ def _loaddata_sql(self: sg.Generator, expression: sge.LoadData) -> str:
     out = ["LOAD DATA"]
     if expression.args.get("overwrite"):
         out.append("OVERWRITE")
+    else:
+        out.append("INTO")
 
-    out.append(f"INTO {self.sql(expression, 'this').strip()}")
+    out.append(self.sql(expression, "this").strip())
 
     # We ignore inpath as it's just a dummy to satisfy sqlglot requirements
     # but BigQuery uses FROM FILES instead.

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/core/compile/sqlglot/sqlglot_ir.py

@@ -581,8 +581,16 @@ def _and(conditions: tuple[sge.Expression, ...]) -> typing.Optional[sge.Expressi
     if not conditions:
         return None
 
+    def check_and_parenthesize(expr: sge.Expression) -> sge.Expression:
+        if isinstance(expr, sge.Or):
+            return sge.paren(expr)
+        return expr
+
     return functools.reduce(
-        lambda left, right: sge.And(this=left, expression=right), conditions
+        lambda left, right: sge.And(
+            this=check_and_parenthesize(left), expression=check_and_parenthesize(right)
+        ),
+        conditions,
     )
 
 

bigframes-2.49.0/bigframes/core/compile/sqlglot/testing.py

@@ -0,0 +1,27 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import bigframes.core.col
+import bigframes.core.compile.sqlglot.expression_compiler
+import bigframes.core.compile.sqlglot.sql
+
+
+def to_sql_snippet(expr: bigframes.core.col.Expression) -> str:
+    """Compiles an Expression into a SQL snippet."""
+
+    sge_expr = bigframes.core.compile.sqlglot.expression_compiler.expression_compiler.compile_expression(
+        expr._value
+    )
+    return bigframes.core.compile.sqlglot.sql.to_sql(sge_expr)

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/dataframe.py

@@ -2907,8 +2907,41 @@ class DataFrame:
         result = block_ops.interpolate(self._block, method)
         return DataFrame(result)
 
-    def fillna(self, value=None) -> DataFrame:
-        return self._apply_binop(value, ops.fillna_op, how="left")
+    @overload  # type: ignore[override]
+    def fillna(
+        self,
+        value: Any = ...,
+        *,
+        inplace: Literal[False] = ...,
+    ) -> DataFrame: ...
+
+    @overload
+    def fillna(
+        self,
+        value: Any = ...,
+        *,
+        inplace: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def fillna(
+        self,
+        value: Any = ...,
+        *,
+        inplace: bool = ...,
+    ) -> DataFrame | None: ...
+
+    def fillna(
+        self,
+        value: Any = None,
+        *,
+        inplace: bool = False,
+    ) -> DataFrame | None:
+        result = self._apply_binop(value, ops.fillna_op, how="left")
+        if inplace:
+            self._set_block(result._block)
+            return None
+        return result
 
     def replace(
         self, to_replace: typing.Any, value: typing.Any = None, *, regex: bool = False

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/extensions/core/series_accessor.py

@@ -19,7 +19,7 @@
 from __future__ import annotations
 
 import abc
-import datetime
+import datetime as dt
 from typing import (
     Any,
     Literal,
@@ -853,7 +853,7 @@ class BigQuerySeriesAccessor(
         start_date: Union[
             series.Series,
             col.Expression,
-            Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
+            Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date],
         ],
         granularity: Union[
             series.Series,
@@ -968,43 +968,6 @@ class BigQuerySeriesAccessor(
         )
         return self._to_series(cast(series.Series, result))
 
-    def extract(
-        self,
-        part: Union[
-            series.Series,
-            col.Expression,
-            Union[Any, Literal[sentinels.Sentinel.ARGUMENT_DEFAULT]],
-        ],
-        time_zone: Union[
-            series.Series,
-            col.Expression,
-            Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], str],
-        ] = sentinels.Sentinel.ARGUMENT_DEFAULT,
-        *,
-        session: Optional[session.Session] = None,
-    ) -> S:
-        """Returns the value corresponding to the specified date part."""
-        from bigframes.operations.googlesql.global_namespace.date import (
-            extract as extract_impl,
-        )
-
-        # Resolve session from other arguments if not passed
-        if session is None:
-            from bigframes.core import googlesql
-
-            session = googlesql._find_session(
-                part,
-                time_zone,
-            )
-
-        bf_series = self._bf_from_series(session)
-        result = extract_impl(
-            bf_series,
-            part,
-            time_zone,
-        )
-        return self._to_series(cast(series.Series, result))
-
     def format_date(
         self,
         format_string: Union[

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/operations/googlesql/global_namespace/conversion.py

@@ -18,7 +18,7 @@
 
 from __future__ import annotations
 
-import datetime
+import datetime as dt
 from typing import Literal, Union
 
 import bigframes.core.col
@@ -173,9 +173,9 @@ def string(
         bigframes.core.col.Expression,
         Union[
             Literal[sentinels.Sentinel.ARGUMENT_DEFAULT],
-            datetime.date,
-            datetime.datetime,
-            datetime.time,
+            dt.date,
+            dt.datetime,
+            dt.time,
             str,
         ],
     ],

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/operations/googlesql/global_namespace/date.py

@@ -18,7 +18,7 @@
 
 from __future__ import annotations
 
-import datetime
+import datetime as dt
 from typing import Any, Literal, Union
 
 import bigframes.core.col
@@ -69,26 +69,11 @@ _DATE_TRUNC_OP = googlesql.GoogleSqlScalarOp(
     args=(googlesql.ArgSpec(), googlesql.ArgSpec()),
     signature=lambda *args: dtypes.DATE_DTYPE,
 )
-_EXTRACT_OP = googlesql.GoogleSqlScalarOp(
-    "EXTRACT",
-    args=(googlesql.ArgSpec(), googlesql.ArgSpec(), googlesql.ArgSpec(optional=True)),
-    signature=lambda *args: dtypes.INT_DTYPE,
-)
 _FORMAT_DATE_OP = googlesql.GoogleSqlScalarOp(
     "FORMAT_DATE",
     args=(googlesql.ArgSpec(), googlesql.ArgSpec()),
     signature=lambda *args: dtypes.STRING_DTYPE,
 )
-_GENERATE_DATE_ARRAY_OP = googlesql.GoogleSqlScalarOp(
-    "GENERATE_DATE_ARRAY",
-    args=(
-        googlesql.ArgSpec(),
-        googlesql.ArgSpec(),
-        googlesql.ArgSpec(optional=True),
-        googlesql.ArgSpec(optional=True),
-    ),
-    signature=lambda *args: dtypes.list_type(dtypes.DATE_DTYPE),
-)
 _LAST_DAY_OP = googlesql.GoogleSqlScalarOp(
     "LAST_DAY",
     args=(googlesql.ArgSpec(), googlesql.ArgSpec(optional=True)),
@@ -124,12 +109,7 @@ def date(
     expression: Union[
         series.Series,
         bigframes.core.col.Expression,
-        Union[
-            Literal[sentinels.Sentinel.ARGUMENT_DEFAULT],
-            datetime.date,
-            datetime.datetime,
-            str,
-        ],
+        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date, dt.datetime, str],
     ] = sentinels.Sentinel.ARGUMENT_DEFAULT,
     time_zone_expression: Union[
         series.Series,
@@ -167,7 +147,7 @@ def date_add(
     date_expression: Union[
         series.Series,
         bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
+        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date],
     ],
     int64_expression: Union[
         series.Series,
@@ -193,12 +173,12 @@ def date_diff(
     end_date: Union[
         series.Series,
         bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
+        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date],
     ],
     start_date: Union[
         series.Series,
         bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
+        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date],
     ],
     granularity: Union[
         series.Series,
@@ -233,7 +213,7 @@ def date_sub(
     date_expression: Union[
         series.Series,
         bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
+        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date],
     ],
     int64_expression: Union[
         series.Series,
@@ -259,7 +239,7 @@ def date_trunc(
     date_value: Union[
         series.Series,
         bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
+        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date],
     ],
     granularity: Union[
         series.Series,
@@ -275,37 +255,6 @@ def date_trunc(
     )
 
 
-def extract(
-    date_expression: Union[
-        series.Series,
-        bigframes.core.col.Expression,
-        Union[
-            Literal[sentinels.Sentinel.ARGUMENT_DEFAULT],
-            datetime.date,
-            datetime.datetime,
-            datetime.time,
-        ],
-    ],
-    part: Union[
-        series.Series,
-        bigframes.core.col.Expression,
-        Union[Any, Literal[sentinels.Sentinel.ARGUMENT_DEFAULT]],
-    ],
-    time_zone: Union[
-        series.Series,
-        bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], str],
-    ] = sentinels.Sentinel.ARGUMENT_DEFAULT,
-) -> Union[series.Series, bigframes.core.col.Expression]:
-    """Returns the value corresponding to the specified date part."""
-    return bigframes.core.googlesql.apply_googlesql_scalar_op(
-        _EXTRACT_OP,
-        date_expression,
-        part,
-        time_zone,
-    )
-
-
 def format_date(
     format_string: Union[
         series.Series,
@@ -315,7 +264,7 @@ def format_date(
     date_expr: Union[
         series.Series,
         bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
+        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date],
     ],
 ) -> Union[series.Series, bigframes.core.col.Expression]:
     """Formats a DATE value according to a specified format string."""
@@ -326,43 +275,11 @@ def format_date(
     )
 
 
-def generate_date_array(
-    start_date: Union[
-        series.Series,
-        bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
-    ],
-    end_date: Union[
-        series.Series,
-        bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
-    ],
-    int64_expression: Union[
-        series.Series,
-        bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], int],
-    ] = sentinels.Sentinel.ARGUMENT_DEFAULT,
-    date_part: Union[
-        series.Series,
-        bigframes.core.col.Expression,
-        Union[Any, Literal[sentinels.Sentinel.ARGUMENT_DEFAULT]],
-    ] = sentinels.Sentinel.ARGUMENT_DEFAULT,
-) -> Union[series.Series, bigframes.core.col.Expression]:
-    """Generates an array of dates in a range."""
-    return bigframes.core.googlesql.apply_googlesql_scalar_op(
-        _GENERATE_DATE_ARRAY_OP,
-        start_date,
-        end_date,
-        int64_expression,
-        date_part,
-    )
-
-
 def last_day(
     date_expression: Union[
         series.Series,
         bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
+        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date],
     ],
     date_part: Union[
         series.Series,
@@ -402,7 +319,7 @@ def unix_date(
     date_expression: Union[
         series.Series,
         bigframes.core.col.Expression,
-        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], datetime.date],
+        Union[Literal[sentinels.Sentinel.ARGUMENT_DEFAULT], dt.date],
     ],
 ) -> Union[series.Series, bigframes.core.col.Expression]:
     """Returns the number of days since 1970-01-01."""

{bigframes-2.48.0 → bigframes-2.49.0}/bigframes/series.py

@@ -997,8 +997,41 @@ class Series:
             block_ops.rank(self._block, method, na_option, ascending, pct=pct)
         )
 
-    def fillna(self, value=None) -> Series:
-        return self._apply_binary_op(value, ops.fillna_op)
+    @overload  # type: ignore[override]
+    def fillna(
+        self,
+        value: Any = ...,
+        *,
+        inplace: Literal[False] = ...,
+    ) -> Series: ...
+
+    @overload
+    def fillna(
+        self,
+        value: Any = ...,
+        *,
+        inplace: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def fillna(
+        self,
+        value: Any = ...,
+        *,
+        inplace: bool = ...,
+    ) -> Series | None: ...
+
+    def fillna(
+        self,
+        value: Any = None,
+        *,
+        inplace: bool = False,
+    ) -> Series | None:
+        result = self._apply_binary_op(value, ops.fillna_op)
+        if inplace:
+            self._set_block(result._block)
+            return None
+        return result
 
     def replace(
         self, to_replace: typing.Any, value: typing.Any = None, *, regex: bool = False