Merge remote-tracking branch 'github/main' into garrettwu-ml

Author: GarrettWu

.librarian/state.yaml

@@ -1,7 +1,7 @@
-image: us-central1-docker.pkg.dev/cloud-sdk-librarian-prod/images-prod/python-librarian-generator@sha256:1a2a85ab507aea26d787c06cc7979decb117164c81dd78a745982dfda80d4f68
+image: us-central1-docker.pkg.dev/cloud-sdk-librarian-prod/images-prod/python-librarian-generator@sha256:160860d189ff1c2f7515638478823712fa5b243e27ccc33a2728669fa1e2ed0c
 libraries:
   - id: bigframes
-    version: 2.36.0
+    version: 2.37.0
     last_generated_commit: ""
     apis: []
     source_roots:

CHANGELOG.md

@@ -4,6 +4,36 @@
 
 [1]: https://pypi.org/project/bigframes/#history
 
+## [2.37.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v2.36.0...v2.37.0) (2026-03-03)
+
+
+### Documentation
+
+* Fix recall_score doc example (#2477) ([a6f499c1e225a962b53621158f9d4a19ca220ccd](https://github.com/googleapis/python-bigquery-dataframes/commit/a6f499c1e225a962b53621158f9d4a19ca220ccd))
+* add code sample and docstring for bpd.options.experiments.sql_compiler (#2474) ([867951bcabcff12e2fce88143b45d929d3237088](https://github.com/googleapis/python-bigquery-dataframes/commit/867951bcabcff12e2fce88143b45d929d3237088))
+* use direct API for image (#2465) ([8a1a82f7a0fd224f2b075c68ab116d1f580d1d82](https://github.com/googleapis/python-bigquery-dataframes/commit/8a1a82f7a0fd224f2b075c68ab116d1f580d1d82))
+* add bigframes default connection warning (#2471) ([f1bbba23667f01d3b8e7c51b18fe64641a4b135f](https://github.com/googleapis/python-bigquery-dataframes/commit/f1bbba23667f01d3b8e7c51b18fe64641a4b135f))
+* Move readme content to new User Guide section (#2464) ([61a948451baeb1caa323e721ad88b31c7cd0b3cb](https://github.com/googleapis/python-bigquery-dataframes/commit/61a948451baeb1caa323e721ad88b31c7cd0b3cb))
+* Skip inherited methods, use autosummary only for big classes (#2470) ([a9512498ef39b9d5260cad2ca0513c701a6d3592](https://github.com/googleapis/python-bigquery-dataframes/commit/a9512498ef39b9d5260cad2ca0513c701a6d3592))
+* Add code examples to configuration docstrings (#2352) ([3c21993e6fca474c32f3c2371c41ef2be146267e](https://github.com/googleapis/python-bigquery-dataframes/commit/3c21993e6fca474c32f3c2371c41ef2be146267e))
+
+
+### Features
+
+* Add cloud_function_cpus option to remote_function (#2475) ([4caf74ccaeb9608d91da864bb80eddf1148a1502](https://github.com/googleapis/python-bigquery-dataframes/commit/4caf74ccaeb9608d91da864bb80eddf1148a1502))
+* Support pd.col simple aggregates (#2480) ([cb00daabce49f067be8e16627166dda00d5d8134](https://github.com/googleapis/python-bigquery-dataframes/commit/cb00daabce49f067be8e16627166dda00d5d8134))
+* add display.render_mode to control DataFrame/Series visualization (#2413) ([7813eaa6fa2ae42943b90583e600c95beaf5d75e](https://github.com/googleapis/python-bigquery-dataframes/commit/7813eaa6fa2ae42943b90583e600c95beaf5d75e))
+* add support for Python 3.14 (#2232) ([c25a6d0151380dde74368a35e13deb7a930b494f](https://github.com/googleapis/python-bigquery-dataframes/commit/c25a6d0151380dde74368a35e13deb7a930b494f))
+* Support pd.col expressions with .loc and getitem (#2473) ([ae5c8b322765aef51eed016bfacaff5a7a917a7b](https://github.com/googleapis/python-bigquery-dataframes/commit/ae5c8b322765aef51eed016bfacaff5a7a917a7b))
+* add dt.tz_localize() (#2469) ([f70f93a1227add1627d522d7e55a37f42fc3549e](https://github.com/googleapis/python-bigquery-dataframes/commit/f70f93a1227add1627d522d7e55a37f42fc3549e))
+* Update bigquery.ai.generate_table output_schema to allow Mapping type (#2463) ([f7fd1895e64a133fe63eddeb90f57a42a35c29b2](https://github.com/googleapis/python-bigquery-dataframes/commit/f7fd1895e64a133fe63eddeb90f57a42a35c29b2))
+
+
+### Bug Fixes
+
+* upload local data through write API if nested JSONs detected (#2478) ([01dc5a34e09171351575d5cbdc9f301e505e1567](https://github.com/googleapis/python-bigquery-dataframes/commit/01dc5a34e09171351575d5cbdc9f301e505e1567))
+* allow IsInOp with same dtypes regardless nullable (#2466) ([1d81b414acbc964502ca624eae72cdb8c14e1576](https://github.com/googleapis/python-bigquery-dataframes/commit/1d81b414acbc964502ca624eae72cdb8c14e1576))
+
 ## [2.36.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v2.35.0...v2.36.0) (2026-02-17)
 
 

bigframes/bigquery/_operations/sql.py

@@ -20,7 +20,7 @@
 
 import google.cloud.bigquery
 
-from bigframes.core.compile.sqlglot import sqlglot_ir
+from bigframes.core.compile.sqlglot import sql
 import bigframes.dtypes
 import bigframes.operations
 import bigframes.series
@@ -68,10 +68,7 @@ def sql_scalar(
     # Another benefit of this is that if there is a syntax error in the SQL
     # template, then this will fail with an error earlier in the process,
     # aiding users in debugging.
-    literals_sql = [
-        sqlglot_ir._literal(None, column.dtype).sql(dialect="bigquery")
-        for column in columns
-    ]
+    literals_sql = [sql.to_sql(sql.literal(None, column.dtype)) for column in columns]
     select_sql = sql_template.format(*literals_sql)
     dry_run_sql = f"SELECT {select_sql}"
 

bigframes/core/col.py

@@ -14,12 +14,18 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Hashable
+from typing import Any, Hashable, Literal, TYPE_CHECKING
 
 import bigframes_vendored.pandas.core.col as pd_col
 
+from bigframes.core import agg_expressions, window_spec
 import bigframes.core.expression as bf_expression
 import bigframes.operations as bf_ops
+import bigframes.operations.aggregations as agg_ops
+
+if TYPE_CHECKING:
+    import bigframes.operations.datetimes as datetimes
+    import bigframes.operations.strings as strings
 
 
 # Not to be confused with the Expression class in `bigframes.core.expressions`
@@ -30,10 +36,26 @@ class Expression:
 
     _value: bf_expression.Expression
 
-    def _apply_unary(self, op: bf_ops.UnaryOp) -> Expression:
+    def _apply_unary_op(self, op: bf_ops.UnaryOp) -> Expression:
         return Expression(op.as_expr(self._value))
 
-    def _apply_binary(self, other: Any, op: bf_ops.BinaryOp, reverse: bool = False):
+    def _apply_unary_agg(self, op: agg_ops.UnaryAggregateOp) -> Expression:
+        # We probably shouldn't need to windowize here, but block apis expect pre-windowized expressions
+        # Later on, we will probably have col expressions in windowed context, so will need to defer windowization
+        # instead of automatically applying the default unbound window
+        agg_expr = op.as_expr(self._value)
+        return Expression(
+            agg_expressions.WindowExpression(agg_expr, window_spec.unbound())
+        )
+
+    # alignment is purely for series compatibility, and is ignored here
+    def _apply_binary_op(
+        self,
+        other: Any,
+        op: bf_ops.BinaryOp,
+        alignment: Literal["outer", "left"] = "outer",
+        reverse: bool = False,
+    ):
         if isinstance(other, Expression):
             other_value = other._value
         else:
@@ -44,79 +66,109 @@ def _apply_binary(self, other: Any, op: bf_ops.BinaryOp, reverse: bool = False):
             return Expression(op.as_expr(self._value, other_value))
 
     def __add__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.add_op)
+        return self._apply_binary_op(other, bf_ops.add_op)
 
     def __radd__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.add_op, reverse=True)
+        return self._apply_binary_op(other, bf_ops.add_op, reverse=True)
 
     def __sub__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.sub_op)
+        return self._apply_binary_op(other, bf_ops.sub_op)
 
     def __rsub__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.sub_op, reverse=True)
+        return self._apply_binary_op(other, bf_ops.sub_op, reverse=True)
 
     def __mul__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.mul_op)
+        return self._apply_binary_op(other, bf_ops.mul_op)
 
     def __rmul__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.mul_op, reverse=True)
+        return self._apply_binary_op(other, bf_ops.mul_op, reverse=True)
 
     def __truediv__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.div_op)
+        return self._apply_binary_op(other, bf_ops.div_op)
 
     def __rtruediv__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.div_op, reverse=True)
+        return self._apply_binary_op(other, bf_ops.div_op, reverse=True)
 
     def __floordiv__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.floordiv_op)
+        return self._apply_binary_op(other, bf_ops.floordiv_op)
 
     def __rfloordiv__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.floordiv_op, reverse=True)
+        return self._apply_binary_op(other, bf_ops.floordiv_op, reverse=True)
 
     def __ge__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.ge_op)
+        return self._apply_binary_op(other, bf_ops.ge_op)
 
     def __gt__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.gt_op)
+        return self._apply_binary_op(other, bf_ops.gt_op)
 
     def __le__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.le_op)
+        return self._apply_binary_op(other, bf_ops.le_op)
 
     def __lt__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.lt_op)
+        return self._apply_binary_op(other, bf_ops.lt_op)
 
     def __eq__(self, other: object) -> Expression:  # type: ignore
-        return self._apply_binary(other, bf_ops.eq_op)
+        return self._apply_binary_op(other, bf_ops.eq_op)
 
     def __ne__(self, other: object) -> Expression:  # type: ignore
-        return self._apply_binary(other, bf_ops.ne_op)
+        return self._apply_binary_op(other, bf_ops.ne_op)
 
     def __mod__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.mod_op)
+        return self._apply_binary_op(other, bf_ops.mod_op)
 
     def __rmod__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.mod_op, reverse=True)
+        return self._apply_binary_op(other, bf_ops.mod_op, reverse=True)
 
     def __and__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.and_op)
