fix: suppress JSONDtypeWarning in Anywidget mode and clean up progress output

bigframes/__init__.py

@@ -14,13 +14,26 @@
 
 """BigQuery DataFrames provides a DataFrame API scaled by the BigQuery engine."""
 
-from bigframes._config import option_context, options
-from bigframes._config.bigquery_options import BigQueryOptions
-from bigframes.core.global_session import close_session, get_global_session
-import bigframes.enums as enums
-import bigframes.exceptions as exceptions
-from bigframes.session import connect, Session
-from bigframes.version import __version__
+import warnings
+
+# Suppress Python version support warnings from google-cloud libraries.
+# These are particularly noisy in Colab which still uses Python 3.10.
+warnings.filterwarnings(
+    "ignore",
+    category=FutureWarning,
+    message=".*Google will stop supporting.*Python.*",
+)
+
+from bigframes._config import option_context, options  # noqa: E402
+from bigframes._config.bigquery_options import BigQueryOptions  # noqa: E402
+from bigframes.core.global_session import (  # noqa: E402
+    close_session,
+    get_global_session,
+)
+import bigframes.enums as enums  # noqa: E402
+import bigframes.exceptions as exceptions  # noqa: E402
+from bigframes.session import connect, Session  # noqa: E402
+from bigframes.version import __version__  # noqa: E402
 
 _MAGIC_NAMES = ["bqsql"]
 

bigframes/_magics.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import warnings
+
 from IPython.core import magic_arguments  # type: ignore
 from IPython.core.getipython import get_ipython
 from IPython.display import display
@@ -42,9 +44,11 @@ def _cell_magic(line, cell):
         print("Query is missing.")
         return
     pyformat_args = ipython.user_ns
-    dataframe = bigframes.pandas._read_gbq_colab(
-        cell, pyformat_args=pyformat_args, dry_run=args.dry_run
-    )
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=FutureWarning)
+        dataframe = bigframes.pandas._read_gbq_colab(
+            cell, pyformat_args=pyformat_args, dry_run=args.dry_run
+        )
     if args.destination_var:
         ipython.push({args.destination_var: dataframe})
 

bigframes/dataframe.py

@@ -332,7 +332,7 @@ def dtypes(self) -> pandas.Series:
 
     @property
     def columns(self) -> pandas.Index:
-        return self.dtypes.index
+        return self._block.column_labels
 
     @columns.setter
     def columns(self, labels: pandas.Index):

bigframes/display/anywidget.py

@@ -23,6 +23,7 @@
 import threading
 from typing import Any, Iterator, Optional
 import uuid
+import warnings
 
 import pandas as pd
 
@@ -111,23 +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):
-            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

bigframes/display/html.py

@@ -363,7 +363,13 @@ def repr_mimebundle(
 
     if opts.repr_mode == "anywidget":
         try:
-            return get_anywidget_bundle(obj, include=include, exclude=exclude)
+            with bigframes.option_context("display.progress_bar", None):
+                with warnings.catch_warnings():
+                    warnings.simplefilter(
+                        "ignore", category=bigframes.exceptions.JSONDtypeWarning
+                    )
+                    warnings.simplefilter("ignore", category=FutureWarning)
+                    return get_anywidget_bundle(obj, include=include, exclude=exclude)
         except ImportError:
             # Anywidget is an optional dependency, so warn rather than fail.
             # TODO(shuowei): When Anywidget becomes the default for all repr modes,

bigframes/formatting_helpers.py

@@ -169,7 +169,7 @@ def progress_callback(
         ):
             previous_display_html = ""
             current_display_id = str(random.random())
-            current_display = display.HTML("Starting.")
+            current_display = display.HTML("")
             display.display(
                 current_display,
                 display_id=current_display_id,
@@ -213,7 +213,8 @@ def progress_callback(
             )
     elif progress_bar == "terminal":
         if isinstance(event, bigframes.core.events.ExecutionStarted):
-            print("Starting execution.")
+            # 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)
             print(message)

bigframes/pandas/io/api.py

@@ -328,33 +328,35 @@ def _read_gbq_colab(
     if pyformat_args is None:
         pyformat_args = {}
 
-    # Only try to set the global location if it's not a dry run. We don't want
-    # to bind to a location too early. This is especially important if the query
-    # only refers to local data and not any BigQuery tables.
-    if dry_run:
-        result = _try_read_gbq_colab_sessionless_dry_run(
-            query_or_table, pyformat_args=pyformat_args
-        )
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=FutureWarning)
+
+        # Only try to set the global location if it's not a dry run. We don't want
+        # to bind to a location too early. This is especially important if the query
+        # only refers to local data and not any BigQuery tables.
+        if dry_run:
+            result = _try_read_gbq_colab_sessionless_dry_run(
+                query_or_table, pyformat_args=pyformat_args
+            )
 
-        if result is not None:
-            return result
-
-        # If we made it this far, we must have a session that has already
-        # started. That means we can safely call the "real" _read_gbq_colab,
-        # which generates slightly nicer SQL.
-    else:
-        # Delay formatting the query with the special "session-less" logic. This
-        # avoids doing unnecessary work if the session already has a location or has
-        # already started.
-        create_query = functools.partial(
-            bigframes.core.pyformat.pyformat,
-            query_or_table,
-            pyformat_args=pyformat_args,
-            dry_run=True,
-        )
-        _set_default_session_location_if_possible_deferred_query(create_query)
-        if not config.options.bigquery._session_started:
-            with warnings.catch_warnings():
+            if result is not None:
+                return result
+
+            # If we made it this far, we must have a session that has already
+            # started. That means we can safely call the "real" _read_gbq_colab,
+            # which generates slightly nicer SQL.
+        else:
+            # Delay formatting the query with the special "session-less" logic. This
+            # avoids doing unnecessary work if the session already has a location or has
+            # already started.
+            create_query = functools.partial(
+                bigframes.core.pyformat.pyformat,
+                query_or_table,
+                pyformat_args=pyformat_args,
+                dry_run=True,
+            )
+            _set_default_session_location_if_possible_deferred_query(create_query)
+            if not config.options.bigquery._session_started:
                 # Don't warning about Polars in SQL cell.
                 # Related to b/437090788.
                 try:
@@ -364,12 +366,12 @@ def _read_gbq_colab(
                 except ImportError:
                     pass  # don't fail if polars isn't available
 
-    return global_session.with_default_session(
-        bigframes.session.Session._read_gbq_colab,
-        query_or_table,
-        pyformat_args=pyformat_args,
-        dry_run=dry_run,
-    )
+        return global_session.with_default_session(
+            bigframes.session.Session._read_gbq_colab,
+            query_or_table,
+            pyformat_args=pyformat_args,
+            dry_run=dry_run,
+        )
 
 
 def read_gbq_model(model_name: str):