diff --git a/CHANGELOG.md b/CHANGELOG.md index c36d024ce7..bfa43f7fc4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,41 @@ [1]: https://pypi.org/project/bigframes/#history +## [2.16.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v2.15.0...v2.16.0) (2025-08-20) + + +### Features + +* Add `bigframes.pandas.options.display.precision` option ([#1979](https://github.com/googleapis/python-bigquery-dataframes/issues/1979)) ([15e6175](https://github.com/googleapis/python-bigquery-dataframes/commit/15e6175ec0aeb1b7b02d0bba9e8e1e018bd11c31)) +* Add level, inplace params to reset_index ([#1988](https://github.com/googleapis/python-bigquery-dataframes/issues/1988)) ([3446950](https://github.com/googleapis/python-bigquery-dataframes/commit/34469504b79a082d3380f9f25c597483aef2068a)) +* Add ML code samples from dbt blog post ([#1978](https://github.com/googleapis/python-bigquery-dataframes/issues/1978)) ([ebaa244](https://github.com/googleapis/python-bigquery-dataframes/commit/ebaa244a9eb7b87f7f9fd9c3bebe5c7db24cd013)) +* Add where, coalesce, fillna, casewhen, invert local impl ([#1976](https://github.com/googleapis/python-bigquery-dataframes/issues/1976)) ([f7f686c](https://github.com/googleapis/python-bigquery-dataframes/commit/f7f686cf85ab7e265d9c07ebc7f0cd59babc5357)) +* Adjust anywidget CSS to prevent overflow ([#1981](https://github.com/googleapis/python-bigquery-dataframes/issues/1981)) ([204f083](https://github.com/googleapis/python-bigquery-dataframes/commit/204f083a2f00fcc9fd1500dcd7a738eda3904d2f)) +* Format page number in table widget ([#1992](https://github.com/googleapis/python-bigquery-dataframes/issues/1992)) ([e83836e](https://github.com/googleapis/python-bigquery-dataframes/commit/e83836e8e1357f009f3f95666f1661bdbe0d3751)) +* Or, And, Xor can execute locally ([#1994](https://github.com/googleapis/python-bigquery-dataframes/issues/1994)) ([59c52a5](https://github.com/googleapis/python-bigquery-dataframes/commit/59c52a55ebea697855eb4c70529e226cc077141f)) +* Support callable bigframes function for dataframe where ([#1990](https://github.com/googleapis/python-bigquery-dataframes/issues/1990)) ([44c1ec4](https://github.com/googleapis/python-bigquery-dataframes/commit/44c1ec48cc4db1c4c9c15ec1fab43d4ef0758e56)) +* Support callable for series where method ([#2005](https://github.com/googleapis/python-bigquery-dataframes/issues/2005)) ([768b82a](https://github.com/googleapis/python-bigquery-dataframes/commit/768b82af96a5dd0c434edcb171036eb42cfb9b41)) +* When using `repr_mode = "anywidget"`, numeric values align right ([15e6175](https://github.com/googleapis/python-bigquery-dataframes/commit/15e6175ec0aeb1b7b02d0bba9e8e1e018bd11c31)) + + +### Bug Fixes + +* Address the packages issue for bigframes function ([#1991](https://github.com/googleapis/python-bigquery-dataframes/issues/1991)) ([68f1d22](https://github.com/googleapis/python-bigquery-dataframes/commit/68f1d22d5ed8457a5cabc7751ed1d178063dd63e)) +* Correct pypdf dependency specifier for remote PDF functions ([#1980](https://github.com/googleapis/python-bigquery-dataframes/issues/1980)) ([0bd5e1b](https://github.com/googleapis/python-bigquery-dataframes/commit/0bd5e1b3c004124d2100c3fbec2fbe1e965d1e96)) +* Enable default retries in calls to BQ Storage Read API ([#1985](https://github.com/googleapis/python-bigquery-dataframes/issues/1985)) ([f25d7bd](https://github.com/googleapis/python-bigquery-dataframes/commit/f25d7bd30800dffa65b6c31b0b7ac711a13d790f)) +* Fix the copyright year in dbt sample files ([#1996](https://github.com/googleapis/python-bigquery-dataframes/issues/1996)) ([fad5722](https://github.com/googleapis/python-bigquery-dataframes/commit/fad57223d129f0c95d0c6a066179bb66880edd06)) + + +### Performance Improvements + +* Faster session startup by defering anon dataset fetch ([#1982](https://github.com/googleapis/python-bigquery-dataframes/issues/1982)) ([2720c4c](https://github.com/googleapis/python-bigquery-dataframes/commit/2720c4cf070bf57a0930d7623bfc41d89cc053ee)) + + +### Documentation + +* Add examples of running bigframes in kaggle ([#2002](https://github.com/googleapis/python-bigquery-dataframes/issues/2002)) ([7d89d76](https://github.com/googleapis/python-bigquery-dataframes/commit/7d89d76976595b75cb0105fbe7b4f7ca2fdf49f2)) +* Remove preview warning from partial ordering mode sample notebook ([#1986](https://github.com/googleapis/python-bigquery-dataframes/issues/1986)) ([132e0ed](https://github.com/googleapis/python-bigquery-dataframes/commit/132e0edfe9f96c15753649d77fcb6edd0b0708a3)) + ## [2.15.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v2.14.0...v2.15.0) (2025-08-11) diff --git a/bigframes/_config/display_options.py b/bigframes/_config/display_options.py index 430abc8ef0..360292dd80 100644 --- a/bigframes/_config/display_options.py +++ b/bigframes/_config/display_options.py @@ -26,8 +26,12 @@ class DisplayOptions: __doc__ = vendored_pandas_config.display_options_doc + # Options borrowed from pandas. max_columns: int = 20 - max_rows: int = 25 + max_rows: int = 10 + precision: int = 6 + + # Options unique to BigQuery DataFrames. progress_bar: Optional[str] = "auto" repr_mode: Literal["head", "deferred", "anywidget"] = "head" @@ -52,6 +56,8 @@ def pandas_repr(display_options: DisplayOptions): display_options.max_columns, "display.max_rows", display_options.max_rows, + "display.precision", + display_options.precision, "display.show_dimensions", True, ) as pandas_context: diff --git a/bigframes/blob/_functions.py b/bigframes/blob/_functions.py index 51c030a23b..8d1ca38e62 100644 --- a/bigframes/blob/_functions.py +++ b/bigframes/blob/_functions.py @@ -473,7 +473,9 @@ def pdf_extract_func(src_obj_ref_rt: str) -> str: return result_json -pdf_extract_def = FunctionDef(pdf_extract_func, ["pypdf", "requests", "pypdf[crypto]"]) +pdf_extract_def = FunctionDef( + pdf_extract_func, ["pypdf>=5.3.1,<6.0.0", "requests", "cryptography==43.0.3"] +) # Extracts text from a PDF url and chunks it simultaneously @@ -527,4 +529,6 @@ def pdf_chunk_func(src_obj_ref_rt: str, chunk_size: int, overlap_size: int) -> s return result_json -pdf_chunk_def = FunctionDef(pdf_chunk_func, ["pypdf", "requests", "pypdf[crypto]"]) +pdf_chunk_def = FunctionDef( + pdf_chunk_func, ["pypdf>=5.3.1,<6.0.0", "requests", "cryptography==43.0.3"] +) diff --git a/bigframes/core/blocks.py b/bigframes/core/blocks.py index c8632ebc8c..d2662da509 100644 --- a/bigframes/core/blocks.py +++ b/bigframes/core/blocks.py @@ -387,25 +387,39 @@ def reversed(self) -> Block: index_labels=self.index.names, ) - def reset_index(self, drop: bool = True) -> Block: + def reset_index(self, level: LevelsType = None, drop: bool = True) -> Block: """Reset the index of the block, promoting the old index to a value column. Arguments: + level: the label or index level of the index levels to remove. name: this is the column id for the new value id derived from the old index Returns: A new Block because dropping index columns can break references from Index classes that point to this block. """ + if level: + # preserve original order, not user provided order + level_ids: Sequence[str] = [ + id for id in self.index_columns if id in self.index.resolve_level(level) + ] + else: + level_ids = self.index_columns + expr = self._expr - if ( + if set(self.index_columns) > set(level_ids): + new_index_cols = [col for col in self.index_columns if col not in level_ids] + new_index_labels = [self.col_id_to_index_name[id] for id in new_index_cols] + elif ( self.session._default_index_type == bigframes.enums.DefaultIndexKind.SEQUENTIAL_INT64 ): expr, new_index_col_id = expr.promote_offsets() new_index_cols = [new_index_col_id] + new_index_labels = [None] elif self.session._default_index_type == bigframes.enums.DefaultIndexKind.NULL: new_index_cols = [] + new_index_labels = [] else: raise ValueError( f"Unrecognized default index kind: {self.session._default_index_type}" @@ -415,22 +429,23 @@ def reset_index(self, drop: bool = True) -> Block: # Even though the index might be part of the ordering, keep that # ordering expression as reset_index shouldn't change the row # order. - expr = expr.drop_columns(self.index_columns) + expr = expr.drop_columns(level_ids) return Block( expr, index_columns=new_index_cols, + index_labels=new_index_labels, column_labels=self.column_labels, ) else: # Add index names to column index - index_labels = self.index.names column_labels_modified = self.column_labels - for level, label in enumerate(index_labels): + for position, level_id in enumerate(level_ids): + label = self.col_id_to_index_name[level_id] if label is None: - if "index" not in self.column_labels and len(index_labels) <= 1: + if "index" not in self.column_labels and self.index.nlevels <= 1: label = "index" else: - label = f"level_{level}" + label = f"level_{self.index_columns.index(level_id)}" if label in self.column_labels: raise ValueError(f"cannot insert {label}, already exists") @@ -439,11 +454,12 @@ def reset_index(self, drop: bool = True) -> Block: label = tuple(label if i == 0 else "" for i in range(nlevels)) # Create index copy with label inserted # See: https://pandas.pydata.org/docs/reference/api/pandas.Index.insert.html - column_labels_modified = column_labels_modified.insert(level, label) + column_labels_modified = column_labels_modified.insert(position, label) return Block( - expr, + expr.select_columns((*new_index_cols, *level_ids, *self.value_columns)), index_columns=new_index_cols, + index_labels=new_index_labels, column_labels=column_labels_modified, ) diff --git a/bigframes/core/compile/polars/compiler.py b/bigframes/core/compile/polars/compiler.py index dd30aec16a..8ae896816f 100644 --- a/bigframes/core/compile/polars/compiler.py +++ b/bigframes/core/compile/polars/compiler.py @@ -168,7 +168,7 @@ def compile_op(self, op: ops.ScalarOp, *args: pl.Expr) -> pl.Expr: @compile_op.register(gen_ops.InvertOp) def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr: - return ~input + return input.not_() @compile_op.register(num_ops.AbsOp) def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr: @@ -198,6 +198,10 @@ def _(self, op: ops.ScalarOp, l_input: pl.Expr, r_input: pl.Expr) -> pl.Expr: def _(self, op: ops.ScalarOp, l_input: pl.Expr, r_input: pl.Expr) -> pl.Expr: return l_input | r_input + @compile_op.register(bool_ops.XorOp) + def _(self, op: ops.ScalarOp, l_input: pl.Expr, r_input: pl.Expr) -> pl.Expr: + return l_input ^ r_input + @compile_op.register(num_ops.AddOp) def _(self, op: ops.ScalarOp, l_input: pl.Expr, r_input: pl.Expr) -> pl.Expr: return l_input + r_input diff --git a/bigframes/core/compile/polars/lowering.py b/bigframes/core/compile/polars/lowering.py index 013651ff17..f6ed6c676c 100644 --- a/bigframes/core/compile/polars/lowering.py +++ b/bigframes/core/compile/polars/lowering.py @@ -14,10 +14,18 @@ import dataclasses +import numpy as np + from bigframes import dtypes from bigframes.core import bigframe_node, expression from bigframes.core.rewrite import op_lowering -from bigframes.operations import comparison_ops, datetime_ops, json_ops, numeric_ops +from bigframes.operations import ( + comparison_ops, + datetime_ops, + generic_ops, + json_ops, + numeric_ops, +) import bigframes.operations as ops # TODO: Would be more precise to actually have separate op set for polars ops (where they diverge from the original ops) @@ -288,6 +296,26 @@ def lower(self, expr: expression.OpExpression) -> expression.Expression: return _lower_cast(expr.op, expr.inputs[0]) +def invert_bytes(byte_string): + inverted_bytes = ~np.frombuffer(byte_string, dtype=np.uint8) + return inverted_bytes.tobytes() + + +class LowerInvertOp(op_lowering.OpLoweringRule): + @property + def op(self) -> type[ops.ScalarOp]: + return generic_ops.InvertOp + + def lower(self, expr: expression.OpExpression) -> expression.Expression: + assert isinstance(expr.op, generic_ops.InvertOp) + arg = expr.children[0] + if arg.output_type == dtypes.BYTES_DTYPE: + return generic_ops.PyUdfOp(invert_bytes, dtypes.BYTES_DTYPE).as_expr( + expr.inputs[0] + ) + return expr + + def _coerce_comparables( expr1: expression.Expression, expr2: expression.Expression, @@ -385,6 +413,7 @@ def _lower_cast(cast_op: ops.AsTypeOp, arg: expression.Expression): LowerFloorDivRule(), LowerModRule(), LowerAsTypeRule(), + LowerInvertOp(), ) diff --git a/bigframes/core/compile/polars/operations/generic_ops.py b/bigframes/core/compile/polars/operations/generic_ops.py index de0e987aa2..4051fa4995 100644 --- a/bigframes/core/compile/polars/operations/generic_ops.py +++ b/bigframes/core/compile/polars/operations/generic_ops.py @@ -45,3 +45,14 @@ def isnull_op_impl( input: pl.Expr, ) -> pl.Expr: return input.is_null() + + +@polars_compiler.register_op(generic_ops.PyUdfOp) +def py_udf_op_impl( + compiler: polars_compiler.PolarsExpressionCompiler, + op: generic_ops.PyUdfOp, # type: ignore + input: pl.Expr, +) -> pl.Expr: + return input.map_elements( + op.fn, return_dtype=polars_compiler._DTYPE_MAPPING[op._output_type] + ) diff --git a/bigframes/core/compile/sqlglot/aggregate_compiler.py b/bigframes/core/compile/sqlglot/aggregate_compiler.py index f7abd7dc7a..52ef4cc26c 100644 --- a/bigframes/core/compile/sqlglot/aggregate_compiler.py +++ b/bigframes/core/compile/sqlglot/aggregate_compiler.py @@ -15,7 +15,7 @@ import sqlglot.expressions as sge -from bigframes.core import expression +from bigframes.core import expression, window_spec from bigframes.core.compile.sqlglot.aggregations import ( binary_compiler, nullary_compiler, @@ -56,3 +56,21 @@ def compile_aggregate( return binary_compiler.compile(aggregate.op, left, right) else: raise ValueError(f"Unexpected aggregation: {aggregate}") + + +def compile_analytic( + aggregate: expression.Aggregation, + window: window_spec.WindowSpec, +) -> sge.Expression: + if isinstance(aggregate, expression.NullaryAggregation): + return nullary_compiler.compile(aggregate.op) + if isinstance(aggregate, expression.UnaryAggregation): + column = typed_expr.TypedExpr( + scalar_compiler.compile_scalar_expression(aggregate.arg), + aggregate.arg.output_type, + ) + return unary_compiler.compile(aggregate.op, column, window) + elif isinstance(aggregate, expression.BinaryAggregation): + raise NotImplementedError("binary analytic operations not yet supported") + else: + raise ValueError(f"Unexpected analytic operation: {aggregate}") diff --git a/bigframes/core/compile/sqlglot/aggregations/unary_compiler.py b/bigframes/core/compile/sqlglot/aggregations/unary_compiler.py index eddf7f56d2..c7eb84cba6 100644 --- a/bigframes/core/compile/sqlglot/aggregations/unary_compiler.py +++ b/bigframes/core/compile/sqlglot/aggregations/unary_compiler.py @@ -18,6 +18,7 @@ import sqlglot.expressions as sge +from bigframes import dtypes from bigframes.core import window_spec import bigframes.core.compile.sqlglot.aggregations.op_registration as reg from bigframes.core.compile.sqlglot.aggregations.windows import apply_window_if_present @@ -36,14 +37,26 @@ def compile( return UNARY_OP_REGISTRATION[op](op, column, window=window) +@UNARY_OP_REGISTRATION.register(agg_ops.CountOp) +def _( + op: agg_ops.CountOp, + column: typed_expr.TypedExpr, + window: typing.Optional[window_spec.WindowSpec] = None, +) -> sge.Expression: + return apply_window_if_present(sge.func("COUNT", column.expr), window) + + @UNARY_OP_REGISTRATION.register(agg_ops.SumOp) def _( op: agg_ops.SumOp, column: typed_expr.TypedExpr, window: typing.Optional[window_spec.WindowSpec] = None, ) -> sge.Expression: + expr = column.expr + if column.dtype == dtypes.BOOL_DTYPE: + expr = sge.Cast(this=column.expr, to="INT64") # Will be null if all inputs are null. Pandas defaults to zero sum though. - expr = apply_window_if_present(sge.func("SUM", column.expr), window) + expr = apply_window_if_present(sge.func("SUM", expr), window) return sge.func("IFNULL", expr, ir._literal(0, column.dtype)) diff --git a/bigframes/core/compile/sqlglot/compiler.py b/bigframes/core/compile/sqlglot/compiler.py index 2ae6b4bb9c..b4dc6174be 100644 --- a/bigframes/core/compile/sqlglot/compiler.py +++ b/bigframes/core/compile/sqlglot/compiler.py @@ -298,6 +298,75 @@ def compile_aggregate( return child.aggregate(aggregations, by_cols, tuple(dropna_cols)) + @_compile_node.register + def compile_window( + self, node: nodes.WindowOpNode, child: ir.SQLGlotIR + ) -> ir.SQLGlotIR: + window_spec = node.window_spec + if node.expression.op.order_independent and window_spec.is_unbounded: + # notably percentile_cont does not support ordering clause + window_spec = window_spec.without_order() + + window_op = aggregate_compiler.compile_analytic(node.expression, window_spec) + + inputs: tuple[sge.Expression, ...] = tuple( + scalar_compiler.compile_scalar_expression(expression.DerefOp(column)) + for column in node.expression.column_references + ) + + clauses: list[tuple[sge.Expression, sge.Expression]] = [] + if node.expression.op.skips_nulls and not node.never_skip_nulls: + for column in inputs: + clauses.append((sge.Is(this=column, expression=sge.Null()), sge.Null())) + + if window_spec.min_periods and len(inputs) > 0: + if node.expression.op.skips_nulls: + # Most operations do not count NULL values towards min_periods + not_null_columns = [ + sge.Not(this=sge.Is(this=column, expression=sge.Null())) + for column in inputs + ] + # All inputs must be non-null for observation to count + if not not_null_columns: + is_observation_expr: sge.Expression = sge.convert(True) + else: + is_observation_expr = not_null_columns[0] + for expr in not_null_columns[1:]: + is_observation_expr = sge.And( + this=is_observation_expr, expression=expr + ) + is_observation = ir._cast(is_observation_expr, "INT64") + observation_count = windows.apply_window_if_present( + sge.func("SUM", is_observation), window_spec + ) + 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. + is_observation = ir._cast( + sge.Not(this=sge.Is(this=inputs[0], expression=sge.Null())), + "INT64", + ) + observation_count = windows.apply_window_if_present( + sge.func("COUNT", is_observation), window_spec + ) + + clauses.append( + ( + observation_count < sge.convert(window_spec.min_periods), + sge.Null(), + ) + ) + if clauses: + when_expressions = [sge.When(this=cond, true=res) for cond, res in clauses] + window_op = sge.Case(ifs=when_expressions, default=window_op) + + # TODO: check if we can directly window the expression. + return child.window( + window_op=window_op, + output_column_id=node.output_name.sql, + ) + def _replace_unsupported_ops(node: nodes.BigFrameNode): node = nodes.bottom_up(node, rewrite.rewrite_slice) diff --git a/bigframes/core/compile/sqlglot/expressions/binary_compiler.py b/bigframes/core/compile/sqlglot/expressions/binary_compiler.py index c46019d909..61f1eba607 100644 --- a/bigframes/core/compile/sqlglot/expressions/binary_compiler.py +++ b/bigframes/core/compile/sqlglot/expressions/binary_compiler.py @@ -14,11 +14,12 @@ from __future__ import annotations -import bigframes_vendored.constants as constants +import bigframes_vendored.constants as bf_constants import sqlglot.expressions as sge from bigframes import dtypes from bigframes import operations as ops +import bigframes.core.compile.sqlglot.expressions.constants as constants from bigframes.core.compile.sqlglot.expressions.op_registration import OpRegistration from bigframes.core.compile.sqlglot.expressions.typed_expr import TypedExpr @@ -69,10 +70,92 @@ def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: return sge.Add(this=left.expr, expression=right.expr) raise TypeError( - f"Cannot add type {left.dtype} and {right.dtype}. {constants.FEEDBACK_LINK}" + f"Cannot add type {left.dtype} and {right.dtype}. {bf_constants.FEEDBACK_LINK}" ) +@BINARY_OP_REGISTRATION.register(ops.div_op) +def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: + left_expr = left.expr + if left.dtype == dtypes.BOOL_DTYPE: + left_expr = sge.Cast(this=left_expr, to="INT64") + right_expr = right.expr + if right.dtype == dtypes.BOOL_DTYPE: + right_expr = sge.Cast(this=right_expr, to="INT64") + + result = sge.func("IEEE_DIVIDE", left_expr, right_expr) + if left.dtype == dtypes.TIMEDELTA_DTYPE and dtypes.is_numeric(right.dtype): + return sge.Cast(this=sge.Floor(this=result), to="INT64") + else: + return result + + +@BINARY_OP_REGISTRATION.register(ops.floordiv_op) +def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: + left_expr = left.expr + if left.dtype == dtypes.BOOL_DTYPE: + left_expr = sge.Cast(this=left_expr, to="INT64") + right_expr = right.expr + if right.dtype == dtypes.BOOL_DTYPE: + right_expr = sge.Cast(this=right_expr, to="INT64") + + result: sge.Expression = sge.Cast( + this=sge.Floor(this=sge.func("IEEE_DIVIDE", left_expr, right_expr)), to="INT64" + ) + + # DIV(N, 0) will error in bigquery, but needs to return `0` for int, and + # `inf`` for float in BQ so we short-circuit in this case. + # Multiplying left by zero propogates nulls. + zero_result = ( + constants._INF + if (left.dtype == dtypes.FLOAT_DTYPE or right.dtype == dtypes.FLOAT_DTYPE) + else constants._ZERO + ) + result = sge.Case( + ifs=[ + sge.If( + this=sge.EQ(this=right_expr, expression=constants._ZERO), + true=zero_result * left_expr, + ) + ], + default=result, + ) + + if dtypes.is_numeric(right.dtype) and left.dtype == dtypes.TIMEDELTA_DTYPE: + result = sge.Cast(this=sge.Floor(this=result), to="INT64") + + return result + + +@BINARY_OP_REGISTRATION.register(ops.ge_op) +def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: + return sge.GTE(this=left.expr, expression=right.expr) + + +@BINARY_OP_REGISTRATION.register(ops.JSONSet) +def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: + return sge.func("JSON_SET", left.expr, sge.convert(op.json_path), right.expr) + + +@BINARY_OP_REGISTRATION.register(ops.mul_op) +def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: + left_expr = left.expr + if left.dtype == dtypes.BOOL_DTYPE: + left_expr = sge.Cast(this=left_expr, to="INT64") + right_expr = right.expr + if right.dtype == dtypes.BOOL_DTYPE: + right_expr = sge.Cast(this=right_expr, to="INT64") + + result = sge.Mul(this=left_expr, expression=right_expr) + + if (dtypes.is_numeric(left.dtype) and right.dtype == dtypes.TIMEDELTA_DTYPE) or ( + left.dtype == dtypes.TIMEDELTA_DTYPE and dtypes.is_numeric(right.dtype) + ): + return sge.Cast(this=sge.Floor(this=result), to="INT64") + else: + return result + + @BINARY_OP_REGISTRATION.register(ops.sub_op) def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: if dtypes.is_numeric(left.dtype) and dtypes.is_numeric(right.dtype): @@ -111,15 +194,10 @@ def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: return sge.Sub(this=left.expr, expression=right.expr) raise TypeError( - f"Cannot subtract type {left.dtype} and {right.dtype}. {constants.FEEDBACK_LINK}" + f"Cannot subtract type {left.dtype} and {right.dtype}. {bf_constants.FEEDBACK_LINK}" ) -@BINARY_OP_REGISTRATION.register(ops.ge_op) +@BINARY_OP_REGISTRATION.register(ops.obj_make_ref_op) def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: - return sge.GTE(this=left.expr, expression=right.expr) - - -@BINARY_OP_REGISTRATION.register(ops.JSONSet) -def _(op, left: TypedExpr, right: TypedExpr) -> sge.Expression: - return sge.func("JSON_SET", left.expr, sge.convert(op.json_path), right.expr) + return sge.func("OBJ.MAKE_REF", left.expr, right.expr) diff --git a/bigframes/core/compile/sqlglot/expressions/constants.py b/bigframes/core/compile/sqlglot/expressions/constants.py new file mode 100644 index 0000000000..20857f6291 --- /dev/null +++ b/bigframes/core/compile/sqlglot/expressions/constants.py @@ -0,0 +1,25 @@ +# 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 sqlglot.expressions as sge + +_ZERO = sge.Cast(this=sge.convert(0), to="INT64") +_NAN = sge.Cast(this=sge.convert("NaN"), to="FLOAT64") +_INF = sge.Cast(this=sge.convert("Infinity"), to="FLOAT64") +_NEG_INF = sge.Cast(this=sge.convert("-Infinity"), to="FLOAT64") + +# Approx Highest number you can pass in to EXP function and get a valid FLOAT64 result +# FLOAT64 has 11 exponent bits, so max values is about 2**(2**10) +# ln(2**(2**10)) == (2**10)*ln(2) ~= 709.78, so EXP(x) for x>709.78 will overflow. +_FLOAT64_EXP_BOUND = sge.convert(709.78) diff --git a/bigframes/core/compile/sqlglot/expressions/unary_compiler.py b/bigframes/core/compile/sqlglot/expressions/unary_compiler.py index 125c60bbf4..ddaf04ae97 100644 --- a/bigframes/core/compile/sqlglot/expressions/unary_compiler.py +++ b/bigframes/core/compile/sqlglot/expressions/unary_compiler.py @@ -22,17 +22,11 @@ import sqlglot.expressions as sge from bigframes import operations as ops +from bigframes.core.compile.constants import UNIT_TO_US_CONVERSION_FACTORS +import bigframes.core.compile.sqlglot.expressions.constants as constants from bigframes.core.compile.sqlglot.expressions.op_registration import OpRegistration from bigframes.core.compile.sqlglot.expressions.typed_expr import TypedExpr -_NAN = sge.Cast(this=sge.convert("NaN"), to="FLOAT64") -_INF = sge.Cast(this=sge.convert("Infinity"), to="FLOAT64") - -# Approx Highest number you can pass in to EXP function and get a valid FLOAT64 result -# FLOAT64 has 11 exponent bits, so max values is about 2**(2**10) -# ln(2**(2**10)) == (2**10)*ln(2) ~= 709.78, so EXP(x) for x>709.78 will overflow. -_FLOAT64_EXP_BOUND = sge.convert(709.78) - UNARY_OP_REGISTRATION = OpRegistration() @@ -51,7 +45,7 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ifs=[ sge.If( this=expr.expr < sge.convert(1), - true=_NAN, + true=constants._NAN, ) ], default=sge.func("ACOSH", expr.expr), @@ -64,7 +58,7 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ifs=[ sge.If( this=sge.func("ABS", expr.expr) > sge.convert(1), - true=_NAN, + true=constants._NAN, ) ], default=sge.func("ACOS", expr.expr), @@ -77,7 +71,7 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ifs=[ sge.If( this=sge.func("ABS", expr.expr) > sge.convert(1), - true=_NAN, + true=constants._NAN, ) ], default=sge.func("ASIN", expr.expr), @@ -100,7 +94,7 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ifs=[ sge.If( this=sge.func("ABS", expr.expr) > sge.convert(1), - true=_NAN, + true=constants._NAN, ) ], default=sge.func("ATANH", expr.expr), @@ -176,7 +170,7 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ifs=[ sge.If( this=sge.func("ABS", expr.expr) > sge.convert(709.78), - true=_INF, + true=constants._INF, ) ], default=sge.func("COSH", expr.expr), @@ -221,8 +215,8 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: return sge.Case( ifs=[ sge.If( - this=expr.expr > _FLOAT64_EXP_BOUND, - true=_INF, + this=expr.expr > constants._FLOAT64_EXP_BOUND, + true=constants._INF, ) ], default=sge.func("EXP", expr.expr), @@ -234,8 +228,8 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: return sge.Case( ifs=[ sge.If( - this=expr.expr > _FLOAT64_EXP_BOUND, - true=_INF, + this=expr.expr > constants._FLOAT64_EXP_BOUND, + true=constants._INF, ) ], default=sge.func("EXP", expr.expr), @@ -347,6 +341,26 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ) +@UNARY_OP_REGISTRATION.register(ops.iso_day_op) +def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: + return sge.Extract(this=sge.Identifier(this="DAYOFWEEK"), expression=expr.expr) + + +@UNARY_OP_REGISTRATION.register(ops.iso_week_op) +def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: + return sge.Extract(this=sge.Identifier(this="ISOWEEK"), expression=expr.expr) + + +@UNARY_OP_REGISTRATION.register(ops.iso_year_op) +def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: + return sge.Extract(this=sge.Identifier(this="ISOYEAR"), expression=expr.expr) + + +@UNARY_OP_REGISTRATION.register(ops.isnull_op) +def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: + return sge.Is(this=expr.expr, expression=sge.Null()) + + @UNARY_OP_REGISTRATION.register(ops.isnumeric_op) def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: return sge.RegexpLike(this=expr.expr, expression=sge.convert(r"^\pN+$")) @@ -382,7 +396,7 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ifs=[ sge.If( this=expr.expr < sge.convert(0), - true=_NAN, + true=constants._NAN, ) ], default=sge.Ln(this=expr.expr), @@ -395,7 +409,7 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ifs=[ sge.If( this=expr.expr < sge.convert(0), - true=_NAN, + true=constants._NAN, ) ], default=sge.Log(this=expr.expr, expression=sge.convert(10)), @@ -408,7 +422,7 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ifs=[ sge.If( this=expr.expr < sge.convert(-1), - true=_NAN, + true=constants._NAN, ) ], default=sge.Ln(this=sge.convert(1) + expr.expr), @@ -445,6 +459,21 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: return sge.TimestampTrunc(this=expr.expr, unit=sge.Identifier(this="DAY")) +@UNARY_OP_REGISTRATION.register(ops.notnull_op) +def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: + return sge.Not(this=sge.Is(this=expr.expr, expression=sge.Null())) + + +@UNARY_OP_REGISTRATION.register(ops.obj_fetch_metadata_op) +def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: + return sge.func("OBJ.FETCH_METADATA", expr.expr) + + +@UNARY_OP_REGISTRATION.register(ops.ObjGetAccessUrl) +def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: + return sge.func("OBJ.GET_ACCESS_URL", expr.expr) + + @UNARY_OP_REGISTRATION.register(ops.pos_op) def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: return expr.expr @@ -476,7 +505,7 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: ifs=[ sge.If( this=expr.expr < sge.convert(0), - true=_NAN, + true=constants._NAN, ) ], default=sge.Sqrt(this=expr.expr), @@ -488,31 +517,6 @@ def _(op: ops.StrStripOp, expr: TypedExpr) -> sge.Expression: return sge.Trim(this=sge.convert(op.to_strip), expression=expr.expr) -@UNARY_OP_REGISTRATION.register(ops.iso_day_op) -def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: - return sge.Extract(this=sge.Identifier(this="DAYOFWEEK"), expression=expr.expr) - - -@UNARY_OP_REGISTRATION.register(ops.iso_week_op) -def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: - return sge.Extract(this=sge.Identifier(this="ISOWEEK"), expression=expr.expr) - - -@UNARY_OP_REGISTRATION.register(ops.iso_year_op) -def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: - return sge.Extract(this=sge.Identifier(this="ISOYEAR"), expression=expr.expr) - - -@UNARY_OP_REGISTRATION.register(ops.isnull_op) -def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: - return sge.Is(this=expr.expr, expression=sge.Null()) - - -@UNARY_OP_REGISTRATION.register(ops.notnull_op) -def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: - return sge.Not(this=sge.Is(this=expr.expr, expression=sge.Null())) - - @UNARY_OP_REGISTRATION.register(ops.sin_op) def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: return sge.func("SIN", expr.expr) @@ -523,8 +527,8 @@ def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression: return sge.Case( ifs=[ sge.If( - this=sge.func("ABS", expr.expr) > _FLOAT64_EXP_BOUND, - true=sge.func("SIGN", expr.expr) * _INF, + this=sge.func("ABS", expr.expr) > constants._FLOAT64_EXP_BOUND, + true=sge.func("SIGN", expr.expr) * constants._INF, ) ], default=sge.func("SINH", expr.expr), @@ -608,7 +612,11 @@ def _(op: ops.ToTimestampOp, expr: TypedExpr) -> sge.Expression: @UNARY_OP_REGISTRATION.register(ops.ToTimedeltaOp) def _(op: ops.ToTimedeltaOp, expr: TypedExpr) -> sge.Expression: - return sge.Interval(this=expr.expr, unit=sge.Identifier(this="SECOND")) + value = expr.expr + factor = UNIT_TO_US_CONVERSION_FACTORS[op.unit] + if factor != 1: + value = sge.Mul(this=value, expression=sge.convert(factor)) + return sge.Interval(this=value, unit=sge.Identifier(this="MICROSECOND")) @UNARY_OP_REGISTRATION.register(ops.UnixMicros) @@ -626,7 +634,6 @@ def _(op: ops.UnixSeconds, expr: TypedExpr) -> sge.Expression: return sge.func("UNIX_SECONDS", expr.expr) -# JSON Ops @UNARY_OP_REGISTRATION.register(ops.JSONExtract) def _(op: ops.JSONExtract, expr: TypedExpr) -> sge.Expression: return sge.func("JSON_EXTRACT", expr.expr, sge.convert(op.json_path)) diff --git a/bigframes/core/compile/sqlglot/scalar_compiler.py b/bigframes/core/compile/sqlglot/scalar_compiler.py index 683dd38c9a..65c2501b71 100644 --- a/bigframes/core/compile/sqlglot/scalar_compiler.py +++ b/bigframes/core/compile/sqlglot/scalar_compiler.py @@ -31,7 +31,7 @@ @functools.singledispatch def compile_scalar_expression( - expression: expression.Expression, + expr: expression.Expression, ) -> sge.Expression: """Compiles BigFrames scalar expression into SQLGlot expression.""" raise ValueError(f"Can't compile unrecognized node: {expression}") diff --git a/bigframes/core/compile/sqlglot/sqlglot_ir.py b/bigframes/core/compile/sqlglot/sqlglot_ir.py index b194fe9e5d..1a00cd0a93 100644 --- a/bigframes/core/compile/sqlglot/sqlglot_ir.py +++ b/bigframes/core/compile/sqlglot/sqlglot_ir.py @@ -409,6 +409,13 @@ def aggregate( new_expr = new_expr.where(condition, append=False) return SQLGlotIR(expr=new_expr, uid_gen=self.uid_gen) + def window( + self, + window_op: sge.Expression, + output_column_id: str, + ) -> SQLGlotIR: + return self.project(((output_column_id, window_op),)) + def insert( self, destination: bigquery.TableReference, diff --git a/bigframes/core/rewrite/schema_binding.py b/bigframes/core/rewrite/schema_binding.py index f7f2ca8c59..cbecf83035 100644 --- a/bigframes/core/rewrite/schema_binding.py +++ b/bigframes/core/rewrite/schema_binding.py @@ -17,7 +17,7 @@ from bigframes.core import bigframe_node from bigframes.core import expression as ex -from bigframes.core import nodes +from bigframes.core import nodes, ordering def bind_schema_to_tree( @@ -79,46 +79,77 @@ def bind_schema_to_node( if isinstance(node, nodes.AggregateNode): aggregations = [] for aggregation, id in node.aggregations: - if isinstance(aggregation, ex.UnaryAggregation): - replaced = typing.cast( - ex.Aggregation, - dataclasses.replace( - aggregation, - arg=typing.cast( - ex.RefOrConstant, - ex.bind_schema_fields( - aggregation.arg, node.child.field_by_id - ), - ), - ), + aggregations.append( + (_bind_schema_to_aggregation_expr(aggregation, node.child), id) + ) + + return dataclasses.replace( + node, + aggregations=tuple(aggregations), + ) + + if isinstance(node, nodes.WindowOpNode): + window_spec = dataclasses.replace( + node.window_spec, + grouping_keys=tuple( + typing.cast( + ex.DerefOp, ex.bind_schema_fields(expr, node.child.field_by_id) ) - aggregations.append((replaced, id)) - elif isinstance(aggregation, ex.BinaryAggregation): - replaced = typing.cast( - ex.Aggregation, - dataclasses.replace( - aggregation, - left=typing.cast( - ex.RefOrConstant, - ex.bind_schema_fields( - aggregation.left, node.child.field_by_id - ), - ), - right=typing.cast( - ex.RefOrConstant, - ex.bind_schema_fields( - aggregation.right, node.child.field_by_id - ), - ), + for expr in node.window_spec.grouping_keys + ), + ordering=tuple( + ordering.OrderingExpression( + scalar_expression=ex.bind_schema_fields( + expr.scalar_expression, node.child.field_by_id ), + direction=expr.direction, + na_last=expr.na_last, ) - aggregations.append((replaced, id)) - else: - aggregations.append((aggregation, id)) - + for expr in node.window_spec.ordering + ), + ) return dataclasses.replace( node, - aggregations=tuple(aggregations), + expression=_bind_schema_to_aggregation_expr(node.expression, node.child), + window_spec=window_spec, ) return node + + +def _bind_schema_to_aggregation_expr( + aggregation: ex.Aggregation, + child: bigframe_node.BigFrameNode, +) -> ex.Aggregation: + assert isinstance( + aggregation, ex.Aggregation + ), f"Expected Aggregation, got {type(aggregation)}" + + if isinstance(aggregation, ex.UnaryAggregation): + return typing.cast( + ex.Aggregation, + dataclasses.replace( + aggregation, + arg=typing.cast( + ex.RefOrConstant, + ex.bind_schema_fields(aggregation.arg, child.field_by_id), + ), + ), + ) + elif isinstance(aggregation, ex.BinaryAggregation): + return typing.cast( + ex.Aggregation, + dataclasses.replace( + aggregation, + left=typing.cast( + ex.RefOrConstant, + ex.bind_schema_fields(aggregation.left, child.field_by_id), + ), + right=typing.cast( + ex.RefOrConstant, + ex.bind_schema_fields(aggregation.right, child.field_by_id), + ), + ), + ) + else: + return aggregation diff --git a/bigframes/dataframe.py b/bigframes/dataframe.py index 4559d7cbb9..c58cbaba6a 100644 --- a/bigframes/dataframe.py +++ b/bigframes/dataframe.py @@ -23,6 +23,7 @@ import re import sys import textwrap +import traceback import typing from typing import ( Callable, @@ -814,7 +815,9 @@ def _repr_html_(self) -> str: except (AttributeError, ValueError, ImportError): # Fallback if anywidget is not available warnings.warn( - "Anywidget mode is not available. Please `pip install anywidget traitlets` or `pip install 'bigframes[anywidget]'` to use interactive tables. Falling back to deferred mode." + "Anywidget mode is not available. " + "Please `pip install anywidget traitlets` or `pip install 'bigframes[anywidget]'` to use interactive tables. " + f"Falling back to deferred mode. Error: {traceback.format_exc()}" ) return formatter.repr_query_job(self._compute_dry_run()) @@ -2312,9 +2315,39 @@ def _assign_series_join_on_index( return DataFrame(block.with_index_labels(self._block.index.names)) - def reset_index(self, *, drop: bool = False) -> DataFrame: - block = self._block.reset_index(drop) - return DataFrame(block) + @overload # type: ignore[override] + def reset_index( + self, + level: blocks.LevelsType = ..., + drop: bool = ..., + inplace: Literal[False] = ..., + ) -> DataFrame: + ... + + @overload + def reset_index( + self, + level: blocks.LevelsType = ..., + drop: bool = ..., + inplace: Literal[True] = ..., + ) -> None: + ... + + @overload + def reset_index( + self, level: blocks.LevelsType = None, drop: bool = False, inplace: bool = ... + ) -> Optional[DataFrame]: + ... + + def reset_index( + self, level: blocks.LevelsType = None, drop: bool = False, inplace: bool = False + ) -> Optional[DataFrame]: + block = self._block.reset_index(level, drop) + if inplace: + self._set_block(block) + return None + else: + return DataFrame(block) def set_index( self, @@ -2764,10 +2797,17 @@ def where(self, cond, other=None): ) # Execute it with the DataFrame when cond or/and other is callable. + # It can be either a plain python function or remote/managed function. if callable(cond): - cond = cond(self) + if hasattr(cond, "bigframes_bigquery_function"): + cond = self.apply(cond, axis=1) + else: + cond = cond(self) if callable(other): - other = other(self) + if hasattr(other, "bigframes_bigquery_function"): + other = self.apply(other, axis=1) + else: + other = other(self) aligned_block, (_, _) = self._block.join(cond._block, how="left") # No left join is needed when 'other' is None or constant. @@ -2780,7 +2820,7 @@ def where(self, cond, other=None): labels = aligned_block.column_labels[:self_len] self_col = {x: ex.deref(y) for x, y in zip(labels, ids)} - if isinstance(cond, bigframes.series.Series) and cond.name in self_col: + if isinstance(cond, bigframes.series.Series): # This is when 'cond' is a valid series. y = aligned_block.value_columns[self_len] cond_col = {x: ex.deref(y) for x in self_col.keys()} diff --git a/bigframes/display/anywidget.py b/bigframes/display/anywidget.py index 8bbb72c11a..5a20ddcb7f 100644 --- a/bigframes/display/anywidget.py +++ b/bigframes/display/anywidget.py @@ -23,6 +23,7 @@ import pandas as pd import bigframes +import bigframes.display.html # anywidget and traitlets are optional dependencies. We don't want the import of this # module to fail if they aren't installed, though. Instead, we try to limit the surface that @@ -201,12 +202,9 @@ def _set_table_html(self): page_data = cached_data.iloc[start:end] # Generate HTML table - self.table_html = page_data.to_html( - index=False, - max_rows=None, + self.table_html = bigframes.display.html.render_html( + dataframe=page_data, table_id=f"table-{self._table_id}", - classes="table table-striped table-hover", - escape=False, ) @traitlets.observe("page") diff --git a/bigframes/display/html.py b/bigframes/display/html.py new file mode 100644 index 0000000000..f1133789b4 --- /dev/null +++ b/bigframes/display/html.py @@ -0,0 +1,79 @@ +# Copyright 2024 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. + +"""HTML rendering for DataFrames and other objects.""" + +from __future__ import annotations + +import html + +import pandas as pd +import pandas.api.types + +from bigframes._config import options + + +def _is_dtype_numeric(dtype) -> bool: + """Check if a dtype is numeric for alignment purposes.""" + return pandas.api.types.is_numeric_dtype(dtype) + + +def render_html( + *, + dataframe: pd.DataFrame, + table_id: str, +) -> str: + """Render a pandas DataFrame to HTML with specific styling.""" + classes = "dataframe table table-striped table-hover" + table_html = [f''] + precision = options.display.precision + + # Render table head + table_html.append(" ") + table_html.append(' ') + for col in dataframe.columns: + table_html.append( + f' ' + ) + table_html.append(" ") + table_html.append(" ") + + # Render table body + table_html.append(" ") + for i in range(len(dataframe)): + table_html.append(" ") + row = dataframe.iloc[i] + for col_name, value in row.items(): + dtype = dataframe.dtypes.loc[col_name] # type: ignore + align = "right" if _is_dtype_numeric(dtype) else "left" + table_html.append( + ' ") + table_html.append(" ") + table_html.append(" ") + table_html.append("
{html.escape(str(col))}
'.format(align) + ) + + # TODO(b/438181139): Consider semi-exploding ARRAY/STRUCT columns + # into multiple rows/columns like the BQ UI does. + if pandas.api.types.is_scalar(value) and pd.isna(value): + table_html.append(' <NA>') + else: + if isinstance(value, float): + formatted_value = f"{value:.{precision}f}" + table_html.append(f" {html.escape(formatted_value)}") + else: + table_html.append(f" {html.escape(str(value))}") + table_html.append("
") + + return "\n".join(table_html) diff --git a/bigframes/display/table_widget.css b/bigframes/display/table_widget.css index 037fcac0f2..0c6c5fa5ef 100644 --- a/bigframes/display/table_widget.css +++ b/bigframes/display/table_widget.css @@ -14,6 +14,10 @@ * limitations under the License. */ +.bigframes-widget { + display: inline-block; +} + .bigframes-widget .table-container { max-height: 620px; overflow: auto; diff --git a/bigframes/display/table_widget.js b/bigframes/display/table_widget.js index 7fff72d1ba..6b4d99ff28 100644 --- a/bigframes/display/table_widget.js +++ b/bigframes/display/table_widget.js @@ -36,8 +36,7 @@ const Event = { */ function render({ model, el }) { // Main container with a unique class for CSS scoping - const container = document.createElement("div"); - container.classList.add("bigframes-widget"); + el.classList.add("bigframes-widget"); // Structure const tableContainer = document.createElement("div"); @@ -89,7 +88,9 @@ function render({ model, el }) { const totalPages = Math.ceil(rowCount / pageSize); rowCountLabel.textContent = `${rowCount.toLocaleString()} total rows`; - paginationLabel.textContent = `Page ${currentPage + 1} of ${totalPages || 1}`; + paginationLabel.textContent = `Page ${( + currentPage + 1 + ).toLocaleString()} of ${(totalPages || 1).toLocaleString()}`; prevPage.disabled = currentPage === 0; nextPage.disabled = currentPage >= totalPages - 1; pageSizeSelect.value = pageSize; @@ -149,10 +150,8 @@ function render({ model, el }) { footer.appendChild(paginationContainer); footer.appendChild(pageSizeContainer); - container.appendChild(tableContainer); - container.appendChild(footer); - - el.appendChild(container); + el.appendChild(tableContainer); + el.appendChild(footer); // Initial render handleTableHTMLChange(); diff --git a/bigframes/exceptions.py b/bigframes/exceptions.py index 53c8deb082..8236a1a2f6 100644 --- a/bigframes/exceptions.py +++ b/bigframes/exceptions.py @@ -113,8 +113,8 @@ class FunctionConflictTypeHintWarning(UserWarning): class FunctionPackageVersionWarning(PreviewWarning): """ - Managed UDF package versions for Numpy, Pandas, and Pyarrow may not - precisely match users' local environment or the exact versions specified. + Warns that package versions in remote function or managed function may not + match local or specified versions, which might cause unexpected behavior. """ diff --git a/bigframes/functions/_function_session.py b/bigframes/functions/_function_session.py index 29e175d02f..90bfb89c56 100644 --- a/bigframes/functions/_function_session.py +++ b/bigframes/functions/_function_session.py @@ -555,10 +555,6 @@ def wrapper(func): warnings.warn(msg, category=bfe.FunctionConflictTypeHintWarning) py_sig = py_sig.replace(return_annotation=output_type) - # Try to get input types via type annotations. - - # The function will actually be receiving a pandas Series, but allow both - # BigQuery DataFrames and pandas object types for compatibility. # The function will actually be receiving a pandas Series, but allow # both BigQuery DataFrames and pandas object types for compatibility. is_row_processor = False diff --git a/bigframes/functions/_utils.py b/bigframes/functions/_utils.py index 37ced54d49..b6dedeac50 100644 --- a/bigframes/functions/_utils.py +++ b/bigframes/functions/_utils.py @@ -25,6 +25,7 @@ import google.api_core.exceptions from google.cloud import bigquery, functions_v2 import numpy +from packaging.requirements import Requirement import pandas import pyarrow @@ -63,6 +64,16 @@ def get_remote_function_locations(bq_location): return bq_location, cloud_function_region +def _package_existed(package_requirements: list[str], package: str) -> bool: + """Checks if a package (regardless of version) exists in a given list.""" + if not package_requirements: + return False + + return Requirement(package).name in { + Requirement(req).name for req in package_requirements + } + + def get_updated_package_requirements( package_requirements=None, is_row_processor=False, @@ -96,13 +107,16 @@ def get_updated_package_requirements( requirements.append(f"pyarrow=={pyarrow.__version__}") requirements.append(f"numpy=={numpy.__version__}") - # TODO(b/435023957): Fix the issue of potential duplicate package versions - # when `package_requirements` also contains `pandas/pyarrow/numpy`. - if package_requirements: - requirements.extend(package_requirements) + if not requirements: + return package_requirements + + if not package_requirements: + package_requirements = [] + for package in requirements: + if not _package_existed(package_requirements, package): + package_requirements.append(package) - requirements = sorted(requirements) - return requirements + return sorted(package_requirements) def clean_up_by_session_id( diff --git a/bigframes/operations/aggregations.py b/bigframes/operations/aggregations.py index 984f7d3798..6889997a10 100644 --- a/bigframes/operations/aggregations.py +++ b/bigframes/operations/aggregations.py @@ -517,6 +517,7 @@ def skips_nulls(self): @dataclasses.dataclass(frozen=True) class DiffOp(UnaryWindowOp): + name: ClassVar[str] = "diff" periods: int @property diff --git a/bigframes/operations/blob_ops.py b/bigframes/operations/blob_ops.py index 2936e0f14f..29f23a2f70 100644 --- a/bigframes/operations/blob_ops.py +++ b/bigframes/operations/blob_ops.py @@ -36,11 +36,11 @@ def output_type(self, *input_types): @dataclasses.dataclass(frozen=True) class ObjMakeRef(base_ops.BinaryOp): - name: typing.ClassVar[str] = "obj.make_ref" + name: typing.ClassVar[str] = "obj_make_ref" def output_type(self, *input_types): if not all(map(dtypes.is_string_like, input_types)): - raise TypeError("obj.make_ref requires string-like arguments") + raise TypeError("obj_make_ref requires string-like arguments") return dtypes.OBJ_REF_DTYPE diff --git a/bigframes/operations/generic_ops.py b/bigframes/operations/generic_ops.py index 152de543db..d6155a770c 100644 --- a/bigframes/operations/generic_ops.py +++ b/bigframes/operations/generic_ops.py @@ -446,3 +446,15 @@ class SqlScalarOp(base_ops.NaryOp): def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: return self._output_type + + +@dataclasses.dataclass(frozen=True) +class PyUdfOp(base_ops.NaryOp): + """Represents a local UDF.""" + + name: typing.ClassVar[str] = "py_udf" + fn: typing.Callable + _output_type: dtypes.ExpressionType + + def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: + return self._output_type diff --git a/bigframes/series.py b/bigframes/series.py index bfc26adc38..6f48935ec9 100644 --- a/bigframes/series.py +++ b/bigframes/series.py @@ -406,17 +406,59 @@ def equals( return False return block_ops.equals(self._block, other._block) + @overload # type: ignore[override] + def reset_index( + self, + level: blocks.LevelsType = ..., + *, + name: typing.Optional[str] = ..., + drop: Literal[False] = ..., + inplace: Literal[False] = ..., + ) -> bigframes.dataframe.DataFrame: + ... + + @overload + def reset_index( + self, + level: blocks.LevelsType = ..., + *, + name: typing.Optional[str] = ..., + drop: Literal[True] = ..., + inplace: Literal[False] = ..., + ) -> Series: + ... + + @overload + def reset_index( + self, + level: blocks.LevelsType = ..., + *, + name: typing.Optional[str] = ..., + drop: bool = ..., + inplace: Literal[True] = ..., + ) -> None: + ... + @validations.requires_ordering() def reset_index( self, + level: blocks.LevelsType = None, *, name: typing.Optional[str] = None, drop: bool = False, - ) -> bigframes.dataframe.DataFrame | Series: - block = self._block.reset_index(drop) + inplace: bool = False, + ) -> bigframes.dataframe.DataFrame | Series | None: + block = self._block.reset_index(level, drop) if drop: + if inplace: + self._set_block(block) + return None return Series(block) else: + if inplace: + raise ValueError( + "Series.reset_index cannot combine inplace=True and drop=False" + ) if name: block = block.assign_label(self._value_column, name) return bigframes.dataframe.DataFrame(block) @@ -1436,7 +1478,23 @@ def items(self): for item in batch_df.squeeze(axis=1).items(): yield item + def _apply_callable(self, condition): + """ "Executes the possible callable condition as needed.""" + if callable(condition): + # When it's a bigframes function. + if hasattr(condition, "bigframes_bigquery_function"): + return self.apply(condition) + # When it's a plain Python function. + else: + return self.apply(condition, by_row=False) + + # When it's not a callable. + return condition + def where(self, cond, other=None): + cond = self._apply_callable(cond) + other = self._apply_callable(other) + value_id, cond_id, other_id, block = self._align3(cond, other) block, result_id = block.project_expr( ops.where_op.as_expr(value_id, cond_id, other_id) diff --git a/bigframes/session/anonymous_dataset.py b/bigframes/session/anonymous_dataset.py index bc785f693f..ec624d4eb4 100644 --- a/bigframes/session/anonymous_dataset.py +++ b/bigframes/session/anonymous_dataset.py @@ -13,6 +13,7 @@ # limitations under the License. import datetime +import threading from typing import List, Optional, Sequence import uuid @@ -40,19 +41,30 @@ def __init__( ): self.bqclient = bqclient self._location = location - self.dataset = bf_io_bigquery.create_bq_dataset_reference( - self.bqclient, - location=self._location, - ) self.session_id = session_id self._table_ids: List[bigquery.TableReference] = [] self._kms_key = kms_key + self._dataset_lock = threading.Lock() + self._datset_ref: Optional[bigquery.DatasetReference] = None + @property def location(self): return self._location + @property + def dataset(self) -> bigquery.DatasetReference: + if self._datset_ref is not None: + return self._datset_ref + with self._dataset_lock: + if self._datset_ref is None: + self._datset_ref = bf_io_bigquery.create_bq_dataset_reference( + self.bqclient, + location=self._location, + ) + return self._datset_ref + def _default_expiration(self): """When should the table expire automatically?""" return ( diff --git a/bigframes/session/polars_executor.py b/bigframes/session/polars_executor.py index ccc577deae..9c45a884e5 100644 --- a/bigframes/session/polars_executor.py +++ b/bigframes/session/polars_executor.py @@ -21,7 +21,7 @@ from bigframes.core import array_value, bigframe_node, expression, local_data, nodes import bigframes.operations from bigframes.operations import aggregations as agg_ops -from bigframes.operations import comparison_ops, generic_ops, numeric_ops +from bigframes.operations import bool_ops, comparison_ops, generic_ops, numeric_ops from bigframes.session import executor, semi_executor if TYPE_CHECKING: @@ -44,6 +44,9 @@ ) _COMPATIBLE_SCALAR_OPS = ( + bool_ops.AndOp, + bool_ops.OrOp, + bool_ops.XorOp, comparison_ops.EqOp, comparison_ops.EqNullsMatchOp, comparison_ops.NeOp, @@ -58,6 +61,13 @@ numeric_ops.FloorDivOp, numeric_ops.ModOp, generic_ops.AsTypeOp, + generic_ops.WhereOp, + generic_ops.CoalesceOp, + generic_ops.FillNaOp, + generic_ops.CaseWhenOp, + generic_ops.InvertOp, + generic_ops.IsNullOp, + generic_ops.NotNullOp, ) _COMPATIBLE_AGG_OPS = ( agg_ops.SizeOp, diff --git a/bigframes/session/read_api_execution.py b/bigframes/session/read_api_execution.py index d5bcf1dbc7..037fde011f 100644 --- a/bigframes/session/read_api_execution.py +++ b/bigframes/session/read_api_execution.py @@ -80,16 +80,12 @@ def execute( read_session=requested_session, max_stream_count=1, ) - session = self.bqstoragereadclient.create_read_session( - request=request, retry=None - ) + session = self.bqstoragereadclient.create_read_session(request=request) if not session.streams: batches: Iterator[pa.RecordBatch] = iter([]) else: - reader = self.bqstoragereadclient.read_rows( - session.streams[0].name, retry=None - ) + reader = self.bqstoragereadclient.read_rows(session.streams[0].name) rowstream = reader.rows() def process_page(page): diff --git a/bigframes/version.py b/bigframes/version.py index 7aff17a40d..6b84e2eb1d 100644 --- a/bigframes/version.py +++ b/bigframes/version.py @@ -12,8 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "2.15.0" +__version__ = "2.16.0" # {x-release-please-start-date} -__release_date__ = "2025-08-11" +__release_date__ = "2025-08-20" # {x-release-please-end} diff --git a/notebooks/.gitignore b/notebooks/.gitignore new file mode 100644 index 0000000000..87620ac7e7 --- /dev/null +++ b/notebooks/.gitignore @@ -0,0 +1 @@ +.ipynb_checkpoints/ diff --git a/notebooks/dataframes/anywidget_mode.ipynb b/notebooks/dataframes/anywidget_mode.ipynb index f6380a9fd4..617329ba65 100644 --- a/notebooks/dataframes/anywidget_mode.ipynb +++ b/notebooks/dataframes/anywidget_mode.ipynb @@ -55,6 +55,7 @@ "metadata": {}, "outputs": [], "source": [ + "bpd.options.bigquery.ordering_mode = \"partial\"\n", "bpd.options.display.repr_mode = \"anywidget\"" ] }, @@ -75,7 +76,7 @@ { "data": { "text/html": [ - "Query job c5fcfd5e-1617-49c8-afa3-86ca21019de4 is DONE. 0 Bytes processed. Open Job" + "Query job a643d120-4af9-44fc-ba3c-ed461cf1092b is DONE. 0 Bytes processed. Open Job" ], "text/plain": [ "" @@ -115,7 +116,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Computation deferred. Computation will process 171.4 MB\n" + "Computation deferred. Computation will process 44.4 MB\n" ] } ], @@ -138,27 +139,15 @@ "id": "ce250157", "metadata": {}, "outputs": [ - { - "data": { - "text/html": [ - "Query job ab900a53-5011-4e80-85d5-0ef2958598db is DONE. 171.4 MB processed. Open Job" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bda63ba739dc4d5f83a5e18eb27b2686", + "model_id": "d2d4ef22ea9f414b89ea5bd85f0e6635", "version_major": 2, "version_minor": 1 }, "text/plain": [ - "TableWidget(row_count=5552452, table_html='" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1630,7 +895,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.14" + "version": "3.10.16" } }, "nbformat": 4, diff --git a/notebooks/kaggle/bq_dataframes_ai_forecast.ipynb b/notebooks/kaggle/bq_dataframes_ai_forecast.ipynb new file mode 100644 index 0000000000..ebccb2c754 --- /dev/null +++ b/notebooks/kaggle/bq_dataframes_ai_forecast.ipynb @@ -0,0 +1 @@ +{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":110281,"databundleVersionId":13391012,"sourceType":"competition"}],"dockerImageVersionId":31089,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# BigQuery DataFrames (BigFrames) AI Forecast\n\nThis notebook is adapted from https://github.com/googleapis/python-bigquery-dataframes/blob/main/notebooks/generative_ai/bq_dataframes_ai_forecast.ipynb to work in the Kaggle runtime. It introduces forecasting with GenAI Foundation Model with BigFrames AI.\n\nInstall the bigframes package and upgrade other packages that are already included in Kaggle but have versions incompatible with bigframes.","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19"}},{"cell_type":"code","source":"%pip install --upgrade bigframes google-cloud-automl google-cloud-translate google-ai-generativelanguage tensorflow ","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Important:** restart the kernel by going to \"Run -> Restart & clear cell outputs\" before continuing.\n\nConfigure bigframes to use your GCP project. First, go to \"Add-ons -> Google Cloud SDK\" and click the \"Attach\" button. Then,","metadata":{}},{"cell_type":"code","source":"from kaggle_secrets import UserSecretsClient\nuser_secrets = UserSecretsClient()\nuser_credential = user_secrets.get_gcloud_credential()\nuser_secrets.set_tensorflow_credential(user_credential)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T19:16:10.449563Z","iopub.execute_input":"2025-08-18T19:16:10.449828Z","iopub.status.idle":"2025-08-18T19:16:10.618943Z","shell.execute_reply.started":"2025-08-18T19:16:10.449803Z","shell.execute_reply":"2025-08-18T19:16:10.617631Z"}},"outputs":[],"execution_count":1},{"cell_type":"code","source":"PROJECT = \"swast-scratch\" # replace with your project\n\n\nimport bigframes.pandas as bpd\nbpd.options.bigquery.project = PROJECT\nbpd.options.bigquery.ordering_mode = \"partial\" # Optional: partial ordering mode can accelerate executions and save costs\n\nimport bigframes.exceptions\nimport warnings\nwarnings.filterwarnings(\"ignore\", category=bigframes.exceptions.AmbiguousWindowWarning)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T19:20:00.851472Z","iopub.execute_input":"2025-08-18T19:20:00.851870Z","iopub.status.idle":"2025-08-18T19:20:00.858175Z","shell.execute_reply.started":"2025-08-18T19:20:00.851842Z","shell.execute_reply":"2025-08-18T19:20:00.857098Z"}},"outputs":[],"execution_count":4},{"cell_type":"markdown","source":"## 1. Create a BigFrames DataFrames from BigQuery public data.","metadata":{}},{"cell_type":"code","source":"df = bpd.read_gbq(\"bigquery-public-data.san_francisco_bikeshare.bikeshare_trips\")\ndf","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T19:20:02.254706Z","iopub.execute_input":"2025-08-18T19:20:02.255184Z","iopub.status.idle":"2025-08-18T19:20:04.754064Z","shell.execute_reply.started":"2025-08-18T19:20:02.255149Z","shell.execute_reply":"2025-08-18T19:20:04.752940Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/core/log_adapter.py:175: TimeTravelCacheWarning: Reading cached table from 2025-08-18 19:19:20.590271+00:00 to avoid\nincompatibilies with previous reads of this table. To read the latest\nversion, set `use_cache=False` or close the current session with\nSession.close() or bigframes.pandas.close_session().\n return method(*args, **kwargs)\n","output_type":"stream"},{"execution_count":5,"output_type":"execute_result","data":{"text/plain":" trip_id duration_sec start_date \\\n201802092135083596 788 2018-02-09 21:35:08+00:00 \n201708152357422491 965 2017-08-15 23:57:42+00:00 \n201802281657253632 560 2018-02-28 16:57:25+00:00 \n201711170046091337 497 2017-11-17 00:46:09+00:00 \n201802201913231257 596 2018-02-20 19:13:23+00:00 \n201708242325001279 1341 2017-08-24 23:25:00+00:00 \n201801161800473291 489 2018-01-16 18:00:47+00:00 \n 20180408155601183 1105 2018-04-08 15:56:01+00:00 \n201803141857032204 619 2018-03-14 18:57:03+00:00 \n201708192053311490 743 2017-08-19 20:53:31+00:00 \n201711181823281960 353 2017-11-18 18:23:28+00:00 \n 20170810204454839 1256 2017-08-10 20:44:54+00:00 \n201801171656553504 500 2018-01-17 16:56:55+00:00 \n201801111613101305 858 2018-01-11 16:13:10+00:00 \n201802241826551215 1235 2018-02-24 18:26:55+00:00 \n201803091621483450 857 2018-03-09 16:21:48+00:00 \n201801021932232717 914 2018-01-02 19:32:23+00:00 \n201803161910283751 564 2018-03-16 19:10:28+00:00 \n 20171212152403227 854 2017-12-12 15:24:03+00:00 \n201803131437033724 917 2018-03-13 14:37:03+00:00 \n201712061755593426 519 2017-12-06 17:55:59+00:00 \n 20180404210034451 366 2018-04-04 21:00:34+00:00 \n201801231907161787 626 2018-01-23 19:07:16+00:00 \n201708271057061157 973 2017-08-27 10:57:06+00:00 \n201709071348372074 11434 2017-09-07 13:48:37+00:00 \n\n start_station_name start_station_id end_date \\\n 10th Ave at E 15th St 222 2018-02-09 21:48:17+00:00 \n 10th St at Fallon St 201 2017-08-16 00:13:48+00:00 \n 10th St at Fallon St 201 2018-02-28 17:06:46+00:00 \n 10th St at Fallon St 201 2017-11-17 00:54:26+00:00 \n 10th St at Fallon St 201 2018-02-20 19:23:19+00:00 \n 10th St at Fallon St 201 2017-08-24 23:47:22+00:00 \n 10th St at Fallon St 201 2018-01-16 18:08:56+00:00 \n 13th St at Franklin St 338 2018-04-08 16:14:26+00:00 \n 13th St at Franklin St 338 2018-03-14 19:07:23+00:00 \n 2nd Ave at E 18th St 200 2017-08-19 21:05:54+00:00 \n 2nd Ave at E 18th St 200 2017-11-18 18:29:22+00:00 \n 2nd Ave at E 18th St 200 2017-08-10 21:05:50+00:00 \nEl Embarcadero at Grand Ave 197 2018-01-17 17:05:16+00:00 \n Frank H Ogawa Plaza 7 2018-01-11 16:27:28+00:00 \n Frank H Ogawa Plaza 7 2018-02-24 18:47:31+00:00 \n Frank H Ogawa Plaza 7 2018-03-09 16:36:06+00:00 \n Frank H Ogawa Plaza 7 2018-01-02 19:47:38+00:00 \n Frank H Ogawa Plaza 7 2018-03-16 19:19:52+00:00 \n Frank H Ogawa Plaza 7 2017-12-12 15:38:17+00:00 \n Grand Ave at Webster St 181 2018-03-13 14:52:20+00:00 \n Lake Merritt BART Station 163 2017-12-06 18:04:39+00:00 \n Lake Merritt BART Station 163 2018-04-04 21:06:41+00:00 \n Lake Merritt BART Station 163 2018-01-23 19:17:43+00:00 \n Lake Merritt BART Station 163 2017-08-27 11:13:19+00:00 \n Lake Merritt BART Station 163 2017-09-07 16:59:12+00:00 \n\n end_station_name end_station_id bike_number zip_code ... \\\n10th Ave at E 15th St 222 3596 ... \n10th Ave at E 15th St 222 2491 ... \n10th Ave at E 15th St 222 3632 ... \n10th Ave at E 15th St 222 1337 ... \n10th Ave at E 15th St 222 1257 ... \n10th Ave at E 15th St 222 1279 ... \n10th Ave at E 15th St 222 3291 ... \n10th Ave at E 15th St 222 183 ... \n10th Ave at E 15th St 222 2204 ... \n10th Ave at E 15th St 222 1490 ... \n10th Ave at E 15th St 222 1960 ... \n10th Ave at E 15th St 222 839 ... \n10th Ave at E 15th St 222 3504 ... \n10th Ave at E 15th St 222 1305 ... \n10th Ave at E 15th St 222 1215 ... \n10th Ave at E 15th St 222 3450 ... \n10th Ave at E 15th St 222 2717 ... \n10th Ave at E 15th St 222 3751 ... \n10th Ave at E 15th St 222 227 ... \n10th Ave at E 15th St 222 3724 ... \n10th Ave at E 15th St 222 3426 ... \n10th Ave at E 15th St 222 451 ... \n10th Ave at E 15th St 222 1787 ... \n10th Ave at E 15th St 222 1157 ... \n10th Ave at E 15th St 222 2074 ... \n\nc_subscription_type start_station_latitude start_station_longitude \\\n 37.792714 -122.24878 \n 37.797673 -122.262997 \n 37.797673 -122.262997 \n 37.797673 -122.262997 \n 37.797673 -122.262997 \n 37.797673 -122.262997 \n 37.797673 -122.262997 \n 37.803189 -122.270579 \n 37.803189 -122.270579 \n 37.800214 -122.25381 \n 37.800214 -122.25381 \n 37.800214 -122.25381 \n 37.808848 -122.24968 \n 37.804562 -122.271738 \n 37.804562 -122.271738 \n 37.804562 -122.271738 \n 37.804562 -122.271738 \n 37.804562 -122.271738 \n 37.804562 -122.271738 \n 37.811377 -122.265192 \n 37.79732 -122.26532 \n 37.79732 -122.26532 \n 37.79732 -122.26532 \n 37.79732 -122.26532 \n 37.79732 -122.26532 \n\n end_station_latitude end_station_longitude member_birth_year \\\n 37.792714 -122.24878 1984 \n 37.792714 -122.24878 \n 37.792714 -122.24878 1984 \n 37.792714 -122.24878 \n 37.792714 -122.24878 1984 \n 37.792714 -122.24878 1969 \n 37.792714 -122.24878 1984 \n 37.792714 -122.24878 1987 \n 37.792714 -122.24878 1982 \n 37.792714 -122.24878 \n 37.792714 -122.24878 1988 \n 37.792714 -122.24878 \n 37.792714 -122.24878 1987 \n 37.792714 -122.24878 1984 \n 37.792714 -122.24878 1969 \n 37.792714 -122.24878 1984 \n 37.792714 -122.24878 1984 \n 37.792714 -122.24878 1987 \n 37.792714 -122.24878 1984 \n 37.792714 -122.24878 1989 \n 37.792714 -122.24878 1986 \n 37.792714 -122.24878 1987 \n 37.792714 -122.24878 1987 \n 37.792714 -122.24878 \n 37.792714 -122.24878 \n\n member_gender bike_share_for_all_trip start_station_geom \\\n Male Yes POINT (-122.24878 37.79271) \n POINT (-122.26300 37.79767) \n Male Yes POINT (-122.26300 37.79767) \n POINT (-122.26300 37.79767) \n Male Yes POINT (-122.26300 37.79767) \n Male POINT (-122.26300 37.79767) \n Male Yes POINT (-122.26300 37.79767) \n Female No POINT (-122.27058 37.80319) \n Other No POINT (-122.27058 37.80319) \n POINT (-122.25381 37.80021) \n Male POINT (-122.25381 37.80021) \n POINT (-122.25381 37.80021) \n Male No POINT (-122.24968 37.80885) \n Male Yes POINT (-122.27174 37.80456) \n Male No POINT (-122.27174 37.80456) \n Male Yes POINT (-122.27174 37.80456) \n Male Yes POINT (-122.27174 37.80456) \n Male No POINT (-122.27174 37.80456) \n Male POINT (-122.27174 37.80456) \n Male No POINT (-122.26519 37.81138) \n Male POINT (-122.26532 37.79732) \n Male No POINT (-122.26532 37.79732) \n Male No POINT (-122.26532 37.79732) \n POINT (-122.26532 37.79732) \n POINT (-122.26532 37.79732) \n\n end_station_geom \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \nPOINT (-122.24878 37.79271) \n...\n\n[1947417 rows x 21 columns]","text/html":"
\n\n
\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
trip_idduration_secstart_datestart_station_namestart_station_idend_dateend_station_nameend_station_idbike_numberzip_code...c_subscription_typestart_station_latitudestart_station_longitudeend_station_latitudeend_station_longitudemember_birth_yearmember_genderbike_share_for_all_tripstart_station_geomend_station_geom
02018020921350835967882018-02-09 21:35:08+00:0010th Ave at E 15th St2222018-02-09 21:48:17+00:0010th Ave at E 15th St2223596<NA>...<NA>37.792714-122.2487837.792714-122.248781984MaleYesPOINT (-122.24878 37.79271)POINT (-122.24878 37.79271)
12017081523574224919652017-08-15 23:57:42+00:0010th St at Fallon St2012017-08-16 00:13:48+00:0010th Ave at E 15th St2222491<NA>...<NA>37.797673-122.26299737.792714-122.24878<NA><NA><NA>POINT (-122.26300 37.79767)POINT (-122.24878 37.79271)
22018022816572536325602018-02-28 16:57:25+00:0010th St at Fallon St2012018-02-28 17:06:46+00:0010th Ave at E 15th St2223632<NA>...<NA>37.797673-122.26299737.792714-122.248781984MaleYesPOINT (-122.26300 37.79767)POINT (-122.24878 37.79271)
32017111700460913374972017-11-17 00:46:09+00:0010th St at Fallon St2012017-11-17 00:54:26+00:0010th Ave at E 15th St2221337<NA>...<NA>37.797673-122.26299737.792714-122.24878<NA><NA><NA>POINT (-122.26300 37.79767)POINT (-122.24878 37.79271)
42018022019132312575962018-02-20 19:13:23+00:0010th St at Fallon St2012018-02-20 19:23:19+00:0010th Ave at E 15th St2221257<NA>...<NA>37.797673-122.26299737.792714-122.248781984MaleYesPOINT (-122.26300 37.79767)POINT (-122.24878 37.79271)
520170824232500127913412017-08-24 23:25:00+00:0010th St at Fallon St2012017-08-24 23:47:22+00:0010th Ave at E 15th St2221279<NA>...<NA>37.797673-122.26299737.792714-122.248781969Male<NA>POINT (-122.26300 37.79767)POINT (-122.24878 37.79271)
62018011618004732914892018-01-16 18:00:47+00:0010th St at Fallon St2012018-01-16 18:08:56+00:0010th Ave at E 15th St2223291<NA>...<NA>37.797673-122.26299737.792714-122.248781984MaleYesPOINT (-122.26300 37.79767)POINT (-122.24878 37.79271)
72018040815560118311052018-04-08 15:56:01+00:0013th St at Franklin St3382018-04-08 16:14:26+00:0010th Ave at E 15th St222183<NA>...<NA>37.803189-122.27057937.792714-122.248781987FemaleNoPOINT (-122.27058 37.80319)POINT (-122.24878 37.79271)
82018031418570322046192018-03-14 18:57:03+00:0013th St at Franklin St3382018-03-14 19:07:23+00:0010th Ave at E 15th St2222204<NA>...<NA>37.803189-122.27057937.792714-122.248781982OtherNoPOINT (-122.27058 37.80319)POINT (-122.24878 37.79271)
92017081920533114907432017-08-19 20:53:31+00:002nd Ave at E 18th St2002017-08-19 21:05:54+00:0010th Ave at E 15th St2221490<NA>...<NA>37.800214-122.2538137.792714-122.24878<NA><NA><NA>POINT (-122.25381 37.80021)POINT (-122.24878 37.79271)
102017111818232819603532017-11-18 18:23:28+00:002nd Ave at E 18th St2002017-11-18 18:29:22+00:0010th Ave at E 15th St2221960<NA>...<NA>37.800214-122.2538137.792714-122.248781988Male<NA>POINT (-122.25381 37.80021)POINT (-122.24878 37.79271)
112017081020445483912562017-08-10 20:44:54+00:002nd Ave at E 18th St2002017-08-10 21:05:50+00:0010th Ave at E 15th St222839<NA>...<NA>37.800214-122.2538137.792714-122.24878<NA><NA><NA>POINT (-122.25381 37.80021)POINT (-122.24878 37.79271)
122018011716565535045002018-01-17 16:56:55+00:00El Embarcadero at Grand Ave1972018-01-17 17:05:16+00:0010th Ave at E 15th St2223504<NA>...<NA>37.808848-122.2496837.792714-122.248781987MaleNoPOINT (-122.24968 37.80885)POINT (-122.24878 37.79271)
132018011116131013058582018-01-11 16:13:10+00:00Frank H Ogawa Plaza72018-01-11 16:27:28+00:0010th Ave at E 15th St2221305<NA>...<NA>37.804562-122.27173837.792714-122.248781984MaleYesPOINT (-122.27174 37.80456)POINT (-122.24878 37.79271)
1420180224182655121512352018-02-24 18:26:55+00:00Frank H Ogawa Plaza72018-02-24 18:47:31+00:0010th Ave at E 15th St2221215<NA>...<NA>37.804562-122.27173837.792714-122.248781969MaleNoPOINT (-122.27174 37.80456)POINT (-122.24878 37.79271)
152018030916214834508572018-03-09 16:21:48+00:00Frank H Ogawa Plaza72018-03-09 16:36:06+00:0010th Ave at E 15th St2223450<NA>...<NA>37.804562-122.27173837.792714-122.248781984MaleYesPOINT (-122.27174 37.80456)POINT (-122.24878 37.79271)
162018010219322327179142018-01-02 19:32:23+00:00Frank H Ogawa Plaza72018-01-02 19:47:38+00:0010th Ave at E 15th St2222717<NA>...<NA>37.804562-122.27173837.792714-122.248781984MaleYesPOINT (-122.27174 37.80456)POINT (-122.24878 37.79271)
172018031619102837515642018-03-16 19:10:28+00:00Frank H Ogawa Plaza72018-03-16 19:19:52+00:0010th Ave at E 15th St2223751<NA>...<NA>37.804562-122.27173837.792714-122.248781987MaleNoPOINT (-122.27174 37.80456)POINT (-122.24878 37.79271)
18201712121524032278542017-12-12 15:24:03+00:00Frank H Ogawa Plaza72017-12-12 15:38:17+00:0010th Ave at E 15th St222227<NA>...<NA>37.804562-122.27173837.792714-122.248781984Male<NA>POINT (-122.27174 37.80456)POINT (-122.24878 37.79271)
192018031314370337249172018-03-13 14:37:03+00:00Grand Ave at Webster St1812018-03-13 14:52:20+00:0010th Ave at E 15th St2223724<NA>...<NA>37.811377-122.26519237.792714-122.248781989MaleNoPOINT (-122.26519 37.81138)POINT (-122.24878 37.79271)
202017120617555934265192017-12-06 17:55:59+00:00Lake Merritt BART Station1632017-12-06 18:04:39+00:0010th Ave at E 15th St2223426<NA>...<NA>37.79732-122.2653237.792714-122.248781986Male<NA>POINT (-122.26532 37.79732)POINT (-122.24878 37.79271)
21201804042100344513662018-04-04 21:00:34+00:00Lake Merritt BART Station1632018-04-04 21:06:41+00:0010th Ave at E 15th St222451<NA>...<NA>37.79732-122.2653237.792714-122.248781987MaleNoPOINT (-122.26532 37.79732)POINT (-122.24878 37.79271)
222018012319071617876262018-01-23 19:07:16+00:00Lake Merritt BART Station1632018-01-23 19:17:43+00:0010th Ave at E 15th St2221787<NA>...<NA>37.79732-122.2653237.792714-122.248781987MaleNoPOINT (-122.26532 37.79732)POINT (-122.24878 37.79271)
232017082710570611579732017-08-27 10:57:06+00:00Lake Merritt BART Station1632017-08-27 11:13:19+00:0010th Ave at E 15th St2221157<NA>...<NA>37.79732-122.2653237.792714-122.24878<NA><NA><NA>POINT (-122.26532 37.79732)POINT (-122.24878 37.79271)
24201709071348372074114342017-09-07 13:48:37+00:00Lake Merritt BART Station1632017-09-07 16:59:12+00:0010th Ave at E 15th St2222074<NA>...<NA>37.79732-122.2653237.792714-122.24878<NA><NA><NA>POINT (-122.26532 37.79732)POINT (-122.24878 37.79271)
\n