+        return self._apply_binary_op(other, bf_ops.and_op)
 
     def __rand__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.and_op, reverse=True)
+        return self._apply_binary_op(other, bf_ops.and_op, reverse=True)
 
     def __or__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.or_op)
+        return self._apply_binary_op(other, bf_ops.or_op)
 
     def __ror__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.or_op, reverse=True)
+        return self._apply_binary_op(other, bf_ops.or_op, reverse=True)
 
     def __xor__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.xor_op)
+        return self._apply_binary_op(other, bf_ops.xor_op)
 
     def __rxor__(self, other: Any) -> Expression:
-        return self._apply_binary(other, bf_ops.xor_op, reverse=True)
+        return self._apply_binary_op(other, bf_ops.xor_op, reverse=True)
 
     def __invert__(self) -> Expression:
-        return self._apply_unary(bf_ops.invert_op)
+        return self._apply_unary_op(bf_ops.invert_op)
+
+    def sum(self) -> Expression:
+        return self._apply_unary_agg(agg_ops.sum_op)
+
+    def mean(self) -> Expression:
+        return self._apply_unary_agg(agg_ops.mean_op)
+
+    def var(self) -> Expression:
+        return self._apply_unary_agg(agg_ops.var_op)
+
+    def std(self) -> Expression:
+        return self._apply_unary_agg(agg_ops.std_op)
+
+    def min(self) -> Expression:
+        return self._apply_unary_agg(agg_ops.min_op)
+
+    def max(self) -> Expression:
+        return self._apply_unary_agg(agg_ops.max_op)
+
+    @property
+    def dt(self) -> datetimes.DatetimeSimpleMethods:
+        import bigframes.operations.datetimes as datetimes
+
+        return datetimes.DatetimeSimpleMethods(self)
+
+    @property
+    def str(self) -> strings.StringMethods:
+        import bigframes.operations.strings as strings
+
+        return strings.StringMethods(self)
 
 
 def col(col_name: Hashable) -> Expression:

