Merge branch 'main' into deduplicate_headers

Author: daniel-sanche

.github/workflows/unittest.yml

@@ -140,7 +140,7 @@ jobs:
           echo "All unit tests passed or were skipped"
 
   cover:
-    if: always() && !cancelled() && needs.all-tests.result == 'success'
+    if: always() && !cancelled() && needs.all-tests.result == 'success' && needs.unit.result != 'skipped'
     runs-on: ubuntu-latest
     needs:
         - all-tests

.release-please-bulk-manifest.json

@@ -54,6 +54,7 @@
   "packages/google-cloud-beyondcorp-clientgateways": "0.8.0",
   "packages/google-cloud-biglake": "0.5.0",
   "packages/google-cloud-biglake-hive": "0.3.1",
+  "packages/google-cloud-bigquery": "3.42.3",
   "packages/google-cloud-bigquery-analyticshub": "0.9.0",
   "packages/google-cloud-bigquery-biglake": "0.8.0",
   "packages/google-cloud-bigquery-connection": "1.22.0",

.release-please-individual-manifest.json

@@ -1,6 +1,6 @@
 {
-  "packages/bigframes": "2.46.0",
-  "packages/google-cloud-bigquery": "3.42.3",
+  "packages/bigframes": "2.47.0",
   "packages/google-crc32c": "1.8.0",
-  "packages/pandas-gbq": "0.35.0"
+  "packages/pandas-gbq": "0.35.0",
+  "preview-packages/google-cloud-compute": "1.51.0-preview.1"
 }

librarian.yaml

@@ -74,7 +74,7 @@ default:
     library_type: GAPIC_AUTO
 libraries:
   - name: bigframes
-    version: 2.46.0
+    version: 2.47.0
     python:
       library_type: INTEGRATION
   - name: bigquery-magics

packages/bigframes/CHANGELOG.md

@@ -4,6 +4,25 @@
 
 [1]: https://pypi.org/project/bigframes/#history
 
