Merge branch 'main' into migrate-datetime-to-integer-label-op

Author: jialuoo

.github/workflows/js-tests.yml

@@ -0,0 +1,20 @@
+name: js-tests
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Install modules
+      working-directory: ./tests/js
+      run: npm install
+    - name: Run tests
+      working-directory: ./tests/js
+      run: npm test

.gitignore

@@ -58,6 +58,7 @@ coverage.xml
 
 # System test environment variables.
 system_tests/local_test_setup
+tests/js/node_modules/
 
 # Make sure a generated file isn't accidentally committed.
 pylintrc

.librarian/state.yaml

@@ -1,7 +1,7 @@
 image: us-central1-docker.pkg.dev/cloud-sdk-librarian-prod/images-prod/python-librarian-generator@sha256:c8612d3fffb3f6a32353b2d1abd16b61e87811866f7ec9d65b59b02eb452a620
 libraries:
   - id: bigframes
-    version: 2.28.0
+    version: 2.29.1
     apis: []
     source_roots:
       - .

README.rst

@@ -6,15 +6,25 @@ BigQuery DataFrames (BigFrames)
 |GA| |pypi| |versions|
 
 BigQuery DataFrames (also known as BigFrames) provides a Pythonic DataFrame
-and machine learning (ML) API powered by the BigQuery engine.
+and machine learning (ML) API powered by the BigQuery engine. It provides modules
+for many use cases, including:
 
-* `bigframes.pandas` provides a pandas API for analytics. Many workloads can be
+* `bigframes.pandas <https://dataframes.bigquery.dev/reference/api/bigframes.pandas.html>`_
+  is a pandas API for analytics. Many workloads can be
   migrated from pandas to bigframes by just changing a few imports.
-* ``bigframes.ml`` provides a scikit-learn-like API for ML.
+* `bigframes.ml <https://dataframes.bigquery.dev/reference/index.html#ml-apis>`_
+  is a scikit-learn-like API for ML.
+* `bigframes.bigquery.ai <https://dataframes.bigquery.dev/reference/api/bigframes.bigquery.ai.html>`_
+  are a collection of powerful AI methods, powered by Gemini.
 
-BigQuery DataFrames is an open-source package.
+BigQuery DataFrames is an `open-source package <https://github.com/googleapis/python-bigquery-dataframes>`_.
 
-**Version 2.0 introduces breaking changes for improved security and performance. See below for details.**
+.. |GA| image:: https://img.shields.io/badge/support-GA-gold.svg
+   :target: https://github.com/googleapis/google-cloud-python/blob/main/README.rst#general-availability
+.. |pypi| image:: https://img.shields.io/pypi/v/bigframes.svg
+   :target: https://pypi.org/project/bigframes/
+.. |versions| image:: https://img.shields.io/pypi/pyversions/bigframes.svg
+   :target: https://pypi.org/project/bigframes/
 
 Getting started with BigQuery DataFrames
 ----------------------------------------
@@ -38,7 +48,8 @@ To use BigFrames in your local development environment,
 
     import bigframes.pandas as bpd
 
-    bpd.options.bigquery.project = your_gcp_project_id
+    bpd.options.bigquery.project = your_gcp_project_id  # Optional in BQ Studio.
+    bpd.options.bigquery.ordering_mode = "partial"  # Recommended for performance.
     df = bpd.read_gbq("bigquery-public-data.usa_names.usa_1910_2013")
     print(
         df.groupby("name")
@@ -48,49 +59,16 @@ To use BigFrames in your local development environment,
         .to_pandas()
     )
 
-
 Documentation
 -------------
 
 To learn more about BigQuery DataFrames, visit these pages
 
 * `Introduction to BigQuery DataFrames (BigFrames) <https://cloud.google.com/bigquery/docs/bigquery-dataframes-introduction>`_
 * `Sample notebooks <https://github.com/googleapis/python-bigquery-dataframes/tree/main/notebooks>`_
-* `API reference <https://cloud.google.com/python/docs/reference/bigframes/latest/summary_overview>`_
+* `API reference <https://dataframes.bigquery.dev/>`_
 * `Source code (GitHub) <https://github.com/googleapis/python-bigquery-dataframes>`_
 
-⚠️ Warning: Breaking Changes in BigQuery DataFrames v2.0
---------------------------------------------------------
-
-Version 2.0 introduces breaking changes for improved security and performance. Key default behaviors have changed, including
-
-* **Large Results (>10GB):** The default value for ``allow_large_results`` has changed to ``False``.
-  Methods like ``to_pandas()`` will now fail if the query result's compressed data size exceeds 10GB,
-  unless large results are explicitly permitted.
-* **Remote Function Security:** The library no longer automatically lets the Compute Engine default service
-  account become the identity of the Cloud Run functions. If that is desired, it has to be indicated by passing
-  ``cloud_function_service_account="default"``. And network ingress now defaults to ``"internal-only"``.
-* **@remote_function Argument Passing:** Arguments other than ``input_types``, ``output_type``, and ``dataset``
-  to ``remote_function`` must now be passed using keyword syntax, as positional arguments are no longer supported.
-* **@udf Argument Passing:** Arguments ``dataset`` and ``name`` to ``udf`` are now mandatory.
-* **Endpoint Connections:** Automatic fallback to locational endpoints in certain regions is removed.
-* **LLM Updates (Gemini Integration):** Integrations now default to the ``gemini-2.0-flash-001`` model.
-  PaLM2 support has been removed; please migrate any existing PaLM2 usage to Gemini. **Note:** The current default
-  model will be removed in Version 3.0.
-
-**Important:** If you are not ready to adapt to these changes, please pin your dependency to a version less than 2.0
-(e.g., ``bigframes==1.42.0``) to avoid disruption.
-
-To learn about these changes and how to migrate to version 2.0, see the
-`updated introduction guide <https://cloud.google.com/bigquery/docs/bigquery-dataframes-introduction>`_.
-
-.. |GA| image:: https://img.shields.io/badge/support-GA-gold.svg
-   :target: https://github.com/googleapis/google-cloud-python/blob/main/README.rst#general-availability
-.. |pypi| image:: https://img.shields.io/pypi/v/bigframes.svg
-   :target: https://pypi.org/project/bigframes/
-.. |versions| image:: https://img.shields.io/pypi/pyversions/bigframes.svg
-   :target: https://pypi.org/project/bigframes/
-
 License
 -------
 

bigframes/_config/__init__.py