bigframes/core/compile/ibis_compiler/scalar_op_registry.py

@@ -982,7 +982,9 @@ def isin_op_impl(x: ibis_types.Value, op: ops.IsInOp):
 
 @scalar_op_compiler.register_unary_op(ops.ToDatetimeOp, pass_op=True)
 def to_datetime_op_impl(x: ibis_types.Value, op: ops.ToDatetimeOp):
-    if x.type() in (ibis_dtypes.str, ibis_dtypes.Timestamp("UTC")):  # type: ignore
+    if x.type() == ibis_dtypes.Timestamp(None):  # type: ignore
+        return x  # already a timestamp, no-op
+    elif x.type() in (ibis_dtypes.str, ibis_dtypes.Timestamp("UTC")):  # type: ignore
         return x.try_cast(ibis_dtypes.Timestamp(None))  # type: ignore
     else:
         # Numerical inputs.

bigframes/core/compile/sqlglot/aggregations/unary_compiler.py

@@ -22,11 +22,11 @@
 
 from bigframes import dtypes
 from bigframes.core import window_spec
+from bigframes.core.compile.sqlglot import sql
 import bigframes.core.compile.sqlglot.aggregations.op_registration as reg
 from bigframes.core.compile.sqlglot.aggregations.windows import apply_window_if_present
 from bigframes.core.compile.sqlglot.expressions import constants
 import bigframes.core.compile.sqlglot.expressions.typed_expr as typed_expr