+## [2.47.0](https://github.com/googleapis/google-cloud-python/compare/bigframes-v2.46.0...bigframes-v2.47.0) (2026-08-03)
+
+
+### Features
+
+* **bigframes:** add ai.embed and ai.similarity to bigquery accessor ([#17927](https://github.com/googleapis/google-cloud-python/issues/17927)) ([2d1372b](https://github.com/googleapis/google-cloud-python/commit/2d1372b25b871aaebba0296f516dbbdd9ef43a37))
+
+
+### Bug Fixes
+
+* **bigframes:** fix mypy errors in _magics.py related to get_ipython ([#17979](https://github.com/googleapis/google-cloud-python/issues/17979)) ([24d955e](https://github.com/googleapis/google-cloud-python/commit/24d955e7573acf5e2941f9d10b342b171d9def24))
+* bump brace-expansion from 5.0.6 to 5.0.7 in /packages/bigframes/bigframes/display/table_widget_angular ([#17794](https://github.com/googleapis/google-cloud-python/issues/17794)) ([2df1bb5](https://github.com/googleapis/google-cloud-python/commit/2df1bb5cb53906bfc41de92c10fdb5a8920ce36f))
+* bump fast-uri from 3.1.1 to 3.1.4 in /packages/bigframes/bigframes/display/table_widget_angular ([#17828](https://github.com/googleapis/google-cloud-python/issues/17828)) ([8ce495a](https://github.com/googleapis/google-cloud-python/commit/8ce495ab51d35cc56332f27589ce33b035215abf))
+* bump hono from 4.12.16 to 4.12.31 in /packages/bigframes/bigframes/display/table_widget_angular ([#17829](https://github.com/googleapis/google-cloud-python/issues/17829)) ([6d6fa39](https://github.com/googleapis/google-cloud-python/commit/6d6fa399b1578dd6c0ed7b2284b35f6bb0922da8))
+* bump immutable from 5.1.7 to 5.1.9 in /packages/bigframes/bigframes/display/table_widget_angular ([#17830](https://github.com/googleapis/google-cloud-python/issues/17830)) ([6abb1da](https://github.com/googleapis/google-cloud-python/commit/6abb1da519e7d4acdbdd531982530047fdafe854))
+* bump postcss from 8.5.14 to 8.5.23 in /packages/bigframes/bigframes/display/table_widget_angular ([#17908](https://github.com/googleapis/google-cloud-python/issues/17908)) ([e68eb8f](https://github.com/googleapis/google-cloud-python/commit/e68eb8ff03948b4a694aca465b69543ae0be6c27))
+* bump tar from 7.5.16 to 7.5.20 in /packages/bigframes/bigframes/display/table_widget_angular ([#17793](https://github.com/googleapis/google-cloud-python/issues/17793)) ([3502d41](https://github.com/googleapis/google-cloud-python/commit/3502d4183d9864e4310b3daf063ec90be9969e25))
+* require Protobuf 6.33.5+ ([#17743](https://github.com/googleapis/google-cloud-python/issues/17743)) ([d267342](https://github.com/googleapis/google-cloud-python/commit/d26734293c23f06ccce048f7d9b0fa365e813410))
+
 ## [2.46.0](https://github.com/googleapis/google-cloud-python/compare/bigframes-v2.45.0...bigframes-v2.46.0) (2026-07-16)
 
 

packages/bigframes/bigframes/core/bytecode.py

@@ -87,18 +87,26 @@
     "POP_JUMP_BACKWARD_IF_TRUE",
 }
 
+_JUMP_IF_NONE_OPNAMES = {
+    "POP_JUMP_IF_NONE",
+    "POP_JUMP_FORWARD_IF_NONE",
+    "POP_JUMP_BACKWARD_IF_NONE",
+}
+
+_JUMP_IF_NOT_NONE_OPNAMES = {
+    "POP_JUMP_IF_NOT_NONE",
+    "POP_JUMP_FORWARD_IF_NOT_NONE",
+    "POP_JUMP_BACKWARD_IF_NOT_NONE",
+}
+
 _CONDITIONAL_JUMP_OPNAMES = (
     _JUMP_IF_FALSE_OPNAMES
     | _JUMP_IF_TRUE_OPNAMES
+    | _JUMP_IF_NONE_OPNAMES
+    | _JUMP_IF_NOT_NONE_OPNAMES
     | {
         "JUMP_IF_FALSE_OR_POP",
         "JUMP_IF_TRUE_OR_POP",
-        "POP_JUMP_IF_NONE",
-        "POP_JUMP_IF_NOT_NONE",
-        "POP_JUMP_FORWARD_IF_NONE",
-        "POP_JUMP_FORWARD_IF_NOT_NONE",
-        "POP_JUMP_BACKWARD_IF_NONE",
-        "POP_JUMP_BACKWARD_IF_NOT_NONE",
     }
 )
 
@@ -424,7 +432,10 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                         and (inst.arg & 1)
                     )
                     if is_method_lookup:
-                        if isinstance(target, py_exprs.Module):
+                        if isinstance(target, py_exprs.Module) or (
+                            isinstance(target, py_exprs.PyObject)
+                            and isinstance(target.value, type)
+                        ):
                             stack.append(_NULL)
                         else:
                             stack.append(target)
@@ -443,6 +454,66 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                         )
                     )
 
+                case "FORMAT_SIMPLE":
+                    if not stack:
+                        raise ValueError("Stack is empty")
+                    value = stack.pop()
+                    stack.append(py_exprs.Call(py_exprs.PyObject(str), (value,)))
+
+                case "CONVERT_VALUE":
+                    flags = inst.arg
+                    assert flags is not None
+                    value = stack.pop()
+                    if flags == 1:
+                        stack.append(py_exprs.Call(py_exprs.PyObject(str), (value,)))
+                    else:
+                        raise NotImplementedError(
+                            "repr() and ascii() conversions are not supported"
+                        )
+
+                case "FORMAT_VALUE":
+                    flags = inst.arg
+                    assert flags is not None
+                    if (flags & 0x04) == 0x04:
+                        stack.pop()
+                        raise NotImplementedError(
+                            "Formatting with specifier is not supported"
+                        )
+
+                    value = stack.pop()
+                    conversion = flags & 0x03
+                    if conversion == 0 or conversion == 1:
+                        stack.append(py_exprs.Call(py_exprs.PyObject(str), (value,)))
+                    else:
+                        raise NotImplementedError(
+                            "repr() and ascii() conversions are not supported"
+                        )
+
+                case "FORMAT_WITH_SPEC":
+                    raise NotImplementedError(
+                        "Formatting with specifier is not supported"
+                    )
+
+                case "BUILD_STRING":
+                    count = inst.arg
+                    assert count is not None
+                    if len(stack) < count:
+                        raise ValueError(
+                            "Stack has fewer elements than BUILD_STRING count"
+                        )
+
+                    if count == 0:
+                        stack.append(py_exprs.PyObject(""))
+                    else:
+                        strings = [stack.pop() for _ in range(count)][::-1]
+                        result = strings[0]
+                        for s in strings[1:]:
+                            result = py_exprs.Call(
+                                py_exprs.PyObject(operator.add),
+                                (result, s),
+                            )
+                        stack.append(result)
+
                 case "COPY":
                     idx = inst.arg
                     if idx is None or idx < 1 or len(stack) < idx:
@@ -533,6 +604,42 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                         )
                     )
 
+                case "IS_OP":
+                    if len(stack) < 2:
+                        raise ValueError("Stack has < 2 elements")
+                    right = stack.pop()
+                    left = stack.pop()
+                    invert = inst.arg
+
+                    def is_none_const(expr) -> bool:
+                        if isinstance(expr, py_exprs.PyObject) and expr.value is None:
+                            return True
+                        if (
+                            isinstance(expr, expression.ScalarConstantExpression)
+                            and expr.value is None
+                        ):
+                            return True
+                        return False
+
+                    if is_none_const(right):
+                        op = (
+                            generic_ops.isnull_op
+                            if not invert
+                            else generic_ops.notnull_op
+                        )
+                        stack.append(py_exprs.Call(py_exprs.PyObject(op), (left,)))
+                    elif is_none_const(left):
+                        op = (
+                            generic_ops.isnull_op
+                            if not invert
+                            else generic_ops.notnull_op
+                        )
+                        stack.append(py_exprs.Call(py_exprs.PyObject(op), (right,)))
+                    else:
+                        raise NotImplementedError(
+                            "Identity comparison (is/is not) is only supported for None"
+                        )
+
                 case "COMPARE_OP":
                     if len(stack) < 2:
                         raise ValueError("Stack has < 2 elements")
@@ -728,6 +835,53 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                     jumped = True
                     break
 
+                case name if (
+                    name in _JUMP_IF_NONE_OPNAMES or name in _JUMP_IF_NOT_NONE_OPNAMES
+                ):
+                    if not stack:
+                        raise ValueError("Stack is empty")
+                    cond_expr = stack.pop()
+                    cond_bool = py_exprs.Call(
+                        py_exprs.PyObject(generic_ops.isnull_op),
+                        (cond_expr,),
+                    )
+
+                    dest = inst.argval
+                    next_offset = next_offsets.get(inst.offset)
+
+                    if opname in _JUMP_IF_NONE_OPNAMES:
+                        not_cond_bool = py_exprs.Call(
+                            py_exprs.PyObject(operator.not_), (cond_bool,)
+                        )
+                        edge_conditions[(offset, dest)] = py_exprs.Call(
+                            py_exprs.PyObject(operator.and_),
+                            (reach_cond, cond_bool),
+                        )
+                        edge_stacks[(offset, dest)] = stack.copy()
+                        if next_offset is not None:
+                            edge_conditions[(offset, next_offset)] = py_exprs.Call(
+                                py_exprs.PyObject(operator.and_),
+                                (reach_cond, not_cond_bool),
+                            )
+                            edge_stacks[(offset, next_offset)] = stack.copy()
+                    else:  # opname in _JUMP_IF_NOT_NONE_OPNAMES
+                        not_cond_bool = py_exprs.Call(
+                            py_exprs.PyObject(operator.not_), (cond_bool,)
+                        )
+                        edge_conditions[(offset, dest)] = py_exprs.Call(
+                            py_exprs.PyObject(operator.and_),
+                            (reach_cond, not_cond_bool),
+                        )
+                        edge_stacks[(offset, dest)] = stack.copy()
+                        if next_offset is not None:
+                            edge_conditions[(offset, next_offset)] = py_exprs.Call(
+                                py_exprs.PyObject(operator.and_),
+                                (reach_cond, cond_bool),
+                            )
+                            edge_stacks[(offset, next_offset)] = stack.copy()
+                    jumped = True
+                    break
+
                 case name if name in _ALL_JUMP_OPNAMES:
                     raise ValueError(f"Unsupported jump opcode: {opname}")
 

packages/bigframes/bigframes/core/compile/polars/compiler.py

@@ -454,6 +454,54 @@ def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
             else:
                 return pl.any_horizontal(*(input.str.ends_with(pat) for pat in op.pat))
 
+        @compile_op.register(string_ops.CapitalizeOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.CapitalizeOp)
+            return (
+                input.str.slice(0, 1).str.to_uppercase()
+                + input.str.slice(1).str.to_lowercase()
+            )
+
+        @compile_op.register(string_ops.IsAlnumOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsAlnumOp)
+            return input.str.contains(r"^[a-zA-Z0-9]+$")
+
+        @compile_op.register(string_ops.IsAlphaOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsAlphaOp)
+            return input.str.contains(r"^[a-zA-Z]+$")
+
+        @compile_op.register(string_ops.IsDigitOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsDigitOp)
+            return input.str.contains(r"^[0-9]+$")
+
+        @compile_op.register(string_ops.IsSpaceOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsSpaceOp)
+            return input.str.contains(r"^\s+$")
+
+        @compile_op.register(string_ops.IsDecimalOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsDecimalOp)
+            return input.str.contains(r"^[0-9]+$")
+
+        @compile_op.register(string_ops.IsNumericOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsNumericOp)
+            return input.str.contains(r"^[0-9]+$")
+
+        @compile_op.register(string_ops.IsLowerOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsLowerOp)
+            return input.str.contains(r"[a-z]") & ~input.str.contains(r"[A-Z]")
+
+        @compile_op.register(string_ops.IsUpperOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsUpperOp)
+            return input.str.contains(r"[A-Z]") & ~input.str.contains(r"[a-z]")
+
         @compile_op.register(freq_ops.FloorDtOp)
         def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
             assert isinstance(op, freq_ops.FloorDtOp)

packages/bigframes/bigframes/core/py_expressions.py

@@ -547,6 +547,13 @@ def resolve_call(
             if fn in _CALLABLE_TO_OP:
                 op = _CALLABLE_TO_OP[fn]
                 return OpExpression(op, call.inputs)
+        elif isinstance(callable.input, PyObject) and isinstance(
+            callable.input.value, type
+        ):
+            fn = getattr(callable.input.value, attr, None)
+            if fn in python_op_maps.PYTHON_TO_BIGFRAMES:
+                op = python_op_maps.PYTHON_TO_BIGFRAMES[fn]
+                return OpExpression(op, call.inputs)
         else:
             # Method call on an expression (e.g. df.col.sum() or s.mean())
             try: