diff --git a/CHANGELOG.md b/CHANGELOG.md index d8befd372d..886e4f8921 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,20 @@ [1]: https://pypi.org/project/bigframes/#history +## [1.34.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v1.33.0...v1.34.0) (2025-01-27) + + +### ⚠ BREAKING CHANGES + +* Enable reading JSON data with `dbjson` extension dtype ([#1139](https://github.com/googleapis/python-bigquery-dataframes/issues/1139)) + +### Features + +* (df|s).hist(), (df|s).line(), (df|s).area(), (df|s).bar(), df.scatter() ([#1320](https://github.com/googleapis/python-bigquery-dataframes/issues/1320)) ([bd3f584](https://github.com/googleapis/python-bigquery-dataframes/commit/bd3f584a7eab5d01dedebb7ca2485942ef5b5ebe)) +* Add DataFrame.corrwith method ([#1315](https://github.com/googleapis/python-bigquery-dataframes/issues/1315)) ([b503355](https://github.com/googleapis/python-bigquery-dataframes/commit/b5033559a77a9bc5ffb7dc1e44e02aaaaf1e051e)) +* Add DataFrame.mask method ([#1302](https://github.com/googleapis/python-bigquery-dataframes/issues/1302)) ([8b8155f](https://github.com/googleapis/python-bigquery-dataframes/commit/8b8155fef9c5cd36cfabf728ccebf6a14a1cbbda)) +* Enable reading JSON data with `dbjson` extension dtype ([#1139](https://github.com/googleapis/python-bigquery-dataframes/issues/1139)) ([f672262](https://github.com/googleapis/python-bigquery-dataframes/commit/f6722629fb47eed5befb0ecae2e6b5ec9042d669)) + ## [1.33.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v1.32.0...v1.33.0) (2025-01-22) diff --git a/bigframes/bigquery/_operations/json.py b/bigframes/bigquery/_operations/json.py index 52b01d3ef7..0223811ebc 100644 --- a/bigframes/bigquery/_operations/json.py +++ b/bigframes/bigquery/_operations/json.py @@ -53,7 +53,7 @@ def json_set( >>> s = bpd.read_gbq("SELECT JSON '{\\\"a\\\": 1}' AS data")["data"] >>> bbq.json_set(s, json_path_value_pairs=[("$.a", 100), ("$.b", "hi")]) 0 {"a":100,"b":"hi"} - Name: data, dtype: large_string[pyarrow] + Name: data, dtype: dbjson Args: input (bigframes.series.Series): @@ -253,7 +253,7 @@ def parse_json( dtype: string >>> bbq.parse_json(s) 0 {"class":{"students":[{"id":5},{"id":12}]}} - dtype: large_string[pyarrow] + dtype: dbjson Args: input (bigframes.series.Series): diff --git a/bigframes/core/__init__.py b/bigframes/core/__init__.py index ee9917f619..d9bba9bdb0 100644 --- a/bigframes/core/__init__.py +++ b/bigframes/core/__init__.py @@ -108,8 +108,8 @@ def from_table( raise ValueError("must set at most one of 'offests', 'primary_key'") if any(i.field_type == "JSON" for i in table.schema if i.name in schema.names): msg = ( - "Interpreting JSON column(s) as pyarrow.large_string. " - "This behavior may change in future versions." + "Interpreting JSON column(s) as the `db_dtypes.dbjson` extension type is" + "in preview; this behavior may change in future versions." ) warnings.warn(msg, bfe.PreviewWarning) # define data source only for needed columns, this makes row-hashing cheaper @@ -405,8 +405,7 @@ def project_window_op( ArrayValue( nodes.WindowOpNode( child=self.node, - column_name=ex.deref(column_name), - op=op, + expression=ex.UnaryAggregation(op, ex.deref(column_name)), window_spec=window_spec, output_name=ids.ColumnId(output_name), never_skip_nulls=never_skip_nulls, diff --git a/bigframes/core/blocks.py b/bigframes/core/blocks.py index afc03dbdea..727ee013f8 100644 --- a/bigframes/core/blocks.py +++ b/bigframes/core/blocks.py @@ -2152,7 +2152,7 @@ def merge( def _align_both_axes( self, other: Block, how: str - ) -> Tuple[Block, pd.Index, Sequence[Tuple[ex.Expression, ex.Expression]]]: + ) -> Tuple[Block, pd.Index, Sequence[Tuple[ex.RefOrConstant, ex.RefOrConstant]]]: # Join rows aligned_block, (get_column_left, get_column_right) = self.join(other, how=how) # join columns schema @@ -2161,7 +2161,7 @@ def _align_both_axes( columns, lcol_indexer, rcol_indexer = self.column_labels, None, None else: columns, lcol_indexer, rcol_indexer = self.column_labels.join( - other.column_labels, how="outer", return_indexers=True + other.column_labels, how=how, return_indexers=True ) lcol_indexer = ( lcol_indexer if (lcol_indexer is not None) else range(len(columns)) @@ -2183,11 +2183,11 @@ def _align_both_axes( left_inputs = [left_input_lookup(i) for i in lcol_indexer] right_inputs = [righ_input_lookup(i) for i in rcol_indexer] - return aligned_block, columns, tuple(zip(left_inputs, right_inputs)) + return aligned_block, columns, tuple(zip(left_inputs, right_inputs)) # type: ignore def _align_axis_0( self, other: Block, how: str - ) -> Tuple[Block, pd.Index, Sequence[Tuple[ex.Expression, ex.Expression]]]: + ) -> Tuple[Block, pd.Index, Sequence[Tuple[ex.DerefOp, ex.DerefOp]]]: assert len(other.value_columns) == 1 aligned_block, (get_column_left, get_column_right) = self.join(other, how=how) @@ -2203,7 +2203,7 @@ def _align_axis_0( def _align_series_block_axis_1( self, other: Block, how: str - ) -> Tuple[Block, pd.Index, Sequence[Tuple[ex.Expression, ex.Expression]]]: + ) -> Tuple[Block, pd.Index, Sequence[Tuple[ex.RefOrConstant, ex.RefOrConstant]]]: assert len(other.value_columns) == 1 if other._transpose_cache is None: raise ValueError( @@ -2244,11 +2244,11 @@ def _align_series_block_axis_1( left_inputs = [left_input_lookup(i) for i in lcol_indexer] right_inputs = [righ_input_lookup(i) for i in rcol_indexer] - return aligned_block, columns, tuple(zip(left_inputs, right_inputs)) + return aligned_block, columns, tuple(zip(left_inputs, right_inputs)) # type: ignore def _align_pd_series_axis_1( self, other: pd.Series, how: str - ) -> Tuple[Block, pd.Index, Sequence[Tuple[ex.Expression, ex.Expression]]]: + ) -> Tuple[Block, pd.Index, Sequence[Tuple[ex.RefOrConstant, ex.RefOrConstant]]]: if self.column_labels.equals(other.index): columns, lcol_indexer, rcol_indexer = self.column_labels, None, None else: @@ -2275,7 +2275,7 @@ def _align_pd_series_axis_1( left_inputs = [left_input_lookup(i) for i in lcol_indexer] right_inputs = [righ_input_lookup(i) for i in rcol_indexer] - return self, columns, tuple(zip(left_inputs, right_inputs)) + return self, columns, tuple(zip(left_inputs, right_inputs)) # type: ignore def _apply_binop( self, diff --git a/bigframes/core/compile/aggregate_compiler.py b/bigframes/core/compile/aggregate_compiler.py index f97856efa5..7a018a662e 100644 --- a/bigframes/core/compile/aggregate_compiler.py +++ b/bigframes/core/compile/aggregate_compiler.py @@ -479,10 +479,9 @@ def _( return _apply_window_if_present(column.dense_rank(), window) + 1 -@compile_unary_agg.register +@compile_nullary_agg.register def _( op: agg_ops.RowNumberOp, - column: ibis_types.Column, window=None, ) -> ibis_types.IntegerValue: return _apply_window_if_present(ibis_api.row_number(), window) diff --git a/bigframes/core/compile/compiled.py b/bigframes/core/compile/compiled.py index 526826495e..15805a38fc 100644 --- a/bigframes/core/compile/compiled.py +++ b/bigframes/core/compile/compiled.py @@ -40,7 +40,6 @@ from bigframes.core.ordering import ( ascending_over, encode_order_string, - join_orderings, OrderingExpression, RowOrdering, TotalOrdering, @@ -420,50 +419,6 @@ def _uniform_sampling(self, fraction: float) -> UnorderedIR: columns=columns, ) - def explode(self, columns: typing.Sequence[ex.DerefOp]) -> UnorderedIR: - table = self._to_ibis_expr() - column_ids = tuple(ref.id.sql for ref in columns) - - # The offset array ensures null represents empty arrays after unnesting. - offset_array_id = bigframes.core.guid.generate_guid("offset_array_") - offset_array = bigframes_vendored.ibis.range( - 0, - bigframes_vendored.ibis.greatest( - 1, # We always want at least 1 element to fill in NULLs for empty arrays. - bigframes_vendored.ibis.least( - *[table[column_id].length() for column_id in column_ids] - ), - ), - 1, - ).name(offset_array_id) - table_w_offset_array = table.select( - offset_array, - *self._column_names, - ) - - unnest_offset_id = bigframes.core.guid.generate_guid("unnest_offset_") - unnest_offset = ( - table_w_offset_array[offset_array_id].unnest().name(unnest_offset_id) - ) - table_w_offset = table_w_offset_array.select( - unnest_offset, - *self._column_names, - ) - - unnested_columns = [ - table_w_offset[column_id][table_w_offset[unnest_offset_id]].name(column_id) - if column_id in column_ids - else table_w_offset[column_id] - for column_id in self._column_names - ] - table_w_unnest = table_w_offset.select(*unnested_columns) - - columns = [table_w_unnest[column_name] for column_name in self._column_names] - return UnorderedIR( - table_w_unnest, - columns=columns, # type: ignore - ) - def as_ordered_ir(self) -> OrderedIR: """Convert to OrderedIr, but without any definite ordering.""" return OrderedIR(self._table, self._columns, predicates=self._predicates) @@ -746,77 +701,6 @@ def _uniform_sampling(self, fraction: float) -> OrderedIR: ordering=self._ordering, ) - def explode(self, columns: typing.Sequence[ex.DerefOp]) -> OrderedIR: - if self.order_non_deterministic: - id = bigframes.core.guid.generate_guid() - return self.promote_offsets(id) - table = self._to_ibis_expr(ordering_mode="unordered", expose_hidden_cols=True) - column_ids = tuple(ref.id.sql for ref in columns) - - offset_array_id = bigframes.core.guid.generate_guid("offset_array_") - offset_array = bigframes_vendored.ibis.range( - 0, - bigframes_vendored.ibis.greatest( - 1, # We always want at least 1 element to fill in NULLs for empty arrays. - bigframes_vendored.ibis.least( - *[table[column_id].length() for column_id in column_ids] - ), - ), - 1, - ).name(offset_array_id) - table_w_offset_array = table.select( - offset_array, - *self._column_names, - *self._hidden_ordering_column_names, - ) - - unnest_offset_id = bigframes.core.guid.generate_guid("unnest_offset_") - unnest_offset = ( - table_w_offset_array[offset_array_id].unnest().name(unnest_offset_id) - ) - table_w_offset = table_w_offset_array.select( - unnest_offset, - *self._column_names, - *self._hidden_ordering_column_names, - ) - - unnested_columns = [ - table_w_offset[column_id][table_w_offset[unnest_offset_id]].name(column_id) - if column_id in column_ids - else table_w_offset[column_id] - for column_id in self._column_names - ] - - table_w_unnest = table_w_offset.select( - table_w_offset[unnest_offset_id], - *unnested_columns, - *self._hidden_ordering_column_names, - ) - - columns = [table_w_unnest[column_name] for column_name in self._column_names] - hidden_ordering_columns = [ - *[ - table_w_unnest[column_name] - for column_name in self._hidden_ordering_column_names - ], - table_w_unnest[unnest_offset_id], - ] - l_mappings = {id: id for id in self._ordering.referenced_columns} - r_mappings = {ids.ColumnId(unnest_offset_id): ids.ColumnId(unnest_offset_id)} - ordering = join_orderings( - self._ordering, - TotalOrdering.from_offset_col(unnest_offset_id), - l_mappings, - r_mappings, - ) - - return OrderedIR( - table_w_unnest, - columns=columns, # type: ignore - hidden_ordering_columns=hidden_ordering_columns, - ordering=ordering, - ) - def promote_offsets(self, col_id: str) -> OrderedIR: """ Convenience function to promote copy of column offsets to a value column. Can be used to reset index. @@ -861,8 +745,7 @@ def promote_offsets(self, col_id: str) -> OrderedIR: ## Methods that only work with ordering def project_window_op( self, - column_name: ex.DerefOp, - op: agg_ops.UnaryWindowOp, + expression: ex.Aggregation, window_spec: WindowSpec, output_name: str, *, @@ -881,8 +764,11 @@ def project_window_op( # See: https://github.com/ibis-project/ibis/issues/9773 used_exprs = map( self._compile_expression, - itertools.chain( - (column_name,), map(ex.DerefOp, window_spec.all_referenced_columns) + map( + ex.DerefOp, + itertools.chain( + expression.column_references, window_spec.all_referenced_columns + ), ), ) can_directly_window = not any( @@ -890,44 +776,54 @@ def project_window_op( ) if not can_directly_window: return self._reproject_to_table().project_window_op( - column_name, - op, + expression, window_spec, output_name, never_skip_nulls=never_skip_nulls, ) - column = typing.cast(ibis_types.Column, self._compile_expression(column_name)) window = self._ibis_window_from_spec( - window_spec, require_total_order=op.uses_total_row_ordering + window_spec, require_total_order=expression.op.uses_total_row_ordering ) bindings = {col: self._get_ibis_column(col) for col in self.column_ids} window_op = agg_compiler.compile_analytic( - ex.UnaryAggregation(op, column_name), + expression, window, bindings=bindings, ) + inputs = tuple( + typing.cast(ibis_types.Column, self._compile_expression(ex.DerefOp(column))) + for column in expression.column_references + ) clauses = [] - if op.skips_nulls and not never_skip_nulls: - clauses.append((column.isnull(), ibis_types.null())) - if window_spec.min_periods: - if op.skips_nulls: + if expression.op.skips_nulls and not never_skip_nulls: + for column in inputs: + clauses.append((column.isnull(), ibis_types.null())) + if window_spec.min_periods and len(inputs) > 0: + if expression.op.skips_nulls: # Most operations do not count NULL values towards min_periods + per_col_does_count = (column.notnull() for column in inputs) + # All inputs must be non-null for observation to count + is_observation = functools.reduce( + lambda x, y: x & y, per_col_does_count + ).cast(int) observation_count = agg_compiler.compile_analytic( - ex.UnaryAggregation(agg_ops.count_op, column_name), + ex.UnaryAggregation(agg_ops.sum_op, ex.deref("_observation_count")), window, - bindings=bindings, + bindings={"_observation_count": is_observation}, ) else: # Operations like count treat even NULLs as valid observations for the sake of min_periods # notnull is just used to convert null values to non-null (FALSE) values to be counted - denulled_value = typing.cast(ibis_types.BooleanColumn, column.notnull()) + is_observation = inputs[0].notnull() observation_count = agg_compiler.compile_analytic( - ex.UnaryAggregation(agg_ops.count_op, ex.deref("_denulled")), + ex.UnaryAggregation( + agg_ops.count_op, ex.deref("_observation_count") + ), window, - bindings={**bindings, "_denulled": denulled_value}, + bindings={"_observation_count": is_observation}, ) clauses.append( ( diff --git a/bigframes/core/compile/compiler.py b/bigframes/core/compile/compiler.py index 9e87b4b4e8..6f47d198c5 100644 --- a/bigframes/core/compile/compiler.py +++ b/bigframes/core/compile/compiler.py @@ -26,6 +26,7 @@ import bigframes.core.compile.compiled as compiled import bigframes.core.compile.concat as concat_impl +import bigframes.core.compile.explode import bigframes.core.compile.ibis_types import bigframes.core.compile.scalar_op_compiler import bigframes.core.compile.scalar_op_compiler as compile_scalar @@ -364,8 +365,7 @@ def compile_aggregate(self, node: nodes.AggregateNode, ordered: bool = True): @_compile_node.register def compile_window(self, node: nodes.WindowOpNode, ordered: bool = True): result = self.compile_ordered_ir(node.child).project_window_op( - node.column_name, - node.op, + node.expression, node.window_spec, node.output_name.sql, never_skip_nulls=node.never_skip_nulls, @@ -374,7 +374,15 @@ def compile_window(self, node: nodes.WindowOpNode, ordered: bool = True): @_compile_node.register def compile_explode(self, node: nodes.ExplodeNode, ordered: bool = True): - return self.compile_node(node.child, ordered).explode(node.column_ids) + offsets_col = node.offsets_col.sql if (node.offsets_col is not None) else None + if ordered: + return bigframes.core.compile.explode.explode_ordered( + self.compile_ordered_ir(node.child), node.column_ids, offsets_col + ) + else: + return bigframes.core.compile.explode.explode_unordered( + self.compile_unordered_ir(node.child), node.column_ids, offsets_col + ) @_compile_node.register def compile_random_sample(self, node: nodes.RandomSampleNode, ordered: bool = True): diff --git a/bigframes/core/compile/explode.py b/bigframes/core/compile/explode.py new file mode 100644 index 0000000000..0dfc129810 --- /dev/null +++ b/bigframes/core/compile/explode.py @@ -0,0 +1,151 @@ +# Copyright 2023 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from __future__ import annotations + +import typing + +import bigframes_vendored.ibis + +import bigframes.core.compile.compiled as compiled +import bigframes.core.expression as ex +import bigframes.core.guid +import bigframes.core.identifiers as ids +import bigframes.core.ordering +from bigframes.core.ordering import TotalOrdering + + +def explode_unordered( + input: compiled.UnorderedIR, + columns: typing.Sequence[ex.DerefOp], + offsets_id: typing.Optional[str], +) -> compiled.UnorderedIR: + table = input._to_ibis_expr() + column_ids = tuple(ref.id.sql for ref in columns) + + # The offset array ensures null represents empty arrays after unnesting. + offset_array_id = bigframes.core.guid.generate_guid("offset_array_") + offset_array = bigframes_vendored.ibis.range( + 0, + bigframes_vendored.ibis.greatest( + 1, # We always want at least 1 element to fill in NULLs for empty arrays. + bigframes_vendored.ibis.least( + *[table[column_id].length() for column_id in column_ids] + ), + ), + 1, + ).name(offset_array_id) + table_w_offset_array = table.select( + offset_array, + *input._column_names, + ) + + unnest_offset_id = offsets_id or bigframes.core.guid.generate_guid("unnest_offset_") + unnest_offset = ( + table_w_offset_array[offset_array_id].unnest().name(unnest_offset_id) + ) + table_w_offset = table_w_offset_array.select( + unnest_offset, + *input._column_names, + ) + + output_cols = tuple(input.column_ids) + ((offsets_id,) if offsets_id else ()) + unnested_columns = [ + table_w_offset[column_id][table_w_offset[unnest_offset_id]].name(column_id) + if column_id in column_ids + else table_w_offset[column_id] + for column_id in output_cols + ] + table_w_unnest = table_w_offset.select(*unnested_columns) + + columns = [table_w_unnest[column_name] for column_name in output_cols] + return compiled.UnorderedIR( + table_w_unnest, + columns=columns, # type: ignore + ) + + +def explode_ordered( + input: compiled.OrderedIR, + columns: typing.Sequence[ex.DerefOp], + offsets_id: typing.Optional[str], +) -> compiled.OrderedIR: + if input.order_non_deterministic: + id = bigframes.core.guid.generate_guid() + return input.promote_offsets(id) + table = input._to_ibis_expr(ordering_mode="unordered", expose_hidden_cols=True) + column_ids = tuple(ref.id.sql for ref in columns) + + offset_array_id = bigframes.core.guid.generate_guid("offset_array_") + offset_array = bigframes_vendored.ibis.range( + 0, + bigframes_vendored.ibis.greatest( + 1, # We always want at least 1 element to fill in NULLs for empty arrays. + bigframes_vendored.ibis.least( + *[table[column_id].length() for column_id in column_ids] + ), + ), + 1, + ).name(offset_array_id) + table_w_offset_array = table.select( + offset_array, + *input._column_names, + *input._hidden_ordering_column_names, + ) + + unnest_offset_id = offsets_id or bigframes.core.guid.generate_guid("unnest_offset_") + unnest_offset = ( + table_w_offset_array[offset_array_id].unnest().name(unnest_offset_id) + ) + table_w_offset = table_w_offset_array.select( + unnest_offset, + *input._column_names, + *input._hidden_ordering_column_names, + ) + + unnested_columns = [ + table_w_offset[column_id][table_w_offset[unnest_offset_id]].name(column_id) + if column_id in column_ids + else table_w_offset[column_id] + for column_id in input._column_names + ] + + table_w_unnest = table_w_offset.select( + table_w_offset[unnest_offset_id], + *unnested_columns, + *input._hidden_ordering_column_names, + ) + + output_cols = tuple(input.column_ids) + ((offsets_id,) if offsets_id else ()) + columns = [table_w_unnest[column_name] for column_name in output_cols] + hidden_ordering_columns = [ + table_w_unnest[column_name] + for column_name in input._hidden_ordering_column_names + ] + if offsets_id is None: + hidden_ordering_columns.append(table_w_unnest[unnest_offset_id]) + l_mappings = {id: id for id in input._ordering.referenced_columns} + r_mappings = {ids.ColumnId(unnest_offset_id): ids.ColumnId(unnest_offset_id)} + ordering = bigframes.core.ordering.join_orderings( + input._ordering, + TotalOrdering.from_offset_col(unnest_offset_id), + l_mappings, + r_mappings, + ) + + return compiled.OrderedIR( + table_w_unnest, + columns=columns, # type: ignore + hidden_ordering_columns=hidden_ordering_columns, + ordering=ordering, + ) diff --git a/bigframes/core/compile/ibis_types.py b/bigframes/core/compile/ibis_types.py index 18f0834903..e5d637e426 100644 --- a/bigframes/core/compile/ibis_types.py +++ b/bigframes/core/compile/ibis_types.py @@ -16,7 +16,6 @@ import textwrap import typing from typing import Any, cast, Dict, Iterable, Optional, Tuple, Union -import warnings import bigframes_vendored.constants as constants import bigframes_vendored.ibis @@ -26,6 +25,7 @@ dtype as python_type_to_ibis_type, ) import bigframes_vendored.ibis.expr.types as ibis_types +import db_dtypes # type: ignore import geopandas as gpd # type: ignore import google.cloud.bigquery as bigquery import numpy as np @@ -33,7 +33,6 @@ import pyarrow as pa import bigframes.dtypes -import bigframes.exceptions as bfe # Type hints for Ibis data types supported by BigQuery DataFrame IbisDtype = Union[ @@ -76,12 +75,13 @@ ibis_dtypes.GeoSpatial(geotype="geography", srid=4326, nullable=True), gpd.array.GeometryDtype(), ), - (ibis_dtypes.json, pd.ArrowDtype(pa.large_string())), + (ibis_dtypes.json, db_dtypes.JSONDtype()), ) BIGFRAMES_TO_IBIS: Dict[bigframes.dtypes.Dtype, ibis_dtypes.DataType] = { pandas: ibis for ibis, pandas in BIDIRECTIONAL_MAPPINGS } +BIGFRAMES_TO_IBIS.update({bigframes.dtypes.TIMEDETLA_DTYPE: ibis_dtypes.int64}) IBIS_TO_BIGFRAMES: Dict[ibis_dtypes.DataType, bigframes.dtypes.Dtype] = { ibis: pandas for ibis, pandas in BIDIRECTIONAL_MAPPINGS } @@ -305,13 +305,7 @@ def ibis_dtype_to_bigframes_dtype( if isinstance(ibis_dtype, ibis_dtypes.Integer): return pd.Int64Dtype() - # Temporary: Will eventually support an explicit json type instead of casting to string. if isinstance(ibis_dtype, ibis_dtypes.JSON): - msg = ( - "Interpreting JSON column(s) as pyarrow.large_string. This behavior may change " - "in future versions." - ) - warnings.warn(msg, category=bfe.PreviewWarning) return bigframes.dtypes.JSON_DTYPE if ibis_dtype in IBIS_TO_BIGFRAMES: diff --git a/bigframes/core/compile/polars/compiler.py b/bigframes/core/compile/polars/compiler.py index 7d8d54a7f0..6d5b11a5e8 100644 --- a/bigframes/core/compile/polars/compiler.py +++ b/bigframes/core/compile/polars/compiler.py @@ -16,7 +16,7 @@ import dataclasses import functools import itertools -from typing import cast, Sequence, TYPE_CHECKING +from typing import cast, Sequence, Tuple, TYPE_CHECKING import bigframes.core import bigframes.core.expression as ex @@ -125,6 +125,24 @@ def get_args( f"Aggregation {agg} not yet supported in polars engine." ) + def compile_agg_expr(self, expr: ex.Aggregation): + if isinstance(expr, ex.NullaryAggregation): + inputs: Tuple = () + elif isinstance(expr, ex.UnaryAggregation): + assert isinstance(expr.arg, ex.DerefOp) + inputs = (expr.arg.id.sql,) + elif isinstance(expr, ex.BinaryAggregation): + assert isinstance(expr.left, ex.DerefOp) + assert isinstance(expr.right, ex.DerefOp) + inputs = ( + expr.left.id.sql, + expr.right.id.sql, + ) + else: + raise ValueError(f"Unexpected aggregation: {expr.op}") + + return self.compile_agg_op(expr.op, inputs) + def compile_agg_op(self, op: agg_ops.WindowOp, inputs: Sequence[str] = []): if isinstance(op, agg_ops.ProductOp): # TODO: Need schema to cast back to original type if posisble (eg float back to int) @@ -320,9 +338,9 @@ def compile_sample(self, node: nodes.RandomSampleNode): @compile_node.register def compile_window(self, node: nodes.WindowOpNode): df = self.compile_node(node.child) - agg_expr = self.agg_compiler.compile_agg_op( - node.op, [node.column_name.id.sql] - ).alias(node.output_name.sql) + agg_expr = self.agg_compiler.compile_agg_expr(node.expression).alias( + node.output_name.sql + ) # Three window types: completely unbound, grouped and row bounded window = node.window_spec diff --git a/bigframes/core/compile/scalar_op_compiler.py b/bigframes/core/compile/scalar_op_compiler.py index 4f670b51ca..b42f983619 100644 --- a/bigframes/core/compile/scalar_op_compiler.py +++ b/bigframes/core/compile/scalar_op_compiler.py @@ -1140,6 +1140,13 @@ def to_timestamp_op_impl(x: ibis_types.Value, op: ops.ToTimestampOp): return x.cast(ibis_dtypes.Timestamp(timezone="UTC")) +@scalar_op_compiler.register_unary_op(ops.ToTimedeltaOp, pass_op=True) +def to_timedelta_op_impl(x: ibis_types.Value, op: ops.ToTimedeltaOp): + return ( + typing.cast(ibis_types.NumericValue, x) * UNIT_TO_US_CONVERSION_FACTORS[op.unit] # type: ignore + ).floor() + + @scalar_op_compiler.register_unary_op(ops.RemoteFunctionOp, pass_op=True) def remote_function_op_impl(x: ibis_types.Value, op: ops.RemoteFunctionOp): ibis_node = getattr(op.func, "ibis_node", None) @@ -1188,34 +1195,33 @@ def array_slice_op_impl(x: ibis_types.Value, op: ops.ArraySliceOp): # JSON Ops @scalar_op_compiler.register_binary_op(ops.JSONSet, pass_op=True) def json_set_op_impl(x: ibis_types.Value, y: ibis_types.Value, op: ops.JSONSet): - if x.type().is_json(): - return json_set( - json_obj=x, - json_path=op.json_path, - json_value=y, - ) - else: - # Enabling JSON type eliminates the need for less efficient string conversions. - return to_json_string( - json_set( # type: ignore - json_obj=parse_json(json_str=x), - json_path=op.json_path, - json_value=y, - ) - ) + return json_set(json_obj=x, json_path=op.json_path, json_value=y) @scalar_op_compiler.register_unary_op(ops.JSONExtract, pass_op=True) def json_extract_op_impl(x: ibis_types.Value, op: ops.JSONExtract): - if x.type().is_json(): - return json_extract(json_obj=x, json_path=op.json_path) - # json string - return json_extract_string(json_obj=x, json_path=op.json_path) + # Define a user-defined function whose returned type is dynamically matching the input. + def json_extract(json_or_json_string, json_path: ibis_dtypes.str): # type: ignore + """Extracts a JSON value and converts it to a SQL JSON-formatted STRING or JSON value.""" + ... + + return_type = x.type() + json_extract.__annotations__["return"] = return_type + json_extract_op = ibis_udf.scalar.builtin(json_extract) + return json_extract_op(json_or_json_string=x, json_path=op.json_path) @scalar_op_compiler.register_unary_op(ops.JSONExtractArray, pass_op=True) def json_extract_array_op_impl(x: ibis_types.Value, op: ops.JSONExtractArray): - return json_extract_array(json_obj=x, json_path=op.json_path) + # Define a user-defined function whose returned type is dynamically matching the input. + def json_extract_array(json_or_json_string, json_path: ibis_dtypes.str): # type: ignore + """Extracts a JSON value and converts it to a SQL JSON-formatted STRING or JSON value.""" + ... + + return_type = x.type() + json_extract_array.__annotations__["return"] = ibis_dtypes.Array[return_type] # type: ignore + json_extract_op = ibis_udf.scalar.builtin(json_extract_array) + return json_extract_op(json_or_json_string=x, json_path=op.json_path) @scalar_op_compiler.register_unary_op(ops.JSONExtractStringArray, pass_op=True) @@ -1937,27 +1943,6 @@ def json_set( # type: ignore[empty-body] """Produces a new SQL JSON value with the specified JSON data inserted or replaced.""" -@ibis_udf.scalar.builtin(name="json_extract") -def json_extract( # type: ignore[empty-body] - json_obj: ibis_dtypes.JSON, json_path: ibis_dtypes.String -) -> ibis_dtypes.JSON: - """Extracts a JSON value and converts it to a JSON value.""" - - -@ibis_udf.scalar.builtin(name="json_extract") -def json_extract_string( # type: ignore[empty-body] - json_obj: ibis_dtypes.String, json_path: ibis_dtypes.String -) -> ibis_dtypes.String: - """Extracts a JSON SRING value and converts it to a SQL JSON-formatted STRING.""" - - -@ibis_udf.scalar.builtin(name="json_extract_array") -def json_extract_array( # type: ignore[empty-body] - json_obj: ibis_dtypes.JSON, json_path: ibis_dtypes.String -) -> ibis_dtypes.Array[ibis_dtypes.String]: - """Extracts a JSON array and converts it to a SQL ARRAY of JSON-formatted STRINGs or JSON values.""" - - @ibis_udf.scalar.builtin(name="json_extract_string_array") def json_extract_string_array( # type: ignore[empty-body] json_obj: ibis_dtypes.JSON, json_path: ibis_dtypes.String diff --git a/bigframes/core/expression.py b/bigframes/core/expression.py index 2d561657cb..9173bebfc4 100644 --- a/bigframes/core/expression.py +++ b/bigframes/core/expression.py @@ -420,3 +420,6 @@ def deterministic(self) -> bool: return ( all(input.deterministic for input in self.inputs) and self.op.deterministic ) + + +RefOrConstant = Union[DerefOp, ScalarConstantExpression] diff --git a/bigframes/core/nodes.py b/bigframes/core/nodes.py index fe79da2bf6..d5083c3737 100644 --- a/bigframes/core/nodes.py +++ b/bigframes/core/nodes.py @@ -33,7 +33,6 @@ import bigframes.core.slices as slices import bigframes.core.window_spec as window import bigframes.dtypes -import bigframes.operations.aggregations as agg_ops if typing.TYPE_CHECKING: import bigframes.core.ordering as orderings @@ -660,16 +659,24 @@ class ScanList: @dataclasses.dataclass(frozen=True, eq=False) class ReadLocalNode(LeafNode): + # TODO: Combine feather_bytes, data_schema, n_rows into a LocalDataDef struct feather_bytes: bytes data_schema: schemata.ArraySchema n_rows: int # Mapping of local ids to bfet id. scan_list: ScanList + # Offsets are generated only if this is non-null + offsets_col: Optional[bigframes.core.identifiers.ColumnId] = None session: typing.Optional[bigframes.session.Session] = None @property def fields(self) -> Iterable[Field]: - return (Field(col_id, dtype) for col_id, dtype, _ in self.scan_list.items) + fields = (Field(col_id, dtype) for col_id, dtype, _ in self.scan_list.items) + if self.offsets_col is not None: + return itertools.chain( + fields, (Field(self.offsets_col, bigframes.dtypes.INT_DTYPE),) + ) + return fields @property def variables_introduced(self) -> int: @@ -698,7 +705,7 @@ def row_count(self) -> typing.Optional[int]: @property def node_defined_ids(self) -> Tuple[bfet_ids.ColumnId, ...]: - return tuple(item.id for item in self.scan_list.items) + return tuple(item.id for item in self.fields) def prune(self, used_cols: COLUMN_SET) -> BigFrameNode: # Don't preoduce empty scan list no matter what, will result in broken sql syntax @@ -712,6 +719,7 @@ def prune(self, used_cols: COLUMN_SET) -> BigFrameNode: self.data_schema, self.n_rows, new_scan_list, + self.offsets_col, self.session, ) @@ -724,7 +732,14 @@ def remap_vars( for item in self.scan_list.items ) ) - return dataclasses.replace(self, scan_list=new_scan_list) + new_offsets_col = ( + mappings.get(self.offsets_col, self.offsets_col) + if (self.offsets_col is not None) + else None + ) + return dataclasses.replace( + self, scan_list=new_scan_list, offsets_col=new_offsets_col + ) def remap_refs(self, mappings: Mapping[bfet_ids.ColumnId, bfet_ids.ColumnId]): return self @@ -1325,8 +1340,7 @@ def remap_refs(self, mappings: Mapping[bfet_ids.ColumnId, bfet_ids.ColumnId]): @dataclasses.dataclass(frozen=True, eq=False) class WindowOpNode(UnaryNode): - column_name: ex.DerefOp - op: agg_ops.UnaryWindowOp + expression: ex.Aggregation window_spec: window.WindowSpec output_name: bigframes.core.identifiers.ColumnId never_skip_nulls: bool = False @@ -1334,7 +1348,7 @@ class WindowOpNode(UnaryNode): def _validate(self): """Validate the local data in the node.""" - assert self.column_name.id in self.child.ids + assert all(ref in self.child.ids for ref in self.expression.column_references) @property def non_local(self) -> bool: @@ -1363,9 +1377,11 @@ def row_count(self) -> Optional[int]: @functools.cached_property def added_field(self) -> Field: - input_type = self.child.get_type(self.column_name.id) - new_item_dtype = self.op.output_type(input_type) - return Field(self.output_name, new_item_dtype) + input_types = self.child._dtype_lookup + return Field( + self.output_name, + bigframes.dtypes.dtype_for_etype(self.expression.output_type(input_types)), + ) @property def node_defined_ids(self) -> Tuple[bfet_ids.ColumnId, ...]: @@ -1376,7 +1392,7 @@ def prune(self, used_cols: COLUMN_SET) -> BigFrameNode: return self.child.prune(used_cols) consumed_ids = ( used_cols.difference([self.output_name]) - .union([self.column_name.id]) + .union(self.expression.column_references) .union(self.window_spec.all_referenced_columns) ) return self.transform_children(lambda x: x.prune(consumed_ids)) @@ -1391,7 +1407,7 @@ def remap_vars( def remap_refs(self, mappings: Mapping[bfet_ids.ColumnId, bfet_ids.ColumnId]): return dataclasses.replace( self, - column_name=self.column_name.remap_column_refs( + expression=self.expression.remap_column_refs( mappings, allow_partial_bindings=True ), window_spec=self.window_spec.remap_column_refs( @@ -1439,6 +1455,8 @@ def remap_refs( @dataclasses.dataclass(frozen=True, eq=False) class ExplodeNode(UnaryNode): column_ids: typing.Tuple[ex.DerefOp, ...] + # Offsets are generated only if this is non-null + offsets_col: Optional[bigframes.core.identifiers.ColumnId] = None @property def row_preserving(self) -> bool: @@ -1446,7 +1464,7 @@ def row_preserving(self) -> bool: @property def fields(self) -> Iterable[Field]: - return ( + fields = ( Field( field.id, bigframes.dtypes.arrow_dtype_to_bigframes_dtype( @@ -1457,6 +1475,11 @@ def fields(self) -> Iterable[Field]: else field for field in self.child.fields ) + if self.offsets_col is not None: + return itertools.chain( + fields, (Field(self.offsets_col, bigframes.dtypes.INT_DTYPE),) + ) + return fields @property def relation_ops_created(self) -> int: @@ -1472,7 +1495,7 @@ def row_count(self) -> Optional[int]: @property def node_defined_ids(self) -> Tuple[bfet_ids.ColumnId, ...]: - return () + return (self.offsets_col,) if (self.offsets_col is not None) else () def prune(self, used_cols: COLUMN_SET) -> BigFrameNode: # Cannot prune explode op @@ -1482,6 +1505,8 @@ def prune(self, used_cols: COLUMN_SET) -> BigFrameNode: def remap_vars( self, mappings: Mapping[bfet_ids.ColumnId, bfet_ids.ColumnId] ) -> BigFrameNode: + if (self.offsets_col is not None) and self.offsets_col in mappings: + return dataclasses.replace(self, offsets_col=mappings[self.offsets_col]) return self def remap_refs( diff --git a/bigframes/dataframe.py b/bigframes/dataframe.py index ce57661919..fec53dbf01 100644 --- a/bigframes/dataframe.py +++ b/bigframes/dataframe.py @@ -1473,6 +1473,48 @@ def cov(self, *, numeric_only: bool = False) -> DataFrame: return result + def corrwith( + self, + other: typing.Union[DataFrame, bigframes.series.Series], + *, + numeric_only: bool = False, + ): + other_frame = other if isinstance(other, DataFrame) else other.to_frame() + if numeric_only: + l_frame = self._drop_non_numeric() + r_frame = other_frame._drop_non_numeric() + else: + l_frame = self._raise_on_non_numeric("corrwith") + r_frame = other_frame._raise_on_non_numeric("corrwith") + + l_block = l_frame.astype(bigframes.dtypes.FLOAT_DTYPE)._block + r_block = r_frame.astype(bigframes.dtypes.FLOAT_DTYPE)._block + + if isinstance(other, DataFrame): + block, labels, expr_pairs = l_block._align_both_axes(r_block, how="inner") + else: + assert isinstance(other, bigframes.series.Series) + block, labels, expr_pairs = l_block._align_axis_0(r_block, how="inner") + + na_cols = l_block.column_labels.join( + r_block.column_labels, how="outer" + ).difference(labels) + + block, _ = block.aggregate( + aggregations=tuple( + ex.BinaryAggregation(agg_ops.CorrOp(), left_ex, right_ex) + for left_ex, right_ex in expr_pairs + ), + column_labels=labels, + ) + block = block.project_exprs( + (ex.const(float("nan")),) * len(na_cols), labels=na_cols + ) + block = block.transpose( + original_row_index=pandas.Index([None]), single_row_mode=True + ) + return bigframes.pandas.Series(block) + def to_arrow( self, *, @@ -2365,6 +2407,9 @@ def where(self, cond, other=None): result.columns.names = self.columns.names return result + def mask(self, cond, other=None): + return self.where(~cond, other=other) + def dropna( self, *, @@ -3951,7 +3996,7 @@ def apply(self, func, *, axis=0, args: typing.Tuple = (), **kwargs): # Early check whether the dataframe dtypes are currently supported # in the remote function # NOTE: Keep in sync with the value converters used in the gcf code - # generated in remote_function_template.py + # generated in function_template.py remote_function_supported_dtypes = ( bigframes.dtypes.INT_DTYPE, bigframes.dtypes.FLOAT_DTYPE, @@ -4268,6 +4313,56 @@ def get_right_id(id): def plot(self): return plotting.PlotAccessor(self) + def hist( + self, by: typing.Optional[typing.Sequence[str]] = None, bins: int = 10, **kwargs + ): + return self.plot.hist(by=by, bins=bins, **kwargs) + + hist.__doc__ = inspect.getdoc(plotting.PlotAccessor.hist) + + def line( + self, + x: typing.Optional[typing.Hashable] = None, + y: typing.Optional[typing.Hashable] = None, + **kwargs, + ): + return self.plot.line(x=x, y=y, **kwargs) + + line.__doc__ = inspect.getdoc(plotting.PlotAccessor.line) + + def area( + self, + x: typing.Optional[typing.Hashable] = None, + y: typing.Optional[typing.Hashable] = None, + stacked: bool = True, + **kwargs, + ): + return self.plot.area(x=x, y=y, stacked=stacked, **kwargs) + + area.__doc__ = inspect.getdoc(plotting.PlotAccessor.area) + + def bar( + self, + x: typing.Optional[typing.Hashable] = None, + y: typing.Optional[typing.Hashable] = None, + **kwargs, + ): + return self.plot.bar(x=x, y=y, **kwargs) + + bar.__doc__ = inspect.getdoc(plotting.PlotAccessor.bar) + + def scatter( + self, + x: typing.Optional[typing.Hashable] = None, + y: typing.Optional[typing.Hashable] = None, + s: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None, + c: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None, + **kwargs, + ): + return self.plot.scatter(x=x, y=y, s=s, c=c, **kwargs) + + scatter.__doc__ = inspect.getdoc(plotting.PlotAccessor.scatter) + def __matmul__(self, other) -> DataFrame: return self.dot(other) diff --git a/bigframes/dtypes.py b/bigframes/dtypes.py index 3da3fa24f3..4db124134a 100644 --- a/bigframes/dtypes.py +++ b/bigframes/dtypes.py @@ -21,6 +21,7 @@ from typing import Any, Dict, List, Literal, Union import bigframes_vendored.constants as constants +import db_dtypes # type: ignore import geopandas as gpd # type: ignore import google.cloud.bigquery import numpy as np @@ -54,12 +55,13 @@ TIME_DTYPE = pd.ArrowDtype(pa.time64("us")) DATETIME_DTYPE = pd.ArrowDtype(pa.timestamp("us")) TIMESTAMP_DTYPE = pd.ArrowDtype(pa.timestamp("us", tz="UTC")) +TIMEDETLA_DTYPE = pd.ArrowDtype(pa.duration("us")) NUMERIC_DTYPE = pd.ArrowDtype(pa.decimal128(38, 9)) BIGNUMERIC_DTYPE = pd.ArrowDtype(pa.decimal256(76, 38)) # No arrow equivalent GEO_DTYPE = gpd.array.GeometryDtype() # JSON -JSON_DTYPE = pd.ArrowDtype(pa.large_string()) +JSON_DTYPE = db_dtypes.JSONDtype() OBJ_REF_DTYPE = pd.ArrowDtype( pa.struct( ( @@ -161,7 +163,7 @@ class SimpleDtypeInfo: ), SimpleDtypeInfo( dtype=JSON_DTYPE, - arrow_dtype=pa.large_string(), + arrow_dtype=db_dtypes.JSONArrowType(), type_kind=("JSON",), orderable=False, clusterable=False, @@ -320,7 +322,6 @@ def is_struct_like(type_: ExpressionType) -> bool: def is_json_like(type_: ExpressionType) -> bool: - # TODO: Add JSON type support return type_ == JSON_DTYPE or type_ == STRING_DTYPE # Including JSON string @@ -632,6 +633,9 @@ def convert_to_schema_field( return google.cloud.bigquery.SchemaField( name, "RECORD", fields=inner_fields ) + if bigframes_dtype.pyarrow_dtype == pa.duration("us"): + # Timedeltas are represented as integers in microseconds. + return google.cloud.bigquery.SchemaField(name, "INTEGER") raise ValueError( f"No arrow conversion for {bigframes_dtype}. {constants.FEEDBACK_LINK}" ) diff --git a/bigframes/functions/_remote_function_client.py b/bigframes/functions/_function_client.py similarity index 99% rename from bigframes/functions/_remote_function_client.py rename to bigframes/functions/_function_client.py index 0d0cc08128..104119a510 100644 --- a/bigframes/functions/_remote_function_client.py +++ b/bigframes/functions/_function_client.py @@ -29,7 +29,7 @@ from bigframes_vendored import constants import requests -import bigframes.functions.remote_function_template +import bigframes.functions.function_template as bff_template if TYPE_CHECKING: from bigframes.session import Session @@ -215,7 +215,7 @@ def generate_cloud_function_code( f.write("\n".join(package_requirements)) # main.py - entry_point = bigframes.functions.remote_function_template.generate_cloud_function_main_code( + entry_point = bff_template.generate_cloud_function_main_code( def_, directory, input_types=input_types, diff --git a/bigframes/functions/_remote_function_session.py b/bigframes/functions/_function_session.py similarity index 99% rename from bigframes/functions/_remote_function_session.py rename to bigframes/functions/_function_session.py index d6b729bf6e..00626a252f 100644 --- a/bigframes/functions/_remote_function_session.py +++ b/bigframes/functions/_function_session.py @@ -52,8 +52,7 @@ import pandas -from . import _remote_function_client as rf_client -from . import _utils +from . import _function_client, _utils class RemoteFunctionSession: @@ -468,7 +467,7 @@ def wrapper(func): signature, input_types, output_type # type: ignore ) - remote_function_client = rf_client.RemoteFunctionClient( + remote_function_client = _function_client.RemoteFunctionClient( dataset_ref.project, cloud_function_region, cloud_functions_client, diff --git a/bigframes/functions/remote_function.py b/bigframes/functions/function.py similarity index 96% rename from bigframes/functions/remote_function.py rename to bigframes/functions/function.py index 533c93e7cb..57df8f9407 100644 --- a/bigframes/functions/remote_function.py +++ b/bigframes/functions/function.py @@ -35,9 +35,9 @@ import bigframes.core.compile.ibis_types import bigframes.dtypes import bigframes.exceptions as bfe -import bigframes.functions.remote_function_template +import bigframes.functions.function_template -from . import _remote_function_session as rf_session +from . import _function_session as bff_session from . import _utils logger = logging.getLogger(__name__) @@ -120,11 +120,11 @@ def get_routine_reference( def remote_function(*args, **kwargs): - remote_function_session = rf_session.RemoteFunctionSession() + remote_function_session = bff_session.RemoteFunctionSession() return remote_function_session.remote_function(*args, **kwargs) -remote_function.__doc__ = rf_session.RemoteFunctionSession.remote_function.__doc__ +remote_function.__doc__ = bff_session.RemoteFunctionSession.remote_function.__doc__ def read_gbq_function( diff --git a/bigframes/functions/remote_function_template.py b/bigframes/functions/function_template.py similarity index 100% rename from bigframes/functions/remote_function_template.py rename to bigframes/functions/function_template.py diff --git a/bigframes/operations/__init__.py b/bigframes/operations/__init__.py index e55cbc4925..d8b0447686 100644 --- a/bigframes/operations/__init__.py +++ b/bigframes/operations/__init__.py @@ -170,6 +170,7 @@ ) from bigframes.operations.struct_ops import StructFieldOp, StructOp from bigframes.operations.time_ops import hour_op, minute_op, normalize_op, second_op +from bigframes.operations.timedelta_ops import ToTimedeltaOp __all__ = [ # Base ops @@ -240,6 +241,8 @@ "minute_op", "second_op", "normalize_op", + # Timedelta ops + "ToTimedeltaOp", # Datetime ops "date_op", "time_op", diff --git a/bigframes/operations/aggregations.py b/bigframes/operations/aggregations.py index 9de58fe5db..365b664ee0 100644 --- a/bigframes/operations/aggregations.py +++ b/bigframes/operations/aggregations.py @@ -381,7 +381,7 @@ def skips_nulls(self): # This should really by a NullaryWindowOp, but APIs don't support that yet. @dataclasses.dataclass(frozen=True) -class RowNumberOp(UnaryWindowOp): +class RowNumberOp(NullaryWindowOp): name: ClassVar[str] = "rownumber" @property diff --git a/bigframes/operations/blob.py b/bigframes/operations/blob.py index a4de2f80c7..205a9fcf5c 100644 --- a/bigframes/operations/blob.py +++ b/bigframes/operations/blob.py @@ -216,7 +216,7 @@ def display_single_url(read_url: str, content_type: str): response = requests.get(read_url) ipy_display.display(ipy_display.Audio(response.content)) elif content_type.startswith("video"): - ipy_display.display(ipy_display.Video(url=read_url)) + ipy_display.display(ipy_display.Video(read_url)) else: # display as raw data response = requests.get(read_url) ipy_display.display(response.content) diff --git a/bigframes/operations/json_ops.py b/bigframes/operations/json_ops.py index 86c5a19ba7..1daacf4e6b 100644 --- a/bigframes/operations/json_ops.py +++ b/bigframes/operations/json_ops.py @@ -50,7 +50,7 @@ def output_type(self, *input_types): + f" Received type: {input_type}" ) return pd.ArrowDtype( - pa.list_(dtypes.bigframes_dtype_to_arrow_dtype(dtypes.STRING_DTYPE)) + pa.list_(dtypes.bigframes_dtype_to_arrow_dtype(input_type)) ) @@ -118,8 +118,7 @@ def output_type(self, *input_types): + f"Received type: {right_type}" ) - # After JSON type implementation, ONLY return JSON data. - return left_type + return dtypes.JSON_DTYPE @dataclasses.dataclass(frozen=True) diff --git a/bigframes/operations/timedelta_ops.py b/bigframes/operations/timedelta_ops.py new file mode 100644 index 0000000000..0bcd6eb08f --- /dev/null +++ b/bigframes/operations/timedelta_ops.py @@ -0,0 +1,31 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import dataclasses +import typing + +from bigframes import dtypes +from bigframes.operations import base_ops + + +@dataclasses.dataclass(frozen=True) +class ToTimedeltaOp(base_ops.UnaryOp): + name: typing.ClassVar[str] = "to_timedelta" + unit: typing.Literal["us", "ms", "s", "m", "h", "d", "W"] + + def output_type(self, *input_types): + if input_types[0] is not dtypes.INT_DTYPE: + raise TypeError("expected integer input") + return dtypes.TIMEDETLA_DTYPE diff --git a/bigframes/pandas/__init__.py b/bigframes/pandas/__init__.py index 395b573916..4a5e4d4b3a 100644 --- a/bigframes/pandas/__init__.py +++ b/bigframes/pandas/__init__.py @@ -34,7 +34,8 @@ import bigframes.core.tools import bigframes.dataframe import bigframes.enums -import bigframes.functions._utils as functions_utils +import bigframes.functions._utils as bff_utils +from bigframes.pandas.core.api import to_timedelta from bigframes.pandas.io.api import ( from_glob_path, read_csv, @@ -222,7 +223,7 @@ def clean_up_by_session_id( session.bqclient, dataset, session_id ) - functions_utils._clean_up_by_session_id( + bff_utils._clean_up_by_session_id( session.bqclient, session.cloudfunctionsclient, dataset, session_id ) @@ -313,6 +314,7 @@ def reset_session(): "read_pickle", "remote_function", "to_datetime", + "to_timedelta", "from_glob_path", # pandas dtype attributes "NA", diff --git a/bigframes/pandas/core/__init__.py b/bigframes/pandas/core/__init__.py new file mode 100644 index 0000000000..0a2669d7a2 --- /dev/null +++ b/bigframes/pandas/core/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/bigframes/pandas/core/api.py b/bigframes/pandas/core/api.py new file mode 100644 index 0000000000..0f3161afcc --- /dev/null +++ b/bigframes/pandas/core/api.py @@ -0,0 +1,17 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from bigframes.pandas.core.tools.timedeltas import to_timedelta + +__all__ = ["to_timedelta"] diff --git a/bigframes/pandas/core/tools/__init__.py b/bigframes/pandas/core/tools/__init__.py new file mode 100644 index 0000000000..0a2669d7a2 --- /dev/null +++ b/bigframes/pandas/core/tools/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/bigframes/pandas/core/tools/timedeltas.py b/bigframes/pandas/core/tools/timedeltas.py new file mode 100644 index 0000000000..0cedf425fe --- /dev/null +++ b/bigframes/pandas/core/tools/timedeltas.py @@ -0,0 +1,64 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import typing + +from bigframes_vendored.pandas.core.tools import ( + timedeltas as vendored_pandas_timedeltas, +) +import pandas as pd + +from bigframes import operations as ops +from bigframes import series + + +def to_timedelta( + arg: typing.Union[series.Series, str, int, float], + unit: typing.Optional[vendored_pandas_timedeltas.UnitChoices] = None, +) -> typing.Union[series.Series, pd.Timedelta]: + if not isinstance(arg, series.Series): + return pd.to_timedelta(arg, unit) + + canonical_unit = "us" if unit is None else _canonicalize_unit(unit) + return arg._apply_unary_op(ops.ToTimedeltaOp(canonical_unit)) + + +to_timedelta.__doc__ = vendored_pandas_timedeltas.to_timedelta.__doc__ + + +def _canonicalize_unit( + unit: vendored_pandas_timedeltas.UnitChoices, +) -> typing.Literal["us", "ms", "s", "m", "h", "d", "W"]: + if unit in {"w", "W"}: + return "W" + + if unit in {"D", "d", "days", "day"}: + return "d" + + if unit in {"hours", "hour", "hr", "h"}: + return "h" + + if unit in {"m", "minute", "min", "minutes"}: + return "m" + + if unit in {"s", "seconds", "sec", "second"}: + return "s" + + if unit in {"ms", "milliseconds", "millisecond", "milli", "millis"}: + return "ms" + + if unit in {"us", "microseconds", "microsecond", "µs", "micro", "micros"}: + return "us" + + raise TypeError(f"Unrecognized unit: {unit}") diff --git a/bigframes/series.py b/bigframes/series.py index 46847996f1..e705a97fa9 100644 --- a/bigframes/series.py +++ b/bigframes/series.py @@ -1984,16 +1984,48 @@ def __array_ufunc__( return NotImplemented - # Keep this at the bottom of the Series class to avoid - # confusing type checker by overriding str - @property - def str(self) -> strings.StringMethods: - return strings.StringMethods(self._block) - @property def plot(self): return plotting.PlotAccessor(self) + def hist( + self, by: typing.Optional[typing.Sequence[str]] = None, bins: int = 10, **kwargs + ): + return self.plot.hist(by=by, bins=bins, **kwargs) + + hist.__doc__ = inspect.getdoc(plotting.PlotAccessor.hist) + + def line( + self, + x: typing.Optional[typing.Hashable] = None, + y: typing.Optional[typing.Hashable] = None, + **kwargs, + ): + return self.plot.line(x=x, y=y, **kwargs) + + line.__doc__ = inspect.getdoc(plotting.PlotAccessor.line) + + def area( + self, + x: typing.Optional[typing.Hashable] = None, + y: typing.Optional[typing.Hashable] = None, + stacked: bool = True, + **kwargs, + ): + return self.plot.area(x=x, y=y, stacked=stacked, **kwargs) + + area.__doc__ = inspect.getdoc(plotting.PlotAccessor.area) + + def bar( + self, + x: typing.Optional[typing.Hashable] = None, + y: typing.Optional[typing.Hashable] = None, + **kwargs, + ): + return self.plot.bar(x=x, y=y, **kwargs) + + bar.__doc__ = inspect.getdoc(plotting.PlotAccessor.bar) + def _slice( self, start: typing.Optional[int] = None, @@ -2022,6 +2054,12 @@ def _cached(self, *, force: bool = True, session_aware: bool = True) -> Series: self._block.cached(force=force, session_aware=session_aware) return self + # Keep this at the bottom of the Series class to avoid + # confusing type checker by overriding str + @property + def str(self) -> strings.StringMethods: + return strings.StringMethods(self._block) + def _is_list_like(obj: typing.Any) -> typing_extensions.TypeGuard[typing.Sequence]: return pandas.api.types.is_list_like(obj) diff --git a/bigframes/session/__init__.py b/bigframes/session/__init__.py index 1d85967729..02f79a7d99 100644 --- a/bigframes/session/__init__.py +++ b/bigframes/session/__init__.py @@ -67,8 +67,8 @@ import bigframes.dtypes import bigframes.exceptions import bigframes.exceptions as bfe -import bigframes.functions._remote_function_session as bigframes_rf_session -import bigframes.functions.remote_function as bigframes_rf +import bigframes.functions._function_session as bff_session +import bigframes.functions.function as bff import bigframes.session._io.bigquery as bf_io_bigquery import bigframes.session.clients import bigframes.session.executor @@ -245,7 +245,7 @@ def __init__( ) self._metrics = bigframes.session.metrics.ExecutionMetrics() - self._remote_function_session = bigframes_rf_session.RemoteFunctionSession() + self._function_session = bff_session.RemoteFunctionSession() self._temp_storage_manager = ( bigframes.session.temp_storage.TemporaryGbqStorageManager( self._clients_provider.bqclient, @@ -377,9 +377,9 @@ def close(self): if temp_storage_manager: self._temp_storage_manager.clean_up_tables() - remote_function_session = getattr(self, "_remote_function_session", None) + remote_function_session = getattr(self, "_function_session", None) if remote_function_session: - self._remote_function_session.clean_up( + self._function_session.clean_up( self.bqclient, self.cloudfunctionsclient, self.session_id ) @@ -1380,7 +1380,7 @@ def remote_function( `bigframes_remote_function` - The bigquery remote function capable of calling into `bigframes_cloud_function`. """ - return self._remote_function_session.remote_function( + return self._function_session.remote_function( input_types, output_type, session=self, @@ -1556,7 +1556,7 @@ def read_gbq_function( not including the `bigframes_cloud_function` property. """ - return bigframes_rf.read_gbq_function( + return bff.read_gbq_function( function_name=function_name, session=self, is_row_processor=is_row_processor, diff --git a/bigframes/session/_io/pandas.py b/bigframes/session/_io/pandas.py index 2f6aade0e5..301e1c4ebb 100644 --- a/bigframes/session/_io/pandas.py +++ b/bigframes/session/_io/pandas.py @@ -17,6 +17,7 @@ from typing import Collection, Union import bigframes_vendored.constants as constants +import db_dtypes # type: ignore import geopandas # type: ignore import numpy as np import pandas @@ -122,6 +123,8 @@ def arrow_to_pandas( ) elif isinstance(dtype, pandas.ArrowDtype): series = _arrow_to_pandas_arrowdtype(column, dtype) + elif isinstance(dtype, db_dtypes.JSONDtype): + series = db_dtypes.JSONArray(column) else: series = column.to_pandas(types_mapper=lambda _: dtype) diff --git a/bigframes/version.py b/bigframes/version.py index 50dde36b01..1fef294cef 100644 --- a/bigframes/version.py +++ b/bigframes/version.py @@ -12,4 +12,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "1.33.0" +__version__ = "1.34.0" diff --git a/notebooks/getting_started/bq_dataframes_template.ipynb b/notebooks/getting_started/bq_dataframes_template.ipynb index 2b47c40397..90186b297d 100644 --- a/notebooks/getting_started/bq_dataframes_template.ipynb +++ b/notebooks/getting_started/bq_dataframes_template.ipynb @@ -137,7 +137,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "id": "oM1iC_MfAts1" }, @@ -158,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "id": "PyQmSRbKA8r-" }, @@ -179,14 +179,15 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "id": "NPPMuw2PXGeo" }, "outputs": [], "source": [ "# Note: The project option is not required in all environments.\n", - "# On BigQuery Studio, the project ID is automatically detected.\n", + "# For example, In BigQuery Studio, the project ID is automatically detected,\n", + "# But in Google Colab it must be set by the user.\n", "bpd.options.bigquery.project = PROJECT_ID\n", "\n", "# Note: The location option is not required.\n", @@ -198,7 +199,13 @@ "# Note: BigQuery DataFrames objects are by default fully ordered like Pandas.\n", "# If ordering is not important for you, you can uncomment the following\n", "# expression to run BigQuery DataFrames in partial ordering mode.\n", - "#bpd.options.bigquery.ordering_mode = \"partial\"" + "#bpd.options.bigquery.ordering_mode = \"partial\"\n", + "\n", + "# Note: By default BigQuery DataFrames emits out BigQuery job metadata via a\n", + "# progress bar. But in this notebook let's disable the progress bar to keep the\n", + "# experience less verbose. If you would like the default behavior, please\n", + "# comment out the following expression. \n", + "bpd.options.display.progress_bar = None" ] }, { @@ -242,24 +249,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": { "id": "Vyex9BQI-BNa" }, - "outputs": [ - { - "data": { - "text/html": [ - "Query job 9c49a31b-7db6-49e1-b711-42eeebfdf7d3 is DONE. 0 Bytes processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# This is how you read a BigQuery table\n", "df = bpd.read_gbq(\"bigquery-public-data.ml_datasets.penguins\")\n", @@ -277,33 +271,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job a4004810-9249-4fe3-ab87-7cc33b69808d is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 09214d4a-8911-41b3-9f14-1c781cb7dc1b is DONE. 31.7 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/html": [ @@ -336,76 +306,76 @@ " \n", " \n", " \n", - " 171\n", - " Adelie Penguin (Pygoscelis adeliae)\n", - " Dream\n", - " 41.1\n", - " 19.0\n", - " 182.0\n", - " 3425.0\n", - " MALE\n", - " \n", - " \n", - " 219\n", + " 198\n", " Gentoo penguin (Pygoscelis papua)\n", " Biscoe\n", - " 45.7\n", - " 13.9\n", - " 214.0\n", + " 43.3\n", + " 13.4\n", + " 209.0\n", " 4400.0\n", " FEMALE\n", " \n", " \n", - " 59\n", - " Gentoo penguin (Pygoscelis papua)\n", - " Biscoe\n", - " 49.9\n", - " 16.1\n", - " 213.0\n", - " 5400.0\n", + " 235\n", + " Adelie Penguin (Pygoscelis adeliae)\n", + " Torgersen\n", + " 35.1\n", + " 19.4\n", + " 193.0\n", + " 4200.0\n", " MALE\n", " \n", " \n", - " 132\n", - " Adelie Penguin (Pygoscelis adeliae)\n", - " Biscoe\n", - " 39.6\n", - " 20.7\n", - " 191.0\n", - " 3900.0\n", + " 317\n", + " Chinstrap penguin (Pygoscelis antarctica)\n", + " Dream\n", + " 45.4\n", + " 18.7\n", + " 188.0\n", + " 3525.0\n", " FEMALE\n", " \n", " \n", - " 223\n", - " Gentoo penguin (Pygoscelis papua)\n", - " Biscoe\n", - " 47.3\n", - " 13.8\n", - " 216.0\n", - " 4725.0\n", - " <NA>\n", + " 117\n", + " Chinstrap penguin (Pygoscelis antarctica)\n", + " Dream\n", + " 48.5\n", + " 17.5\n", + " 191.0\n", + " 3400.0\n", + " MALE\n", + " \n", + " \n", + " 159\n", + " Chinstrap penguin (Pygoscelis antarctica)\n", + " Dream\n", + " 45.6\n", + " 19.4\n", + " 194.0\n", + " 3525.0\n", + " FEMALE\n", " \n", " \n", "\n", "" ], "text/plain": [ - " species island culmen_length_mm \\\n", - "171 Adelie Penguin (Pygoscelis adeliae) Dream 41.1 \n", - "219 Gentoo penguin (Pygoscelis papua) Biscoe 45.7 \n", - "59 Gentoo penguin (Pygoscelis papua) Biscoe 49.9 \n", - "132 Adelie Penguin (Pygoscelis adeliae) Biscoe 39.6 \n", - "223 Gentoo penguin (Pygoscelis papua) Biscoe 47.3 \n", + " species island culmen_length_mm \\\n", + "198 Gentoo penguin (Pygoscelis papua) Biscoe 43.3 \n", + "235 Adelie Penguin (Pygoscelis adeliae) Torgersen 35.1 \n", + "317 Chinstrap penguin (Pygoscelis antarctica) Dream 45.4 \n", + "117 Chinstrap penguin (Pygoscelis antarctica) Dream 48.5 \n", + "159 Chinstrap penguin (Pygoscelis antarctica) Dream 45.6 \n", "\n", " culmen_depth_mm flipper_length_mm body_mass_g sex \n", - "171 19.0 182.0 3425.0 MALE \n", - "219 13.9 214.0 4400.0 FEMALE \n", - "59 16.1 213.0 5400.0 MALE \n", - "132 20.7 191.0 3900.0 FEMALE \n", - "223 13.8 216.0 4725.0 " + "198 13.4 209.0 4400.0 FEMALE \n", + "235 19.4 193.0 4200.0 MALE \n", + "317 18.7 188.0 3525.0 FEMALE \n", + "117 17.5 191.0 3400.0 MALE \n", + "159 19.4 194.0 3525.0 FEMALE " ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -454,28 +424,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": { "id": "YKwCW7Nsavap" }, "outputs": [ - { - "data": { - "text/html": [ - "Query job 788957fa-55af-40af-a17c-913c1d0ec170 is DONE. 2.7 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", "text": [ - "average_body_mass: 4201.754385964913\n" + "average_body_mass: 4201.754385964906\n" ] } ], @@ -495,35 +453,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": { "id": "4PyKMR61-Mjy" }, "outputs": [ - { - "data": { - "text/html": [ - "Query job 0026583d-b326-4393-82f9-a1d2629fa745 is DONE. 15.6 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 30e17097-f818-4e87-a4a1-3eef82bc38be is DONE. 163 Bytes processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/html": [ @@ -580,7 +514,7 @@ "[3 rows x 1 columns]" ] }, - "execution_count": 5, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -609,7 +543,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -625,45 +559,21 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job 223af6b4-d58d-42c3-b7c9-13a303536e21 is DONE. 31.7 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 96fb4ef9-6c12-4cfa-aa2c-16377efed8f3 is DONE. 11.0 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/plain": [ "133 {'culmen_length_mm': None, 'culmen_depth_mm': ...\n", "279 {'culmen_length_mm': 37.9, 'culmen_depth_mm': ...\n", "34 {'culmen_length_mm': 37.8, 'culmen_depth_mm': ...\n", + "208 {'culmen_length_mm': 40.5, 'culmen_depth_mm': ...\n", "96 {'culmen_length_mm': 37.7, 'culmen_depth_mm': ...\n", - "18 {'culmen_length_mm': 38.8, 'culmen_depth_mm': ...\n", "dtype: struct[pyarrow]" ] }, - "execution_count": 7, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -684,45 +594,21 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job 81db1901-0704-4af2-8395-4c310e043f30 is DONE. 34.5 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job dfb40bba-3170-47b8-9ab4-c3ed5ab7550e is DONE. 8.2 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/plain": [ - "116 \n", - "308 15.5\n", - "285 15.9\n", - "2 16.0\n", - "245 16.1\n", + "133 \n", + "279 18.6\n", + "34 18.3\n", + "96 18.7\n", + "208 18.9\n", "dtype: Float64" ] }, - "execution_count": 8, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -753,34 +639,22 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job 4420834b-8f6f-46ce-9488-a7ae3960e72b is DONE. 34.5 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/plain": [ "" ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -795,46 +669,22 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job 2e9d7f11-c442-4a6b-905f-0f5ac498b399 is DONE. 12.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 27db4f04-849b-4193-acae-6ecff5f4350f is DONE. 23.8 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/plain": [ "" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -859,72 +709,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "Query job 58f9cb42-382b-428b-9ed5-95c064e3ab29 is DONE. 12.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 18128891-8a44-42bb-9f30-a1e978203f41 is DONE. 12.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 1ddc23a6-4b05-448b-bb21-d778634ea5c5 is DONE. 12.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job b4617c85-24c9-4b63-8926-b5db63e7c319 is DONE. 12.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 95df92b9-1b7d-4c6d-9f20-69f928e36850 is DONE. 12.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -957,7 +747,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -966,46 +756,10 @@ "text": [ "\n", "We have a dataframe of \n", - "\n" - ] - }, - { - "data": { - "text/html": [ - "Query job 6474b1c7-b6e5-4be7-93c6-cf8b0338dd58 is DONE. 34.5 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ "\n", - "We have a dataframe of \n", - "\n" - ] - }, - { - "data": { - "text/html": [ - "Load job c93fdfb6-bbe1-446c-b7be-4922d67498ed is DONE. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "\n", + "We have a dataframe of \n", + "\n", "\n", "We have a dataframe of \n", "\n" @@ -1047,33 +801,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job c8682a2f-c1df-437f-95c3-836a317752d5 is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job e4198287-043e-45cf-b615-990b00abc521 is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", @@ -1111,69 +841,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job c45c1c1c-7a9a-4598-929c-ef18455a5d58 is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job a6ccb958-f34e-48c1-9ec6-961e1e07ae25 is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 3f357436-61ea-4d75-9a3c-a7042d20330e is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 040b5cc6-9ded-43ea-9176-89a7eaf741ce is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 99f1db63-2cb7-40de-9dea-bc5624c540d0 is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", @@ -1215,7 +885,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1231,7 +901,7 @@ " ('linreg', LinearRegression(fit_intercept=False))])" ] }, - "execution_count": 8, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1269,57 +939,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 19, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job 1ccf6bcb-f38d-4680-a5df-89aaa03d6ea5 is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job cefb04e4-6fd2-477b-a579-be3b2ca745ba is DONE. 22.6 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job bebcf4df-d8d1-45c4-9efc-86c7645cd40d is DONE. 30.0 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 25d66657-3a7b-4e79-bca2-5a8116ba5c94 is DONE. 6.2 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/html": [ @@ -1352,52 +974,52 @@ " \n", " \n", " \n", - " 286\n", - " 3230.741308\n", + " 37\n", + " -18640.718256\n", " Biscoe\n", - " 37.9\n", - " 18.6\n", - " 172.0\n", - " FEMALE\n", - " Adelie Penguin (Pygoscelis adeliae)\n", + " 44.5\n", + " 15.7\n", + " 217.0\n", + " .\n", + " Gentoo penguin (Pygoscelis papua)\n", " \n", " \n", - " 41\n", - " 3186.002207\n", - " Torgersen\n", - " 40.2\n", - " 17.0\n", - " 176.0\n", + " 245\n", + " 3109.962252\n", + " Dream\n", + " 33.1\n", + " 16.1\n", + " 178.0\n", " FEMALE\n", " Adelie Penguin (Pygoscelis adeliae)\n", " \n", " \n", - " 72\n", - " 3324.549608\n", - " Dream\n", - " 36.5\n", - " 18.0\n", + " 267\n", + " 3372.443434\n", + " Torgersen\n", + " 41.1\n", + " 17.6\n", " 182.0\n", " FEMALE\n", " Adelie Penguin (Pygoscelis adeliae)\n", " \n", " \n", - " 36\n", - " 3426.252381\n", - " Dream\n", - " 36.0\n", - " 18.5\n", - " 186.0\n", + " 280\n", + " 3341.376012\n", + " Torgersen\n", + " 36.6\n", + " 17.8\n", + " 185.0\n", " FEMALE\n", " Adelie Penguin (Pygoscelis adeliae)\n", " \n", " \n", - " 247\n", - " 3413.687704\n", + " 40\n", + " 3310.178937\n", " Biscoe\n", - " 39.0\n", - " 17.5\n", - " 186.0\n", + " 37.6\n", + " 17.0\n", + " 185.0\n", " FEMALE\n", " Adelie Penguin (Pygoscelis adeliae)\n", " \n", @@ -1407,21 +1029,21 @@ ], "text/plain": [ " predicted_body_mass_g island culmen_length_mm culmen_depth_mm \\\n", - "286 3230.741308 Biscoe 37.9 18.6 \n", - "41 3186.002207 Torgersen 40.2 17.0 \n", - "72 3324.549608 Dream 36.5 18.0 \n", - "36 3426.252381 Dream 36.0 18.5 \n", - "247 3413.687704 Biscoe 39.0 17.5 \n", + "37 -18640.718256 Biscoe 44.5 15.7 \n", + "245 3109.962252 Dream 33.1 16.1 \n", + "267 3372.443434 Torgersen 41.1 17.6 \n", + "280 3341.376012 Torgersen 36.6 17.8 \n", + "40 3310.178937 Biscoe 37.6 17.0 \n", "\n", " flipper_length_mm sex species \n", - "286 172.0 FEMALE Adelie Penguin (Pygoscelis adeliae) \n", - "41 176.0 FEMALE Adelie Penguin (Pygoscelis adeliae) \n", - "72 182.0 FEMALE Adelie Penguin (Pygoscelis adeliae) \n", - "36 186.0 FEMALE Adelie Penguin (Pygoscelis adeliae) \n", - "247 186.0 FEMALE Adelie Penguin (Pygoscelis adeliae) " + "37 217.0 . Gentoo penguin (Pygoscelis papua) \n", + "245 178.0 FEMALE Adelie Penguin (Pygoscelis adeliae) \n", + "267 182.0 FEMALE Adelie Penguin (Pygoscelis adeliae) \n", + "280 185.0 FEMALE Adelie Penguin (Pygoscelis adeliae) \n", + "40 185.0 FEMALE Adelie Penguin (Pygoscelis adeliae) " ] }, - "execution_count": 12, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1448,33 +1070,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 20, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job 33f30db0-43ab-47f4-ae17-bf8c7e5e8bdc is DONE. 30.0 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 0a49d654-7883-409b-bc8f-3b16eeee873b is DONE. 48 Bytes processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/html": [ @@ -1507,12 +1105,12 @@ " \n", " \n", " 0\n", - " 233.280852\n", - " 79664.958768\n", - " 0.004725\n", - " 200.960554\n", - " 0.889414\n", - " 0.897374\n", + " 582.272638\n", + " 8337651.200465\n", + " 0.004989\n", + " 193.446297\n", + " -11.273389\n", + " -11.091156\n", " \n", " \n", "\n", @@ -1521,15 +1119,15 @@ ], "text/plain": [ " mean_absolute_error mean_squared_error mean_squared_log_error \\\n", - "0 233.280852 79664.958768 0.004725 \n", + "0 582.272638 8337651.200465 0.004989 \n", "\n", - " median_absolute_error r2_score explained_variance \n", - "0 200.960554 0.889414 0.897374 \n", + " median_absolute_error r2_score explained_variance \n", + "0 193.446297 -11.273389 -11.091156 \n", "\n", "[1 rows x 6 columns]" ] }, - "execution_count": 13, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1547,52 +1145,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 21, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job d42f72e4-c1dc-4859-8d2f-99e09006ed64 is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 5b8dc932-3d79-47ab-b43a-8cd987091883 is DONE. 28.9 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job b93b8f2f-533d-46b7-b320-0349cee22635 is DONE. 30.0 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/plain": [ - "0.8894138438612413" + "-11.273389374372979" ] }, - "execution_count": 14, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1609,7 +1171,9 @@ "source": [ "## Generative AI with BigQuery DataFrames\n", "\n", - "BigQuery DataFrames integration with the Large Language Models (LLM) supported by BigQuery ML. Check out the [`bigframes.ml.llm`](https://cloud.google.com/python/docs/reference/bigframes/latest/bigframes.ml.llm) module for all the available models." + "BigQuery DataFrames integration with the Large Language Models (LLM) supported by BigQuery ML. Check out the [`bigframes.ml.llm`](https://cloud.google.com/python/docs/reference/bigframes/latest/bigframes.ml.llm) module for all the available models.\n", + "\n", + "To use this feature you would need to have a few additional APIs enabled and IAM roles configured. Please make sure of that by following [this documentation](https://cloud.google.com/bigquery/docs/use-bigquery-dataframes#remote-models) and then uncomment the code in the following cells to try out the integration with Gemini." ] }, { @@ -1623,21 +1187,9 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 22, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job 180784d4-bff2-4165-9958-07f77b711980 is DONE. 0 Bytes processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/html": [ @@ -1689,17 +1241,17 @@ "[3 rows x 1 columns]" ] }, - "execution_count": 44, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df = bpd.DataFrame(\n", - " {\n", - " \"prompt\": [\"What is BigQuery?\", \"What is BQML?\", \"What is BigQuery DataFrames?\"],\n", - " })\n", - "df" + "# df = bpd.DataFrame(\n", + "# {\n", + "# \"prompt\": [\"What is BigQuery?\", \"What is BQML?\", \"What is BigQuery DataFrames?\"],\n", + "# })\n", + "# df" ] }, { @@ -1713,65 +1265,17 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 23, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job aefe66a0-70da-44e4-89be-05a152b046f8 is DONE. 0 Bytes processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 8b3b543d-e4a2-4534-b55a-6a499e958108 is DONE. 0 Bytes processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/google/home/shobs/code/bigframes/bigframes/core/__init__.py:109: PreviewWarning: Interpreting JSON column(s) as StringDtype. This behavior may change in future versions.\n", - " warnings.warn(\n" + "/usr/local/google/home/shobs/code/bigframes/bigframes/core/__init__.py:114: PreviewWarning: Interpreting JSON column(s) as pyarrow.large_string. This behavior may change in future versions.\n", + " warnings.warn(msg, bfe.PreviewWarning)\n" ] }, - { - "data": { - "text/html": [ - "Query job cef454ea-1d31-4de4-a724-eed712e36d2c is DONE. 6 Bytes processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Query job 1eb4c2a5-9626-40fb-a346-1e6c137c5239 is DONE. 10.7 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "text/html": [ @@ -1802,15 +1306,18 @@ " \n", " \n", " 0\n", - " BigQuery is a serverless, highly scalable, and...\n", - " [{\"category\":1,\"probability\":1,\"probability_sc...\n", + " ## BigQuery: Your Data Warehouse in the Cloud\n", + "...\n", + " [{\"category\":\"HARM_CATEGORY_HATE_SPEECH\",\"prob...\n", " \n", " What is BigQuery?\n", " \n", " \n", " 1\n", - " ## BQML: Bringing Quantum Machine Learning to ...\n", - " [{\"category\":1,\"probability\":1,\"probability_sc...\n", + " ## BQML - BigQuery Machine Learning\n", + "\n", + "BQML stan...\n", + " [{\"category\":\"HARM_CATEGORY_HATE_SPEECH\",\"prob...\n", " \n", " What is BQML?\n", " \n", @@ -1819,7 +1326,7 @@ " ## BigQuery DataFrames\n", "\n", "BigQuery DataFrames is...\n", - " [{\"category\":1,\"probability\":1,\"probability_sc...\n", + " [{\"category\":\"HARM_CATEGORY_HATE_SPEECH\",\"prob...\n", " \n", " What is BigQuery DataFrames?\n", " \n", @@ -1830,16 +1337,19 @@ ], "text/plain": [ " ml_generate_text_llm_result \\\n", - "0 BigQuery is a serverless, highly scalable, and... \n", - "1 ## BQML: Bringing Quantum Machine Learning to ... \n", + "0 ## BigQuery: Your Data Warehouse in the Cloud\n", + "... \n", + "1 ## BQML - BigQuery Machine Learning\n", + "\n", + "BQML stan... \n", "2 ## BigQuery DataFrames\n", "\n", "BigQuery DataFrames is... \n", "\n", " ml_generate_text_rai_result ml_generate_text_status \\\n", - "0 [{\"category\":1,\"probability\":1,\"probability_sc... \n", - "1 [{\"category\":1,\"probability\":1,\"probability_sc... \n", - "2 [{\"category\":1,\"probability\":1,\"probability_sc... \n", + "0 [{\"category\":\"HARM_CATEGORY_HATE_SPEECH\",\"prob... \n", + "1 [{\"category\":\"HARM_CATEGORY_HATE_SPEECH\",\"prob... \n", + "2 [{\"category\":\"HARM_CATEGORY_HATE_SPEECH\",\"prob... \n", "\n", " prompt \n", "0 What is BigQuery? \n", @@ -1849,18 +1359,18 @@ "[3 rows x 4 columns]" ] }, - "execution_count": 45, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from bigframes.ml.llm import GeminiTextGenerator\n", + "# from bigframes.ml.llm import GeminiTextGenerator\n", "\n", - "model = GeminiTextGenerator()\n", + "# model = GeminiTextGenerator()\n", "\n", - "pred = model.predict(df)\n", - "pred" + "# pred = model.predict(df)\n", + "# pred" ] }, { @@ -1872,66 +1382,49 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 24, "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job d5fed4ed-26c2-45a6-b842-3af8c901985c is DONE. 10.7 kB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", "text": [ "## BigQuery DataFrames\n", "\n", - "BigQuery DataFrames is an open-source project offered by Google that provides the capabilities of using pandas-style APIs directly in BigQuery's serverless environment for performing SQL and DDL queries. This essentially means you have the flexibility to write pandas code within BigQuery for data exploration, transformation, visualization and building machine learning models. It acts as an intermediary bridge that facilitates SQL queries to the BigQuery engine for running your analysis with speed and scalability on large datasets without requiring manual configuration. It can further extend its functionalities through third-party libraries like scikit-learn, matplotlib, seaborn etc., enhancing its versatility within the realm of data manipulation.\n", - "\n", - "Here's are some key benefits associated with BigQuery DataFrames:\n", - "\n", - "\n", - "### Streamlined Experience:\n", - "\n", - "BigQuery DataFrames simplifies your development workflow by eliminating the back-and-forth communication between pandas and BigQuery environments for data operations. It allows working seamlessly within BigQuery to leverage powerful SQL features while using familiar pandas functions on data stored within. This enables a smoother process from ingesting, analyzing, and visualizing your data efficiently.\n", - "\n", - "### Serverless Infrastructure:\n", - "\n", - "One of the greatest advantages of BigQuery DataFrames is that it runs on serverless infrastructure, eliminating the need to maintain complex environments for development. This translates to less complexity, easy management, and a focus on efficient analysis rather than infrastructure upkeep.\n", - "\n", - "### Scalable Capabilities:\n", - "\n", - "As mentioned, BigQuery excels in dealing with immense data sets with efficient storage and processing power due to its architecture built for handling petabyte-scale datasets in Google Cloud Storage. DataFrames inherits this strength, empowering the analysis of vast information while ensuring speed and reliability throughout.\n", + "BigQuery DataFrames is a Python library that allows you to interact with BigQuery data using the familiar Pandas API. This means you can use all the powerful tools and methods from the Pandas library to explore, analyze, and transform your BigQuery data, without needing to learn a new language or API.\n", "\n", - "### Open-source Ecosystem:\n", + "Here are some of the key benefits of using BigQuery DataFrames:\n", "\n", - "While Google spearheads its initial creation, DataFrames benefits immensely from its open-source structure. This fosters community-wide involvement in its advancement; developers are continually making contributions that bolster functionalities, introduce improvements with regular updates and fixes.\n", + "* **Ease of use:** If you're already familiar with Pandas, you can start using BigQuery DataFrames with minimal learning curve.\n", + "* **Speed and efficiency:** BigQuery DataFrames leverages the power of BigQuery to perform complex operations on large datasets efficiently.\n", + "* **Flexibility:** You can use BigQuery DataFrames for a wide range of tasks, including data exploration, analysis, cleaning, and transformation.\n", + "* **Integration with other tools:** BigQuery DataFrames integrates seamlessly with other Google Cloud tools like Colab and Vertex AI, allowing you to build end-to-end data analysis pipelines.\n", "\n", - "Here are a few scenarios where using BigQuery DataFrames might prove particularly valuable:\n", + "Here are some of the key features of BigQuery DataFrames:\n", "\n", - "- Performing exploratory analysis on a diverse range of dataset directly on serverless infrastructure with scalability, saving valuable operational cost and time.\n", + "* **Support for most Pandas operations:** You can use most of the DataFrame methods you're familiar with, such as `groupby`, `filter`, `sort_values`, and `apply`.\n", + "* **Automatic schema inference:** BigQuery DataFrames automatically infers the schema of your data, so you don't need to manually specify it.\n", + "* **Efficient handling of large datasets:** BigQuery DataFrames pushes computations to BigQuery, which allows you to work with large datasets without running out of memory.\n", + "* **Support for both public and private datasets:** You can use BigQuery DataFrames to access both public and private datasets stored in BigQuery.\n", "\n", - "- Implementing data preprocessing steps using Python and DataFrames within Google Cloud Platform without having to transfer and analyze it elsewhere, streamlining workflow within the same framework.\n", + "## Getting Started with BigQuery DataFrames\n", "\n", - "- When building and training ML models directly from datasets without exporting the data outside, maintaining security within and improving efficiency.\n", + "Getting started with BigQuery DataFrames is easy. You just need to install the library and configure your authentication. Once you're set up, you can start using it to interact with your BigQuery data.\n", "\n", + "Here are some resources to help you get started:\n", "\n", - "However, be aware that DataFrames is an ever-evolving project and some aspects such as DML functionalities remain under active development to reach feature completion as compared to standard SQL commands which have matured functionality already in place within DataFrames.\n", + "* **Documentation:** https://cloud.google.com/bigquery/docs/reference/libraries/bigquery-dataframe\n", + "* **Quickstart:** https://cloud.google.com/bigquery/docs/reference/libraries/bigquery-dataframe-python-quickstart\n", + "* **Tutorials:** https://cloud.google.com/bigquery/docs/tutorials/bq-dataframe-pandas-tutorial\n", "\n", + "## Conclusion\n", "\n", - "Would you like me to delve deeper into specific features of DataFrames, its current limitations or perhaps provide examples of its applications or user cases?\n" + "BigQuery DataFrames is a powerful tool that can help you get the most out of your BigQuery data. If you're looking for a way to easily analyze and transform your BigQuery data using the familiar Pandas API, then BigQuery DataFrames is a great option.\n" ] } ], "source": [ - "print(pred.loc[2][\"ml_generate_text_llm_result\"])" + "# print(pred.loc[2][\"ml_generate_text_llm_result\"])" ] }, { @@ -1998,7 +1491,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.6" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/setup.py b/setup.py index 74a0d5475c..047da2348c 100644 --- a/setup.py +++ b/setup.py @@ -62,6 +62,7 @@ "ipywidgets >=7.7.1", "humanize >=4.6.0", "matplotlib >=3.7.1", + "db-dtypes >=1.4.0", # For vendored ibis-framework. "atpublic>=2.3,<6", "parsy>=2,<3", diff --git a/testing/constraints-3.9.txt b/testing/constraints-3.9.txt index 015153cb01..8b7ad892c0 100644 --- a/testing/constraints-3.9.txt +++ b/testing/constraints-3.9.txt @@ -26,6 +26,7 @@ tabulate==0.9 ipywidgets==7.7.1 humanize==4.6.0 matplotlib==3.7.1 +db-dtypes==1.4.0 # For vendored ibis-framework. atpublic==2.3 parsy==2.0 diff --git a/tests/system/large/test_remote_function.py b/tests/system/large/test_remote_function.py index d0eb6c1904..f226143b50 100644 --- a/tests/system/large/test_remote_function.py +++ b/tests/system/large/test_remote_function.py @@ -32,7 +32,7 @@ import bigframes.dataframe import bigframes.dtypes import bigframes.exceptions -import bigframes.functions._utils as functions_utils +import bigframes.functions._utils as bff_utils import bigframes.pandas as bpd import bigframes.series from tests.system.utils import ( @@ -633,11 +633,9 @@ def add_one(x): add_one_uniq, add_one_uniq_dir = make_uniq_udf(add_one) # Expected cloud function name for the unique udf - package_requirements = functions_utils._get_updated_package_requirements() - add_one_uniq_hash = functions_utils._get_hash( - add_one_uniq, package_requirements - ) - add_one_uniq_cf_name = functions_utils.get_cloud_function_name( + package_requirements = bff_utils._get_updated_package_requirements() + add_one_uniq_hash = bff_utils._get_hash(add_one_uniq, package_requirements) + add_one_uniq_cf_name = bff_utils.get_cloud_function_name( add_one_uniq_hash, session.session_id ) diff --git a/tests/system/small/bigquery/test_json.py b/tests/system/small/bigquery/test_json.py index b01ac3aaf2..aa490749ae 100644 --- a/tests/system/small/bigquery/test_json.py +++ b/tests/system/small/bigquery/test_json.py @@ -118,7 +118,6 @@ def test_json_set_w_invalid_series_type(): def test_json_extract_from_json(): s = _get_series_from_json([{"a": {"b": [1, 2]}}, {"a": {"c": 1}}, {"a": {"b": 0}}]) actual = bbq.json_extract(s, "$.a.b").to_pandas() - # After the introduction of the JSON type, the output should be a JSON-formatted series. expected = _get_series_from_json([[1, 2], None, 0]).to_pandas() pd.testing.assert_series_equal( actual, @@ -129,12 +128,10 @@ def test_json_extract_from_json(): def test_json_extract_from_string(): s = bpd.Series(['{"a": {"b": [1, 2]}}', '{"a": {"c": 1}}', '{"a": {"b": 0}}']) actual = bbq.json_extract(s, "$.a.b") - expected = _get_series_from_json([[1, 2], None, 0]) + expected = bpd.Series(["[1,2]", None, "0"]) pd.testing.assert_series_equal( actual.to_pandas(), expected.to_pandas(), - check_names=False, - check_dtype=False, # json_extract returns string type. While _get_series_from_json gives a JSON series (pa.large_string). ) @@ -143,20 +140,58 @@ def test_json_extract_w_invalid_series_type(): bbq.json_extract(bpd.Series([1, 2]), "$.a") +def test_json_extract_array_from_json(): + s = _get_series_from_json( + [{"a": ["ab", "2", "3 xy"]}, {"a": []}, {"a": ["4", "5"]}, {}] + ) + actual = bbq.json_extract_array(s, "$.a") + + # This code provides a workaround for issue https://github.com/apache/arrow/issues/45262, + # which currently prevents constructing a series using the pa.list_(db_types.JSONArrrowType()) + sql = """ + SELECT 0 AS id, [JSON '"ab"', JSON '"2"', JSON '"3 xy"'] AS data, + UNION ALL + SELECT 1, [], + UNION ALL + SELECT 2, [JSON '"4"', JSON '"5"'], + UNION ALL + SELECT 3, null, + """ + df = bpd.read_gbq(sql).set_index("id").sort_index() + expected = df["data"] + + pd.testing.assert_series_equal( + actual.to_pandas(), + expected.to_pandas(), + ) + + def test_json_extract_array_from_json_strings(): - s = bpd.Series(['{"a": ["ab", "2", "3 xy"]}', '{"a": []}', '{"a": ["4","5"]}']) + s = bpd.Series( + ['{"a": ["ab", "2", "3 xy"]}', '{"a": []}', '{"a": ["4","5"]}', "{}"], + dtype=pd.StringDtype(storage="pyarrow"), + ) actual = bbq.json_extract_array(s, "$.a") - expected = bpd.Series([['"ab"', '"2"', '"3 xy"'], [], ['"4"', '"5"']]) + expected = bpd.Series( + [['"ab"', '"2"', '"3 xy"'], [], ['"4"', '"5"'], None], + dtype=pd.StringDtype(storage="pyarrow"), + ) pd.testing.assert_series_equal( actual.to_pandas(), expected.to_pandas(), ) -def test_json_extract_array_from_array_strings(): - s = bpd.Series(["[1, 2, 3]", "[]", "[4,5]"]) +def test_json_extract_array_from_json_array_strings(): + s = bpd.Series( + ["[1, 2, 3]", "[]", "[4,5]"], + dtype=pd.StringDtype(storage="pyarrow"), + ) actual = bbq.json_extract_array(s) - expected = bpd.Series([["1", "2", "3"], [], ["4", "5"]]) + expected = bpd.Series( + [["1", "2", "3"], [], ["4", "5"]], + dtype=pd.StringDtype(storage="pyarrow"), + ) pd.testing.assert_series_equal( actual.to_pandas(), expected.to_pandas(), @@ -164,8 +199,9 @@ def test_json_extract_array_from_array_strings(): def test_json_extract_array_w_invalid_series_type(): + s = bpd.Series([1, 2]) with pytest.raises(TypeError): - bbq.json_extract_array(bpd.Series([1, 2])) + bbq.json_extract_array(s) def test_json_extract_string_array_from_json_strings(): @@ -203,14 +239,6 @@ def test_json_extract_string_array_w_invalid_series_type(): bbq.json_extract_string_array(bpd.Series([1, 2])) -# b/381148539 -def test_json_in_struct(): - df = bpd.read_gbq( - "SELECT STRUCT(JSON '{\\\"a\\\": 1}' AS data, 1 AS number) as struct_col" - ) - assert df["struct_col"].struct.field("data")[0] == '{"a":1}' - - def test_parse_json_w_invalid_series_type(): with pytest.raises(TypeError): bbq.parse_json(bpd.Series([1, 2])) diff --git a/tests/system/small/operations/test_plotting.py b/tests/system/small/operations/test_plotting.py index 3624232ea0..c2f3ba423f 100644 --- a/tests/system/small/operations/test_plotting.py +++ b/tests/system/small/operations/test_plotting.py @@ -34,10 +34,20 @@ def _check_legend_labels(ax, labels): assert label == e -def test_series_hist_bins(scalars_dfs): +@pytest.mark.parametrize( + ("alias"), + [ + pytest.param(True), + pytest.param(False), + ], +) +def test_series_hist_bins(scalars_dfs, alias): scalars_df, scalars_pandas_df = scalars_dfs bins = 5 - ax = scalars_df["int64_col"].plot.hist(bins=bins) + if alias: + ax = scalars_df["int64_col"].hist(bins=bins) + else: + ax = scalars_df["int64_col"].plot.hist(bins=bins) pd_ax = scalars_pandas_df["int64_col"].plot.hist(bins=bins) # Compares axis values and height between bigframes and pandas histograms. @@ -49,11 +59,21 @@ def test_series_hist_bins(scalars_dfs): assert ax.patches[i]._height == pd_ax.patches[i]._height -def test_dataframes_hist_bins(scalars_dfs): +@pytest.mark.parametrize( + ("alias"), + [ + pytest.param(True), + pytest.param(False), + ], +) +def test_dataframes_hist_bins(scalars_dfs, alias): scalars_df, scalars_pandas_df = scalars_dfs bins = 7 columns = ["int64_col", "int64_too", "float64_col"] - ax = scalars_df[columns].plot.hist(bins=bins) + if alias: + ax = scalars_df[columns].hist(bins=bins) + else: + ax = scalars_df[columns].plot.hist(bins=bins) pd_ax = scalars_pandas_df[columns].plot.hist(bins=bins) # Compares axis values and height between bigframes and pandas histograms. @@ -171,10 +191,25 @@ def test_hist_kwargs_ticks_props(scalars_dfs): tm.assert_almost_equal(ylabels[i].get_rotation(), pd_ylables[i].get_rotation()) -def test_line(scalars_dfs): +@pytest.mark.parametrize( + ("col_names", "alias"), + [ + pytest.param( + ["int64_col", "float64_col", "int64_too", "bool_col"], True, id="df_alias" + ), + pytest.param( + ["int64_col", "float64_col", "int64_too", "bool_col"], False, id="df" + ), + pytest.param(["int64_col"], True, id="series_alias"), + pytest.param(["int64_col"], False, id="series"), + ], +) +def test_line(scalars_dfs, col_names, alias): scalars_df, scalars_pandas_df = scalars_dfs - col_names = ["int64_col", "float64_col", "int64_too", "bool_col"] - ax = scalars_df[col_names].plot.line() + if alias: + ax = scalars_df[col_names].line() + else: + ax = scalars_df[col_names].plot.line() pd_ax = scalars_pandas_df[col_names].plot.line() tm.assert_almost_equal(ax.get_xticks(), pd_ax.get_xticks()) tm.assert_almost_equal(ax.get_yticks(), pd_ax.get_yticks()) @@ -183,10 +218,21 @@ def test_line(scalars_dfs): tm.assert_almost_equal(line.get_data()[1], pd_line.get_data()[1]) -def test_area(scalars_dfs): +@pytest.mark.parametrize( + ("col_names", "alias"), + [ + pytest.param(["int64_col", "float64_col", "int64_too"], True, id="df_alias"), + pytest.param(["int64_col", "float64_col", "int64_too"], False, id="df"), + pytest.param(["int64_col"], True, id="series_alias"), + pytest.param(["int64_col"], False, id="series"), + ], +) +def test_area(scalars_dfs, col_names, alias): scalars_df, scalars_pandas_df = scalars_dfs - col_names = ["int64_col", "float64_col", "int64_too"] - ax = scalars_df[col_names].plot.area(stacked=False) + if alias: + ax = scalars_df[col_names].area(stacked=False) + else: + ax = scalars_df[col_names].plot.area(stacked=False) pd_ax = scalars_pandas_df[col_names].plot.area(stacked=False) tm.assert_almost_equal(ax.get_xticks(), pd_ax.get_xticks()) tm.assert_almost_equal(ax.get_yticks(), pd_ax.get_yticks()) @@ -195,10 +241,21 @@ def test_area(scalars_dfs): tm.assert_almost_equal(line.get_data()[1], pd_line.get_data()[1]) -def test_bar(scalars_dfs): +@pytest.mark.parametrize( + ("col_names", "alias"), + [ + pytest.param(["int64_col", "float64_col", "int64_too"], True, id="df_alias"), + pytest.param(["int64_col", "float64_col", "int64_too"], False, id="df"), + pytest.param(["int64_col"], True, id="series_alias"), + pytest.param(["int64_col"], False, id="series"), + ], +) +def test_bar(scalars_dfs, col_names, alias): scalars_df, scalars_pandas_df = scalars_dfs - col_names = ["int64_col", "float64_col", "int64_too"] - ax = scalars_df[col_names].plot.bar() + if alias: + ax = scalars_df[col_names].bar() + else: + ax = scalars_df[col_names].plot.bar() pd_ax = scalars_pandas_df[col_names].plot.bar() tm.assert_almost_equal(ax.get_xticks(), pd_ax.get_xticks()) tm.assert_almost_equal(ax.get_yticks(), pd_ax.get_yticks()) @@ -207,10 +264,23 @@ def test_bar(scalars_dfs): tm.assert_almost_equal(line.get_data()[1], pd_line.get_data()[1]) -def test_scatter(scalars_dfs): +@pytest.mark.parametrize( + ("col_names", "alias"), + [ + pytest.param( + ["int64_col", "float64_col", "int64_too", "bool_col"], True, id="df_alias" + ), + pytest.param( + ["int64_col", "float64_col", "int64_too", "bool_col"], False, id="df" + ), + ], +) +def test_scatter(scalars_dfs, col_names, alias): scalars_df, scalars_pandas_df = scalars_dfs - col_names = ["int64_col", "float64_col", "int64_too", "bool_col"] - ax = scalars_df[col_names].plot.scatter(x="int64_col", y="float64_col") + if alias: + ax = scalars_df[col_names].scatter(x="int64_col", y="float64_col") + else: + ax = scalars_df[col_names].plot.scatter(x="int64_col", y="float64_col") pd_ax = scalars_pandas_df[col_names].plot.scatter(x="int64_col", y="float64_col") tm.assert_almost_equal(ax.get_xticks(), pd_ax.get_xticks()) tm.assert_almost_equal(ax.get_yticks(), pd_ax.get_yticks()) diff --git a/tests/system/small/test_dataframe.py b/tests/system/small/test_dataframe.py index e7d6ad67e1..4266cdba88 100644 --- a/tests/system/small/test_dataframe.py +++ b/tests/system/small/test_dataframe.py @@ -331,6 +331,17 @@ def test_where_series_cond(scalars_df_index, scalars_pandas_df_index): pandas.testing.assert_frame_equal(bf_result, pd_result) +def test_mask_series_cond(scalars_df_index, scalars_pandas_df_index): + cond_bf = scalars_df_index["int64_col"] > 0 + cond_pd = scalars_pandas_df_index["int64_col"] > 0 + + bf_df = scalars_df_index[["int64_too", "int64_col", "float64_col"]] + pd_df = scalars_pandas_df_index[["int64_too", "int64_col", "float64_col"]] + bf_result = bf_df.mask(cond_bf, bf_df + 1).to_pandas() + pd_result = pd_df.mask(cond_pd, pd_df + 1) + pandas.testing.assert_frame_equal(bf_result, pd_result) + + def test_where_series_multi_index(scalars_df_index, scalars_pandas_df_index): # Test when a dataframe has multi-index or multi-columns. columns = ["int64_col", "float64_col"] @@ -2235,6 +2246,72 @@ def test_cov_w_numeric_only(scalars_dfs_maybe_ordered, columns, numeric_only): ) +def test_df_corrwith_df(scalars_dfs_maybe_ordered): + scalars_df, scalars_pandas_df = scalars_dfs_maybe_ordered + + l_cols = ["int64_col", "float64_col", "int64_too"] + r_cols = ["int64_too", "float64_col"] + + bf_result = scalars_df[l_cols].corrwith(scalars_df[r_cols]).to_pandas() + pd_result = scalars_pandas_df[l_cols].corrwith(scalars_pandas_df[r_cols]) + + # BigFrames and Pandas differ in their data type handling: + # - Column types: BigFrames uses Float64, Pandas uses float64. + # - Index types: BigFrames uses strign, Pandas uses object. + pd.testing.assert_series_equal( + bf_result, pd_result, check_dtype=False, check_index_type=False + ) + + +def test_df_corrwith_df_numeric_only(scalars_dfs): + scalars_df, scalars_pandas_df = scalars_dfs + + l_cols = ["int64_col", "float64_col", "int64_too", "string_col"] + r_cols = ["int64_too", "float64_col", "bool_col"] + + bf_result = ( + scalars_df[l_cols].corrwith(scalars_df[r_cols], numeric_only=True).to_pandas() + ) + pd_result = scalars_pandas_df[l_cols].corrwith( + scalars_pandas_df[r_cols], numeric_only=True + ) + + # BigFrames and Pandas differ in their data type handling: + # - Column types: BigFrames uses Float64, Pandas uses float64. + # - Index types: BigFrames uses strign, Pandas uses object. + pd.testing.assert_series_equal( + bf_result, pd_result, check_dtype=False, check_index_type=False + ) + + +def test_df_corrwith_df_non_numeric_error(scalars_dfs): + scalars_df, _ = scalars_dfs + + l_cols = ["int64_col", "float64_col", "int64_too", "string_col"] + r_cols = ["int64_too", "float64_col", "bool_col"] + + with pytest.raises(NotImplementedError): + scalars_df[l_cols].corrwith(scalars_df[r_cols], numeric_only=False) + + +@skip_legacy_pandas +def test_df_corrwith_series(scalars_dfs_maybe_ordered): + scalars_df, scalars_pandas_df = scalars_dfs_maybe_ordered + + l_cols = ["int64_col", "float64_col", "int64_too"] + r_col = "float64_col" + + bf_result = scalars_df[l_cols].corrwith(scalars_df[r_col]).to_pandas() + pd_result = scalars_pandas_df[l_cols].corrwith(scalars_pandas_df[r_col]) + + # BigFrames and Pandas differ in their data type handling: + # - Column types: BigFrames uses Float64, Pandas uses float64. + # - Index types: BigFrames uses strign, Pandas uses object. + pd.testing.assert_series_equal( + bf_result, pd_result, check_dtype=False, check_index_type=False + ) + + @pytest.mark.parametrize( ("op"), [ diff --git a/tests/system/small/test_dataframe_io.py b/tests/system/small/test_dataframe_io.py index 848e21f6bd..10637b2395 100644 --- a/tests/system/small/test_dataframe_io.py +++ b/tests/system/small/test_dataframe_io.py @@ -12,8 +12,10 @@ # See the License for the specific language governing permissions and # limitations under the License. +import math from typing import Tuple +import db_dtypes # type:ignore import google.api_core.exceptions import pandas as pd import pandas.testing @@ -247,23 +249,146 @@ def test_to_pandas_array_struct_correct_result(session): ) -def test_load_json(session): - df = session.read_gbq( - """SELECT - JSON_OBJECT('foo', 10, 'bar', TRUE) AS json_column - """ - ) - +def test_load_json_w_unboxed_py_value(session): + sql = """ + SELECT 0 AS id, JSON_OBJECT('boolean', True) AS json_col, + UNION ALL + SELECT 1, JSON_OBJECT('int', 100), + UNION ALL + SELECT 2, JSON_OBJECT('float', 0.98), + UNION ALL + SELECT 3, JSON_OBJECT('string', 'hello world'), + UNION ALL + SELECT 4, JSON_OBJECT('array', [8, 9, 10]), + UNION ALL + SELECT 5, JSON_OBJECT('null', null), + UNION ALL + SELECT + 6, + JSON_OBJECT( + 'dict', + JSON_OBJECT( + 'int', 1, + 'array', [JSON_OBJECT('bar', 'hello'), JSON_OBJECT('foo', 1)] + ) + ), + """ + df = session.read_gbq(sql, index_col="id") + + assert df.dtypes["json_col"] == db_dtypes.JSONDtype() + assert isinstance(df["json_col"][0], dict) + + assert df["json_col"][0]["boolean"] + assert df["json_col"][1]["int"] == 100 + assert math.isclose(df["json_col"][2]["float"], 0.98) + assert df["json_col"][3]["string"] == "hello world" + assert df["json_col"][4]["array"] == [8, 9, 10] + assert df["json_col"][5]["null"] is None + assert df["json_col"][6]["dict"] == { + "int": 1, + "array": [{"bar": "hello"}, {"foo": 1}], + } + + +def test_load_json_to_pandas_has_correct_result(session): + df = session.read_gbq("SELECT JSON_OBJECT('foo', 10, 'bar', TRUE) AS json_col") + assert df.dtypes["json_col"] == db_dtypes.JSONDtype() result = df.to_pandas() - expected = pd.DataFrame( - { - "json_column": ['{"bar":true,"foo":10}'], - }, - dtype=pd.ArrowDtype(pa.large_string()), - ) - expected.index = expected.index.astype("Int64") - pd.testing.assert_series_equal(result.dtypes, expected.dtypes) - pd.testing.assert_series_equal(result["json_column"], expected["json_column"]) + + # The order of keys within the JSON object shouldn't matter for equality checks. + pd_df = pd.DataFrame( + {"json_col": [{"bar": True, "foo": 10}]}, + dtype=db_dtypes.JSONDtype(), + ) + pd_df.index = pd_df.index.astype("Int64") + pd.testing.assert_series_equal(result.dtypes, pd_df.dtypes) + pd.testing.assert_series_equal(result["json_col"], pd_df["json_col"]) + + +def test_load_json_in_struct(session): + """Avoid regressions for internal issue 381148539.""" + sql = """ + SELECT 0 AS id, STRUCT(JSON_OBJECT('boolean', True) AS data, 1 AS number) AS struct_col + UNION ALL + SELECT 1, STRUCT(JSON_OBJECT('int', 100), 2), + UNION ALL + SELECT 2, STRUCT(JSON_OBJECT('float', 0.98), 3), + UNION ALL + SELECT 3, STRUCT(JSON_OBJECT('string', 'hello world'), 4), + UNION ALL + SELECT 4, STRUCT(JSON_OBJECT('array', [8, 9, 10]), 5), + UNION ALL + SELECT 5, STRUCT(JSON_OBJECT('null', null), 6), + UNION ALL + SELECT + 6, + STRUCT(JSON_OBJECT( + 'dict', + JSON_OBJECT( + 'int', 1, + 'array', [JSON_OBJECT('bar', 'hello'), JSON_OBJECT('foo', 1)] + ) + ), 7), + """ + df = session.read_gbq(sql, index_col="id") + + assert isinstance(df.dtypes["struct_col"], pd.ArrowDtype) + assert isinstance(df.dtypes["struct_col"].pyarrow_dtype, pa.StructType) + + data = df["struct_col"].struct.field("data") + assert data.dtype == db_dtypes.JSONDtype() + + assert data[0]["boolean"] + assert data[1]["int"] == 100 + assert math.isclose(data[2]["float"], 0.98) + assert data[3]["string"] == "hello world" + assert data[4]["array"] == [8, 9, 10] + assert data[5]["null"] is None + assert data[6]["dict"] == { + "int": 1, + "array": [{"bar": "hello"}, {"foo": 1}], + } + + +def test_load_json_in_array(session): + sql = """ + SELECT + 0 AS id, + [ + JSON_OBJECT('boolean', True), + JSON_OBJECT('int', 100), + JSON_OBJECT('float', 0.98), + JSON_OBJECT('string', 'hello world'), + JSON_OBJECT('array', [8, 9, 10]), + JSON_OBJECT('null', null), + JSON_OBJECT( + 'dict', + JSON_OBJECT( + 'int', 1, + 'array', [JSON_OBJECT('bar', 'hello'), JSON_OBJECT('foo', 1)] + ) + ) + ] AS array_col, + """ + df = session.read_gbq(sql, index_col="id") + + assert isinstance(df.dtypes["array_col"], pd.ArrowDtype) + assert isinstance(df.dtypes["array_col"].pyarrow_dtype, pa.ListType) + + data = df["array_col"].list + assert data.len()[0] == 7 + assert data[0].dtype == db_dtypes.JSONDtype() + + assert data[0][0]["boolean"] + assert data[1][0]["int"] == 100 + assert math.isclose(data[2][0]["float"], 0.98) + assert data[3][0]["string"] == "hello world" + assert data[4][0]["array"] == [8, 9, 10] + assert data[5][0]["null"] is None + assert data[6][0]["dict"] == { + "int": 1, + "array": [{"bar": "hello"}, {"foo": 1}], + } def test_to_pandas_batches_w_correct_dtypes(scalars_df_default_index): diff --git a/tests/system/small/test_pandas.py b/tests/system/small/test_pandas.py index 30ffaa8a7d..e46d073056 100644 --- a/tests/system/small/test_pandas.py +++ b/tests/system/small/test_pandas.py @@ -13,6 +13,7 @@ # limitations under the License. from datetime import datetime +import typing import pandas as pd import pytest @@ -726,3 +727,69 @@ def test_to_datetime_timestamp_inputs(arg, utc, output_in_utc): pd.testing.assert_series_equal( bf_result, pd_result, check_index_type=False, check_names=False ) + + +@pytest.mark.parametrize( + "unit", + [ + "W", + "w", + "D", + "d", + "days", + "day", + "hours", + "hour", + "hr", + "h", + "m", + "minute", + "min", + "minutes", + "s", + "seconds", + "sec", + "second", + "ms", + "milliseconds", + "millisecond", + "milli", + "millis", + "us", + "microseconds", + "microsecond", + "µs", + "micro", + "micros", + ], +) +def test_to_timedelta_with_bf_series(session, unit): + bf_series = bpd.Series([1, 2, 3], session=session) + pd_series = pd.Series([1, 2, 3]) + + actual_result = ( + typing.cast(bpd.Series, bpd.to_timedelta(bf_series, unit)) + .to_pandas() + .astype("timedelta64[ns]") + ) + + expected_result = pd.to_timedelta(pd_series, unit) + pd.testing.assert_series_equal( + actual_result, expected_result, check_index_type=False + ) + + +@pytest.mark.parametrize( + "unit", + ["Y", "M", "whatever"], +) +def test_to_timedelta_with_bf_series_invalid_unit(session, unit): + bf_series = bpd.Series([1, 2, 3], session=session) + + with pytest.raises(TypeError): + bpd.to_timedelta(bf_series, unit) + + +@pytest.mark.parametrize("input", [1, 1.2, "1s"]) +def test_to_timedelta_non_bf_series(input): + assert bpd.to_timedelta(input) == pd.to_timedelta(input) diff --git a/tests/system/small/test_remote_function.py b/tests/system/small/test_remote_function.py index c3f3890459..0dc8960f62 100644 --- a/tests/system/small/test_remote_function.py +++ b/tests/system/small/test_remote_function.py @@ -25,8 +25,8 @@ import bigframes import bigframes.dtypes import bigframes.exceptions -from bigframes.functions import _utils as rf_utils -from bigframes.functions import remote_function as rf +from bigframes.functions import _utils as bff_utils +from bigframes.functions import function as bff from tests.system.utils import assert_pandas_df_equal _prefixer = test_utils.prefixer.Prefixer("bigframes", "") @@ -94,12 +94,12 @@ def get_rf_name(func, package_requirements=None, is_row_processor=False): """Get a remote function name for testing given a udf.""" # Augment user package requirements with any internal package # requirements - package_requirements = rf_utils._get_updated_package_requirements( + package_requirements = bff_utils._get_updated_package_requirements( package_requirements, is_row_processor ) # Compute a unique hash representing the user code - function_hash = rf_utils._get_hash(func, package_requirements) + function_hash = bff_utils._get_hash(func, package_requirements) return f"bigframes_{function_hash}" @@ -117,7 +117,7 @@ def test_remote_function_direct_no_session_param( def square(x): return x * x - square = rf.remote_function( + square = bff.remote_function( int, int, bigquery_client=bigquery_client, @@ -176,7 +176,7 @@ def test_remote_function_direct_no_session_param_location_specified( def square(x): return x * x - square = rf.remote_function( + square = bff.remote_function( int, int, bigquery_client=bigquery_client, @@ -235,7 +235,7 @@ def square(x): ValueError, match=re.escape("The location does not match BigQuery connection location:"), ): - rf.remote_function( + bff.remote_function( int, int, bigquery_client=bigquery_client, @@ -263,7 +263,7 @@ def test_remote_function_direct_no_session_param_location_project_specified( def square(x): return x * x - square = rf.remote_function( + square = bff.remote_function( int, int, bigquery_client=bigquery_client, @@ -324,7 +324,7 @@ def square(x): "The project_id does not match BigQuery connection gcp_project_id:" ), ): - rf.remote_function( + bff.remote_function( int, int, bigquery_client=bigquery_client, @@ -346,7 +346,7 @@ def test_remote_function_direct_session_param( def square(x): return x * x - square = rf.remote_function( + square = bff.remote_function( int, int, session=session_with_bq_connection, @@ -636,7 +636,7 @@ def add_one(x): def test_read_gbq_function_detects_invalid_function(session, dataset_id): dataset_ref = bigquery.DatasetReference.from_string(dataset_id) with pytest.raises(ValueError) as e: - rf.read_gbq_function( + bff.read_gbq_function( str(dataset_ref.routine("not_a_function")), session=session, ) @@ -658,7 +658,7 @@ def test_read_gbq_function_like_original( def square1(x): return x * x - square1 = rf.remote_function( + square1 = bff.remote_function( [int], int, bigquery_client=bigquery_client, @@ -674,7 +674,7 @@ def square1(x): # Function should still work normally. assert square1(2) == 4 - square2 = rf.read_gbq_function( + square2 = bff.read_gbq_function( function_name=square1.bigframes_remote_function, # type: ignore session=session, ) @@ -745,7 +745,7 @@ def test_read_gbq_function_reads_udfs(session, bigquery_client, dataset_id): for routine in (sql_routine, js_routine): # Create the routine in BigQuery and read it back using read_gbq_function. bigquery_client.create_routine(routine, exists_ok=True) - square = rf.read_gbq_function( + square = bff.read_gbq_function( str(routine.reference), session=session, ) @@ -757,7 +757,7 @@ def test_read_gbq_function_reads_udfs(session, bigquery_client, dataset_id): src = {"x": [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]} - routine_ref_str = rf_utils.routine_ref_to_string_for_query(routine.reference) + routine_ref_str = bff_utils.routine_ref_to_string_for_query(routine.reference) direct_sql = " UNION ALL ".join( [f"SELECT {x} AS x, {routine_ref_str}({x}) AS y" for x in src["x"]] ) @@ -818,7 +818,7 @@ def test_read_gbq_function_requires_explicit_types( bigquery_client.create_routine(only_arg_type_specified, exists_ok=True) bigquery_client.create_routine(neither_type_specified, exists_ok=True) - rf.read_gbq_function( + bff.read_gbq_function( str(both_types_specified.reference), session=session, ) @@ -826,17 +826,17 @@ def test_read_gbq_function_requires_explicit_types( bigframes.exceptions.UnknownDataTypeWarning, match="missing input data types.*assume default data type", ): - rf.read_gbq_function( + bff.read_gbq_function( str(only_return_type_specified.reference), session=session, ) with pytest.raises(ValueError): - rf.read_gbq_function( + bff.read_gbq_function( str(only_arg_type_specified.reference), session=session, ) with pytest.raises(ValueError): - rf.read_gbq_function( + bff.read_gbq_function( str(neither_type_specified.reference), session=session, ) @@ -878,13 +878,13 @@ def test_read_gbq_function_respects_python_output_type( body="TO_JSON_STRING([x, x+1, x+2])", arguments=[arg], return_type=bigquery.StandardSqlDataType(bigquery.StandardSqlTypeNames.STRING), - description=rf_utils.get_bigframes_metadata(python_output_type=array_type), + description=bff_utils.get_bigframes_metadata(python_output_type=array_type), type_=bigquery.RoutineType.SCALAR_FUNCTION, ) # Create the routine in BigQuery and read it back using read_gbq_function. bigquery_client.create_routine(sql_routine, exists_ok=True) - func = rf.read_gbq_function(str(sql_routine.reference), session=session) + func = bff.read_gbq_function(str(sql_routine.reference), session=session) # test that the function works as expected s = bigframes.series.Series([1, 10, 100]) @@ -920,7 +920,7 @@ def test_read_gbq_function_supports_python_output_type_only_for_string_outputs( body="x+1", arguments=[arg], return_type=bigquery.StandardSqlDataType(bigquery.StandardSqlTypeNames.INT64), - description=rf_utils.get_bigframes_metadata(python_output_type=array_type), + description=bff_utils.get_bigframes_metadata(python_output_type=array_type), type_=bigquery.RoutineType.SCALAR_FUNCTION, ) @@ -933,7 +933,7 @@ def test_read_gbq_function_supports_python_output_type_only_for_string_outputs( TypeError, match="An explicit output_type should be provided only for a BigQuery function with STRING output.", ): - rf.read_gbq_function(str(sql_routine.reference), session=session) + bff.read_gbq_function(str(sql_routine.reference), session=session) @pytest.mark.parametrize( @@ -959,13 +959,13 @@ def test_read_gbq_function_supported_python_output_type( body="CAST(x AS STRING)", arguments=[arg], return_type=bigquery.StandardSqlDataType(bigquery.StandardSqlTypeNames.STRING), - description=rf_utils.get_bigframes_metadata(python_output_type=array_type), + description=bff_utils.get_bigframes_metadata(python_output_type=array_type), type_=bigquery.RoutineType.SCALAR_FUNCTION, ) # Create the routine in BigQuery and read it back using read_gbq_function. bigquery_client.create_routine(sql_routine, exists_ok=True) - rf.read_gbq_function(str(sql_routine.reference), session=session) + bff.read_gbq_function(str(sql_routine.reference), session=session) @pytest.mark.flaky(retries=2, delay=120) diff --git a/tests/system/small/test_series.py b/tests/system/small/test_series.py index 670828f616..3d76122e9d 100644 --- a/tests/system/small/test_series.py +++ b/tests/system/small/test_series.py @@ -17,6 +17,7 @@ import re import tempfile +import db_dtypes # type: ignore import geopandas as gpd # type: ignore import numpy from packaging.version import Version @@ -281,7 +282,7 @@ def test_get_column(scalars_dfs, col_name, expected_dtype): def test_get_column_w_json(json_df, json_pandas_df): series = json_df["json_col"] series_pandas = series.to_pandas() - assert series.dtype == pd.ArrowDtype(pa.large_string()) + assert series.dtype == db_dtypes.JSONDtype() assert series_pandas.shape[0] == json_pandas_df.shape[0] diff --git a/tests/system/utils.py b/tests/system/utils.py index 83d0e683bc..7c12c8033a 100644 --- a/tests/system/utils.py +++ b/tests/system/utils.py @@ -26,7 +26,7 @@ import pyarrow as pa # type: ignore import pytest -import bigframes.functions._utils as functions_utils +import bigframes.functions._utils as bff_utils import bigframes.pandas ML_REGRESSION_METRICS = [ @@ -351,7 +351,7 @@ def get_cloud_functions( not name or not name_prefix ), "Either 'name' or 'name_prefix' can be passed but not both." - _, location = functions_utils.get_remote_function_locations(location) + _, location = bff_utils.get_remote_function_locations(location) parent = f"projects/{project}/locations/{location}" request = functions_v2.ListFunctionsRequest(parent=parent) page_result = functions_client.list_functions(request=request) diff --git a/tests/unit/functions/test_remote_function_template.py b/tests/unit/functions/test_function_template.py similarity index 92% rename from tests/unit/functions/test_remote_function_template.py rename to tests/unit/functions/test_function_template.py index 70b033d938..11db01ed9e 100644 --- a/tests/unit/functions/test_remote_function_template.py +++ b/tests/unit/functions/test_function_template.py @@ -20,7 +20,7 @@ import pytest import bigframes.dtypes -import bigframes.functions.remote_function_template as remote_function_template +import bigframes.functions.function_template as bff_template HELLO_WORLD_BASE64_BYTES = b"SGVsbG8sIFdvcmxkIQ==" HELLO_WORLD_BASE64_STR = "SGVsbG8sIFdvcmxkIQ==" @@ -59,7 +59,7 @@ ), ) def test_convert_from_bq_json(type_, json_value, expected): - got = remote_function_template.convert_from_bq_json(type_, json_value) + got = bff_template.convert_from_bq_json(type_, json_value) assert got == expected @@ -76,7 +76,7 @@ def test_convert_from_bq_json(type_, json_value, expected): ], ) def test_convert_from_bq_json_none(type_): - got = remote_function_template.convert_from_bq_json(type_, None) + got = bff_template.convert_from_bq_json(type_, None) assert got is None @@ -113,7 +113,7 @@ def test_convert_from_bq_json_none(type_): ), ) def test_convert_to_bq_json(type_, value, expected): - got = remote_function_template.convert_to_bq_json(type_, value) + got = bff_template.convert_to_bq_json(type_, value) assert got == expected @@ -130,7 +130,7 @@ def test_convert_to_bq_json(type_, value, expected): ], ) def test_convert_to_bq_json_none(type_): - got = remote_function_template.convert_to_bq_json(type_, None) + got = bff_template.convert_to_bq_json(type_, None) assert got is None @@ -176,7 +176,7 @@ def test_convert_to_bq_json_none(type_): ), ) def test_get_pd_series(row_json, expected): - got = remote_function_template.get_pd_series(row_json) + got = bff_template.get_pd_series(row_json) pandas.testing.assert_series_equal(got, expected) diff --git a/tests/unit/polars_session.py b/tests/unit/polars_session.py index dfb1f5bfa6..cffd8ff7ca 100644 --- a/tests/unit/polars_session.py +++ b/tests/unit/polars_session.py @@ -82,7 +82,7 @@ def __init__(self): self._allow_ambiguity = False # type: ignore self._default_index_type = bigframes.enums.DefaultIndexKind.SEQUENTIAL_INT64 self._metrics = bigframes.session.metrics.ExecutionMetrics() - self._remote_function_session = None # type: ignore + self._function_session = None # type: ignore self._temp_storage_manager = None # type: ignore self._executor = TestExecutor() self._loader = None # type: ignore diff --git a/tests/unit/test_remote_function.py b/tests/unit/test_remote_function.py index a8c4f2ac2e..413a694680 100644 --- a/tests/unit/test_remote_function.py +++ b/tests/unit/test_remote_function.py @@ -21,7 +21,7 @@ import bigframes.core.compile.ibis_types import bigframes.dtypes -import bigframes.functions.remote_function +import bigframes.functions.function as bff import bigframes.series from tests.unit import resources @@ -42,9 +42,7 @@ def test_series_input_types_to_str(series_type): """Check that is_row_processor=True uses str as the input type to serialize a row.""" session = resources.create_bigquery_session() - remote_function_decorator = bigframes.functions.remote_function.remote_function( - session=session - ) + remote_function_decorator = bff.remote_function(session=session) with pytest.warns( bigframes.exceptions.PreviewWarning, @@ -75,9 +73,7 @@ def test_supported_types_correspond(): def test_missing_input_types(): session = resources.create_bigquery_session() - remote_function_decorator = bigframes.functions.remote_function.remote_function( - session=session - ) + remote_function_decorator = bff.remote_function(session=session) def function_without_parameter_annotations(myparam) -> str: return str(myparam) @@ -93,9 +89,7 @@ def function_without_parameter_annotations(myparam) -> str: def test_missing_output_type(): session = resources.create_bigquery_session() - remote_function_decorator = bigframes.functions.remote_function.remote_function( - session=session - ) + remote_function_decorator = bff.remote_function(session=session) def function_without_return_annotation(myparam: int): return str(myparam) diff --git a/third_party/bigframes_vendored/pandas/core/frame.py b/third_party/bigframes_vendored/pandas/core/frame.py index c8ca1b74b5..f5aa23d00b 100644 --- a/third_party/bigframes_vendored/pandas/core/frame.py +++ b/third_party/bigframes_vendored/pandas/core/frame.py @@ -2048,6 +2048,98 @@ def where(self, cond, other): """ raise NotImplementedError(constants.ABSTRACT_METHOD_ERROR_MESSAGE) + def mask(self, cond, other): + """Replace values where the condition is False. + + **Examples:** + + >>> import bigframes.pandas as bpd + >>> bpd.options.display.progress_bar = None + + >>> df = bpd.DataFrame({'a': [20, 10, 0], 'b': [0, 10, 20]}) + >>> df + a b + 0 20 0 + 1 10 10 + 2 0 20 + + [3 rows x 2 columns] + + You can filter the values in the dataframe based on a condition. The + values matching the condition would be kept, and not matching would be + replaced. The default replacement value is ``NA``. For example, when the + condition is a dataframe: + + >>> df.mask(df > 0) + a b + 0 0 + 1 + 2 0 + + [3 rows x 2 columns] + + You can specify a custom replacement value for non-matching values. + + >>> df.mask(df > 0, -1) + a b + 0 -1 0 + 1 -1 -1 + 2 0 -1 + + [3 rows x 2 columns] + + Besides dataframe, the condition can be a series too. For example: + + >>> df.mask(df['a'] > 10, -1) + a b + 0 -1 -1 + 1 10 10 + 2 0 20 + + [3 rows x 2 columns] + + As for the replacement, it can be a dataframe too. For example: + + >>> df.mask(df > 10, -df) + a b + 0 -20 0 + 1 10 10 + 2 0 -20 + + [3 rows x 2 columns] + + >>> df.mask(df['a'] > 10, -df) + a b + 0 -20 0 + 1 10 10 + 2 0 20 + + [3 rows x 2 columns] + + Please note, replacement doesn't support Series for now. In pandas, when + specifying a Series as replacement, the axis value should be specified + at the same time, which is not supported in bigframes DataFrame. + + Args: + cond (bool Series/DataFrame, array-like, or callable): + Where cond is False, keep the original value. Where True, replace + with corresponding value from other. If cond is callable, it is + computed on the Series/DataFrame and returns boolean + Series/DataFrame or array. The callable must not change input + Series/DataFrame (though pandas doesn’t check it). + other (scalar, DataFrame, or callable): + Entries where cond is True are replaced with corresponding value + from other. If other is callable, it is computed on the + DataFrame and returns scalar or DataFrame. The callable must not + change input DataFrame (though pandas doesn’t check it). If not + specified, entries will be filled with the corresponding NULL + value (np.nan for numpy dtypes, pd.NA for extension dtypes). + + Returns: + DataFrame: DataFrame after the replacement. + """ + raise NotImplementedError(constants.ABSTRACT_METHOD_ERROR_MESSAGE) + # ---------------------------------------------------------------------- # Sorting @@ -4054,6 +4146,47 @@ def cov(self, *, numeric_only) -> DataFrame: """ raise NotImplementedError(constants.ABSTRACT_METHOD_ERROR_MESSAGE) + def corrwith( + self, + other, + *, + numeric_only: bool = False, + ): + """ + Compute pairwise correlation. + + Pairwise correlation is computed between rows or columns of + DataFrame with rows or columns of Series or DataFrame. DataFrames + are first aligned along both axes before computing the + correlations. + + **Examples:** + >>> import bigframes.pandas as bpd + >>> bpd.options.display.progress_bar = None + + >>> index = ["a", "b", "c", "d", "e"] + >>> columns = ["one", "two", "three", "four"] + >>> df1 = bpd.DataFrame(np.arange(20).reshape(5, 4), index=index, columns=columns) + >>> df2 = bpd.DataFrame(np.arange(16).reshape(4, 4), index=index[:4], columns=columns) + >>> df1.corrwith(df2) + one 1.0 + two 1.0 + three 1.0 + four 1.0 + dtype: Float64 + + Args: + other (DataFrame, Series): + Object with which to compute correlations. + + numeric_only (bool, default False): + Include only `float`, `int` or `boolean` data. + + Returns: + bigframes.pandas.Series: Pairwise correlations. + """ + raise NotImplementedError(constants.ABSTRACT_METHOD_ERROR_MESSAGE) + def update( self, other, join: str = "left", overwrite: bool = True, filter_func=None ) -> DataFrame: diff --git a/third_party/bigframes_vendored/pandas/core/tools/timedeltas.py b/third_party/bigframes_vendored/pandas/core/tools/timedeltas.py new file mode 100644 index 0000000000..9442e965fa --- /dev/null +++ b/third_party/bigframes_vendored/pandas/core/tools/timedeltas.py @@ -0,0 +1,99 @@ +# Contains code from https://github.com/pandas-dev/pandas/blob/v2.2.3/pandas/core/tools/timedeltas.py + +import typing + +from bigframes_vendored import constants +import pandas as pd + +from bigframes import series + +UnitChoices = typing.Literal[ + "W", + "w", + "D", + "d", + "days", + "day", + "hours", + "hour", + "hr", + "h", + "m", + "minute", + "min", + "minutes", + "s", + "seconds", + "sec", + "second", + "ms", + "milliseconds", + "millisecond", + "milli", + "millis", + "us", + "microseconds", + "microsecond", + "µs", + "micro", + "micros", +] + + +def to_timedelta( + arg: typing.Union[series.Series, str, int, float], + unit: typing.Optional[UnitChoices] = None, +) -> typing.Union[series.Series, pd.Timedelta]: + """ + Converts a scalar or Series to a timedelta object. + + .. note:: + BigQuery only supports precision up to microseconds (us). Therefore, when working + with timedeltas that have a finer granularity than microseconds, be aware that + the additional precision will not be represented in BigQuery. + + **Examples:** + + >>> import bigframes.pandas as bpd + >>> bpd.options.display.progress_bar = None + + Converting a Scalar to timedelta + + >>> scalar = 2 + >>> bpd.to_timedelta(scalar, unit='s') + Timedelta('0 days 00:00:02') + + Converting a Series of integers to a Series of timedeltas + + >>> int_series = bpd.Series([1,2,3]) + >>> bpd.to_timedelta(int_series, unit='s') + 0 0 days 00:00:01 + 1 0 days 00:00:02 + 2 0 days 00:00:03 + dtype: duration[us][pyarrow] + + Args: + arg (int, float, str, Series): + The object to convert to a dataframe + unit (str, default 'us'): + Denotes the unit of the arg for numeric `arg`. Defaults to ``"us"``. + + Possible values: + + * 'W' + * 'D' / 'days' / 'day' + * 'hours' / 'hour' / 'hr' / 'h' / 'H' + * 'm' / 'minute' / 'min' / 'minutes' + * 's' / 'seconds' / 'sec' / 'second' + * 'ms' / 'milliseconds' / 'millisecond' / 'milli' / 'millis' + * 'us' / 'microseconds' / 'microsecond' / 'micro' / 'micros' + + Returns: + Union[pandas.Timedelta, bigframes.pandas.Series]: + Return type depends on input + - Series: Series of duration[us][pyarrow] dtype + - scalar: timedelta + + """ + + raise NotImplementedError(constants.ABSTRACT_METHOD_ERROR_MESSAGE) diff --git a/third_party/bigframes_vendored/version.py b/third_party/bigframes_vendored/version.py index 50dde36b01..1fef294cef 100644 --- a/third_party/bigframes_vendored/version.py +++ b/third_party/bigframes_vendored/version.py @@ -12,4 +12,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "1.33.0" +__version__ = "1.34.0"