-import bigframes.core.compile.sqlglot.sqlglot_ir as ir
 from bigframes.operations import aggregations as agg_ops
 
 UNARY_OP_REGISTRATION = reg.OpRegistration()
@@ -157,9 +157,9 @@ def _cut_ops_w_int_bins(
     for this_bin in range(bins):
         value: sge.Expression
         if op.labels is False:
-            value = ir._literal(this_bin, dtypes.INT_DTYPE)
+            value = sql.literal(this_bin, dtypes.INT_DTYPE)
         elif isinstance(op.labels, typing.Iterable):
-            value = ir._literal(list(op.labels)[this_bin], dtypes.STRING_DTYPE)
+            value = sql.literal(list(op.labels)[this_bin], dtypes.STRING_DTYPE)
         else:
             left_adj: sge.Expression = (
                 adj if this_bin == 0 and op.right else sge.convert(0)
@@ -217,10 +217,10 @@ def _cut_ops_w_intervals(
 ) -> sge.Case:
     case_expr = sge.Case()
     for this_bin, interval in enumerate(bins):
-        left: sge.Expression = ir._literal(
+        left: sge.Expression = sql.literal(
             interval[0], dtypes.infer_literal_type(interval[0])
         )
-        right: sge.Expression = ir._literal(
+        right: sge.Expression = sql.literal(
             interval[1], dtypes.infer_literal_type(interval[1])
         )
         condition: sge.Expression
@@ -237,9 +237,9 @@ def _cut_ops_w_intervals(
 
         value: sge.Expression
         if op.labels is False:
-            value = ir._literal(this_bin, dtypes.INT_DTYPE)
+            value = sql.literal(this_bin, dtypes.INT_DTYPE)
         elif isinstance(op.labels, typing.Iterable):
-            value = ir._literal(list(op.labels)[this_bin], dtypes.STRING_DTYPE)
+            value = sql.literal(list(op.labels)[this_bin], dtypes.STRING_DTYPE)
         else:
             if op.right:
                 left_identifier = sge.Identifier(this="left_exclusive", quoted=True)
@@ -609,7 +609,7 @@ def _(
 
     # Will be null if all inputs are null. Pandas defaults to zero sum though.
     zero = pd.to_timedelta(0) if column.dtype == dtypes.TIMEDELTA_DTYPE else 0
-    return sge.func("IFNULL", expr, ir._literal(zero, column.dtype))
+    return sge.func("IFNULL", expr, sql.literal(zero, column.dtype))
 
 
 @UNARY_OP_REGISTRATION.register(agg_ops.VarOp)