Merge branch 'shuowei-anywidget-disable-future-warnings' into shuowei-anywidget-disable-warning

# Conflicts:
#	bigframes/display/anywidget.py
#	bigframes/formatting_helpers.py

Author: shuoweil

bigframes/core/compile/polars/compiler.py

@@ -16,7 +16,6 @@
 import dataclasses
 import functools
 import itertools
-import json
 from typing import cast, Literal, Optional, Sequence, Tuple, Type, TYPE_CHECKING
 
 import pandas as pd
@@ -430,68 +429,7 @@ def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
         @compile_op.register(json_ops.JSONDecode)
         def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
             assert isinstance(op, json_ops.JSONDecode)
-            target_dtype = _bigframes_dtype_to_polars_dtype(op.to_type)
-            if op.safe:
-                # Polars does not support safe JSON decoding (returning null on failure).
-                # We use map_elements to provide safe JSON decoding.
-                def safe_decode(val):
-                    if val is None:
-                        return None
-                    try:
-                        decoded = json.loads(val)
-                    except Exception:
-                        return None
-
-                    if decoded is None:
-                        return None
-
-                    if op.to_type == bigframes.dtypes.INT_DTYPE:
-                        if type(decoded) is bool:
-                            return None
-                        if isinstance(decoded, int):
-                            return decoded
-                        if isinstance(decoded, float):
-                            if decoded.is_integer():
-                                return int(decoded)
-                        if isinstance(decoded, str):
-                            try:
-                                return int(decoded)
-                            except Exception:
-                                pass
-                        return None
-
-                    if op.to_type == bigframes.dtypes.FLOAT_DTYPE:
-                        if type(decoded) is bool:
-                            return None
-                        if isinstance(decoded, (int, float)):
-                            return float(decoded)
-                        if isinstance(decoded, str):
-                            try:
-                                return float(decoded)
-                            except Exception:
-                                pass
-                        return None
-
-                    if op.to_type == bigframes.dtypes.BOOL_DTYPE:
-                        if isinstance(decoded, bool):
-                            return decoded
-                        if isinstance(decoded, str):
-                            if decoded.lower() == "true":
-                                return True
-                            if decoded.lower() == "false":
-                                return False
-                        return None
-
-                    if op.to_type == bigframes.dtypes.STRING_DTYPE:
-                        if isinstance(decoded, str):
-                            return decoded
-                        return None
-
-                    return decoded
-
-                return input.map_elements(safe_decode, return_dtype=target_dtype)
-
-            return input.str.json_decode(target_dtype)
+            return input.str.json_decode(_DTYPE_MAPPING[op.to_type])
 
         @compile_op.register(arr_ops.ToArrayOp)
         def _(self, op: ops.ToArrayOp, *inputs: pl.Expr) -> pl.Expr:

bigframes/core/compile/polars/lowering.py

@@ -391,7 +391,7 @@ def _lower_cast(cast_op: ops.AsTypeOp, arg: expression.Expression):
         return arg
 
     if arg.output_type == dtypes.JSON_DTYPE:
-        return json_ops.JSONDecode(cast_op.to_type, safe=cast_op.safe).as_expr(arg)
+        return json_ops.JSONDecode(cast_op.to_type).as_expr(arg)
     if (
         arg.output_type == dtypes.STRING_DTYPE
         and cast_op.to_type == dtypes.DATETIME_DTYPE

bigframes/display/anywidget.py

@@ -112,26 +112,32 @@ def __init__(self, dataframe: bigframes.dataframe.DataFrame):
         self.page_size = initial_page_size
         self.max_columns = initial_max_columns
 
-        # TODO(b/469861913): Nested columns from structs (e.g., 'struct_col.name') are not currently sortable.
-        # TODO(b/463754889): Support non-string column labels for sorting.
-        if all(isinstance(col, str) for col in dataframe.columns):
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore", bigframes.exceptions.JSONDtypeWarning)
-                warnings.simplefilter("ignore", category=FutureWarning)
-                self.orderable_columns = [
-                    str(col_name)
-                    for col_name, dtype in dataframe.dtypes.items()
-                    if dtypes.is_orderable(dtype)
-                ]
-        else:
-            self.orderable_columns = []
+        self.orderable_columns = self._get_orderable_columns(dataframe)
 
         self._initial_load()
 
         # Signals to the frontend that the initial data load is complete.
         # Also used as a guard to prevent observers from firing during initialization.
         self._initial_load_complete = True
 
+    def _get_orderable_columns(
+        self, dataframe: bigframes.dataframe.DataFrame
+    ) -> list[str]:
+        """Determine which columns can be used for client-side sorting."""
+        # TODO(b/469861913): Nested columns from structs (e.g., 'struct_col.name') are not currently sortable.
+        # TODO(b/463754889): Support non-string column labels for sorting.
+        if not all(isinstance(col, str) for col in dataframe.columns):
+            return []
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", bigframes.exceptions.JSONDtypeWarning)
+            warnings.simplefilter("ignore", category=FutureWarning)
+            return [
+                str(col_name)
+                for col_name, dtype in dataframe.dtypes.items()
+                if dtypes.is_orderable(dtype)
+            ]
+
     def _initial_load(self) -> None:
         """Get initial data and row count."""
         # obtain the row counts
@@ -279,7 +285,8 @@ def _reset_batch_cache(self) -> None:
 
     def _reset_batches_for_new_page_size(self) -> None:
         """Reset the batch iterator when page size changes."""
-        self._batches = self._dataframe.to_pandas_batches(page_size=self.page_size)
+        with bigframes.option_context("display.progress_bar", None):
+            self._batches = self._dataframe.to_pandas_batches(page_size=self.page_size)
 
         self._reset_batch_cache()
 

bigframes/formatting_helpers.py

@@ -213,6 +213,7 @@ def progress_callback(
             )
     elif progress_bar == "terminal":
         if isinstance(event, bigframes.core.events.ExecutionStarted):
+            # No action needed as "Starting execution." is too noisy for terminal.
             pass
         elif isinstance(event, bigframes.core.events.BigQuerySentEvent):
             message = render_bqquery_sent_event_plaintext(event)

bigframes/operations/json_ops.py

@@ -220,7 +220,6 @@ def output_type(self, *input_types):
 class JSONDecode(base_ops.UnaryOp):
     name: typing.ClassVar[str] = "json_decode"
     to_type: dtypes.Dtype
-    safe: bool = False
 
     def output_type(self, *input_types):
         input_type = input_types[0]

bigframes/session/polars_executor.py

@@ -34,7 +34,6 @@
     numeric_ops,
     string_ops,
 )
-import bigframes.operations.json_ops as json_ops
 from bigframes.session import executor, semi_executor
 
 if TYPE_CHECKING:
@@ -95,7 +94,6 @@
     string_ops.EndsWithOp,
     string_ops.StrContainsOp,
     string_ops.StrContainsRegexOp,
-    json_ops.JSONDecode,
 )
 _COMPATIBLE_AGG_OPS = (
     agg_ops.SizeOp,