25 rows × 21 columns

\n[1947417 rows x 21 columns in total]"},"metadata":{}}],"execution_count":5},{"cell_type":"markdown","source":"## 2. Preprocess Data\n\nOnly take the `start_date` after 2018 and the \"Subscriber\" category as input. `start_date` are truncated to each hour.","metadata":{}},{"cell_type":"code","source":"df = df[df[\"start_date\"] >= \"2018-01-01\"]\ndf = df[df[\"subscriber_type\"] == \"Subscriber\"]\ndf[\"trip_hour\"] = df[\"start_date\"].dt.floor(\"h\")\ndf = df[[\"trip_hour\", \"trip_id\"]]","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T19:20:44.397712Z","iopub.execute_input":"2025-08-18T19:20:44.398876Z","iopub.status.idle":"2025-08-18T19:20:44.421504Z","shell.execute_reply.started":"2025-08-18T19:20:44.398742Z","shell.execute_reply":"2025-08-18T19:20:44.420509Z"}},"outputs":[],"execution_count":6},{"cell_type":"markdown","source":"Group and count each hour's num of trips.","metadata":{}},{"cell_type":"code","source":"df_grouped = df.groupby(\"trip_hour\").count()\ndf_grouped = df_grouped.reset_index().rename(columns={\"trip_id\": \"num_trips\"})\ndf_grouped","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T19:20:57.499571Z","iopub.execute_input":"2025-08-18T19:20:57.500413Z","iopub.status.idle":"2025-08-18T19:21:02.999663Z","shell.execute_reply.started":"2025-08-18T19:20:57.500376Z","shell.execute_reply":"2025-08-18T19:21:02.998792Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"","text/html":"Query job e3df71d2-9248-491a-8e5f-4bb5bfedb686 is DONE. 58.7 MB processed. Open Job"},"metadata":{}},{"execution_count":7,"output_type":"execute_result","data":{"text/plain":" trip_hour num_trips\n2018-01-01 00:00:00+00:00 20\n2018-01-01 01:00:00+00:00 25\n2018-01-01 02:00:00+00:00 13\n2018-01-01 03:00:00+00:00 11\n2018-01-01 05:00:00+00:00 4\n2018-01-01 06:00:00+00:00 8\n2018-01-01 07:00:00+00:00 8\n2018-01-01 08:00:00+00:00 20\n2018-01-01 09:00:00+00:00 30\n2018-01-01 10:00:00+00:00 41\n2018-01-01 11:00:00+00:00 45\n2018-01-01 12:00:00+00:00 54\n2018-01-01 13:00:00+00:00 57\n2018-01-01 14:00:00+00:00 68\n2018-01-01 15:00:00+00:00 86\n2018-01-01 16:00:00+00:00 72\n2018-01-01 17:00:00+00:00 72\n2018-01-01 18:00:00+00:00 47\n2018-01-01 19:00:00+00:00 32\n2018-01-01 20:00:00+00:00 34\n2018-01-01 21:00:00+00:00 27\n2018-01-01 22:00:00+00:00 15\n2018-01-01 23:00:00+00:00 6\n2018-01-02 00:00:00+00:00 2\n2018-01-02 01:00:00+00:00 1\n...\n\n[2842 rows x 2 columns]","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
trip_hournum_trips
02018-01-01 00:00:00+00:0020
12018-01-01 01:00:00+00:0025
22018-01-01 02:00:00+00:0013
32018-01-01 03:00:00+00:0011
42018-01-01 05:00:00+00:004
52018-01-01 06:00:00+00:008
62018-01-01 07:00:00+00:008
72018-01-01 08:00:00+00:0020
82018-01-01 09:00:00+00:0030
92018-01-01 10:00:00+00:0041
102018-01-01 11:00:00+00:0045
112018-01-01 12:00:00+00:0054
122018-01-01 13:00:00+00:0057
132018-01-01 14:00:00+00:0068
142018-01-01 15:00:00+00:0086
152018-01-01 16:00:00+00:0072
162018-01-01 17:00:00+00:0072
172018-01-01 18:00:00+00:0047
182018-01-01 19:00:00+00:0032
192018-01-01 20:00:00+00:0034
202018-01-01 21:00:00+00:0027
212018-01-01 22:00:00+00:0015
222018-01-01 23:00:00+00:006
232018-01-02 00:00:00+00:002
242018-01-02 01:00:00+00:001
\n

25 rows × 2 columns

\n
[2842 rows x 2 columns in total]"},"metadata":{}}],"execution_count":7},{"cell_type":"markdown","source":"## 3. Make forecastings for next 1 week with DataFrames.ai.forecast API","metadata":{}},{"cell_type":"code","source":"# Using all the data except the last week (2842-168) for training. And predict the last week (168).\nresult = df_grouped.head(2842-168).ai.forecast(timestamp_column=\"trip_hour\", data_column=\"num_trips\", horizon=168) \nresult","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T19:22:58.943589Z","iopub.execute_input":"2025-08-18T19:22:58.944068Z","iopub.status.idle":"2025-08-18T19:23:11.364356Z","shell.execute_reply.started":"2025-08-18T19:22:58.944036Z","shell.execute_reply":"2025-08-18T19:23:11.363152Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"","text/html":"Query job 3f1225a8-b80b-4dfa-a7cf-94b93e7c18c2 is DONE. 68.2 kB processed. Open Job"},"metadata":{}},{"execution_count":8,"output_type":"execute_result","data":{"text/plain":" forecast_timestamp forecast_value confidence_level \\\n2018-04-24 12:00:00+00:00 144.577728 0.95 \n2018-04-25 00:00:00+00:00 54.215515 0.95 \n2018-04-26 05:00:00+00:00 8.140533 0.95 \n2018-04-26 14:00:00+00:00 198.744949 0.95 \n2018-04-27 02:00:00+00:00 9.91806 0.95 \n2018-04-29 03:00:00+00:00 32.063339 0.95 \n2018-04-27 04:00:00+00:00 25.757111 0.95 \n2018-04-30 06:00:00+00:00 89.808456 0.95 \n2018-04-30 02:00:00+00:00 -10.584175 0.95 \n2018-04-30 05:00:00+00:00 18.118111 0.95 \n2018-04-24 07:00:00+00:00 359.036957 0.95 \n2018-04-25 10:00:00+00:00 227.272049 0.95 \n2018-04-27 15:00:00+00:00 208.631363 0.95 \n2018-04-25 13:00:00+00:00 159.799911 0.95 \n2018-04-26 12:00:00+00:00 190.226944 0.95 \n2018-04-24 04:00:00+00:00 11.162338 0.95 \n2018-04-24 14:00:00+00:00 136.70816 0.95 \n2018-04-28 21:00:00+00:00 65.308899 0.95 \n2018-04-29 20:00:00+00:00 71.788849 0.95 \n2018-04-30 15:00:00+00:00 142.560944 0.95 \n2018-04-26 18:00:00+00:00 533.783813 0.95 \n2018-04-28 03:00:00+00:00 25.379761 0.95 \n2018-04-30 12:00:00+00:00 158.313385 0.95 \n2018-04-25 07:00:00+00:00 358.756592 0.95 \n2018-04-27 22:00:00+00:00 103.589096 0.95 \n\n prediction_interval_lower_bound prediction_interval_upper_bound \\\n 120.01921 169.136247 \n 46.8394 61.591631 \n -14.613272 30.894339 \n 174.982268 222.50763 \n -26.749948 46.586069 \n -35.730978 99.857656 \n 8.178037 43.336184 \n 15.214961 164.401952 \n -60.772024 39.603674 \n -40.902133 77.138355 \n 250.880334 467.193579 \n 170.918819 283.625279 \n 188.977435 228.285291 \n 150.066363 169.53346 \n 177.898865 202.555023 \n -18.581041 40.905717 \n 134.165413 139.250907 \n 63.000915 67.616883 \n -2.49023 146.067928 \n 41.495553 243.626334 \n 412.068752 655.498875 \n 22.565752 28.193769 \n 79.466457 237.160313 \n 276.305603 441.207581 \n 94.45235 112.725842 \n\nai_forecast_status \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n...\n\n[168 rows x 6 columns]","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
forecast_timestampforecast_valueconfidence_levelprediction_interval_lower_boundprediction_interval_upper_boundai_forecast_status
02018-04-24 12:00:00+00:00144.5777280.95120.01921169.136247
12018-04-25 00:00:00+00:0054.2155150.9546.839461.591631
22018-04-26 05:00:00+00:008.1405330.95-14.61327230.894339
32018-04-26 14:00:00+00:00198.7449490.95174.982268222.50763
42018-04-27 02:00:00+00:009.918060.95-26.74994846.586069
52018-04-29 03:00:00+00:0032.0633390.95-35.73097899.857656
62018-04-27 04:00:00+00:0025.7571110.958.17803743.336184
72018-04-30 06:00:00+00:0089.8084560.9515.214961164.401952
82018-04-30 02:00:00+00:00-10.5841750.95-60.77202439.603674
92018-04-30 05:00:00+00:0018.1181110.95-40.90213377.138355
102018-04-24 07:00:00+00:00359.0369570.95250.880334467.193579
112018-04-25 10:00:00+00:00227.2720490.95170.918819283.625279
122018-04-27 15:00:00+00:00208.6313630.95188.977435228.285291
132018-04-25 13:00:00+00:00159.7999110.95150.066363169.53346
142018-04-26 12:00:00+00:00190.2269440.95177.898865202.555023
152018-04-24 04:00:00+00:0011.1623380.95-18.58104140.905717
162018-04-24 14:00:00+00:00136.708160.95134.165413139.250907
172018-04-28 21:00:00+00:0065.3088990.9563.00091567.616883
182018-04-29 20:00:00+00:0071.7888490.95-2.49023146.067928
192018-04-30 15:00:00+00:00142.5609440.9541.495553243.626334
202018-04-26 18:00:00+00:00533.7838130.95412.068752655.498875
212018-04-28 03:00:00+00:0025.3797610.9522.56575228.193769
222018-04-30 12:00:00+00:00158.3133850.9579.466457237.160313
232018-04-25 07:00:00+00:00358.7565920.95276.305603441.207581
242018-04-27 22:00:00+00:00103.5890960.9594.45235112.725842
\n

25 rows × 6 columns

\n
[168 rows x 6 columns in total]"},"metadata":{}}],"execution_count":8},{"cell_type":"markdown","source":"# 4. Process the raw result and draw a line plot along with the training data","metadata":{}},{"cell_type":"code","source":"result = result.sort_values(\"forecast_timestamp\")\nresult = result[[\"forecast_timestamp\", \"forecast_value\"]]\nresult = result.rename(columns={\"forecast_timestamp\": \"trip_hour\", \"forecast_value\": \"num_trips_forecast\"})\ndf_all = bpd.concat([df_grouped, result])\ndf_all = df_all.tail(672) # 4 weeks","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T19:27:08.305886Z","iopub.execute_input":"2025-08-18T19:27:08.306367Z","iopub.status.idle":"2025-08-18T19:27:08.318514Z","shell.execute_reply.started":"2025-08-18T19:27:08.306336Z","shell.execute_reply":"2025-08-18T19:27:08.317016Z"}},"outputs":[],"execution_count":9},{"cell_type":"markdown","source":"Plot a line chart and compare with the actual result.","metadata":{}},{"cell_type":"code","source":"df_all = df_all.set_index(\"trip_hour\")\ndf_all.plot.line(figsize=(16, 8))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T19:27:19.461164Z","iopub.execute_input":"2025-08-18T19:27:19.461528Z","iopub.status.idle":"2025-08-18T19:27:20.737558Z","shell.execute_reply.started":"2025-08-18T19:27:19.461497Z","shell.execute_reply":"2025-08-18T19:27:20.736422Z"}},"outputs":[{"execution_count":10,"output_type":"execute_result","data":{"text/plain":""},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"
","image/png":"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\n"},"metadata":{}}],"execution_count":10},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]} diff --git a/notebooks/kaggle/describe-product-images-with-bigframes-multimodal.ipynb b/notebooks/kaggle/describe-product-images-with-bigframes-multimodal.ipynb new file mode 100644 index 0000000000..1c2e2b53a8 --- /dev/null +++ b/notebooks/kaggle/describe-product-images-with-bigframes-multimodal.ipynb @@ -0,0 +1 @@ +{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":110281,"databundleVersionId":13391012,"sourceType":"competition"}],"dockerImageVersionId":31089,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Describe product images with BigFrames multimodal DataFrames\n\nBased on notebook at https://github.com/googleapis/python-bigquery-dataframes/blob/main/notebooks/multimodal/multimodal_dataframe.ipynb\n\nThis notebook is introducing BigFrames Multimodal features:\n\n1. Create Multimodal DataFrame\n2. Combine unstructured data with structured data\n3. Conduct image transformations\n4. Use LLM models to ask questions and generate embeddings on images\n5. PDF chunking function\n\nInstall the bigframes package and upgrade other packages that are already included in Kaggle but have versions incompatible with bigframes.","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19"}},{"cell_type":"code","source":"%pip install --upgrade bigframes google-cloud-automl google-cloud-translate google-ai-generativelanguage tensorflow ","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Important:** restart the kernel by going to \"Run -> Restart & clear cell outputs\" before continuing.\n\nConfigure bigframes to use your GCP project. First, go to \"Add-ons -> Google Cloud SDK\" and click the \"Attach\" button. Then,","metadata":{}},{"cell_type":"code","source":"from kaggle_secrets import UserSecretsClient\nuser_secrets = UserSecretsClient()\nuser_credential = user_secrets.get_gcloud_credential()\nuser_secrets.set_tensorflow_credential(user_credential)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:17:14.872905Z","iopub.execute_input":"2025-08-18T20:17:14.873201Z","iopub.status.idle":"2025-08-18T20:17:14.946971Z","shell.execute_reply.started":"2025-08-18T20:17:14.873171Z","shell.execute_reply":"2025-08-18T20:17:14.945996Z"}},"outputs":[],"execution_count":2},{"cell_type":"code","source":"PROJECT = \"bigframes-dev\" # replace with your project. \n# Refer to https://cloud.google.com/bigquery/docs/multimodal-data-dataframes-tutorial#required_roles for your required permissions\n\nOUTPUT_BUCKET = \"bigframes_blob_test\" # replace with your GCS bucket. \n# The connection (or bigframes-default-connection of the project) must have read/write permission to the bucket. \n# Refer to https://cloud.google.com/bigquery/docs/multimodal-data-dataframes-tutorial#grant-permissions for setting up connection service account permissions.\n# In this Notebook it uses bigframes-default-connection by default. You can also bring in your own connections in each method.\n\nimport bigframes\n# Setup project\nbigframes.options.bigquery.project = PROJECT\n\n# Display options\nbigframes.options.display.blob_display_width = 300\nbigframes.options.display.progress_bar = None\n\nimport bigframes.pandas as bpd","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:17:25.573874Z","iopub.execute_input":"2025-08-18T20:17:25.574192Z","iopub.status.idle":"2025-08-18T20:17:45.102002Z","shell.execute_reply.started":"2025-08-18T20:17:25.574168Z","shell.execute_reply":"2025-08-18T20:17:45.101140Z"}},"outputs":[],"execution_count":3},{"cell_type":"code","source":"# Create blob columns from wildcard path.\ndf_image = bpd.from_glob_path(\n \"gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/images/*\", name=\"image\"\n)\n# Other ways are: from string uri column\n# df = bpd.DataFrame({\"uri\": [\"gs:///\", \"gs:///\"]})\n# df[\"blob_col\"] = df[\"uri\"].str.to_blob()\n\n# From an existing object table\n# df = bpd.read_gbq_object_table(\"\", name=\"blob_col\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:17:45.103249Z","iopub.execute_input":"2025-08-18T20:17:45.103530Z","iopub.status.idle":"2025-08-18T20:17:47.424586Z","shell.execute_reply.started":"2025-08-18T20:17:45.103499Z","shell.execute_reply":"2025-08-18T20:17:47.423762Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/core/global_session.py:103: DefaultLocationWarning: No explicit location is set, so using location US for the session.\n _global_session = bigframes.session.connect(\n","output_type":"stream"},{"name":"stdout","text":"Please ensure you have selected a BigQuery account in the Notebook Add-ons menu.\n","output_type":"stream"}],"execution_count":4},{"cell_type":"code","source":"# Take only the 5 images to deal with. Preview the content of the Mutimodal DataFrame\ndf_image = df_image.head(5)\ndf_image","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:17:47.425578Z","iopub.execute_input":"2025-08-18T20:17:47.425873Z","iopub.status.idle":"2025-08-18T20:18:07.919961Z","shell.execute_reply.started":"2025-08-18T20:17:47.425844Z","shell.execute_reply":"2025-08-18T20:18:07.918942Z"}},"outputs":[{"execution_count":5,"output_type":"execute_result","data":{"text/plain":" image\n0 {'uri': 'gs://cloud-samples-data/bigquery/tuto...\n1 {'uri': 'gs://cloud-samples-data/bigquery/tuto...\n2 {'uri': 'gs://cloud-samples-data/bigquery/tuto...\n3 {'uri': 'gs://cloud-samples-data/bigquery/tuto...\n4 {'uri': 'gs://cloud-samples-data/bigquery/tuto...\n\n[5 rows x 1 columns]","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
image
0
1
2
3
4
\n

5 rows × 1 columns

\n
[5 rows x 1 columns in total]"},"metadata":{}}],"execution_count":5},{"cell_type":"markdown","source":"# 2. Combine unstructured data with structured data\n\nNow you can put more information into the table to describe the files. Such as author info from inputs, or other metadata from the gcs object itself.","metadata":{}},{"cell_type":"code","source":"# Combine unstructured data with structured data\ndf_image[\"author\"] = [\"alice\", \"bob\", \"bob\", \"alice\", \"bob\"] # type: ignore\ndf_image[\"content_type\"] = df_image[\"image\"].blob.content_type()\ndf_image[\"size\"] = df_image[\"image\"].blob.size()\ndf_image[\"updated\"] = df_image[\"image\"].blob.updated()\ndf_image","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:18:07.921884Z","iopub.execute_input":"2025-08-18T20:18:07.922593Z","iopub.status.idle":"2025-08-18T20:18:35.549725Z","shell.execute_reply.started":"2025-08-18T20:18:07.922551Z","shell.execute_reply":"2025-08-18T20:18:35.548942Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/bigquery/_operations/json.py:124: UserWarning: The `json_extract` is deprecated and will be removed in a future\nversion. Use `json_query` instead.\n warnings.warn(bfe.format_message(msg), category=UserWarning)\n/usr/local/lib/python3.11/dist-packages/bigframes/bigquery/_operations/json.py:124: UserWarning: The `json_extract` is deprecated and will be removed in a future\nversion. Use `json_query` instead.\n warnings.warn(bfe.format_message(msg), category=UserWarning)\n/usr/local/lib/python3.11/dist-packages/bigframes/bigquery/_operations/json.py:124: UserWarning: The `json_extract` is deprecated and will be removed in a future\nversion. Use `json_query` instead.\n warnings.warn(bfe.format_message(msg), category=UserWarning)\n","output_type":"stream"},{"execution_count":6,"output_type":"execute_result","data":{"text/plain":" image author content_type \\\n0 {'uri': 'gs://cloud-samples-data/bigquery/tuto... alice image/png \n1 {'uri': 'gs://cloud-samples-data/bigquery/tuto... bob image/png \n2 {'uri': 'gs://cloud-samples-data/bigquery/tuto... bob image/png \n3 {'uri': 'gs://cloud-samples-data/bigquery/tuto... alice image/png \n4 {'uri': 'gs://cloud-samples-data/bigquery/tuto... bob image/png \n\n size updated \n0 1591240 2025-03-20 17:45:04+00:00 \n1 1182951 2025-03-20 17:45:02+00:00 \n2 1520884 2025-03-20 17:44:55+00:00 \n3 1235401 2025-03-20 17:45:19+00:00 \n4 1591923 2025-03-20 17:44:47+00:00 \n\n[5 rows x 5 columns]","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
imageauthorcontent_typesizeupdated
0aliceimage/png15912402025-03-20 17:45:04+00:00
1bobimage/png11829512025-03-20 17:45:02+00:00
2bobimage/png15208842025-03-20 17:44:55+00:00
3aliceimage/png12354012025-03-20 17:45:19+00:00
4bobimage/png15919232025-03-20 17:44:47+00:00
\n

5 rows × 5 columns

\n
[5 rows x 5 columns in total]"},"metadata":{}}],"execution_count":6},{"cell_type":"markdown","source":"Then you can filter the rows based on the structured data. And for different content types, you can display them respectively or together.","metadata":{}},{"cell_type":"code","source":"# filter images and display, you can also display audio and video types\ndf_image[df_image[\"author\"] == \"alice\"][\"image\"].blob.display()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:18:55.299993Z","iopub.execute_input":"2025-08-18T20:18:55.300314Z","iopub.status.idle":"2025-08-18T20:19:09.154492Z","shell.execute_reply.started":"2025-08-18T20:18:55.300289Z","shell.execute_reply":"2025-08-18T20:19:09.153315Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/bigquery/_operations/json.py:124: UserWarning: The `json_extract` is deprecated and will be removed in a future\nversion. Use `json_query` instead.\n warnings.warn(bfe.format_message(msg), category=UserWarning)\n","output_type":"stream"},{"output_type":"display_data","data":{"text/html":"","text/plain":""},"metadata":{}},{"output_type":"display_data","data":{"text/html":"","text/plain":""},"metadata":{}}],"execution_count":7},{"cell_type":"markdown","source":"# 3. Conduct image transformations\n\nBigFrames Multimodal DataFrame provides image(and other) transformation functions. Such as image_blur, image_resize and image_normalize. The output can be saved to GCS folders or to BQ as bytes.","metadata":{}},{"cell_type":"code","source":"df_image[\"blurred\"] = df_image[\"image\"].blob.image_blur(\n (20, 20), dst=f\"gs://{OUTPUT_BUCKET}/image_blur_transformed/\", engine=\"opencv\"\n)\ndf_image[\"resized\"] = df_image[\"image\"].blob.image_resize(\n (300, 200), dst=f\"gs://{OUTPUT_BUCKET}/image_resize_transformed/\", engine=\"opencv\"\n)\ndf_image[\"normalized\"] = df_image[\"image\"].blob.image_normalize(\n alpha=50.0,\n beta=150.0,\n norm_type=\"minmax\",\n dst=f\"gs://{OUTPUT_BUCKET}/image_normalize_transformed/\",\n engine=\"opencv\",\n)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:19:22.950277Z","iopub.execute_input":"2025-08-18T20:19:22.950652Z","iopub.status.idle":"2025-08-18T20:31:51.799997Z","shell.execute_reply.started":"2025-08-18T20:19:22.950625Z","shell.execute_reply":"2025-08-18T20:31:51.798840Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/core/log_adapter.py:175: FunctionAxisOnePreviewWarning: Blob Functions use bigframes DataFrame Managed function with axis=1 senario, which is a preview feature.\n return method(*args, **kwargs)\n/usr/local/lib/python3.11/dist-packages/bigframes/core/log_adapter.py:175: FunctionAxisOnePreviewWarning: Blob Functions use bigframes DataFrame Managed function with axis=1 senario, which is a preview feature.\n return method(*args, **kwargs)\n/usr/local/lib/python3.11/dist-packages/bigframes/core/log_adapter.py:175: FunctionAxisOnePreviewWarning: Blob Functions use bigframes DataFrame Managed function with axis=1 senario, which is a preview feature.\n return method(*args, **kwargs)\n","output_type":"stream"}],"execution_count":8},{"cell_type":"code","source":"# You can also chain functions together\ndf_image[\"blur_resized\"] = df_image[\"blurred\"].blob.image_resize((300, 200), dst=f\"gs://{OUTPUT_BUCKET}/image_blur_resize_transformed/\", engine=\"opencv\")\ndf_image","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:31:51.802219Z","iopub.execute_input":"2025-08-18T20:31:51.802745Z","iopub.status.idle":"2025-08-18T20:36:13.953258Z","shell.execute_reply.started":"2025-08-18T20:31:51.802700Z","shell.execute_reply":"2025-08-18T20:36:13.951930Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/core/log_adapter.py:175: FunctionAxisOnePreviewWarning: Blob Functions use bigframes DataFrame Managed function with axis=1 senario, which is a preview feature.\n return method(*args, **kwargs)\n","output_type":"stream"},{"execution_count":9,"output_type":"execute_result","data":{"text/plain":" image author content_type \\\n0 {'uri': 'gs://cloud-samples-data/bigquery/tuto... alice image/png \n1 {'uri': 'gs://cloud-samples-data/bigquery/tuto... bob image/png \n2 {'uri': 'gs://cloud-samples-data/bigquery/tuto... bob image/png \n3 {'uri': 'gs://cloud-samples-data/bigquery/tuto... alice image/png \n4 {'uri': 'gs://cloud-samples-data/bigquery/tuto... bob image/png \n\n size updated \\\n0 1591240 2025-03-20 17:45:04+00:00 \n1 1182951 2025-03-20 17:45:02+00:00 \n2 1520884 2025-03-20 17:44:55+00:00 \n3 1235401 2025-03-20 17:45:19+00:00 \n4 1591923 2025-03-20 17:44:47+00:00 \n\n blurred \\\n0 {'uri': 'gs://bigframes_blob_test/image_blur_t... \n1 {'uri': 'gs://bigframes_blob_test/image_blur_t... \n2 {'uri': 'gs://bigframes_blob_test/image_blur_t... \n3 {'uri': 'gs://bigframes_blob_test/image_blur_t... \n4 {'uri': 'gs://bigframes_blob_test/image_blur_t... \n\n resized \\\n0 {'uri': 'gs://bigframes_blob_test/image_resize... \n1 {'uri': 'gs://bigframes_blob_test/image_resize... \n2 {'uri': 'gs://bigframes_blob_test/image_resize... \n3 {'uri': 'gs://bigframes_blob_test/image_resize... \n4 {'uri': 'gs://bigframes_blob_test/image_resize... \n\n normalized \\\n0 {'uri': 'gs://bigframes_blob_test/image_normal... \n1 {'uri': 'gs://bigframes_blob_test/image_normal... \n2 {'uri': 'gs://bigframes_blob_test/image_normal... \n3 {'uri': 'gs://bigframes_blob_test/image_normal... \n4 {'uri': 'gs://bigframes_blob_test/image_normal... \n\n blur_resized \n0 {'uri': 'gs://bigframes_blob_test/image_blur_r... \n1 {'uri': 'gs://bigframes_blob_test/image_blur_r... \n2 {'uri': 'gs://bigframes_blob_test/image_blur_r... \n3 {'uri': 'gs://bigframes_blob_test/image_blur_r... \n4 {'uri': 'gs://bigframes_blob_test/image_blur_r... \n\n[5 rows x 9 columns]","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
imageauthorcontent_typesizeupdatedblurredresizednormalizedblur_resized
0aliceimage/png15912402025-03-20 17:45:04+00:00
1bobimage/png11829512025-03-20 17:45:02+00:00
2bobimage/png15208842025-03-20 17:44:55+00:00
3aliceimage/png12354012025-03-20 17:45:19+00:00
4bobimage/png15919232025-03-20 17:44:47+00:00
\n

5 rows × 9 columns

\n
[5 rows x 9 columns in total]"},"metadata":{}}],"execution_count":9},{"cell_type":"markdown","source":"# 4. Use LLM models to ask questions and generate embeddings on images","metadata":{}},{"cell_type":"code","source":"from bigframes.ml import llm\ngemini = llm.GeminiTextGenerator()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:36:13.954340Z","iopub.execute_input":"2025-08-18T20:36:13.954686Z","iopub.status.idle":"2025-08-18T20:36:43.225449Z","shell.execute_reply.started":"2025-08-18T20:36:13.954661Z","shell.execute_reply":"2025-08-18T20:36:43.224579Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/core/log_adapter.py:175: FutureWarning: Since upgrading the default model can cause unintended breakages, the\ndefault model will be removed in BigFrames 3.0. Please supply an\nexplicit model to avoid this message.\n return method(*args, **kwargs)\n","output_type":"stream"}],"execution_count":10},{"cell_type":"code","source":"# Ask the same question on the images\ndf_image = df_image.head(2)\nanswer = gemini.predict(df_image, prompt=[\"what item is it?\", df_image[\"image\"]])\nanswer[[\"ml_generate_text_llm_result\", \"image\"]]","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:36:43.227457Z","iopub.execute_input":"2025-08-18T20:36:43.227798Z","iopub.status.idle":"2025-08-18T20:37:25.238649Z","shell.execute_reply.started":"2025-08-18T20:36:43.227764Z","shell.execute_reply":"2025-08-18T20:37:25.237623Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/core/array_value.py:108: PreviewWarning: JSON column interpretation as a custom PyArrow extention in\n`db_dtypes` is a preview feature and subject to change.\n warnings.warn(msg, bfe.PreviewWarning)\n","output_type":"stream"},{"execution_count":11,"output_type":"execute_result","data":{"text/plain":" ml_generate_text_llm_result \\\n0 The item is a tin of K9 Guard Dog Paw Balm. \n1 The item is a bottle of K9 Guard Dog Hot Spot ... \n\n image \n0 {'uri': 'gs://cloud-samples-data/bigquery/tuto... \n1 {'uri': 'gs://cloud-samples-data/bigquery/tuto... \n\n[2 rows x 2 columns]","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
ml_generate_text_llm_resultimage
0The item is a tin of K9 Guard Dog Paw Balm.
1The item is a bottle of K9 Guard Dog Hot Spot Spray.
\n

2 rows × 2 columns

\n
[2 rows x 2 columns in total]"},"metadata":{}}],"execution_count":11},{"cell_type":"code","source":"# Ask different questions\ndf_image[\"question\"] = [\"what item is it?\", \"what color is the picture?\"]","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:37:25.239607Z","iopub.execute_input":"2025-08-18T20:37:25.239875Z","iopub.status.idle":"2025-08-18T20:37:25.263034Z","shell.execute_reply.started":"2025-08-18T20:37:25.239847Z","shell.execute_reply":"2025-08-18T20:37:25.262002Z"}},"outputs":[],"execution_count":12},{"cell_type":"code","source":"answer_alt = gemini.predict(df_image, prompt=[df_image[\"question\"], df_image[\"image\"]])\nanswer_alt[[\"ml_generate_text_llm_result\", \"image\"]]","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:37:25.264072Z","iopub.execute_input":"2025-08-18T20:37:25.264585Z","iopub.status.idle":"2025-08-18T20:38:10.129667Z","shell.execute_reply.started":"2025-08-18T20:37:25.264518Z","shell.execute_reply":"2025-08-18T20:38:10.128677Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/core/array_value.py:108: PreviewWarning: JSON column interpretation as a custom PyArrow extention in\n`db_dtypes` is a preview feature and subject to change.\n warnings.warn(msg, bfe.PreviewWarning)\n","output_type":"stream"},{"execution_count":13,"output_type":"execute_result","data":{"text/plain":" ml_generate_text_llm_result \\\n0 The item is a tin of K9 Guard Dog Paw Balm. \n1 The picture has colors such as white, gray, an... \n\n image \n0 {'uri': 'gs://cloud-samples-data/bigquery/tuto... \n1 {'uri': 'gs://cloud-samples-data/bigquery/tuto... \n\n[2 rows x 2 columns]","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
ml_generate_text_llm_resultimage
0The item is a tin of K9 Guard Dog Paw Balm.
1The picture has colors such as white, gray, and a light blue (cyan).
\n

2 rows × 2 columns