@@ -17,175 +17,24 @@
 DataFrames from this package.
 """
 
-from __future__ import annotations
-
-import copy
-from dataclasses import dataclass, field
-import threading
-from typing import Optional
-
-import bigframes_vendored.pandas._config.config as pandas_config
-
-import bigframes._config.bigquery_options as bigquery_options
-import bigframes._config.compute_options as compute_options
-import bigframes._config.display_options as display_options
-import bigframes._config.experiment_options as experiment_options
-import bigframes._config.sampling_options as sampling_options
-
-
-@dataclass
-class ThreadLocalConfig(threading.local):
-    # If unset, global settings will be used
-    bigquery_options: Optional[bigquery_options.BigQueryOptions] = None
-    # Note: use default factory instead of default instance so each thread initializes to default values
-    display_options: display_options.DisplayOptions = field(
-        default_factory=display_options.DisplayOptions
-    )
-    sampling_options: sampling_options.SamplingOptions = field(
-        default_factory=sampling_options.SamplingOptions
-    )
-    compute_options: compute_options.ComputeOptions = field(
-        default_factory=compute_options.ComputeOptions
-    )
-    experiment_options: experiment_options.ExperimentOptions = field(
-        default_factory=experiment_options.ExperimentOptions
-    )
-
-
-class Options:
-    """Global options affecting BigQuery DataFrames behavior."""
-
-    def __init__(self):
-        self.reset()
-
-    def reset(self) -> Options:
-        """Reset the option settings to defaults.
-
-        Returns:
-            bigframes._config.Options: Options object with default values.
-        """
-        self._local = ThreadLocalConfig()
-
-        # BigQuery options are special because they can only be set once per
-        # session, so we need an indicator as to whether we are using the
-        # thread-local session or the global session.
-        self._bigquery_options = bigquery_options.BigQueryOptions()
-        return self
-
-    def _init_bigquery_thread_local(self):
-        """Initialize thread-local options, based on current global options."""
-
-        # Already thread-local, so don't reset any options that have been set
-        # already. No locks needed since this only modifies thread-local
-        # variables.
-        if self._local.bigquery_options is not None:
-            return
-
-        self._local.bigquery_options = copy.deepcopy(self._bigquery_options)
-        self._local.bigquery_options._session_started = False
-
-    @property
-    def bigquery(self) -> bigquery_options.BigQueryOptions:
-        """Options to use with the BigQuery engine.
-
-        Returns:
-            bigframes._config.bigquery_options.BigQueryOptions:
-                Options for BigQuery engine.
-        """
-        if self._local.bigquery_options is not None:
-            # The only way we can get here is if someone called
-            # _init_bigquery_thread_local.
-            return self._local.bigquery_options
-
-        return self._bigquery_options
-
-    @property
-    def display(self) -> display_options.DisplayOptions:
-        """Options controlling object representation.
-
-        Returns:
-            bigframes._config.display_options.DisplayOptions:
-                Options for controlling object representation.
-        """
-        return self._local.display_options
-
-    @property
-    def sampling(self) -> sampling_options.SamplingOptions:
-        """Options controlling downsampling when downloading data
-        to memory.
-
-        The data can be downloaded into memory explicitly
-        (e.g., to_pandas, to_numpy, values) or implicitly (e.g.,
-        matplotlib plotting). This option can be overridden by
-        parameters in specific functions.
-
-        Returns:
-            bigframes._config.sampling_options.SamplingOptions:
-                Options for controlling downsampling.
-        """
-        return self._local.sampling_options
-
-    @property
-    def compute(self) -> compute_options.ComputeOptions:
-        """Thread-local options controlling object computation.
-
-        Returns:
-            bigframes._config.compute_options.ComputeOptions:
-                Thread-local options for controlling object computation
-        """
-        return self._local.compute_options
-
-    @property
-    def experiments(self) -> experiment_options.ExperimentOptions:
-        """Options controlling experiments
-
-        Returns:
-            bigframes._config.experiment_options.ExperimentOptions:
-               Thread-local options for controlling experiments
-        """
-        return self._local.experiment_options
-
-    @property
-    def is_bigquery_thread_local(self) -> bool:
-        """Indicator that we're using a thread-local session.
-
-        A thread-local session can be started by using
-        `with bigframes.option_context("bigquery.some_option", "some-value"):`.
-
-        Returns:
-            bool:
-                A boolean value, where a value is True if a thread-local session
-                is in use; otherwise False.
-        """
-        return self._local.bigquery_options is not None
-
-    @property
-    def _allow_large_results(self) -> bool:
-        """The effective 'allow_large_results' setting.
-
-        This value is `self.compute.allow_large_results` if set (not `None`),
-        otherwise it defaults to `self.bigquery.allow_large_results`.
-
-        Returns:
-            bool:
-                Whether large query results are permitted.
-                - `True`: The BigQuery result size limit (e.g., 10 GB) is removed.
-                - `False`: Results are restricted to this limit (potentially faster).
-                BigQuery will raise an error if this limit is exceeded.
-        """
-        if self.compute.allow_large_results is None:
-            return self.bigquery.allow_large_results
-        return self.compute.allow_large_results
-
-
-options = Options()
-"""Global options for default session."""
-
-option_context = pandas_config.option_context
+from bigframes._config.bigquery_options import BigQueryOptions
+from bigframes._config.compute_options import ComputeOptions
+from bigframes._config.display_options import DisplayOptions
+from bigframes._config.experiment_options import ExperimentOptions
+from bigframes._config.global_options import option_context, Options
+import bigframes._config.global_options as global_options
+from bigframes._config.sampling_options import SamplingOptions
 
+options = global_options.options
+"""Global options for the default session."""
 
 __all__ = (
     "Options",
     "options",
     "option_context",
+    "BigQueryOptions",
+    "ComputeOptions",
+    "DisplayOptions",
+    "ExperimentOptions",
+    "SamplingOptions",
 )