\n
[2 rows x 2 columns in total]"},"metadata":{}}],"execution_count":13},{"cell_type":"code","source":"# Generate embeddings.\nembed_model = llm.MultimodalEmbeddingGenerator()\nembeddings = embed_model.predict(df_image[\"image\"])\nembeddings","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-08-18T20:38:10.130617Z","iopub.execute_input":"2025-08-18T20:38:10.130851Z","iopub.status.idle":"2025-08-18T20:39:04.790416Z","shell.execute_reply.started":"2025-08-18T20:38:10.130833Z","shell.execute_reply":"2025-08-18T20:39:04.789398Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/bigframes/core/log_adapter.py:175: FutureWarning: Since upgrading the default model can cause unintended breakages, the\ndefault model will be removed in BigFrames 3.0. Please supply an\nexplicit model to avoid this message.\n return method(*args, **kwargs)\n/usr/local/lib/python3.11/dist-packages/bigframes/core/array_value.py:108: PreviewWarning: JSON column interpretation as a custom PyArrow extention in\n`db_dtypes` is a preview feature and subject to change.\n warnings.warn(msg, bfe.PreviewWarning)\n","output_type":"stream"},{"execution_count":14,"output_type":"execute_result","data":{"text/plain":" ml_generate_embedding_result \\\n0 [ 0.00638822 0.01666385 0.00451817 ... -0.02... \n1 [ 0.00973672 0.02148364 0.00244308 ... 0.00... \n\n ml_generate_embedding_status ml_generate_embedding_start_sec \\\n0 \n1 \n\n ml_generate_embedding_end_sec \\\n0 \n1 \n\n content \n0 {\"access_urls\":{\"expiry_time\":\"2025-08-19T02:3... \n1 {\"access_urls\":{\"expiry_time\":\"2025-08-19T02:3... \n\n[2 rows x 5 columns]","text/html":"
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
ml_generate_embedding_resultml_generate_embedding_statusml_generate_embedding_start_secml_generate_embedding_end_seccontent
0[ 0.00638822 0.01666385 0.00451817 ... -0.02...<NA><NA>{\"access_urls\":{\"expiry_time\":\"2025-08-19T02:3...
1[ 0.00973672 0.02148364 0.00244308 ... 0.00...<NA><NA>{\"access_urls\":{\"expiry_time\":\"2025-08-19T02:3...
\n

2 rows × 5 columns

\n
[2 rows x 5 columns in total]"},"metadata":{}}],"execution_count":14},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]} diff --git a/notebooks/kaggle/vector-search-with-bigframes-over-national-jukebox.ipynb b/notebooks/kaggle/vector-search-with-bigframes-over-national-jukebox.ipynb new file mode 100644 index 0000000000..fe2d567d1b --- /dev/null +++ b/notebooks/kaggle/vector-search-with-bigframes-over-national-jukebox.ipynb @@ -0,0 +1,1137 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "194%" + } + } + } + }, + "editable": true, + "slideshow": { + "slide_type": "subslide" + }, + "tags": [] + }, + "source": [ + "# Creating a searchable index of the National Jukebox\n", + "\n", + "_Extracting text from audio and indexing it with BigQuery DataFrames_\n", + "\n", + "* Tim Swena (formerly, Swast)\n", + "* swast@google.com\n", + "* https://vis.social/@timswast on Mastodon\n", + "\n", + "This notebook lives in\n", + "\n", + "* https://github.com/tswast/code-snippets\n", + "* at https://github.com/tswast/code-snippets/blob/main/2025/national-jukebox/transcribe_songs.ipynb\n", + "\n", + "To follow along, you'll need a Google Cloud project\n", + "\n", + "* Go to https://cloud.google.com/free to start a free trial." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "z-index": "0", + "zoom": "216%" + } + } + } + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "The National Jukebox is a project of the USA Library of Congress to provide access to thousands of acoustic sound recordings from the very earliest days of the commercial record industry.\n", + "\n", + "* Learn more at https://www.loc.gov/collections/national-jukebox/about-this-collection/\n", + "\n", + "\"recording" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "z-index": "0", + "zoom": "181%" + } + } + } + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "\n", + "To search the National Jukebox, we combine powerful features of BigQuery:\n", + "\n", + "\"audio\n", + "\n", + "1. Integrations with multi-modal AI models to extract information from unstructured data, in this case audio files.\n", + "\n", + " https://cloud.google.com/bigquery/docs/multimodal-data-dataframes-tutorial\n", + " \n", + "2. Vector search to find similar text using embedding models.\n", + "\n", + " https://cloud.google.com/bigquery/docs/vector-index-text-search-tutorial\n", + "\n", + "3. BigQuery DataFrames to use Python instead of SQL.\n", + "\n", + " https://cloud.google.com/bigquery/docs/bigquery-dataframes-introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "275%" + } + } + } + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Getting started with BigQuery DataFrames (bigframes)\n", + "\n", + "Install the bigframes package." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "214%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T15:53:02.494188Z", + "iopub.status.busy": "2025-08-14T15:53:02.493469Z", + "iopub.status.idle": "2025-08-14T15:53:08.492291Z", + "shell.execute_reply": "2025-08-14T15:53:08.491183Z", + "shell.execute_reply.started": "2025-08-14T15:53:02.494152Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "%pip install --upgrade bigframes google-cloud-automl google-cloud-translate google-ai-generativelanguage tensorflow " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "z-index": "4", + "zoom": "236%" + } + } + } + } + }, + "source": [ + "**Important:** restart the kernel by going to \"Run -> Restart & clear cell outputs\" before continuing.\n", + "\n", + "Configure bigframes to use your GCP project. First, go to \"Add-ons -> Google Cloud SDK\" and click the \"Attach\" button. Then," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-08-14T15:53:08.494636Z", + "iopub.status.busy": "2025-08-14T15:53:08.494313Z", + "iopub.status.idle": "2025-08-14T15:53:08.609706Z", + "shell.execute_reply": "2025-08-14T15:53:08.608705Z", + "shell.execute_reply.started": "2025-08-14T15:53:08.494604Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "from kaggle_secrets import UserSecretsClient\n", + "user_secrets = UserSecretsClient()\n", + "user_credential = user_secrets.get_gcloud_credential()\n", + "user_secrets.set_tensorflow_credential(user_credential)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "193%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T15:53:08.610982Z", + "iopub.status.busy": "2025-08-14T15:53:08.610686Z", + "iopub.status.idle": "2025-08-14T15:53:17.658993Z", + "shell.execute_reply": "2025-08-14T15:53:17.657745Z", + "shell.execute_reply.started": "2025-08-14T15:53:08.610961Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "import bigframes._config\n", + "import bigframes.pandas as bpd\n", + "\n", + "bpd.options.bigquery.location = \"US\"\n", + "\n", + "# Set to your GCP project ID.\n", + "bpd.options.bigquery.project = \"swast-scratch\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "207%" + } + } + } + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Reading data\n", + "\n", + "BigQuery DataFrames can read data from BigQuery, GCS, or even local sources. With `engine=\"bigquery\"`, BigQuery's distributed processing reads the file without it ever having to reach your local Python environment." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "225%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T15:53:17.662234Z", + "iopub.status.busy": "2025-08-14T15:53:17.661901Z", + "iopub.status.idle": "2025-08-14T15:53:34.486799Z", + "shell.execute_reply": "2025-08-14T15:53:34.485777Z", + "shell.execute_reply.started": "2025-08-14T15:53:17.662207Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "df = bpd.read_json(\n", + " \"gs://cloud-samples-data/third-party/usa-loc-national-jukebox/jukebox.jsonl\",\n", + " engine=\"bigquery\",\n", + " orient=\"records\",\n", + " lines=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "122%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T15:53:34.488610Z", + "iopub.status.busy": "2025-08-14T15:53:34.488332Z", + "iopub.status.idle": "2025-08-14T15:53:40.347014Z", + "shell.execute_reply": "2025-08-14T15:53:40.345773Z", + "shell.execute_reply.started": "2025-08-14T15:53:34.488589Z" + }, + "slideshow": { + "slide_type": "slide" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "# Use `peek()` instead of `head()` to see arbitrary rows rather than the \"first\" rows.\n", + "df.peek()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "134%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T15:53:40.348376Z", + "iopub.status.busy": "2025-08-14T15:53:40.348021Z", + "iopub.status.idle": "2025-08-14T15:53:40.364129Z", + "shell.execute_reply": "2025-08-14T15:53:40.363204Z", + "shell.execute_reply.started": "2025-08-14T15:53:40.348351Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-08-14T15:55:55.448664Z", + "iopub.status.busy": "2025-08-14T15:55:55.448310Z", + "iopub.status.idle": "2025-08-14T15:55:59.440964Z", + "shell.execute_reply": "2025-08-14T15:55:59.439988Z", + "shell.execute_reply.started": "2025-08-14T15:55:55.448637Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "# For the purposes of a demo, select only a subset of rows.\n", + "df = df.sample(n=250)\n", + "df.cache()\n", + "df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "161%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T15:56:02.040804Z", + "iopub.status.busy": "2025-08-14T15:56:02.040450Z", + "iopub.status.idle": "2025-08-14T15:56:06.544384Z", + "shell.execute_reply": "2025-08-14T15:56:06.543240Z", + "shell.execute_reply.started": "2025-08-14T15:56:02.040777Z" + }, + "slideshow": { + "slide_type": "slide" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "# As a side effect of how I extracted the song information from the HTML DOM,\n", + "# we ended up with lists in places where we only expect one item.\n", + "#\n", + "# We can \"explode\" to flatten these lists.\n", + "flattened = df.explode([\n", + " \"Recording Repository\",\n", + " \"Recording Label\",\n", + " \"Recording Take Number\",\n", + " \"Recording Date\",\n", + " \"Recording Matrix Number\",\n", + " \"Recording Catalog Number\",\n", + " \"Media Size\",\n", + " \"Recording Location\",\n", + " \"Summary\",\n", + " \"Rights Advisory\",\n", + " \"Title\",\n", + "])\n", + "flattened.peek()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-08-14T15:56:06.546531Z", + "iopub.status.busy": "2025-08-14T15:56:06.546140Z", + "iopub.status.idle": "2025-08-14T15:56:06.566005Z", + "shell.execute_reply": "2025-08-14T15:56:06.564355Z", + "shell.execute_reply.started": "2025-08-14T15:56:06.546494Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "flattened.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "216%" + } + } + } + }, + "editable": true, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "To access unstructured data from BigQuery, create a URI pointing to a file in Google Cloud Storage (GCS). Then, construct a \"blob\" (also known as an \"Object Ref\" in BigQuery terms) so that BigQuery can read from GCS." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "211%" + } + } + } + }, + "editable": true, + "execution": { + "iopub.execute_input": "2025-08-14T15:56:07.394879Z", + "iopub.status.busy": "2025-08-14T15:56:07.394509Z", + "iopub.status.idle": "2025-08-14T15:56:12.217017Z", + "shell.execute_reply": "2025-08-14T15:56:12.215852Z", + "shell.execute_reply.started": "2025-08-14T15:56:07.394853Z" + }, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "trusted": true + }, + "outputs": [], + "source": [ + "flattened = flattened.assign(**{\n", + " \"GCS Prefix\": \"gs://cloud-samples-data/third-party/usa-loc-national-jukebox/\",\n", + " \"GCS Stub\": flattened['URL'].str.extract(r'/(jukebox-[0-9]+)/'),\n", + "})\n", + "flattened[\"GCS URI\"] = flattened[\"GCS Prefix\"] + flattened[\"GCS Stub\"] + \".mp3\"\n", + "flattened[\"GCS Blob\"] = flattened[\"GCS URI\"].str.to_blob()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "317%" + } + } + } + }, + "editable": true, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "BigQuery (and BigQuery DataFrames) provide access to powerful models and multimodal capabilities. Here, we transcribe audio to text." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "execution": { + "iopub.execute_input": "2025-08-14T15:56:20.908198Z", + "iopub.status.busy": "2025-08-14T15:56:20.907791Z", + "iopub.status.idle": "2025-08-14T15:58:45.909086Z", + "shell.execute_reply": "2025-08-14T15:58:45.908060Z", + "shell.execute_reply.started": "2025-08-14T15:56:20.908170Z" + }, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "trusted": true + }, + "outputs": [], + "source": [ + "flattened[\"Transcription\"] = flattened[\"GCS Blob\"].blob.audio_transcribe(\n", + " model_name=\"gemini-2.0-flash-001\",\n", + " verbose=True,\n", + ")\n", + "flattened[\"Transcription\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "229%" + } + } + } + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Sometimes the model has transient errors. Check the status column to see if there are errors." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "177%" + } + } + } + }, + "editable": true, + "execution": { + "iopub.execute_input": "2025-08-14T15:59:43.609239Z", + "iopub.status.busy": "2025-08-14T15:59:43.607976Z", + "iopub.status.idle": "2025-08-14T15:59:44.515118Z", + "shell.execute_reply": "2025-08-14T15:59:44.514275Z", + "shell.execute_reply.started": "2025-08-14T15:59:43.609201Z" + }, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "trusted": true + }, + "outputs": [], + "source": [ + "print(f\"Successful rows: {(flattened['Transcription'].struct.field('status') == '').sum()}\")\n", + "print(f\"Failed rows: {(flattened['Transcription'].struct.field('status') != '').sum()}\")\n", + "flattened.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "141%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T15:59:44.820256Z", + "iopub.status.busy": "2025-08-14T15:59:44.819926Z", + "iopub.status.idle": "2025-08-14T15:59:53.147159Z", + "shell.execute_reply": "2025-08-14T15:59:53.146281Z", + "shell.execute_reply.started": "2025-08-14T15:59:44.820232Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "# Show transcribed lyrics.\n", + "flattened[\"Transcription\"].struct.field(\"content\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "152%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T15:59:53.149222Z", + "iopub.status.busy": "2025-08-14T15:59:53.148783Z", + "iopub.status.idle": "2025-08-14T15:59:58.868959Z", + "shell.execute_reply": "2025-08-14T15:59:58.867804Z", + "shell.execute_reply.started": "2025-08-14T15:59:53.149198Z" + }, + "slideshow": { + "slide_type": "slide" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "# Find all instrumentatal songs\n", + "instrumental = flattened[flattened[\"Transcription\"].struct.field(\"content\") == \"\"]\n", + "print(instrumental.shape)\n", + "song = instrumental.peek(1)\n", + "song" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "152%" + } + } + } + }, + "editable": true, + "execution": { + "iopub.execute_input": "2025-08-14T15:59:58.870143Z", + "iopub.status.busy": "2025-08-14T15:59:58.869868Z", + "iopub.status.idle": "2025-08-14T16:00:15.502470Z", + "shell.execute_reply": "2025-08-14T16:00:15.500813Z", + "shell.execute_reply.started": "2025-08-14T15:59:58.870123Z" + }, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "trusted": true + }, + "outputs": [], + "source": [ + "import gcsfs\n", + "import IPython.display\n", + "\n", + "fs = gcsfs.GCSFileSystem(project='bigframes-dev')\n", + "with fs.open(song[\"GCS URI\"].iloc[0]) as song_file:\n", + " song_bytes = song_file.read()\n", + "\n", + "IPython.display.Audio(song_bytes)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "181%" + } + } + } + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Creating a searchable index\n", + "\n", + "To be able to search by semantics rather than just text, generate embeddings and then create an index to efficiently search these.\n", + "\n", + "See also, this example: https://github.com/googleapis/python-bigquery-dataframes/blob/main/notebooks/generative_ai/bq_dataframes_llm_vector_search.ipynb" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "163%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T16:00:15.506380Z", + "iopub.status.busy": "2025-08-14T16:00:15.505775Z", + "iopub.status.idle": "2025-08-14T16:00:25.134987Z", + "shell.execute_reply": "2025-08-14T16:00:25.134124Z", + "shell.execute_reply.started": "2025-08-14T16:00:15.506337Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "from bigframes.ml.llm import TextEmbeddingGenerator\n", + "\n", + "text_model = TextEmbeddingGenerator(model_name=\"text-multilingual-embedding-002\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "125%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T16:00:25.136017Z", + "iopub.status.busy": "2025-08-14T16:00:25.135744Z", + "iopub.status.idle": "2025-08-14T16:00:34.860878Z", + "shell.execute_reply": "2025-08-14T16:00:34.859925Z", + "shell.execute_reply.started": "2025-08-14T16:00:25.135997Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "df_to_index = (\n", + " flattened\n", + " .assign(content=flattened[\"Transcription\"].struct.field(\"content\"))\n", + " [flattened[\"Transcription\"].struct.field(\"content\") != \"\"]\n", + ")\n", + "embedding = text_model.predict(df_to_index)\n", + "embedding.peek(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "178%" + } + } + } + }, + "editable": true, + "execution": { + "iopub.execute_input": "2025-08-14T16:01:20.816923Z", + "iopub.status.busy": "2025-08-14T16:01:20.816523Z", + "iopub.status.idle": "2025-08-14T16:01:22.480554Z", + "shell.execute_reply": "2025-08-14T16:01:22.479604Z", + "shell.execute_reply.started": "2025-08-14T16:01:20.816894Z" + }, + "slideshow": { + "slide_type": "slide" + }, + "tags": [], + "trusted": true + }, + "outputs": [], + "source": [ + "# Check the status column to look for errors.\n", + "print(f\"Successful rows: {(embedding['ml_generate_embedding_status'] == '').sum()}\")\n", + "print(f\"Failed rows: {(embedding['ml_generate_embedding_status'] != '').sum()}\")\n", + "embedding.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "224%" + } + } + } + } + }, + "source": [ + "We're now ready to save this to a table." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "172%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T16:03:43.611592Z", + "iopub.status.busy": "2025-08-14T16:03:43.611265Z", + "iopub.status.idle": "2025-08-14T16:03:47.459025Z", + "shell.execute_reply": "2025-08-14T16:03:47.458079Z", + "shell.execute_reply.started": "2025-08-14T16:03:43.611568Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "embedding_table_id = f\"{bpd.options.bigquery.project}.kaggle.national_jukebox\"\n", + "embedding.to_gbq(embedding_table_id, if_exists=\"replace\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "183%" + } + } + } + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Searching the database\n", + "\n", + "To search by semantics, we:\n", + "\n", + "1. Turn our search string into an embedding using the same model as our index.\n", + "2. Find the closest matches to the search string." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "92%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T16:03:52.674429Z", + "iopub.status.busy": "2025-08-14T16:03:52.673629Z", + "iopub.status.idle": "2025-08-14T16:03:59.962635Z", + "shell.execute_reply": "2025-08-14T16:03:59.961482Z", + "shell.execute_reply.started": "2025-08-14T16:03:52.674399Z" + }, + "slideshow": { + "slide_type": "skip" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "import bigframes.pandas as bpd\n", + "\n", + "df_written = bpd.read_gbq(embedding_table_id)\n", + "df_written.peek(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "127%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T16:03:59.964634Z", + "iopub.status.busy": "2025-08-14T16:03:59.964268Z", + "iopub.status.idle": "2025-08-14T16:04:55.051531Z", + "shell.execute_reply": "2025-08-14T16:04:55.050393Z", + "shell.execute_reply.started": "2025-08-14T16:03:59.964598Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "from bigframes.ml.llm import TextEmbeddingGenerator\n", + "\n", + "search_string = \"walking home\"\n", + "\n", + "text_model = TextEmbeddingGenerator(model_name=\"text-multilingual-embedding-002\")\n", + "search_df = bpd.DataFrame([search_string], columns=['search_string'])\n", + "search_embedding = text_model.predict(search_df)\n", + "search_embedding" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "175%" + } + } + } + }, + "editable": true, + "execution": { + "iopub.execute_input": "2025-08-14T16:05:46.473357Z", + "iopub.status.busy": "2025-08-14T16:05:46.473056Z", + "iopub.status.idle": "2025-08-14T16:05:50.564470Z", + "shell.execute_reply": "2025-08-14T16:05:50.563277Z", + "shell.execute_reply.started": "2025-08-14T16:05:46.473336Z" + }, + "slideshow": { + "slide_type": "slide" + }, + "tags": [], + "trusted": true + }, + "outputs": [], + "source": [ + "import bigframes.bigquery as bbq\n", + "\n", + "vector_search_results = bbq.vector_search(\n", + " base_table=f\"swast-scratch.scipy2025.national_jukebox\",\n", + " column_to_search=\"ml_generate_embedding_result\",\n", + " query=search_embedding,\n", + " distance_type=\"COSINE\",\n", + " query_column_to_search=\"ml_generate_embedding_result\",\n", + " top_k=5,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2025-08-14T16:05:50.566930Z", + "iopub.status.busy": "2025-08-14T16:05:50.566422Z", + "iopub.status.idle": "2025-08-14T16:05:50.576293Z", + "shell.execute_reply": "2025-08-14T16:05:50.575186Z", + "shell.execute_reply.started": "2025-08-14T16:05:50.566893Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "vector_search_results.dtypes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "158%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T16:05:54.787080Z", + "iopub.status.busy": "2025-08-14T16:05:54.786649Z", + "iopub.status.idle": "2025-08-14T16:05:55.581285Z", + "shell.execute_reply": "2025-08-14T16:05:55.580012Z", + "shell.execute_reply.started": "2025-08-14T16:05:54.787054Z" + }, + "slideshow": { + "slide_type": "slide" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "results = vector_search_results[[\"Title\", \"Summary\", \"Names\", \"GCS URI\", \"Transcription\", \"distance\"]].sort_values(\"distance\").to_pandas()\n", + "results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "@deathbeds/jupyterlab-fonts": { + "styles": { + "": { + "body[data-jp-deck-mode='presenting'] &": { + "zoom": "138%" + } + } + } + }, + "execution": { + "iopub.execute_input": "2025-08-14T16:05:56.142373Z", + "iopub.status.busy": "2025-08-14T16:05:56.142038Z", + "iopub.status.idle": "2025-08-14T16:05:56.149020Z", + "shell.execute_reply": "2025-08-14T16:05:56.147966Z", + "shell.execute_reply.started": "2025-08-14T16:05:56.142350Z" + }, + "trusted": true + }, + "outputs": [], + "source": [ + "print(results[\"Transcription\"].struct.field(\"content\").iloc[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "execution": { + "iopub.execute_input": "2025-08-14T16:06:04.542878Z", + "iopub.status.busy": "2025-08-14T16:06:04.542537Z", + "iopub.status.idle": "2025-08-14T16:06:04.843052Z", + "shell.execute_reply": "2025-08-14T16:06:04.841220Z", + "shell.execute_reply.started": "2025-08-14T16:06:04.542854Z" + }, + "scrolled": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "trusted": true + }, + "outputs": [], + "source": [ + "import gcsfs\n", + "import IPython.display\n", + "\n", + "fs = gcsfs.GCSFileSystem(project='bigframes-dev')\n", + "with fs.open(results[\"GCS URI\"].iloc[0]) as song_file:\n", + " song_bytes = song_file.read()\n", + "\n", + "IPython.display.Audio(song_bytes)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "trusted": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kaggle": { + "accelerator": "none", + "dataSources": [ + { + "databundleVersionId": 13238728, + "sourceId": 110281, + "sourceType": "competition" + } + ], + "dockerImageVersionId": 31089, + "isGpuEnabled": false, + "isInternetEnabled": true, + "language": "python", + "sourceType": "notebook" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/noxfile.py b/noxfile.py index 7adf499a08..cc38a3b8c0 100644 --- a/noxfile.py +++ b/noxfile.py @@ -838,11 +838,10 @@ def notebook(session: nox.Session): ] ) - # Convert each Path notebook object to a string using a list comprehension. + # Convert each Path notebook object to a string using a list comprehension, + # and remove tests that we choose not to test. notebooks = [str(nb) for nb in notebooks_list] - - # Remove tests that we choose not to test. - notebooks = list(filter(lambda nb: nb not in denylist, notebooks)) + notebooks = [nb for nb in notebooks if nb not in denylist and "/kaggle/" not in nb] # Regionalized notebooks notebooks_reg = { diff --git a/samples/dbt/.dbt.yml b/samples/dbt/.dbt.yml index a2fd2ffd4c..a4301a0bab 100644 --- a/samples/dbt/.dbt.yml +++ b/samples/dbt/.dbt.yml @@ -1,4 +1,4 @@ -# Copyright 2019 Google LLC +# 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. diff --git a/samples/dbt/README.md b/samples/dbt/README.md index c52b633116..986aa2eae3 100644 --- a/samples/dbt/README.md +++ b/samples/dbt/README.md @@ -10,6 +10,8 @@ It includes basic configurations and sample models to help you get started quick - `dbt_project.yml`: configures your dbt project - **dbt_sample_project**. - `dbt_bigframes_code_sample_1.py`: An example to read BigQuery data and perform basic transformation. - `dbt_bigframes_code_sample_2.py`: An example to build an incremental model that leverages BigFrames UDF capabilities. +- `prepare_table.py`: An ML example to consolidate various data sources into a single, unified table for later usage. +- `prediction.py`: An ML example to train models and then generate predictions using the prepared table. ## Requirements diff --git a/samples/dbt/dbt_sample_project/dbt_project.yml b/samples/dbt/dbt_sample_project/dbt_project.yml index aef376e1fc..789f4d2549 100644 --- a/samples/dbt/dbt_sample_project/dbt_project.yml +++ b/samples/dbt/dbt_sample_project/dbt_project.yml @@ -1,4 +1,4 @@ -# Copyright 2019 Google LLC +# 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. diff --git a/samples/dbt/dbt_sample_project/models/example/dbt_bigframes_code_sample_1.py b/samples/dbt/dbt_sample_project/models/example/dbt_bigframes_code_sample_1.py index e397549afe..2e24596b79 100644 --- a/samples/dbt/dbt_sample_project/models/example/dbt_bigframes_code_sample_1.py +++ b/samples/dbt/dbt_sample_project/models/example/dbt_bigframes_code_sample_1.py @@ -1,4 +1,4 @@ -# Copyright 2019 Google LLC +# 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. diff --git a/samples/dbt/dbt_sample_project/models/example/dbt_bigframes_code_sample_2.py b/samples/dbt/dbt_sample_project/models/example/dbt_bigframes_code_sample_2.py index 3795d0eee9..1f060cd60b 100644 --- a/samples/dbt/dbt_sample_project/models/example/dbt_bigframes_code_sample_2.py +++ b/samples/dbt/dbt_sample_project/models/example/dbt_bigframes_code_sample_2.py @@ -1,4 +1,4 @@ -# Copyright 2019 Google LLC +# 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. diff --git a/samples/dbt/dbt_sample_project/models/ml_example/prediction.py b/samples/dbt/dbt_sample_project/models/ml_example/prediction.py new file mode 100644 index 0000000000..d2fb54b384 --- /dev/null +++ b/samples/dbt/dbt_sample_project/models/ml_example/prediction.py @@ -0,0 +1,67 @@ +# 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. + +# This DBT Python model prepares and trains a machine learning model to predict +# ozone levels. +# 1. Data Preparation: The model first gets a prepared dataset and splits it +# into three subsets based on the year: training data (before 2017), +# testing data (2017-2019), and prediction data (2020 and later). +# 2. Model Training: It then uses the LinearRegression model from BigFrames +# ML library. The model is trained on the historical data, using other +# atmospheric parameters to predict the 'o3' (ozone) levels. +# 3. Prediction: Finally, the trained model makes predictions on the most +# recent data (from 2020 onwards) and returns the resulting DataFrame of +# predicted ozone values. +# +# See more details from the related blog post: https://docs.getdbt.com/blog/train-linear-dbt-bigframes + + +def model(dbt, session): + dbt.config(submission_method="bigframes", timeout=6000) + + df = dbt.ref("prepare_table") + + # Define the rules for separating the training, test and prediction data. + train_data_filter = (df.date_local.dt.year < 2017) + test_data_filter = ( + (df.date_local.dt.year >= 2017) & (df.date_local.dt.year < 2020) + ) + predict_data_filter = (df.date_local.dt.year >= 2020) + + # Define index_columns again here in prediction. + index_columns = ["state_name", "county_name", "site_num", "date_local", "time_local"] + + # Separate the training, test and prediction data. + df_train = df[train_data_filter].set_index(index_columns) + df_test = df[test_data_filter].set_index(index_columns) + df_predict = df[predict_data_filter].set_index(index_columns) + + # Finalize the training dataframe. + X_train = df_train.drop(columns="o3") + y_train = df_train["o3"] + + # Finalize the prediction dataframe. + X_predict = df_predict.drop(columns="o3") + + # Import the LinearRegression model from bigframes.ml module. + from bigframes.ml.linear_model import LinearRegression + + # Train the model. + model = LinearRegression() + model.fit(X_train, y_train) + + # Make the prediction using the model. + df_pred = model.predict(X_predict) + + return df_pred diff --git a/samples/dbt/dbt_sample_project/models/ml_example/prepare_table.py b/samples/dbt/dbt_sample_project/models/ml_example/prepare_table.py new file mode 100644 index 0000000000..23b54a9122 --- /dev/null +++ b/samples/dbt/dbt_sample_project/models/ml_example/prepare_table.py @@ -0,0 +1,93 @@ +# 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. + +# This DBT Python model processes EPA historical air quality data from BigQuery +# using BigFrames. The primary goal is to merge several hourly summary +# tables into a single, unified DataFrame for later prediction. It includes the +# following steps: +# 1. Reading and Cleaning: It reads individual hourly summary tables from +# BigQuery for various atmospheric parameters (like CO, O3, temperature, +# and wind speed). Each table is cleaned by sorting, removing duplicates, +# and renaming columns for clarity. +# 2. Combining Data: It then merges these cleaned tables into a single, +# comprehensive DataFrame. An inner join is used to ensure the final output +# only includes records with complete data across all parameters. +# 3. Final Output: The unified DataFrame is returned as the model's output, +# creating a corresponding BigQuery table for future use. +# +# See more details from the related blog post: https://docs.getdbt.com/blog/train-linear-dbt-bigframes + + +import bigframes.pandas as bpd + +def model(dbt, session): + # Optional: override settings from dbt_project.yml. + # When both are set, dbt.config takes precedence over dbt_project.yml. + dbt.config(submission_method="bigframes", timeout=6000) + + # Define the dataset and the columns of interest representing various parameters + # in the atmosphere. + dataset = "bigquery-public-data.epa_historical_air_quality" + index_columns = ["state_name", "county_name", "site_num", "date_local", "time_local"] + param_column = "parameter_name" + value_column = "sample_measurement" + + # Initialize a list for collecting dataframes from individual parameters. + params_dfs = [] + + # Collect dataframes from tables which contain data for single parameter. + table_param_dict = { + "co_hourly_summary" : "co", + "no2_hourly_summary" : "no2", + "o3_hourly_summary" : "o3", + "pressure_hourly_summary" : "pressure", + "so2_hourly_summary" : "so2", + "temperature_hourly_summary" : "temperature", + } + + for table, param in table_param_dict.items(): + param_df = bpd.read_gbq( + f"{dataset}.{table}", + columns=index_columns + [value_column] + ) + param_df = param_df\ + .sort_values(index_columns)\ + .drop_duplicates(index_columns)\ + .set_index(index_columns)\ + .rename(columns={value_column : param}) + params_dfs.append(param_df) + + # Collect dataframes from the table containing wind speed. + # Optionally: collect dataframes from other tables containing + # wind direction, NO, NOx, and NOy data as needed. + wind_table = f"{dataset}.wind_hourly_summary" + bpd.read_gbq(wind_table, columns=[param_column]).value_counts() + + wind_speed_df = bpd.read_gbq( + wind_table, + columns=index_columns + [value_column], + filters=[(param_column, "==", "Wind Speed - Resultant")] + ) + wind_speed_df = wind_speed_df\ + .sort_values(index_columns)\ + .drop_duplicates(index_columns)\ + .set_index(index_columns)\ + .rename(columns={value_column: "wind_speed"}) + params_dfs.append(wind_speed_df) + + # Combine data for all the selected parameters. + df = bpd.concat(params_dfs, axis=1, join="inner") + df = df.reset_index() + + return df diff --git a/specs/2025-08-11-anywidget-align-text.md b/specs/2025-08-11-anywidget-align-text.md new file mode 100644 index 0000000000..03305538dc --- /dev/null +++ b/specs/2025-08-11-anywidget-align-text.md @@ -0,0 +1,132 @@ +# Anywidget: align text left and numerics right + +The "anywidget" rendering mode outputs an HTML table per page right now, but +the values need to be aligned according to their data type. + +## Background + +Anywidget currently renders pages like the following: + +```html + + + + + + + + + + + + + + + + + + + + + + + + + + + +
stategenderyearnamenumber
VAM1930Pat6
TXM1968Kennith18
+``` + +* This change fixes internal issue b/437697339. +* Numeric data should be right aligned so that it is easier to compare numbers, + especially if they all are rounded to the same precision. +* Text data is better left aligned, since many languages read left to right. + +## Acceptance Criteria + +- [ ] Header cells should align left. +- [ ] Header cells should use the resize CSS property to allow resizing. +- [ ] STRING columns are left-aligned in the output of `TableWidget` in + `bigframes/display/anywidget.py`. +- [ ] Numeric columns (INT64, FLOAT64, NUMERIC, BIGNUMERIC) are right-aligned + in the output of `TableWidget` in `bigframes/display/anywidget.py`. +- [ ] Create option `DisplayOptions.precision` in + `bigframes/_config/display_options.py` that can override the output + precision (defaults to 6, just like `pandas.options.display.precision`). +- [ ] All other non-numeric column types, including BYTES, BOOLEAN, TIMESTAMP, + and more, are left-aligned in the output of `TableWidget` in + `bigframes/display/anywidget.py`. +- [ ] There are parameterized unit tests verifying the alignment is set + correctly. + +## Detailed Steps + +### 1. Create Display Precision Configuration + +- [ ] In `bigframes/_config/display_options.py`, add a new `precision` attribute to the `DisplayOptions` dataclass. +- [ ] Set the default value to `6`. +- [ ] Add precision to the items in `def pandas_repr` that get passed to the pandas options context. +- [ ] Add a docstring explaining that it controls the floating point output precision, similar to `pandas.options.display.precision`. +- [ ] Check these items off with `[x]` as they are completed. + +### 2. Improve the headers + +- [ ] Create `bigframes/display/html.py`. +- [ ] In `bigframes/display/html.py`, create a `def render_html(*, dataframe: pandas.DataFrame, table_id: str)` method. +- [ ] Loop through the column names to create the table head. +- [ ] Apply the `text-align: left` style to the header. +- [ ] Wrap the cell text in a resizable `div`. +- [ ] Check these items off with `[x]` as they are completed. + +### 3. Implement Alignment and Precision Logic in TableWidget + +- [ ] Create a helper function `_is_dtype_numeric(dtype)` that takes a pandas + dtype returns True for types that that should be right-aligned. These + dtypes should correspond to the BigQuery data types: `INT64`, `FLOAT64`, + `NUMERIC`, `BIGNUMERIC`. Use the `bigframes.dtypes` module to map from + pandas type to BigQuery type. +- [ ] In the loop that generates the table rows (`` elements), add a function to determine the style based on the column's `dtype`. +- [ ] If the column's `dtype` is in the numeric set, apply the CSS style `text-align: right`. +- [ ] For all other `dtypes` (including `STRING`, `BYTES`, `BOOLEAN`, `TIMESTAMP`, etc.), apply `text-align: left`. +- [ ] When formatting floating-point numbers for display, use the `bigframes.options.display.precision` value. +- [ ] In `bigframes/display/anywidget.py`, modify the `_set_table_html` method of the `TableWidget` class to call `bigframes.display.html.render_html(...)`. +- [ ] Render the notebook at `notebooks/dataframes/anywidget_mode.ipynb` with + the `jupyter nbconvert --to notebook --execute notebooks/dataframes/anywidget_mode.ipynb` + command and validate that the rendered notebook includes the desired + changes to the HTML tables. +- [ ] Check these items off with `[x]` as they are completed. + +### 4. Add Parameterized Unit Tests + +- [ ] Create a new test file: `tests/unit/display/test_html.py`. +- [ ] Create a parameterized test method, e.g., `test_render_html_alignment_and_precision`. +- [ ] Use `@pytest.mark.parametrize` to test various scenarios. +- [ ] **Scenario 1: Alignment.** + - Create a sample `bigframes.dataframe.DataFrame` with columns of different types: a string, an integer, a float, and a boolean. + - Render the `pandas.DataFrame` to HTML. + - Assert that the integer and float column headers and data cells (`` and ``) have `style="text-align: right;"`. + - Assert that the string and boolean columns have `style="text-align: left;"`. +- [ ] **Scenario 2: Precision.** + - Create a `bigframes.dataframe.DataFrame` with a `FLOAT64` column containing a number with many decimal places (e.g., `3.14159265`). + - Set `bigframes.options.display.precision = 4`. + - Render the `pandas.DataFrame` to HTML. + - Assert that the output string contains the number formatted to 4 decimal places (e.g., `3.1416`). + - Remember to reset the option value after the test to avoid side effects. +- [ ] Check these items off with `[x]` as they are completed. + +## Verification + +*Specify the commands to run to verify the changes.* + +- [ ] The `nox -r -s format lint lint_setup_py` linter should pass. +- [ ] The `nox -r -s mypy` static type checker should pass. +- [ ] The `nox -r -s docs docfx` docs should successfully build and include relevant docs in the output. +- [ ] All new and existing unit tests `pytest tests/unit` should pass. +- [ ] Identify all related system tests in the `tests/system` directories. +- [ ] All related system tests `pytest tests/system/small/path_to_relevant_test.py::test_name` should pass. +- [ ] Check these items off with `[x]` as they are completed. + +## Constraints + +Follow the guidelines listed in GEMINI.md at the root of the repository. diff --git a/tests/system/large/blob/test_function.py b/tests/system/large/blob/test_function.py index a594b144f5..c8fa63d493 100644 --- a/tests/system/large/blob/test_function.py +++ b/tests/system/large/blob/test_function.py @@ -302,37 +302,16 @@ def test_blob_image_normalize_to_bq(images_mm_df: bpd.DataFrame, bq_connection: @pytest.mark.parametrize( - "verbose, expected", + "verbose", [ - ( - True, - pd.Series( - [ - {"status": "File has not been decrypted", "content": ""}, - { - "status": "", - "content": "Sample PDF This is a testing file. Some dummy messages are used for testing purposes. ", - }, - ] - ), - ), - ( - False, - pd.Series( - [ - "", - "Sample PDF This is a testing file. Some dummy messages are used for testing purposes. ", - ], - name="pdf", - ), - ), + (True), + (False), ], ) def test_blob_pdf_extract( pdf_mm_df: bpd.DataFrame, verbose: bool, bq_connection: str, - expected: pd.Series, ): actual = ( pdf_mm_df["pdf"] @@ -341,49 +320,44 @@ def test_blob_pdf_extract( .to_pandas() ) - pd.testing.assert_series_equal( - actual, - expected, - check_dtype=False, - check_index=False, + # check relative length + expected_text = "Sample PDF This is a testing file. Some dummy messages are used for testing purposes." + expected_len = len(expected_text) + + actual_text = "" + if verbose: + # The first entry is for a file that doesn't exist, so we check the second one + successful_results = actual[actual.apply(lambda x: x["status"] == "")] + actual_text = successful_results.apply(lambda x: x["content"]).iloc[0] + else: + actual_text = actual[actual != ""].iloc[0] + actual_len = len(actual_text) + + relative_length_tolerance = 0.25 + min_acceptable_len = expected_len * (1 - relative_length_tolerance) + max_acceptable_len = expected_len * (1 + relative_length_tolerance) + assert min_acceptable_len <= actual_len <= max_acceptable_len, ( + f"Item (verbose={verbose}): Extracted text length {actual_len} is outside the acceptable range " + f"[{min_acceptable_len:.0f}, {max_acceptable_len:.0f}]. " + f"Expected reference length was {expected_len}. " ) + # check for major keywords + major_keywords = ["Sample", "PDF", "testing", "dummy", "messages"] + for keyword in major_keywords: + assert ( + keyword.lower() in actual_text.lower() + ), f"Item (verbose={verbose}): Expected keyword '{keyword}' not found in extracted text. " + @pytest.mark.parametrize( - "verbose, expected", + "verbose", [ - ( - True, - pd.Series( - [ - {"status": "File has not been decrypted", "content": []}, - { - "status": "", - "content": [ - "Sample PDF This is a testing file. Some ", - "dummy messages are used for testing ", - "purposes. ", - ], - }, - ] - ), - ), - ( - False, - pd.Series( - [ - pd.NA, - "Sample PDF This is a testing file. Some ", - "dummy messages are used for testing ", - "purposes. ", - ], - ), - ), + (True), + (False), ], ) -def test_blob_pdf_chunk( - pdf_mm_df: bpd.DataFrame, verbose: bool, bq_connection: str, expected: pd.Series -): +def test_blob_pdf_chunk(pdf_mm_df: bpd.DataFrame, verbose: bool, bq_connection: str): actual = ( pdf_mm_df["pdf"] .blob.pdf_chunk( @@ -397,13 +371,36 @@ def test_blob_pdf_chunk( .to_pandas() ) - pd.testing.assert_series_equal( - actual, - expected, - check_dtype=False, - check_index=False, + # check relative length + expected_text = "Sample PDF This is a testing file. Some dummy messages are used for testing purposes." + expected_len = len(expected_text) + + actual_text = "" + if verbose: + # The first entry is for a file that doesn't exist, so we check the second one + successful_results = actual[actual.apply(lambda x: x["status"] == "")] + actual_text = "".join(successful_results.apply(lambda x: x["content"]).iloc[0]) + else: + # First entry is NA + actual_text = "".join(actual.dropna()) + actual_len = len(actual_text) + + relative_length_tolerance = 0.25 + min_acceptable_len = expected_len * (1 - relative_length_tolerance) + max_acceptable_len = expected_len * (1 + relative_length_tolerance) + assert min_acceptable_len <= actual_len <= max_acceptable_len, ( + f"Item (verbose={verbose}): Extracted text length {actual_len} is outside the acceptable range " + f"[{min_acceptable_len:.0f}, {max_acceptable_len:.0f}]. " + f"Expected reference length was {expected_len}. " ) + # check for major keywords + major_keywords = ["Sample", "PDF", "testing", "dummy", "messages"] + for keyword in major_keywords: + assert ( + keyword.lower() in actual_text.lower() + ), f"Item (verbose={verbose}): Expected keyword '{keyword}' not found in extracted text. " + @pytest.mark.parametrize( "model_name, verbose", diff --git a/tests/system/large/functions/test_managed_function.py b/tests/system/large/functions/test_managed_function.py index 5349529f1d..262f5f0fe2 100644 --- a/tests/system/large/functions/test_managed_function.py +++ b/tests/system/large/functions/test_managed_function.py @@ -963,3 +963,151 @@ def float_parser(row): cleanup_function_assets( float_parser_mf, session.bqclient, ignore_failures=False ) + + +def test_managed_function_df_where(session, dataset_id, scalars_dfs): + try: + + # The return type has to be bool type for callable where condition. + def is_sum_positive(a, b): + return a + b > 0 + + is_sum_positive_mf = session.udf( + input_types=[int, int], + output_type=bool, + dataset=dataset_id, + name=prefixer.create_prefix(), + )(is_sum_positive) + + scalars_df, scalars_pandas_df = scalars_dfs + int64_cols = ["int64_col", "int64_too"] + + bf_int64_df = scalars_df[int64_cols] + bf_int64_df_filtered = bf_int64_df.dropna() + pd_int64_df = scalars_pandas_df[int64_cols] + pd_int64_df_filtered = pd_int64_df.dropna() + + # Use callable condition in dataframe.where method. + bf_result = bf_int64_df_filtered.where(is_sum_positive_mf).to_pandas() + # Pandas doesn't support such case, use following as workaround. + pd_result = pd_int64_df_filtered.where(pd_int64_df_filtered.sum(axis=1) > 0) + + # Ignore any dtype difference. + pandas.testing.assert_frame_equal(bf_result, pd_result, check_dtype=False) + + # Make sure the read_gbq_function path works for this function. + is_sum_positive_ref = session.read_gbq_function( + function_name=is_sum_positive_mf.bigframes_bigquery_function + ) + + bf_result_gbq = bf_int64_df_filtered.where( + is_sum_positive_ref, -bf_int64_df_filtered + ).to_pandas() + pd_result_gbq = pd_int64_df_filtered.where( + pd_int64_df_filtered.sum(axis=1) > 0, -pd_int64_df_filtered + ) + + # Ignore any dtype difference. + pandas.testing.assert_frame_equal( + bf_result_gbq, pd_result_gbq, check_dtype=False + ) + + finally: + # Clean up the gcp assets created for the managed function. + cleanup_function_assets( + is_sum_positive_mf, session.bqclient, ignore_failures=False + ) + + +def test_managed_function_df_where_series(session, dataset_id, scalars_dfs): + try: + + # The return type has to be bool type for callable where condition. + def is_sum_positive_series(s): + return s["int64_col"] + s["int64_too"] > 0 + + is_sum_positive_series_mf = session.udf( + input_types=bigframes.series.Series, + output_type=bool, + dataset=dataset_id, + name=prefixer.create_prefix(), + )(is_sum_positive_series) + + scalars_df, scalars_pandas_df = scalars_dfs + int64_cols = ["int64_col", "int64_too"] + + bf_int64_df = scalars_df[int64_cols] + bf_int64_df_filtered = bf_int64_df.dropna() + pd_int64_df = scalars_pandas_df[int64_cols] + pd_int64_df_filtered = pd_int64_df.dropna() + + # Use callable condition in dataframe.where method. + bf_result = bf_int64_df_filtered.where(is_sum_positive_series).to_pandas() + pd_result = pd_int64_df_filtered.where(is_sum_positive_series) + + # Ignore any dtype difference. + pandas.testing.assert_frame_equal(bf_result, pd_result, check_dtype=False) + + # Make sure the read_gbq_function path works for this function. + is_sum_positive_series_ref = session.read_gbq_function( + function_name=is_sum_positive_series_mf.bigframes_bigquery_function, + is_row_processor=True, + ) + + # This is for callable `other` arg in dataframe.where method. + def func_for_other(x): + return -x + + bf_result_gbq = bf_int64_df_filtered.where( + is_sum_positive_series_ref, func_for_other + ).to_pandas() + pd_result_gbq = pd_int64_df_filtered.where( + is_sum_positive_series, func_for_other + ) + + # Ignore any dtype difference. + pandas.testing.assert_frame_equal( + bf_result_gbq, pd_result_gbq, check_dtype=False + ) + + finally: + # Clean up the gcp assets created for the managed function. + cleanup_function_assets( + is_sum_positive_series_mf, session.bqclient, ignore_failures=False + ) + + +def test_managed_function_series_where(session, dataset_id, scalars_dfs): + try: + + # The return type has to be bool type for callable where condition. + def _is_positive(s): + return s + 1000 > 0 + + is_positive_mf = session.udf( + input_types=int, + output_type=bool, + dataset=dataset_id, + name=prefixer.create_prefix(), + )(_is_positive) + + scalars, scalars_pandas = scalars_dfs + + bf_int64 = scalars["int64_col"] + bf_int64_filtered = bf_int64.dropna() + pd_int64 = scalars_pandas["int64_col"] + pd_int64_filtered = pd_int64.dropna() + + # The cond is a callable (managed function) and the other is not a + # callable in series.where method. + bf_result = bf_int64_filtered.where( + cond=is_positive_mf, other=-bf_int64_filtered + ).to_pandas() + pd_result = pd_int64_filtered.where(cond=_is_positive, other=-pd_int64_filtered) + + # Ignore any dtype difference. + pandas.testing.assert_series_equal(bf_result, pd_result, check_dtype=False) + + finally: + # Clean up the gcp assets created for the managed function. + cleanup_function_assets(is_positive_mf, session.bqclient, ignore_failures=False) diff --git a/tests/system/large/functions/test_remote_function.py b/tests/system/large/functions/test_remote_function.py index a93435d11a..9e2c1e2c81 100644 --- a/tests/system/large/functions/test_remote_function.py +++ b/tests/system/large/functions/test_remote_function.py @@ -2847,3 +2847,125 @@ def foo(x: int) -> int: finally: # clean up the gcp assets created for the remote function cleanup_function_assets(foo, session.bqclient, session.cloudfunctionsclient) + + +@pytest.mark.flaky(retries=2, delay=120) +def test_remote_function_df_where(session, dataset_id, scalars_dfs): + try: + + # The return type has to be bool type for callable where condition. + def is_sum_positive(a, b): + return a + b > 0 + + is_sum_positive_mf = session.remote_function( + input_types=[int, int], + output_type=bool, + dataset=dataset_id, + reuse=False, + cloud_function_service_account="default", + )(is_sum_positive) + + scalars_df, scalars_pandas_df = scalars_dfs + int64_cols = ["int64_col", "int64_too"] + + bf_int64_df = scalars_df[int64_cols] + bf_int64_df_filtered = bf_int64_df.dropna() + pd_int64_df = scalars_pandas_df[int64_cols] + pd_int64_df_filtered = pd_int64_df.dropna() + + # Use callable condition in dataframe.where method. + bf_result = bf_int64_df_filtered.where(is_sum_positive_mf, 0).to_pandas() + # Pandas doesn't support such case, use following as workaround. + pd_result = pd_int64_df_filtered.where(pd_int64_df_filtered.sum(axis=1) > 0, 0) + + # Ignore any dtype difference. + pandas.testing.assert_frame_equal(bf_result, pd_result, check_dtype=False) + + finally: + # Clean up the gcp assets created for the remote function. + cleanup_function_assets( + is_sum_positive_mf, session.bqclient, ignore_failures=False + ) + + +@pytest.mark.flaky(retries=2, delay=120) +def test_remote_function_df_where_series(session, dataset_id, scalars_dfs): + try: + + # The return type has to be bool type for callable where condition. + def is_sum_positive_series(s): + return s["int64_col"] + s["int64_too"] > 0 + + is_sum_positive_series_mf = session.remote_function( + input_types=bigframes.series.Series, + output_type=bool, + dataset=dataset_id, + reuse=False, + cloud_function_service_account="default", + )(is_sum_positive_series) + + scalars_df, scalars_pandas_df = scalars_dfs + int64_cols = ["int64_col", "int64_too"] + + bf_int64_df = scalars_df[int64_cols] + bf_int64_df_filtered = bf_int64_df.dropna() + pd_int64_df = scalars_pandas_df[int64_cols] + pd_int64_df_filtered = pd_int64_df.dropna() + + # This is for callable `other` arg in dataframe.where method. + def func_for_other(x): + return -x + + # Use callable condition in dataframe.where method. + bf_result = bf_int64_df_filtered.where( + is_sum_positive_series, func_for_other + ).to_pandas() + pd_result = pd_int64_df_filtered.where(is_sum_positive_series, func_for_other) + + # Ignore any dtype difference. + pandas.testing.assert_frame_equal(bf_result, pd_result, check_dtype=False) + + finally: + # Clean up the gcp assets created for the remote function. + cleanup_function_assets( + is_sum_positive_series_mf, session.bqclient, ignore_failures=False + ) + + +@pytest.mark.flaky(retries=2, delay=120) +def test_remote_function_series_where(session, dataset_id, scalars_dfs): + try: + + def _ten_times(x): + return x * 10 + + ten_times_mf = session.remote_function( + input_types=float, + output_type=float, + dataset=dataset_id, + reuse=False, + cloud_function_service_account="default", + )(_ten_times) + + scalars, scalars_pandas = scalars_dfs + + bf_int64 = scalars["float64_col"] + bf_int64_filtered = bf_int64.dropna() + pd_int64 = scalars_pandas["float64_col"] + pd_int64_filtered = pd_int64.dropna() + + # The cond is not a callable and the other is a callable (remote + # function) in series.where method. + bf_result = bf_int64_filtered.where( + cond=bf_int64_filtered < 0, other=ten_times_mf + ).to_pandas() + pd_result = pd_int64_filtered.where( + cond=pd_int64_filtered < 0, other=_ten_times + ) + + # Ignore any dtype difference. + pandas.testing.assert_series_equal(bf_result, pd_result, check_dtype=False) + + finally: + # Clean up the gcp assets created for the remote function. + cleanup_function_assets(ten_times_mf, session.bqclient, ignore_failures=False) diff --git a/tests/system/small/engines/test_bool_ops.py b/tests/system/small/engines/test_bool_ops.py new file mode 100644 index 0000000000..065a43c209 --- /dev/null +++ b/tests/system/small/engines/test_bool_ops.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 itertools + +import pytest + +from bigframes.core import array_value +import bigframes.operations as ops +from bigframes.session import polars_executor +from bigframes.testing.engine_utils import assert_equivalence_execution + +pytest.importorskip("polars") + +# Polars used as reference as its fast and local. Generally though, prefer gbq engine where they disagree. +REFERENCE_ENGINE = polars_executor.PolarsExecutor() + + +def apply_op_pairwise( + array: array_value.ArrayValue, op: ops.BinaryOp, excluded_cols=[] +) -> array_value.ArrayValue: + exprs = [] + for l_arg, r_arg in itertools.permutations(array.column_ids, 2): + if (l_arg in excluded_cols) or (r_arg in excluded_cols): + continue + try: + _ = op.output_type( + array.get_column_type(l_arg), array.get_column_type(r_arg) + ) + exprs.append(op.as_expr(l_arg, r_arg)) + except TypeError: + continue + assert len(exprs) > 0 + new_arr, _ = array.compute_values(exprs) + return new_arr + + +@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +@pytest.mark.parametrize( + "op", + [ + ops.and_op, + ops.or_op, + ops.xor_op, + ], +) +def test_engines_project_boolean_op( + scalars_array_value: array_value.ArrayValue, engine, op +): + # exclude string cols as does not contain dates + # bool col actually doesn't work properly for bq engine + arr = apply_op_pairwise(scalars_array_value, op, excluded_cols=["string_col"]) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) diff --git a/tests/system/small/engines/test_generic_ops.py b/tests/system/small/engines/test_generic_ops.py index af114991eb..9fdb6bca78 100644 --- a/tests/system/small/engines/test_generic_ops.py +++ b/tests/system/small/engines/test_generic_ops.py @@ -59,6 +59,7 @@ def test_engines_astype_int(scalars_array_value: array_value.ArrayValue, engine) ops.AsTypeOp(to_type=bigframes.dtypes.INT_DTYPE), excluded_cols=["string_col"], ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -73,6 +74,7 @@ def test_engines_astype_string_int(scalars_array_value: array_value.ArrayValue, for val in vals ] ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -83,6 +85,7 @@ def test_engines_astype_float(scalars_array_value: array_value.ArrayValue, engin ops.AsTypeOp(to_type=bigframes.dtypes.FLOAT_DTYPE), excluded_cols=["string_col"], ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -99,6 +102,7 @@ def test_engines_astype_string_float( for val in vals ] ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -107,6 +111,7 @@ def test_engines_astype_bool(scalars_array_value: array_value.ArrayValue, engine arr = apply_op( scalars_array_value, ops.AsTypeOp(to_type=bigframes.dtypes.BOOL_DTYPE) ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -118,6 +123,7 @@ def test_engines_astype_string(scalars_array_value: array_value.ArrayValue, engi ops.AsTypeOp(to_type=bigframes.dtypes.STRING_DTYPE), excluded_cols=["float64_col"], ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -128,6 +134,7 @@ def test_engines_astype_numeric(scalars_array_value: array_value.ArrayValue, eng ops.AsTypeOp(to_type=bigframes.dtypes.NUMERIC_DTYPE), excluded_cols=["string_col"], ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -144,6 +151,7 @@ def test_engines_astype_string_numeric( for val in vals ] ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -154,6 +162,7 @@ def test_engines_astype_date(scalars_array_value: array_value.ArrayValue, engine ops.AsTypeOp(to_type=bigframes.dtypes.DATE_DTYPE), excluded_cols=["string_col"], ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -170,6 +179,7 @@ def test_engines_astype_string_date( for val in vals ] ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -180,6 +190,7 @@ def test_engines_astype_datetime(scalars_array_value: array_value.ArrayValue, en ops.AsTypeOp(to_type=bigframes.dtypes.DATETIME_DTYPE), excluded_cols=["string_col"], ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -196,6 +207,7 @@ def test_engines_astype_string_datetime( for val in vals ] ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -206,6 +218,7 @@ def test_engines_astype_timestamp(scalars_array_value: array_value.ArrayValue, e ops.AsTypeOp(to_type=bigframes.dtypes.TIMESTAMP_DTYPE), excluded_cols=["string_col"], ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -226,6 +239,7 @@ def test_engines_astype_string_timestamp( for val in vals ] ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -236,6 +250,7 @@ def test_engines_astype_time(scalars_array_value: array_value.ArrayValue, engine ops.AsTypeOp(to_type=bigframes.dtypes.TIME_DTYPE), excluded_cols=["string_col", "int64_col", "int64_too"], ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -256,6 +271,7 @@ def test_engines_astype_from_json(scalars_array_value: array_value.ArrayValue, e ), ] arr, _ = scalars_array_value.compute_values(exprs) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) @@ -265,4 +281,112 @@ def test_engines_astype_timedelta(scalars_array_value: array_value.ArrayValue, e scalars_array_value, ops.AsTypeOp(to_type=bigframes.dtypes.TIMEDELTA_DTYPE), ) + + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) + + +@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +def test_engines_where_op(scalars_array_value: array_value.ArrayValue, engine): + arr, _ = scalars_array_value.compute_values( + [ + ops.where_op.as_expr( + expression.deref("int64_col"), + expression.deref("bool_col"), + expression.deref("float64_col"), + ) + ] + ) + + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) + + +@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +def test_engines_coalesce_op(scalars_array_value: array_value.ArrayValue, engine): + arr, _ = scalars_array_value.compute_values( + [ + ops.coalesce_op.as_expr( + expression.deref("int64_col"), + expression.deref("float64_col"), + ) + ] + ) + + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) + + +@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +def test_engines_fillna_op(scalars_array_value: array_value.ArrayValue, engine): + arr, _ = scalars_array_value.compute_values( + [ + ops.fillna_op.as_expr( + expression.deref("int64_col"), + expression.deref("float64_col"), + ) + ] + ) + + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) + + +@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +def test_engines_casewhen_op_single_case( + scalars_array_value: array_value.ArrayValue, engine +): + arr, _ = scalars_array_value.compute_values( + [ + ops.case_when_op.as_expr( + expression.deref("bool_col"), + expression.deref("int64_col"), + ) + ] + ) + + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) + + +@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +def test_engines_casewhen_op_double_case( + scalars_array_value: array_value.ArrayValue, engine +): + arr, _ = scalars_array_value.compute_values( + [ + ops.case_when_op.as_expr( + ops.gt_op.as_expr(expression.deref("int64_col"), expression.const(3)), + expression.deref("int64_col"), + ops.lt_op.as_expr(expression.deref("int64_col"), expression.const(-3)), + expression.deref("int64_too"), + ) + ] + ) + + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) + + +@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +def test_engines_isnull_op(scalars_array_value: array_value.ArrayValue, engine): + arr, _ = scalars_array_value.compute_values( + [ops.isnull_op.as_expr(expression.deref("string_col"))] + ) + + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) + + +@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +def test_engines_notnull_op(scalars_array_value: array_value.ArrayValue, engine): + arr, _ = scalars_array_value.compute_values( + [ops.notnull_op.as_expr(expression.deref("string_col"))] + ) + + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) + + +@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +def test_engines_invert_op(scalars_array_value: array_value.ArrayValue, engine): + arr, _ = scalars_array_value.compute_values( + [ + ops.invert_op.as_expr(expression.deref("bytes_col")), + ops.invert_op.as_expr(expression.deref("bool_col")), + ] + ) + assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) diff --git a/tests/system/small/engines/test_numeric_ops.py b/tests/system/small/engines/test_numeric_ops.py index 7e5b85857b..7928922e41 100644 --- a/tests/system/small/engines/test_numeric_ops.py +++ b/tests/system/small/engines/test_numeric_ops.py @@ -71,7 +71,7 @@ def test_engines_project_sub( assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) -@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +@pytest.mark.parametrize("engine", ["polars", "bq", "bq-sqlglot"], indirect=True) def test_engines_project_mul( scalars_array_value: array_value.ArrayValue, engine, @@ -80,7 +80,7 @@ def test_engines_project_mul( assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) -@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +@pytest.mark.parametrize("engine", ["polars", "bq", "bq-sqlglot"], indirect=True) def test_engines_project_div(scalars_array_value: array_value.ArrayValue, engine): # TODO: Duration div is sensitive to zeroes # TODO: Numeric col is sensitive to scale shifts @@ -90,7 +90,7 @@ def test_engines_project_div(scalars_array_value: array_value.ArrayValue, engine assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) -@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +@pytest.mark.parametrize("engine", ["polars", "bq", "bq-sqlglot"], indirect=True) def test_engines_project_div_durations( scalars_array_value: array_value.ArrayValue, engine ): @@ -117,7 +117,7 @@ def test_engines_project_div_durations( assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) -@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +@pytest.mark.parametrize("engine", ["polars", "bq", "bq-sqlglot"], indirect=True) def test_engines_project_floordiv( scalars_array_value: array_value.ArrayValue, engine, @@ -130,7 +130,7 @@ def test_engines_project_floordiv( assert_equivalence_execution(arr.node, REFERENCE_ENGINE, engine) -@pytest.mark.parametrize("engine", ["polars", "bq"], indirect=True) +@pytest.mark.parametrize("engine", ["polars", "bq", "bq-sqlglot"], indirect=True) def test_engines_project_floordiv_durations( scalars_array_value: array_value.ArrayValue, engine ): diff --git a/tests/system/small/engines/test_windowing.py b/tests/system/small/engines/test_windowing.py index f4c2b61e6f..a5f20a47cd 100644 --- a/tests/system/small/engines/test_windowing.py +++ b/tests/system/small/engines/test_windowing.py @@ -12,10 +12,12 @@ # See the License for the specific language governing permissions and # limitations under the License. +from google.cloud import bigquery import pytest -from bigframes.core import array_value -from bigframes.session import polars_executor +from bigframes.core import array_value, expression, identifiers, nodes, window_spec +import bigframes.operations.aggregations as agg_ops +from bigframes.session import direct_gbq_execution, polars_executor from bigframes.testing.engine_utils import assert_equivalence_execution pytest.importorskip("polars") @@ -31,3 +33,30 @@ def test_engines_with_offsets( ): result, _ = scalars_array_value.promote_offsets() assert_equivalence_execution(result.node, REFERENCE_ENGINE, engine) + + +@pytest.mark.parametrize("never_skip_nulls", [True, False]) +@pytest.mark.parametrize("agg_op", [agg_ops.sum_op, agg_ops.count_op]) +def test_engines_with_rows_window( + scalars_array_value: array_value.ArrayValue, + bigquery_client: bigquery.Client, + never_skip_nulls, + agg_op, +): + window = window_spec.WindowSpec( + bounds=window_spec.RowsWindowBounds.from_window_size(3, "left"), + ) + window_node = nodes.WindowOpNode( + child=scalars_array_value.node, + expression=expression.UnaryAggregation(agg_op, expression.deref("int64_too")), + window_spec=window, + output_name=identifiers.ColumnId("agg_int64"), + never_skip_nulls=never_skip_nulls, + skip_reproject_unsafe=False, + ) + + bq_executor = direct_gbq_execution.DirectGbqExecutor(bigquery_client) + bq_sqlgot_executor = direct_gbq_execution.DirectGbqExecutor( + bigquery_client, compiler="sqlglot" + ) + assert_equivalence_execution(window_node, bq_executor, bq_sqlgot_executor) diff --git a/tests/system/small/test_dataframe.py b/tests/system/small/test_dataframe.py index 50989ae150..3b70dec0e9 100644 --- a/tests/system/small/test_dataframe.py +++ b/tests/system/small/test_dataframe.py @@ -2070,6 +2070,26 @@ def test_reset_index(scalars_df_index, scalars_pandas_df_index, drop): pandas.testing.assert_frame_equal(bf_result, pd_result) +@pytest.mark.parametrize( + ("drop",), + ((True,), (False,)), +) +def test_reset_index_inplace(scalars_df_index, scalars_pandas_df_index, drop): + df = scalars_df_index.copy() + df.reset_index(drop=drop, inplace=True) + assert df.index.name is None + + bf_result = df.to_pandas() + pd_result = scalars_pandas_df_index.copy() + pd_result.reset_index(drop=drop, inplace=True) + + # Pandas uses int64 instead of Int64 (nullable) dtype. + pd_result.index = pd_result.index.astype(pd.Int64Dtype()) + + # reset_index should maintain the original ordering. + pandas.testing.assert_frame_equal(bf_result, pd_result) + + def test_reset_index_then_filter( scalars_df_index, scalars_pandas_df_index, diff --git a/tests/system/small/test_multiindex.py b/tests/system/small/test_multiindex.py index 13b5b1886f..0c23ea97ae 100644 --- a/tests/system/small/test_multiindex.py +++ b/tests/system/small/test_multiindex.py @@ -101,20 +101,69 @@ def test_set_multi_index(scalars_df_index, scalars_pandas_df_index): pandas.testing.assert_frame_equal(bf_result, pd_result) -def test_reset_multi_index(scalars_df_index, scalars_pandas_df_index): +@pytest.mark.parametrize( + ("level", "drop"), + [ + (None, True), + (None, False), + (1, True), + ("bool_col", True), + (["float64_col", "int64_too"], True), + ([2, 0], False), + ], +) +def test_df_reset_multi_index(scalars_df_index, scalars_pandas_df_index, level, drop): bf_result = ( - scalars_df_index.set_index(["bool_col", "int64_too"]).reset_index().to_pandas() + scalars_df_index.set_index(["bool_col", "int64_too", "float64_col"]) + .reset_index(level=level, drop=drop) + .to_pandas() ) pd_result = scalars_pandas_df_index.set_index( - ["bool_col", "int64_too"] - ).reset_index() + ["bool_col", "int64_too", "float64_col"] + ).reset_index(level=level, drop=drop) # Pandas uses int64 instead of Int64 (nullable) dtype. - pd_result.index = pd_result.index.astype(pandas.Int64Dtype()) + if pd_result.index.dtype != bf_result.index.dtype: + pd_result.index = pd_result.index.astype(pandas.Int64Dtype()) pandas.testing.assert_frame_equal(bf_result, pd_result) +@pytest.mark.parametrize( + ("level", "drop"), + [ + (None, True), + (None, False), + (1, True), + ("bool_col", True), + (["float64_col", "int64_too"], True), + ([2, 0], False), + ], +) +def test_series_reset_multi_index( + scalars_df_index, scalars_pandas_df_index, level, drop +): + bf_result = ( + scalars_df_index.set_index(["bool_col", "int64_too", "float64_col"])[ + "string_col" + ] + .reset_index(level=level, drop=drop) + .to_pandas() + ) + pd_result = scalars_pandas_df_index.set_index( + ["bool_col", "int64_too", "float64_col"] + )["string_col"].reset_index(level=level, drop=drop) + + # Pandas uses int64 instead of Int64 (nullable) dtype. + if pd_result.index.dtype != bf_result.index.dtype: + pd_result.index = pd_result.index.astype(pandas.Int64Dtype()) + + if drop: + pandas.testing.assert_series_equal(bf_result, pd_result) + else: + pandas.testing.assert_frame_equal(bf_result, pd_result) + + def test_series_multi_index_idxmin(scalars_df_index, scalars_pandas_df_index): bf_result = scalars_df_index.set_index(["bool_col", "int64_too"])[ "float64_col" diff --git a/tests/system/small/test_series.py b/tests/system/small/test_series.py index e94250e98f..2172962046 100644 --- a/tests/system/small/test_series.py +++ b/tests/system/small/test_series.py @@ -1339,6 +1339,18 @@ def test_reset_index_drop(scalars_df_index, scalars_pandas_df_index): pd.testing.assert_series_equal(bf_result.to_pandas(), pd_result) +def test_series_reset_index_inplace(scalars_df_index, scalars_pandas_df_index): + bf_result = scalars_df_index.sort_index(ascending=False)["float64_col"] + bf_result.reset_index(drop=True, inplace=True) + pd_result = scalars_pandas_df_index.sort_index(ascending=False)["float64_col"] + pd_result.reset_index(drop=True, inplace=True) + + # BigQuery DataFrames default indices use nullable Int64 always + pd_result.index = pd_result.index.astype("Int64") + + pd.testing.assert_series_equal(bf_result.to_pandas(), pd_result) + + @pytest.mark.parametrize( ("name",), [ @@ -3097,6 +3109,26 @@ def test_where_with_default(scalars_df_index, scalars_pandas_df_index): ) +def test_where_with_callable(scalars_df_index, scalars_pandas_df_index): + def _is_positive(x): + return x > 0 + + # Both cond and other are callable. + bf_result = ( + scalars_df_index["int64_col"] + .where(cond=_is_positive, other=lambda x: x * 10) + .to_pandas() + ) + pd_result = scalars_pandas_df_index["int64_col"].where( + cond=_is_positive, other=lambda x: x * 10 + ) + + pd.testing.assert_series_equal( + bf_result, + pd_result, + ) + + @pytest.mark.parametrize( ("ordered"), [ diff --git a/tests/unit/_config/test_threaded_options.py b/tests/unit/_config/test_threaded_options.py index 7fc97a9f72..b16a3550bc 100644 --- a/tests/unit/_config/test_threaded_options.py +++ b/tests/unit/_config/test_threaded_options.py @@ -37,5 +37,5 @@ def mutate_options_threaded(options, result_dict): assert result_dict["this_before"] == 50 assert result_dict["this_after"] == 50 - assert result_dict["other_before"] == 25 + assert result_dict["other_before"] == 10 assert result_dict["other_after"] == 100 diff --git a/tests/unit/core/compile/sqlglot/conftest.py b/tests/unit/core/compile/sqlglot/conftest.py index 754c19ac90..f65343fd66 100644 --- a/tests/unit/core/compile/sqlglot/conftest.py +++ b/tests/unit/core/compile/sqlglot/conftest.py @@ -89,6 +89,7 @@ def scalar_types_table_schema() -> typing.Sequence[bigquery.SchemaField]: bigquery.SchemaField("string_col", "STRING"), bigquery.SchemaField("time_col", "TIME"), bigquery.SchemaField("timestamp_col", "TIMESTAMP"), + bigquery.SchemaField("duration_col", "INTEGER"), ] diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_div_numeric/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_div_numeric/out.sql new file mode 100644 index 0000000000..03d48276a0 --- /dev/null +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_div_numeric/out.sql @@ -0,0 +1,122 @@ +WITH `bfcte_0` AS ( + SELECT + `bool_col` AS `bfcol_0`, + `int64_col` AS `bfcol_1`, + `float64_col` AS `bfcol_2`, + `rowindex` AS `bfcol_3` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + `bfcol_3` AS `bfcol_8`, + `bfcol_1` AS `bfcol_9`, + `bfcol_0` AS `bfcol_10`, + `bfcol_2` AS `bfcol_11`, + IEEE_DIVIDE(`bfcol_1`, `bfcol_1`) AS `bfcol_12` + FROM `bfcte_0` +), `bfcte_2` AS ( + SELECT + *, + `bfcol_8` AS `bfcol_18`, + `bfcol_9` AS `bfcol_19`, + `bfcol_10` AS `bfcol_20`, + `bfcol_11` AS `bfcol_21`, + `bfcol_12` AS `bfcol_22`, + IEEE_DIVIDE(`bfcol_9`, 1) AS `bfcol_23` + FROM `bfcte_1` +), `bfcte_3` AS ( + SELECT + *, + `bfcol_18` AS `bfcol_30`, + `bfcol_19` AS `bfcol_31`, + `bfcol_20` AS `bfcol_32`, + `bfcol_21` AS `bfcol_33`, + `bfcol_22` AS `bfcol_34`, + `bfcol_23` AS `bfcol_35`, + IEEE_DIVIDE(`bfcol_19`, 0.0) AS `bfcol_36` + FROM `bfcte_2` +), `bfcte_4` AS ( + SELECT + *, + `bfcol_30` AS `bfcol_44`, + `bfcol_31` AS `bfcol_45`, + `bfcol_32` AS `bfcol_46`, + `bfcol_33` AS `bfcol_47`, + `bfcol_34` AS `bfcol_48`, + `bfcol_35` AS `bfcol_49`, + `bfcol_36` AS `bfcol_50`, + IEEE_DIVIDE(`bfcol_31`, `bfcol_33`) AS `bfcol_51` + FROM `bfcte_3` +), `bfcte_5` AS ( + SELECT + *, + `bfcol_44` AS `bfcol_60`, + `bfcol_45` AS `bfcol_61`, + `bfcol_46` AS `bfcol_62`, + `bfcol_47` AS `bfcol_63`, + `bfcol_48` AS `bfcol_64`, + `bfcol_49` AS `bfcol_65`, + `bfcol_50` AS `bfcol_66`, + `bfcol_51` AS `bfcol_67`, + IEEE_DIVIDE(`bfcol_47`, `bfcol_45`) AS `bfcol_68` + FROM `bfcte_4` +), `bfcte_6` AS ( + SELECT + *, + `bfcol_60` AS `bfcol_78`, + `bfcol_61` AS `bfcol_79`, + `bfcol_62` AS `bfcol_80`, + `bfcol_63` AS `bfcol_81`, + `bfcol_64` AS `bfcol_82`, + `bfcol_65` AS `bfcol_83`, + `bfcol_66` AS `bfcol_84`, + `bfcol_67` AS `bfcol_85`, + `bfcol_68` AS `bfcol_86`, + IEEE_DIVIDE(`bfcol_63`, 0.0) AS `bfcol_87` + FROM `bfcte_5` +), `bfcte_7` AS ( + SELECT + *, + `bfcol_78` AS `bfcol_98`, + `bfcol_79` AS `bfcol_99`, + `bfcol_80` AS `bfcol_100`, + `bfcol_81` AS `bfcol_101`, + `bfcol_82` AS `bfcol_102`, + `bfcol_83` AS `bfcol_103`, + `bfcol_84` AS `bfcol_104`, + `bfcol_85` AS `bfcol_105`, + `bfcol_86` AS `bfcol_106`, + `bfcol_87` AS `bfcol_107`, + IEEE_DIVIDE(`bfcol_79`, CAST(`bfcol_80` AS INT64)) AS `bfcol_108` + FROM `bfcte_6` +), `bfcte_8` AS ( + SELECT + *, + `bfcol_98` AS `bfcol_120`, + `bfcol_99` AS `bfcol_121`, + `bfcol_100` AS `bfcol_122`, + `bfcol_101` AS `bfcol_123`, + `bfcol_102` AS `bfcol_124`, + `bfcol_103` AS `bfcol_125`, + `bfcol_104` AS `bfcol_126`, + `bfcol_105` AS `bfcol_127`, + `bfcol_106` AS `bfcol_128`, + `bfcol_107` AS `bfcol_129`, + `bfcol_108` AS `bfcol_130`, + IEEE_DIVIDE(CAST(`bfcol_100` AS INT64), `bfcol_99`) AS `bfcol_131` + FROM `bfcte_7` +) +SELECT + `bfcol_120` AS `rowindex`, + `bfcol_121` AS `int64_col`, + `bfcol_122` AS `bool_col`, + `bfcol_123` AS `float64_col`, + `bfcol_124` AS `int_div_int`, + `bfcol_125` AS `int_div_1`, + `bfcol_126` AS `int_div_0`, + `bfcol_127` AS `int_div_float`, + `bfcol_128` AS `float_div_int`, + `bfcol_129` AS `float_div_0`, + `bfcol_130` AS `int_div_bool`, + `bfcol_131` AS `bool_div_int` +FROM `bfcte_8` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_div_timedelta/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_div_timedelta/out.sql new file mode 100644 index 0000000000..6e05302fc9 --- /dev/null +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_div_timedelta/out.sql @@ -0,0 +1,21 @@ +WITH `bfcte_0` AS ( + SELECT + `int64_col` AS `bfcol_0`, + `rowindex` AS `bfcol_1`, + `timestamp_col` AS `bfcol_2` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + `bfcol_1` AS `bfcol_6`, + `bfcol_2` AS `bfcol_7`, + `bfcol_0` AS `bfcol_8`, + CAST(FLOOR(IEEE_DIVIDE(86400000000, `bfcol_0`)) AS INT64) AS `bfcol_9` + FROM `bfcte_0` +) +SELECT + `bfcol_6` AS `rowindex`, + `bfcol_7` AS `timestamp_col`, + `bfcol_8` AS `int64_col`, + `bfcol_9` AS `timedelta_div_numeric` +FROM `bfcte_1` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_floordiv_numeric/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_floordiv_numeric/out.sql new file mode 100644 index 0000000000..c38bc18523 --- /dev/null +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_floordiv_numeric/out.sql @@ -0,0 +1,154 @@ +WITH `bfcte_0` AS ( + SELECT + `bool_col` AS `bfcol_0`, + `int64_col` AS `bfcol_1`, + `float64_col` AS `bfcol_2`, + `rowindex` AS `bfcol_3` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + `bfcol_3` AS `bfcol_8`, + `bfcol_1` AS `bfcol_9`, + `bfcol_0` AS `bfcol_10`, + `bfcol_2` AS `bfcol_11`, + CASE + WHEN `bfcol_1` = CAST(0 AS INT64) + THEN CAST(0 AS INT64) * `bfcol_1` + ELSE CAST(FLOOR(IEEE_DIVIDE(`bfcol_1`, `bfcol_1`)) AS INT64) + END AS `bfcol_12` + FROM `bfcte_0` +), `bfcte_2` AS ( + SELECT + *, + `bfcol_8` AS `bfcol_18`, + `bfcol_9` AS `bfcol_19`, + `bfcol_10` AS `bfcol_20`, + `bfcol_11` AS `bfcol_21`, + `bfcol_12` AS `bfcol_22`, + CASE + WHEN 1 = CAST(0 AS INT64) + THEN CAST(0 AS INT64) * `bfcol_9` + ELSE CAST(FLOOR(IEEE_DIVIDE(`bfcol_9`, 1)) AS INT64) + END AS `bfcol_23` + FROM `bfcte_1` +), `bfcte_3` AS ( + SELECT + *, + `bfcol_18` AS `bfcol_30`, + `bfcol_19` AS `bfcol_31`, + `bfcol_20` AS `bfcol_32`, + `bfcol_21` AS `bfcol_33`, + `bfcol_22` AS `bfcol_34`, + `bfcol_23` AS `bfcol_35`, + CASE + WHEN 0.0 = CAST(0 AS INT64) + THEN CAST('Infinity' AS FLOAT64) * `bfcol_19` + ELSE CAST(FLOOR(IEEE_DIVIDE(`bfcol_19`, 0.0)) AS INT64) + END AS `bfcol_36` + FROM `bfcte_2` +), `bfcte_4` AS ( + SELECT + *, + `bfcol_30` AS `bfcol_44`, + `bfcol_31` AS `bfcol_45`, + `bfcol_32` AS `bfcol_46`, + `bfcol_33` AS `bfcol_47`, + `bfcol_34` AS `bfcol_48`, + `bfcol_35` AS `bfcol_49`, + `bfcol_36` AS `bfcol_50`, + CASE + WHEN `bfcol_33` = CAST(0 AS INT64) + THEN CAST('Infinity' AS FLOAT64) * `bfcol_31` + ELSE CAST(FLOOR(IEEE_DIVIDE(`bfcol_31`, `bfcol_33`)) AS INT64) + END AS `bfcol_51` + FROM `bfcte_3` +), `bfcte_5` AS ( + SELECT + *, + `bfcol_44` AS `bfcol_60`, + `bfcol_45` AS `bfcol_61`, + `bfcol_46` AS `bfcol_62`, + `bfcol_47` AS `bfcol_63`, + `bfcol_48` AS `bfcol_64`, + `bfcol_49` AS `bfcol_65`, + `bfcol_50` AS `bfcol_66`, + `bfcol_51` AS `bfcol_67`, + CASE + WHEN `bfcol_45` = CAST(0 AS INT64) + THEN CAST('Infinity' AS FLOAT64) * `bfcol_47` + ELSE CAST(FLOOR(IEEE_DIVIDE(`bfcol_47`, `bfcol_45`)) AS INT64) + END AS `bfcol_68` + FROM `bfcte_4` +), `bfcte_6` AS ( + SELECT + *, + `bfcol_60` AS `bfcol_78`, + `bfcol_61` AS `bfcol_79`, + `bfcol_62` AS `bfcol_80`, + `bfcol_63` AS `bfcol_81`, + `bfcol_64` AS `bfcol_82`, + `bfcol_65` AS `bfcol_83`, + `bfcol_66` AS `bfcol_84`, + `bfcol_67` AS `bfcol_85`, + `bfcol_68` AS `bfcol_86`, + CASE + WHEN 0.0 = CAST(0 AS INT64) + THEN CAST('Infinity' AS FLOAT64) * `bfcol_63` + ELSE CAST(FLOOR(IEEE_DIVIDE(`bfcol_63`, 0.0)) AS INT64) + END AS `bfcol_87` + FROM `bfcte_5` +), `bfcte_7` AS ( + SELECT + *, + `bfcol_78` AS `bfcol_98`, + `bfcol_79` AS `bfcol_99`, + `bfcol_80` AS `bfcol_100`, + `bfcol_81` AS `bfcol_101`, + `bfcol_82` AS `bfcol_102`, + `bfcol_83` AS `bfcol_103`, + `bfcol_84` AS `bfcol_104`, + `bfcol_85` AS `bfcol_105`, + `bfcol_86` AS `bfcol_106`, + `bfcol_87` AS `bfcol_107`, + CASE + WHEN CAST(`bfcol_80` AS INT64) = CAST(0 AS INT64) + THEN CAST(0 AS INT64) * `bfcol_79` + ELSE CAST(FLOOR(IEEE_DIVIDE(`bfcol_79`, CAST(`bfcol_80` AS INT64))) AS INT64) + END AS `bfcol_108` + FROM `bfcte_6` +), `bfcte_8` AS ( + SELECT + *, + `bfcol_98` AS `bfcol_120`, + `bfcol_99` AS `bfcol_121`, + `bfcol_100` AS `bfcol_122`, + `bfcol_101` AS `bfcol_123`, + `bfcol_102` AS `bfcol_124`, + `bfcol_103` AS `bfcol_125`, + `bfcol_104` AS `bfcol_126`, + `bfcol_105` AS `bfcol_127`, + `bfcol_106` AS `bfcol_128`, + `bfcol_107` AS `bfcol_129`, + `bfcol_108` AS `bfcol_130`, + CASE + WHEN `bfcol_99` = CAST(0 AS INT64) + THEN CAST(0 AS INT64) * CAST(`bfcol_100` AS INT64) + ELSE CAST(FLOOR(IEEE_DIVIDE(CAST(`bfcol_100` AS INT64), `bfcol_99`)) AS INT64) + END AS `bfcol_131` + FROM `bfcte_7` +) +SELECT + `bfcol_120` AS `rowindex`, + `bfcol_121` AS `int64_col`, + `bfcol_122` AS `bool_col`, + `bfcol_123` AS `float64_col`, + `bfcol_124` AS `int_div_int`, + `bfcol_125` AS `int_div_1`, + `bfcol_126` AS `int_div_0`, + `bfcol_127` AS `int_div_float`, + `bfcol_128` AS `float_div_int`, + `bfcol_129` AS `float_div_0`, + `bfcol_130` AS `int_div_bool`, + `bfcol_131` AS `bool_div_int` +FROM `bfcte_8` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_floordiv_timedelta/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_floordiv_timedelta/out.sql new file mode 100644 index 0000000000..bc4f94d306 --- /dev/null +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_floordiv_timedelta/out.sql @@ -0,0 +1,18 @@ +WITH `bfcte_0` AS ( + SELECT + `date_col` AS `bfcol_0`, + `rowindex` AS `bfcol_1`, + `timestamp_col` AS `bfcol_2` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + 43200000000 AS `bfcol_6` + FROM `bfcte_0` +) +SELECT + `bfcol_1` AS `rowindex`, + `bfcol_2` AS `timestamp_col`, + `bfcol_0` AS `date_col`, + `bfcol_6` AS `timedelta_div_numeric` +FROM `bfcte_1` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_mul_numeric/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_mul_numeric/out.sql new file mode 100644 index 0000000000..a9c81f4744 --- /dev/null +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_mul_numeric/out.sql @@ -0,0 +1,54 @@ +WITH `bfcte_0` AS ( + SELECT + `bool_col` AS `bfcol_0`, + `int64_col` AS `bfcol_1`, + `rowindex` AS `bfcol_2` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + `bfcol_2` AS `bfcol_6`, + `bfcol_1` AS `bfcol_7`, + `bfcol_0` AS `bfcol_8`, + `bfcol_1` * `bfcol_1` AS `bfcol_9` + FROM `bfcte_0` +), `bfcte_2` AS ( + SELECT + *, + `bfcol_6` AS `bfcol_14`, + `bfcol_7` AS `bfcol_15`, + `bfcol_8` AS `bfcol_16`, + `bfcol_9` AS `bfcol_17`, + `bfcol_7` * 1 AS `bfcol_18` + FROM `bfcte_1` +), `bfcte_3` AS ( + SELECT + *, + `bfcol_14` AS `bfcol_24`, + `bfcol_15` AS `bfcol_25`, + `bfcol_16` AS `bfcol_26`, + `bfcol_17` AS `bfcol_27`, + `bfcol_18` AS `bfcol_28`, + `bfcol_15` * CAST(`bfcol_16` AS INT64) AS `bfcol_29` + FROM `bfcte_2` +), `bfcte_4` AS ( + SELECT + *, + `bfcol_24` AS `bfcol_36`, + `bfcol_25` AS `bfcol_37`, + `bfcol_26` AS `bfcol_38`, + `bfcol_27` AS `bfcol_39`, + `bfcol_28` AS `bfcol_40`, + `bfcol_29` AS `bfcol_41`, + CAST(`bfcol_26` AS INT64) * `bfcol_25` AS `bfcol_42` + FROM `bfcte_3` +) +SELECT + `bfcol_36` AS `rowindex`, + `bfcol_37` AS `int64_col`, + `bfcol_38` AS `bool_col`, + `bfcol_39` AS `int_mul_int`, + `bfcol_40` AS `int_mul_1`, + `bfcol_41` AS `int_mul_bool`, + `bfcol_42` AS `bool_mul_int` +FROM `bfcte_4` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_mul_timedelta/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_mul_timedelta/out.sql new file mode 100644 index 0000000000..c8a8cf6cbf --- /dev/null +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_mul_timedelta/out.sql @@ -0,0 +1,43 @@ +WITH `bfcte_0` AS ( + SELECT + `int64_col` AS `bfcol_0`, + `rowindex` AS `bfcol_1`, + `timestamp_col` AS `bfcol_2`, + `duration_col` AS `bfcol_3` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + `bfcol_1` AS `bfcol_8`, + `bfcol_2` AS `bfcol_9`, + `bfcol_0` AS `bfcol_10`, + INTERVAL `bfcol_3` MICROSECOND AS `bfcol_11` + FROM `bfcte_0` +), `bfcte_2` AS ( + SELECT + *, + `bfcol_8` AS `bfcol_16`, + `bfcol_9` AS `bfcol_17`, + `bfcol_10` AS `bfcol_18`, + `bfcol_11` AS `bfcol_19`, + CAST(FLOOR(`bfcol_11` * `bfcol_10`) AS INT64) AS `bfcol_20` + FROM `bfcte_1` +), `bfcte_3` AS ( + SELECT + *, + `bfcol_16` AS `bfcol_26`, + `bfcol_17` AS `bfcol_27`, + `bfcol_18` AS `bfcol_28`, + `bfcol_19` AS `bfcol_29`, + `bfcol_20` AS `bfcol_30`, + CAST(FLOOR(`bfcol_18` * `bfcol_19`) AS INT64) AS `bfcol_31` + FROM `bfcte_2` +) +SELECT + `bfcol_26` AS `rowindex`, + `bfcol_27` AS `timestamp_col`, + `bfcol_28` AS `int64_col`, + `bfcol_29` AS `duration_col`, + `bfcol_30` AS `timedelta_mul_numeric`, + `bfcol_31` AS `numeric_mul_timedelta` +FROM `bfcte_3` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_obj_make_ref/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_obj_make_ref/out.sql new file mode 100644 index 0000000000..e3228feaaa --- /dev/null +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_obj_make_ref/out.sql @@ -0,0 +1,15 @@ +WITH `bfcte_0` AS ( + SELECT + `rowindex` AS `bfcol_0`, + `string_col` AS `bfcol_1` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + OBJ.MAKE_REF(`bfcol_1`, 'bigframes-dev.test-region.bigframes-default-connection') AS `bfcol_4` + FROM `bfcte_0` +) +SELECT + `bfcol_0` AS `rowindex`, + `bfcol_4` AS `string_col` +FROM `bfcte_1` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_sub_timedelta/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_sub_timedelta/out.sql index 41e45d3333..460f941d1b 100644 --- a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_sub_timedelta/out.sql +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_binary_compiler/test_sub_timedelta/out.sql @@ -2,59 +2,81 @@ WITH `bfcte_0` AS ( SELECT `date_col` AS `bfcol_0`, `rowindex` AS `bfcol_1`, - `timestamp_col` AS `bfcol_2` + `timestamp_col` AS `bfcol_2`, + `duration_col` AS `bfcol_3` FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` ), `bfcte_1` AS ( SELECT *, - `bfcol_1` AS `bfcol_6`, - `bfcol_2` AS `bfcol_7`, - `bfcol_0` AS `bfcol_8`, - TIMESTAMP_SUB(CAST(`bfcol_0` AS DATETIME), INTERVAL 86400000000 MICROSECOND) AS `bfcol_9` + `bfcol_1` AS `bfcol_8`, + `bfcol_2` AS `bfcol_9`, + `bfcol_0` AS `bfcol_10`, + INTERVAL `bfcol_3` MICROSECOND AS `bfcol_11` FROM `bfcte_0` ), `bfcte_2` AS ( SELECT *, - `bfcol_6` AS `bfcol_14`, - `bfcol_7` AS `bfcol_15`, `bfcol_8` AS `bfcol_16`, `bfcol_9` AS `bfcol_17`, - TIMESTAMP_SUB(`bfcol_7`, INTERVAL 86400000000 MICROSECOND) AS `bfcol_18` + `bfcol_11` AS `bfcol_18`, + `bfcol_10` AS `bfcol_19`, + TIMESTAMP_SUB(CAST(`bfcol_10` AS DATETIME), INTERVAL `bfcol_11` MICROSECOND) AS `bfcol_20` FROM `bfcte_1` ), `bfcte_3` AS ( SELECT *, - `bfcol_14` AS `bfcol_24`, - `bfcol_15` AS `bfcol_25`, `bfcol_16` AS `bfcol_26`, `bfcol_17` AS `bfcol_27`, `bfcol_18` AS `bfcol_28`, - TIMESTAMP_DIFF(CAST(`bfcol_16` AS DATETIME), CAST(`bfcol_16` AS DATETIME), MICROSECOND) AS `bfcol_29` + `bfcol_19` AS `bfcol_29`, + `bfcol_20` AS `bfcol_30`, + TIMESTAMP_SUB(`bfcol_17`, INTERVAL `bfcol_18` MICROSECOND) AS `bfcol_31` FROM `bfcte_2` ), `bfcte_4` AS ( SELECT *, - `bfcol_24` AS `bfcol_36`, - `bfcol_25` AS `bfcol_37`, `bfcol_26` AS `bfcol_38`, `bfcol_27` AS `bfcol_39`, `bfcol_28` AS `bfcol_40`, `bfcol_29` AS `bfcol_41`, - TIMESTAMP_DIFF(`bfcol_25`, `bfcol_25`, MICROSECOND) AS `bfcol_42` + `bfcol_30` AS `bfcol_42`, + `bfcol_31` AS `bfcol_43`, + TIMESTAMP_DIFF(CAST(`bfcol_29` AS DATETIME), CAST(`bfcol_29` AS DATETIME), MICROSECOND) AS `bfcol_44` FROM `bfcte_3` ), `bfcte_5` AS ( SELECT *, - 0 AS `bfcol_50` + `bfcol_38` AS `bfcol_52`, + `bfcol_39` AS `bfcol_53`, + `bfcol_40` AS `bfcol_54`, + `bfcol_41` AS `bfcol_55`, + `bfcol_42` AS `bfcol_56`, + `bfcol_43` AS `bfcol_57`, + `bfcol_44` AS `bfcol_58`, + TIMESTAMP_DIFF(`bfcol_39`, `bfcol_39`, MICROSECOND) AS `bfcol_59` FROM `bfcte_4` +), `bfcte_6` AS ( + SELECT + *, + `bfcol_52` AS `bfcol_68`, + `bfcol_53` AS `bfcol_69`, + `bfcol_54` AS `bfcol_70`, + `bfcol_55` AS `bfcol_71`, + `bfcol_56` AS `bfcol_72`, + `bfcol_57` AS `bfcol_73`, + `bfcol_58` AS `bfcol_74`, + `bfcol_59` AS `bfcol_75`, + `bfcol_54` - `bfcol_54` AS `bfcol_76` + FROM `bfcte_5` ) SELECT - `bfcol_36` AS `rowindex`, - `bfcol_37` AS `timestamp_col`, - `bfcol_38` AS `date_col`, - `bfcol_39` AS `date_sub_timedelta`, - `bfcol_40` AS `timestamp_sub_timedelta`, - `bfcol_41` AS `timestamp_sub_date`, - `bfcol_42` AS `date_sub_timestamp`, - `bfcol_50` AS `timedelta_sub_timedelta` -FROM `bfcte_5` \ No newline at end of file + `bfcol_68` AS `rowindex`, + `bfcol_69` AS `timestamp_col`, + `bfcol_70` AS `duration_col`, + `bfcol_71` AS `date_col`, + `bfcol_72` AS `date_sub_timedelta`, + `bfcol_73` AS `timestamp_sub_timedelta`, + `bfcol_74` AS `timestamp_sub_date`, + `bfcol_75` AS `date_sub_timestamp`, + `bfcol_76` AS `timedelta_sub_timedelta` +FROM `bfcte_6` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_obj_fetch_metadata/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_obj_fetch_metadata/out.sql new file mode 100644 index 0000000000..134fdc363b --- /dev/null +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_obj_fetch_metadata/out.sql @@ -0,0 +1,25 @@ +WITH `bfcte_0` AS ( + SELECT + `rowindex` AS `bfcol_0`, + `string_col` AS `bfcol_1` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + OBJ.MAKE_REF(`bfcol_1`, 'bigframes-dev.test-region.bigframes-default-connection') AS `bfcol_4` + FROM `bfcte_0` +), `bfcte_2` AS ( + SELECT + *, + OBJ.FETCH_METADATA(`bfcol_4`) AS `bfcol_7` + FROM `bfcte_1` +), `bfcte_3` AS ( + SELECT + *, + `bfcol_7`.`version` AS `bfcol_10` + FROM `bfcte_2` +) +SELECT + `bfcol_0` AS `rowindex`, + `bfcol_10` AS `version` +FROM `bfcte_3` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_obj_get_access_url/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_obj_get_access_url/out.sql new file mode 100644 index 0000000000..4a963b4972 --- /dev/null +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_obj_get_access_url/out.sql @@ -0,0 +1,25 @@ +WITH `bfcte_0` AS ( + SELECT + `rowindex` AS `bfcol_0`, + `string_col` AS `bfcol_1` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + OBJ.MAKE_REF(`bfcol_1`, 'bigframes-dev.test-region.bigframes-default-connection') AS `bfcol_4` + FROM `bfcte_0` +), `bfcte_2` AS ( + SELECT + *, + OBJ.GET_ACCESS_URL(`bfcol_4`) AS `bfcol_7` + FROM `bfcte_1` +), `bfcte_3` AS ( + SELECT + *, + JSON_VALUE(`bfcol_7`, '$.access_urls.read_url') AS `bfcol_10` + FROM `bfcte_2` +) +SELECT + `bfcol_0` AS `rowindex`, + `bfcol_10` AS `string_col` +FROM `bfcte_3` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_to_timedelta/out.sql b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_to_timedelta/out.sql index b89056d65f..01ebebc455 100644 --- a/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_to_timedelta/out.sql +++ b/tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_to_timedelta/out.sql @@ -1,13 +1,37 @@ WITH `bfcte_0` AS ( SELECT - `int64_col` AS `bfcol_0` + `int64_col` AS `bfcol_0`, + `rowindex` AS `bfcol_1` FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` ), `bfcte_1` AS ( SELECT *, - INTERVAL `bfcol_0` SECOND AS `bfcol_1` + `bfcol_1` AS `bfcol_4`, + `bfcol_0` AS `bfcol_5`, + INTERVAL `bfcol_0` MICROSECOND AS `bfcol_6` FROM `bfcte_0` +), `bfcte_2` AS ( + SELECT + *, + `bfcol_4` AS `bfcol_10`, + `bfcol_5` AS `bfcol_11`, + `bfcol_6` AS `bfcol_12`, + INTERVAL (`bfcol_5` * 1000000) MICROSECOND AS `bfcol_13` + FROM `bfcte_1` +), `bfcte_3` AS ( + SELECT + *, + `bfcol_10` AS `bfcol_18`, + `bfcol_11` AS `bfcol_19`, + `bfcol_12` AS `bfcol_20`, + `bfcol_13` AS `bfcol_21`, + INTERVAL (`bfcol_11` * 604800000000) MICROSECOND AS `bfcol_22` + FROM `bfcte_2` ) SELECT - `bfcol_1` AS `int64_col` -FROM `bfcte_1` \ No newline at end of file + `bfcol_18` AS `rowindex`, + `bfcol_19` AS `int64_col`, + `bfcol_20` AS `duration_us`, + `bfcol_21` AS `duration_s`, + `bfcol_22` AS `duration_w` +FROM `bfcte_3` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/expressions/test_binary_compiler.py b/tests/unit/core/compile/sqlglot/expressions/test_binary_compiler.py index 05d9c26945..49426fe6c3 100644 --- a/tests/unit/core/compile/sqlglot/expressions/test_binary_compiler.py +++ b/tests/unit/core/compile/sqlglot/expressions/test_binary_compiler.py @@ -82,6 +82,57 @@ def test_add_unsupported_raises(scalar_types_df: bpd.DataFrame): _apply_binary_op(scalar_types_df, ops.add_op, "int64_col", "string_col") +def test_div_numeric(scalar_types_df: bpd.DataFrame, snapshot): + bf_df = scalar_types_df[["int64_col", "bool_col", "float64_col"]] + + bf_df["int_div_int"] = bf_df["int64_col"] / bf_df["int64_col"] + bf_df["int_div_1"] = bf_df["int64_col"] / 1 + bf_df["int_div_0"] = bf_df["int64_col"] / 0.0 + + bf_df["int_div_float"] = bf_df["int64_col"] / bf_df["float64_col"] + bf_df["float_div_int"] = bf_df["float64_col"] / bf_df["int64_col"] + bf_df["float_div_0"] = bf_df["float64_col"] / 0.0 + + bf_df["int_div_bool"] = bf_df["int64_col"] / bf_df["bool_col"] + bf_df["bool_div_int"] = bf_df["bool_col"] / bf_df["int64_col"] + + snapshot.assert_match(bf_df.sql, "out.sql") + + +def test_div_timedelta(scalar_types_df: bpd.DataFrame, snapshot): + bf_df = scalar_types_df[["timestamp_col", "int64_col"]] + timedelta = pd.Timedelta(1, unit="d") + bf_df["timedelta_div_numeric"] = timedelta / bf_df["int64_col"] + + snapshot.assert_match(bf_df.sql, "out.sql") + + +def test_floordiv_numeric(scalar_types_df: bpd.DataFrame, snapshot): + bf_df = scalar_types_df[["int64_col", "bool_col", "float64_col"]] + + bf_df["int_div_int"] = bf_df["int64_col"] // bf_df["int64_col"] + bf_df["int_div_1"] = bf_df["int64_col"] // 1 + bf_df["int_div_0"] = bf_df["int64_col"] // 0.0 + + bf_df["int_div_float"] = bf_df["int64_col"] // bf_df["float64_col"] + bf_df["float_div_int"] = bf_df["float64_col"] // bf_df["int64_col"] + bf_df["float_div_0"] = bf_df["float64_col"] // 0.0 + + bf_df["int_div_bool"] = bf_df["int64_col"] // bf_df["bool_col"] + bf_df["bool_div_int"] = bf_df["bool_col"] // bf_df["int64_col"] + + snapshot.assert_match(bf_df.sql, "out.sql") + + +def test_floordiv_timedelta(scalar_types_df: bpd.DataFrame, snapshot): + bf_df = scalar_types_df[["timestamp_col", "date_col"]] + timedelta = pd.Timedelta(1, unit="d") + + bf_df["timedelta_div_numeric"] = timedelta // 2 + + snapshot.assert_match(bf_df.sql, "out.sql") + + def test_json_set(json_types_df: bpd.DataFrame, snapshot): bf_df = json_types_df[["json_col"]] sql = _apply_binary_op( @@ -104,14 +155,14 @@ def test_sub_numeric(scalar_types_df: bpd.DataFrame, snapshot): def test_sub_timedelta(scalar_types_df: bpd.DataFrame, snapshot): - bf_df = scalar_types_df[["timestamp_col", "date_col"]] - timedelta = pd.Timedelta(1, unit="d") + bf_df = scalar_types_df[["timestamp_col", "duration_col", "date_col"]] + bf_df["duration_col"] = bpd.to_timedelta(bf_df["duration_col"], unit="us") - bf_df["date_sub_timedelta"] = bf_df["date_col"] - timedelta - bf_df["timestamp_sub_timedelta"] = bf_df["timestamp_col"] - timedelta + bf_df["date_sub_timedelta"] = bf_df["date_col"] - bf_df["duration_col"] + bf_df["timestamp_sub_timedelta"] = bf_df["timestamp_col"] - bf_df["duration_col"] bf_df["timestamp_sub_date"] = bf_df["date_col"] - bf_df["date_col"] bf_df["date_sub_timestamp"] = bf_df["timestamp_col"] - bf_df["timestamp_col"] - bf_df["timedelta_sub_timedelta"] = timedelta - timedelta + bf_df["timedelta_sub_timedelta"] = bf_df["duration_col"] - bf_df["duration_col"] snapshot.assert_match(bf_df.sql, "out.sql") @@ -122,3 +173,30 @@ def test_sub_unsupported_raises(scalar_types_df: bpd.DataFrame): with pytest.raises(TypeError): _apply_binary_op(scalar_types_df, ops.sub_op, "int64_col", "string_col") + + +def test_mul_numeric(scalar_types_df: bpd.DataFrame, snapshot): + bf_df = scalar_types_df[["int64_col", "bool_col"]] + + bf_df["int_mul_int"] = bf_df["int64_col"] * bf_df["int64_col"] + bf_df["int_mul_1"] = bf_df["int64_col"] * 1 + + bf_df["int_mul_bool"] = bf_df["int64_col"] * bf_df["bool_col"] + bf_df["bool_mul_int"] = bf_df["bool_col"] * bf_df["int64_col"] + + snapshot.assert_match(bf_df.sql, "out.sql") + + +def test_mul_timedelta(scalar_types_df: bpd.DataFrame, snapshot): + bf_df = scalar_types_df[["timestamp_col", "int64_col", "duration_col"]] + bf_df["duration_col"] = bpd.to_timedelta(bf_df["duration_col"], unit="us") + + bf_df["timedelta_mul_numeric"] = bf_df["duration_col"] * bf_df["int64_col"] + bf_df["numeric_mul_timedelta"] = bf_df["int64_col"] * bf_df["duration_col"] + + snapshot.assert_match(bf_df.sql, "out.sql") + + +def test_obj_make_ref(scalar_types_df: bpd.DataFrame, snapshot): + blob_df = scalar_types_df["string_col"].str.to_blob() + snapshot.assert_match(blob_df.to_frame().sql, "out.sql") diff --git a/tests/unit/core/compile/sqlglot/expressions/test_unary_compiler.py b/tests/unit/core/compile/sqlglot/expressions/test_unary_compiler.py index 0a930d68ae..4a5b586c77 100644 --- a/tests/unit/core/compile/sqlglot/expressions/test_unary_compiler.py +++ b/tests/unit/core/compile/sqlglot/expressions/test_unary_compiler.py @@ -405,6 +405,18 @@ def test_normalize(scalar_types_df: bpd.DataFrame, snapshot): snapshot.assert_match(sql, "out.sql") +def test_obj_fetch_metadata(scalar_types_df: bpd.DataFrame, snapshot): + blob_s = scalar_types_df["string_col"].str.to_blob() + sql = blob_s.blob.version().to_frame().sql + snapshot.assert_match(sql, "out.sql") + + +def test_obj_get_access_url(scalar_types_df: bpd.DataFrame, snapshot): + blob_s = scalar_types_df["string_col"].str.to_blob() + sql = blob_s.blob.read_url().to_frame().sql + snapshot.assert_match(sql, "out.sql") + + def test_pos(scalar_types_df: bpd.DataFrame, snapshot): bf_df = scalar_types_df[["float64_col"]] sql = _apply_unary_op(bf_df, ops.pos_op, "float64_col") @@ -587,9 +599,11 @@ def test_to_timestamp(scalar_types_df: bpd.DataFrame, snapshot): def test_to_timedelta(scalar_types_df: bpd.DataFrame, snapshot): bf_df = scalar_types_df[["int64_col"]] - sql = _apply_unary_op(bf_df, ops.ToTimedeltaOp("s"), "int64_col") + bf_df["duration_us"] = bpd.to_timedelta(bf_df["int64_col"], "us") + bf_df["duration_s"] = bpd.to_timedelta(bf_df["int64_col"], "s") + bf_df["duration_w"] = bpd.to_timedelta(bf_df["int64_col"], "W") - snapshot.assert_match(sql, "out.sql") + snapshot.assert_match(bf_df.sql, "out.sql") def test_unix_micros(scalar_types_df: bpd.DataFrame, snapshot): diff --git a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readtable/test_compile_readtable/out.sql b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readtable/test_compile_readtable/out.sql index 34fc8e3c49..10c2a2088a 100644 --- a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readtable/test_compile_readtable/out.sql +++ b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readtable/test_compile_readtable/out.sql @@ -13,7 +13,8 @@ WITH `bfcte_0` AS ( `rowindex_2` AS `bfcol_10`, `string_col` AS `bfcol_11`, `time_col` AS `bfcol_12`, - `timestamp_col` AS `bfcol_13` + `timestamp_col` AS `bfcol_13`, + `duration_col` AS `bfcol_14` FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` ) SELECT @@ -31,5 +32,6 @@ SELECT `bfcol_10` AS `rowindex_2`, `bfcol_11` AS `string_col`, `bfcol_12` AS `time_col`, - `bfcol_13` AS `timestamp_col` + `bfcol_13` AS `timestamp_col`, + `bfcol_14` AS `duration_col` FROM `bfcte_0` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_w_groupby_rolling/out.sql b/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_w_groupby_rolling/out.sql new file mode 100644 index 0000000000..beb3caa073 --- /dev/null +++ b/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_w_groupby_rolling/out.sql @@ -0,0 +1,76 @@ +WITH `bfcte_0` AS ( + SELECT + `bool_col` AS `bfcol_0`, + `int64_col` AS `bfcol_1`, + `rowindex` AS `bfcol_2` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + `bfcol_2` AS `bfcol_6`, + `bfcol_0` AS `bfcol_7`, + `bfcol_1` AS `bfcol_8`, + `bfcol_0` AS `bfcol_9` + FROM `bfcte_0` +), `bfcte_2` AS ( + SELECT + * + FROM `bfcte_1` + WHERE + NOT `bfcol_9` IS NULL +), `bfcte_3` AS ( + SELECT + *, + CASE + WHEN SUM(CAST(NOT `bfcol_7` IS NULL AS INT64)) OVER ( + PARTITION BY `bfcol_9` + ORDER BY `bfcol_9` IS NULL ASC NULLS LAST, `bfcol_9` ASC NULLS LAST, `bfcol_2` IS NULL ASC NULLS LAST, `bfcol_2` ASC NULLS LAST + ROWS BETWEEN 3 PRECEDING AND CURRENT ROW + ) < 3 + THEN NULL + ELSE COALESCE( + SUM(CAST(`bfcol_7` AS INT64)) OVER ( + PARTITION BY `bfcol_9` + ORDER BY `bfcol_9` IS NULL ASC NULLS LAST, `bfcol_9` ASC NULLS LAST, `bfcol_2` IS NULL ASC NULLS LAST, `bfcol_2` ASC NULLS LAST + ROWS BETWEEN 3 PRECEDING AND CURRENT ROW + ), + 0 + ) + END AS `bfcol_15` + FROM `bfcte_2` +), `bfcte_4` AS ( + SELECT + * + FROM `bfcte_3` + WHERE + NOT `bfcol_9` IS NULL +), `bfcte_5` AS ( + SELECT + *, + CASE + WHEN SUM(CAST(NOT `bfcol_8` IS NULL AS INT64)) OVER ( + PARTITION BY `bfcol_9` + ORDER BY `bfcol_9` IS NULL ASC NULLS LAST, `bfcol_9` ASC NULLS LAST, `bfcol_2` IS NULL ASC NULLS LAST, `bfcol_2` ASC NULLS LAST + ROWS BETWEEN 3 PRECEDING AND CURRENT ROW + ) < 3 + THEN NULL + ELSE COALESCE( + SUM(`bfcol_8`) OVER ( + PARTITION BY `bfcol_9` + ORDER BY `bfcol_9` IS NULL ASC NULLS LAST, `bfcol_9` ASC NULLS LAST, `bfcol_2` IS NULL ASC NULLS LAST, `bfcol_2` ASC NULLS LAST + ROWS BETWEEN 3 PRECEDING AND CURRENT ROW + ), + 0 + ) + END AS `bfcol_21` + FROM `bfcte_4` +) +SELECT + `bfcol_9` AS `bool_col`, + `bfcol_6` AS `rowindex`, + `bfcol_15` AS `bool_col_1`, + `bfcol_21` AS `int64_col` +FROM `bfcte_5` +ORDER BY + `bfcol_9` ASC NULLS LAST, + `bfcol_2` ASC NULLS LAST \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_w_range_rolling/out.sql b/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_w_range_rolling/out.sql new file mode 100644 index 0000000000..581c81c6b4 --- /dev/null +++ b/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_w_range_rolling/out.sql @@ -0,0 +1,30 @@ +WITH `bfcte_0` AS ( + SELECT + * + FROM UNNEST(ARRAY>[STRUCT(CAST('2025-01-01T00:00:00+00:00' AS TIMESTAMP), 0, 0), STRUCT(CAST('2025-01-01T00:00:01+00:00' AS TIMESTAMP), 1, 1), STRUCT(CAST('2025-01-01T00:00:02+00:00' AS TIMESTAMP), 2, 2), STRUCT(CAST('2025-01-01T00:00:03+00:00' AS TIMESTAMP), 3, 3), STRUCT(CAST('2025-01-01T00:00:04+00:00' AS TIMESTAMP), 0, 4), STRUCT(CAST('2025-01-01T00:00:05+00:00' AS TIMESTAMP), 1, 5), STRUCT(CAST('2025-01-01T00:00:06+00:00' AS TIMESTAMP), 2, 6), STRUCT(CAST('2025-01-01T00:00:07+00:00' AS TIMESTAMP), 3, 7), STRUCT(CAST('2025-01-01T00:00:08+00:00' AS TIMESTAMP), 0, 8), STRUCT(CAST('2025-01-01T00:00:09+00:00' AS TIMESTAMP), 1, 9), STRUCT(CAST('2025-01-01T00:00:10+00:00' AS TIMESTAMP), 2, 10), STRUCT(CAST('2025-01-01T00:00:11+00:00' AS TIMESTAMP), 3, 11), STRUCT(CAST('2025-01-01T00:00:12+00:00' AS TIMESTAMP), 0, 12), STRUCT(CAST('2025-01-01T00:00:13+00:00' AS TIMESTAMP), 1, 13), STRUCT(CAST('2025-01-01T00:00:14+00:00' AS TIMESTAMP), 2, 14), STRUCT(CAST('2025-01-01T00:00:15+00:00' AS TIMESTAMP), 3, 15), STRUCT(CAST('2025-01-01T00:00:16+00:00' AS TIMESTAMP), 0, 16), STRUCT(CAST('2025-01-01T00:00:17+00:00' AS TIMESTAMP), 1, 17), STRUCT(CAST('2025-01-01T00:00:18+00:00' AS TIMESTAMP), 2, 18), STRUCT(CAST('2025-01-01T00:00:19+00:00' AS TIMESTAMP), 3, 19)]) +), `bfcte_1` AS ( + SELECT + *, + CASE + WHEN SUM(CAST(NOT `bfcol_1` IS NULL AS INT64)) OVER ( + ORDER BY UNIX_MICROS(`bfcol_0`) ASC NULLS LAST + RANGE BETWEEN 2999999 PRECEDING AND CURRENT ROW + ) < 1 + THEN NULL + ELSE COALESCE( + SUM(`bfcol_1`) OVER ( + ORDER BY UNIX_MICROS(`bfcol_0`) ASC NULLS LAST + RANGE BETWEEN 2999999 PRECEDING AND CURRENT ROW + ), + 0 + ) + END AS `bfcol_6` + FROM `bfcte_0` +) +SELECT + `bfcol_0` AS `ts_col`, + `bfcol_6` AS `int_col` +FROM `bfcte_1` +ORDER BY + `bfcol_0` ASC NULLS LAST, + `bfcol_2` ASC NULLS LAST \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_w_skips_nulls_op/out.sql b/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_w_skips_nulls_op/out.sql new file mode 100644 index 0000000000..6d779a40ac --- /dev/null +++ b/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_w_skips_nulls_op/out.sql @@ -0,0 +1,30 @@ +WITH `bfcte_0` AS ( + SELECT + `int64_col` AS `bfcol_0`, + `rowindex` AS `bfcol_1` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + CASE + WHEN SUM(CAST(NOT `bfcol_0` IS NULL AS INT64)) OVER ( + ORDER BY `bfcol_1` IS NULL ASC NULLS LAST, `bfcol_1` ASC NULLS LAST + ROWS BETWEEN 2 PRECEDING AND CURRENT ROW + ) < 3 + THEN NULL + ELSE COALESCE( + SUM(`bfcol_0`) OVER ( + ORDER BY `bfcol_1` IS NULL ASC NULLS LAST, `bfcol_1` ASC NULLS LAST + ROWS BETWEEN 2 PRECEDING AND CURRENT ROW + ), + 0 + ) + END AS `bfcol_4` + FROM `bfcte_0` +) +SELECT + `bfcol_1` AS `rowindex`, + `bfcol_4` AS `int64_col` +FROM `bfcte_1` +ORDER BY + `bfcol_1` ASC NULLS LAST \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_wo_skips_nulls_op/out.sql b/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_wo_skips_nulls_op/out.sql new file mode 100644 index 0000000000..1d5d9a9e45 --- /dev/null +++ b/tests/unit/core/compile/sqlglot/snapshots/test_compile_window/test_compile_window_wo_skips_nulls_op/out.sql @@ -0,0 +1,27 @@ +WITH `bfcte_0` AS ( + SELECT + `int64_col` AS `bfcol_0`, + `rowindex` AS `bfcol_1` + FROM `bigframes-dev`.`sqlglot_test`.`scalar_types` +), `bfcte_1` AS ( + SELECT + *, + CASE + WHEN COUNT(CAST(NOT `bfcol_0` IS NULL AS INT64)) OVER ( + ORDER BY `bfcol_1` IS NULL ASC NULLS LAST, `bfcol_1` ASC NULLS LAST + ROWS BETWEEN 4 PRECEDING AND CURRENT ROW + ) < 5 + THEN NULL + ELSE COUNT(`bfcol_0`) OVER ( + ORDER BY `bfcol_1` IS NULL ASC NULLS LAST, `bfcol_1` ASC NULLS LAST + ROWS BETWEEN 4 PRECEDING AND CURRENT ROW + ) + END AS `bfcol_4` + FROM `bfcte_0` +) +SELECT + `bfcol_1` AS `rowindex`, + `bfcol_4` AS `int64_col` +FROM `bfcte_1` +ORDER BY + `bfcol_1` ASC NULLS LAST \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/test_compile_window.py b/tests/unit/core/compile/sqlglot/test_compile_window.py new file mode 100644 index 0000000000..1fc70dc30f --- /dev/null +++ b/tests/unit/core/compile/sqlglot/test_compile_window.py @@ -0,0 +1,70 @@ +# 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 sys + +import numpy as np +import pandas as pd +import pytest + +import bigframes.pandas as bpd + +pytest.importorskip("pytest_snapshot") + + +if sys.version_info < (3, 12): + pytest.skip( + "Skipping test due to inconsistent SQL formatting on Python < 3.12.", + allow_module_level=True, + ) + + +def test_compile_window_w_skips_nulls_op(scalar_types_df: bpd.DataFrame, snapshot): + bf_df = scalar_types_df[["int64_col"]].sort_index() + # The SumOp's skips_nulls is True + result = bf_df.rolling(window=3).sum() + snapshot.assert_match(result.sql, "out.sql") + + +def test_compile_window_wo_skips_nulls_op(scalar_types_df: bpd.DataFrame, snapshot): + bf_df = scalar_types_df[["int64_col"]].sort_index() + # The CountOp's skips_nulls is False + result = bf_df.rolling(window=5).count() + snapshot.assert_match(result.sql, "out.sql") + + +def test_compile_window_w_groupby_rolling(scalar_types_df: bpd.DataFrame, snapshot): + bf_df = scalar_types_df[["bool_col", "int64_col"]].sort_index() + result = ( + bf_df.groupby(scalar_types_df["bool_col"]) + .rolling(window=3, closed="both") + .sum() + ) + snapshot.assert_match(result.sql, "out.sql") + + +def test_compile_window_w_range_rolling(compiler_session, snapshot): + # TODO: use `duration_col` instead. + values = np.arange(20) + pd_df = pd.DataFrame( + { + "ts_col": pd.Timestamp("20250101", tz="UTC") + pd.to_timedelta(values, "s"), + "int_col": values % 4, + "float_col": values / 2, + } + ) + bf_df = compiler_session.read_pandas(pd_df) + bf_series = bf_df.set_index("ts_col")["int_col"].sort_index() + result = bf_series.rolling(window="3s").sum() + snapshot.assert_match(result.to_frame().sql, "out.sql") diff --git a/tests/unit/display/test_html.py b/tests/unit/display/test_html.py new file mode 100644 index 0000000000..fcf1455362 --- /dev/null +++ b/tests/unit/display/test_html.py @@ -0,0 +1,151 @@ +# Copyright 2024 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 datetime + +import pandas as pd +import pyarrow as pa +import pytest + +import bigframes as bf +import bigframes.display.html as bf_html + + +@pytest.mark.parametrize( + ("data", "expected_alignments", "expected_strings"), + [ + pytest.param( + { + "string_col": ["a", "b", "c"], + "int_col": [1, 2, 3], + "float_col": [1.1, 2.2, 3.3], + "bool_col": [True, False, True], + }, + { + "string_col": "left", + "int_col": "right", + "float_col": "right", + "bool_col": "left", + }, + ["1.100000", "2.200000", "3.300000"], + id="scalars", + ), + pytest.param( + { + "timestamp_col": pa.array( + [ + datetime.datetime.fromisoformat(value) + for value in [ + "2024-01-01 00:00:00", + "2024-01-01 00:00:01", + "2024-01-01 00:00:02", + ] + ], + pa.timestamp("us", tz="UTC"), + ), + "datetime_col": pa.array( + [ + datetime.datetime.fromisoformat(value) + for value in [ + "2027-06-05 04:03:02.001", + "2027-01-01 00:00:01", + "2027-01-01 00:00:02", + ] + ], + pa.timestamp("us"), + ), + "date_col": pa.array( + [ + datetime.date(1999, 1, 1), + datetime.date(1999, 1, 2), + datetime.date(1999, 1, 3), + ], + pa.date32(), + ), + "time_col": pa.array( + [ + datetime.time(11, 11, 0), + datetime.time(11, 11, 1), + datetime.time(11, 11, 2), + ], + pa.time64("us"), + ), + }, + { + "timestamp_col": "left", + "datetime_col": "left", + "date_col": "left", + "time_col": "left", + }, + [ + "2024-01-01 00:00:00", + "2027-06-05 04:03:02.001", + "1999-01-01", + "11:11:01", + ], + id="datetimes", + ), + pytest.param( + { + "array_col": pd.Series( + [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + dtype=pd.ArrowDtype(pa.list_(pa.int64())), + ), + }, + { + "array_col": "left", + }, + ["[1, 2, 3]", "[4, 5, 6]", "[7, 8, 9]"], + id="array", + ), + pytest.param( + { + "struct_col": pd.Series( + [{"v": 1}, {"v": 2}, {"v": 3}], + dtype=pd.ArrowDtype(pa.struct([("v", pa.int64())])), + ), + }, + { + "struct_col": "left", + }, + ["{'v': 1}", "{'v': 2}", "{'v': 3}"], + id="struct", + ), + ], +) +def test_render_html_alignment_and_precision( + data, expected_alignments, expected_strings +): + df = pd.DataFrame(data) + html = bf_html.render_html(dataframe=df, table_id="test-table") + + for _, align in expected_alignments.items(): + assert 'th style="text-align: left;"' in html + assert f'=1.2.0"] + + # Exact match + assert _utils._package_existed(reqs, "pandas==1.0") + # Different version + assert _utils._package_existed(reqs, "pandas==2.0") + # No version specified + assert _utils._package_existed(reqs, "numpy") + # Not in list + assert not _utils._package_existed(reqs, "xgboost") + # Empty list + assert not _utils._package_existed([], "pandas") + + +def test_has_conflict_output_type_no_conflict(): + """Tests has_conflict_output_type with type annotation.""" + # Helper functions with type annotation for has_conflict_output_type. + def _func_with_return_type(x: int) -> int: + return x + + signature = inspect.signature(_func_with_return_type) + + assert _utils.has_conflict_output_type(signature, output_type=float) + assert not _utils.has_conflict_output_type(signature, output_type=int) + + +def test_has_conflict_output_type_no_annotation(): + """Tests has_conflict_output_type without type annotation.""" + # Helper functions without type annotation for has_conflict_output_type. + def _func_without_return_type(x): + return x + + signature = inspect.signature(_func_without_return_type) + + assert not _utils.has_conflict_output_type(signature, output_type=int) + assert not _utils.has_conflict_output_type(signature, output_type=float) + + @pytest.mark.parametrize( ["metadata_options", "metadata_string"], ( @@ -54,6 +222,7 @@ ), ) def test_get_bigframes_metadata(metadata_options, metadata_string): + assert _utils.get_bigframes_metadata(**metadata_options) == metadata_string @@ -72,6 +241,7 @@ def test_get_bigframes_metadata(metadata_options, metadata_string): def test_get_bigframes_metadata_array_type_not_serializable(output_type): with pytest.raises(ValueError) as context: _utils.get_bigframes_metadata(python_output_type=output_type) + assert str(context.value) == ( f"python_output_type {output_type} is not serializable. {constants.FEEDBACK_LINK}" ) @@ -125,6 +295,7 @@ def test_get_bigframes_metadata_array_type_not_serializable(output_type): def test_get_python_output_type_from_bigframes_metadata( metadata_string, python_output_type ): + assert ( _utils.get_python_output_type_from_bigframes_metadata(metadata_string) == python_output_type @@ -135,4 +306,5 @@ def test_metadata_roundtrip_supported_array_types(): for array_of in function_typing.RF_SUPPORTED_ARRAY_OUTPUT_PYTHON_TYPES: ser = _utils.get_bigframes_metadata(python_output_type=list[array_of]) # type: ignore deser = _utils.get_python_output_type_from_bigframes_metadata(ser) + assert deser == list[array_of] # type: ignore diff --git a/tests/unit/test_dataframe_polars.py b/tests/unit/test_dataframe_polars.py index 2070b25d66..a6f5c3d1ef 100644 --- a/tests/unit/test_dataframe_polars.py +++ b/tests/unit/test_dataframe_polars.py @@ -1657,13 +1657,11 @@ def test_reset_index_with_unnamed_index( pandas.testing.assert_frame_equal(bf_result, pd_result) -def test_reset_index_with_unnamed_multiindex( - scalars_df_index, - scalars_pandas_df_index, -): +def test_reset_index_with_unnamed_multiindex(session): bf_df = dataframe.DataFrame( ([1, 2, 3], [2, 5, 7]), index=pd.MultiIndex.from_tuples([("a", "aa"), ("a", "aa")]), + session=session, ) pd_df = pd.DataFrame( ([1, 2, 3], [2, 5, 7]), diff --git a/third_party/bigframes_vendored/ibis/expr/operations/numeric.py b/third_party/bigframes_vendored/ibis/expr/operations/numeric.py index 174de5ab7f..384323c596 100644 --- a/third_party/bigframes_vendored/ibis/expr/operations/numeric.py +++ b/third_party/bigframes_vendored/ibis/expr/operations/numeric.py @@ -326,7 +326,7 @@ class Tan(TrigonometricUnary): class BitwiseNot(Unary): """Bitwise NOT operation.""" - arg: Integer + arg: Value[dt.Integer | dt.Binary] dtype = rlz.numeric_like("args", operator.invert) diff --git a/third_party/bigframes_vendored/ibis/expr/types/binary.py b/third_party/bigframes_vendored/ibis/expr/types/binary.py index ba6140a49f..08fea31a1c 100644 --- a/third_party/bigframes_vendored/ibis/expr/types/binary.py +++ b/third_party/bigframes_vendored/ibis/expr/types/binary.py @@ -32,6 +32,9 @@ def hashbytes( """ return ops.HashBytes(self, how).to_expr() + def __invert__(self) -> BinaryValue: + return ops.BitwiseNot(self).to_expr() + @public class BinaryScalar(Scalar, BinaryValue): diff --git a/third_party/bigframes_vendored/pandas/core/config_init.py b/third_party/bigframes_vendored/pandas/core/config_init.py index 51d056a2c8..3425674e4f 100644 --- a/third_party/bigframes_vendored/pandas/core/config_init.py +++ b/third_party/bigframes_vendored/pandas/core/config_init.py @@ -84,6 +84,9 @@ memory_usage (bool): This specifies if the memory usage of a DataFrame should be displayed when df.info() is called. Valid values True,False, + precision (int): + Controls the floating point output precision, similar to + `pandas.options.display.precision`. blob_display (bool): Whether to display the blob content in notebook DataFrame preview. Default True. blob_display_width (int or None): diff --git a/third_party/bigframes_vendored/pandas/core/frame.py b/third_party/bigframes_vendored/pandas/core/frame.py index 1f79c428c1..00984935a4 100644 --- a/third_party/bigframes_vendored/pandas/core/frame.py +++ b/third_party/bigframes_vendored/pandas/core/frame.py @@ -1601,8 +1601,10 @@ def droplevel(self, level, axis: str | int = 0): def reset_index( self, + level=None, *, drop: bool = False, + inplace: bool = False, ) -> DataFrame | None: """Reset the index. @@ -1696,9 +1698,14 @@ class name speed max Args: + level (int, str, tuple, or list, default None): + Only remove the given levels from the index. Removes all levels by + default. drop (bool, default False): Do not try to insert index into dataframe columns. This resets the index to the default integer index. + inplace (bool, default False): + Whether to modify the DataFrame rather than creating a new one. Returns: bigframes.pandas.DataFrame: DataFrame with the new index. @@ -5972,22 +5979,18 @@ def melt(self, id_vars, value_vars, var_name, value_name): Using `melt` without optional arguments: >>> df.melt() - variable value - 0 A 1.0 - 1 A - 2 A 3.0 - 3 A 4.0 - 4 A 5.0 - 5 B 1.0 - 6 B 2.0 - 7 B 3.0 - 8 B 4.0 - 9 B 5.0 - 10 C - 11 C 3.5 - 12 C - 13 C 4.5 - 14 C 5.0 + variable value + 0 A 1.0 + 1 A + 2 A 3.0 + 3 A 4.0 + 4 A 5.0 + 5 B 1.0 + 6 B 2.0 + 7 B 3.0 + 8 B 4.0 + 9 B 5.0 + ... [15 rows x 2 columns] diff --git a/third_party/bigframes_vendored/pandas/core/series.py b/third_party/bigframes_vendored/pandas/core/series.py index 0160a7eb50..7b420cf6e3 100644 --- a/third_party/bigframes_vendored/pandas/core/series.py +++ b/third_party/bigframes_vendored/pandas/core/series.py @@ -321,9 +321,11 @@ def transpose(self) -> Series: def reset_index( self, + level=None, *, drop: bool = False, name=pd_ext.no_default, + inplace: bool = False, ) -> DataFrame | Series | None: """ Generate a new DataFrame or Series with the index reset. @@ -399,6 +401,9 @@ def reset_index( [4 rows x 3 columns] Args: + level (int, str, tuple, or list, default optional): + For a Series with a MultiIndex, only remove the specified levels + from the index. Removes all levels by default. drop (bool, default False): Just reset the index, without inserting it as a column in the new DataFrame. @@ -406,6 +411,8 @@ def reset_index( The name to use for the column containing the original Series values. Uses ``self.name`` by default. This argument is ignored when `drop` is True. + inplace (bool, default False): + Modify the Series in place (do not create a new object). Returns: bigframes.pandas.Series or bigframes.pandas.DataFrame or None: diff --git a/third_party/bigframes_vendored/version.py b/third_party/bigframes_vendored/version.py index 7aff17a40d..6b84e2eb1d 100644 --- a/third_party/bigframes_vendored/version.py +++ b/third_party/bigframes_vendored/version.py @@ -12,8 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "2.15.0" +__version__ = "2.16.0" # {x-release-please-start-date} -__release_date__ = "2025-08-11" +__release_date__ = "2025-08-20" # {x-release-please-end}