bigframes 2.43.0__tar.gz → 2.44.0__tar.gz

{bigframes-2.43.0/bigframes.egg-info → bigframes-2.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bigframes
-Version: 2.43.0
+Version: 2.44.0
 Summary: BigQuery DataFrames -- scalable analytics and machine learning with BigQuery
 Home-page: https://dataframes.bigquery.dev
 Download-URL: https://github.com/googleapis/google-cloud-python/tree/main/packages/bigframes/releases

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/_config/experiment_options.py

@@ -28,6 +28,7 @@ class ExperimentOptions:
         self._semantic_operators: bool = False
         self._ai_operators: bool = False
         self._sql_compiler: Literal["legacy", "stable", "experimental"] = "stable"
+        self._enable_python_transpiler: bool = False
 
     @property
     def semantic_operators(self) -> bool:
@@ -166,3 +167,17 @@ class ExperimentOptions:
         warnings.warn(msg, category=bfe.ApiDeprecationWarning)
 
         bigframes.options.display.blob_display_height = value
+
+    @property
+    def enable_python_transpiler(self) -> bool:
+        return self._enable_python_transpiler
+
+    @enable_python_transpiler.setter
+    def enable_python_transpiler(self, value: bool):
+        if value:
+            msg = bfe.format_message(
+                "Python transpiler is an unstable, experimental feature, and not yet fully "
+                "validated, use at your own risk."
+            )
+            warnings.warn(msg, category=bfe.PythonTranspilerPreviewWarning)
+        self._enable_python_transpiler = value

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/_tools/docs.py

@@ -34,6 +34,20 @@ def inherit_docs(source_class):
                         except AttributeError:
                             pass
 
+                        underlying = None
+                        if isinstance(target_item, property):
+                            underlying = target_item.fget
+                        elif hasattr(target_item, "__func__"):
+                            underlying = target_item.__func__
+                        elif hasattr(target_item, "func"):
+                            underlying = getattr(target_item, "func", None)
+
+                        if underlying is not None:
+                            try:
+                                underlying.__doc__ = source_item.__doc__
+                            except AttributeError:
+                                pass
+
         return target_class
 
     return decorator

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/bigquery/__init__.py

@@ -126,6 +126,21 @@ from bigframes.operations.googlesql.global_namespace.conversion import (
     parse_numeric,
     string,
 )
+from bigframes.operations.googlesql.global_namespace.date import (
+    current_date,
+    date,
+    date_add,
+    date_diff,
+    date_from_unix_date,
+    date_sub,
+    date_trunc,
+    extract,
+    format_date,
+    generate_date_array,
+    last_day,
+    parse_date,
+    unix_date,
+)
 
 _functions = [
     # approximate aggregate ops
@@ -156,6 +171,20 @@ _functions = [
     parse_bignumeric,
     parse_numeric,
     string,
+    # date ops
+    current_date,
+    date,
+    date_add,
+    date_diff,
+    date_from_unix_date,
+    date_sub,
+    date_trunc,
+    extract,
+    format_date,
+    generate_date_array,
+    last_day,
+    parse_date,
+    unix_date,
     # datetime ops
     unix_micros,
     unix_millis,
@@ -240,6 +269,20 @@ __all__ = [
     "parse_bignumeric",
     "parse_numeric",
     "string",
+    # date ops
+    "current_date",
+    "date",
+    "date_add",
+    "date_diff",
+    "date_from_unix_date",
+    "date_sub",
+    "date_trunc",
+    "extract",
+    "format_date",
+    "generate_date_array",
+    "last_day",
+    "parse_date",
+    "unix_date",
     # datetime ops
     "unix_micros",
     "unix_millis",

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/bigquery/_operations/ai.py

@@ -87,7 +87,7 @@ def generate(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML selects a recent stable
             version of Gemini to use.
@@ -178,7 +178,7 @@ def generate_bool(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML selects a recent stable
             version of Gemini to use.
@@ -252,7 +252,7 @@ def generate_int(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML selects a recent stable
             version of Gemini to use.
@@ -326,7 +326,7 @@ def generate_double(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML selects a recent stable
             version of Gemini to use.
@@ -809,7 +809,7 @@ def if_(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML dynamically chooses a model based on your query to have the
             best cost to quality tradeoff for the task.
@@ -960,7 +960,7 @@ def score(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an endpoint value, BigQuery ML dynamically chooses a model
             based on your query to have the best cost to quality tradeoff for the task.

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/core/block_transforms.py

@@ -14,8 +14,9 @@
 from __future__ import annotations
 
 import functools
+import inspect
 import typing
-from typing import Optional, Sequence
+from typing import Callable, Hashable, Optional, Sequence
 
 import bigframes_vendored.constants as constants
 import pandas as pd
@@ -23,13 +24,48 @@ import pandas as pd
 import bigframes.constants
 import bigframes.core as core
 import bigframes.core.blocks as blocks
+import bigframes.core.bytecode as bytecode
 import bigframes.core.expression as ex
 import bigframes.core.ordering as ordering
 import bigframes.core.window_spec as windows
 import bigframes.dtypes as dtypes
 import bigframes.operations as ops
 import bigframes.operations.aggregations as agg_ops
-from bigframes.core import agg_expressions
+from bigframes.core import agg_expressions, py_expressions
+
+
+def apply_to_block_rows(
+    func: Callable, block: blocks.Block, *args, **kwargs
+) -> blocks.Block:
+    """
+    Apply the given function to each row of the block.
+
+    The function is applied to each row of the block, and the result is returned
+    as a new block with the same index.
+    """
+    expr = bytecode._compile_bytecode_to_py_expr(func)
+    sig = inspect.signature(func)
+
+    bindings: dict[Hashable, ex.Expression] = {}
+
+    bound_args = sig.bind(*(None, *args), **kwargs)
+    bound_args.apply_defaults()
+    bound_params = bound_args.arguments
+    for name, value in bound_params.items():
+        bindings[name] = ex.const(value)
+
+    expr = py_expressions.resolve_py_exprs(
+        expr,
+        series_arg=next(iter(sig.parameters.keys())),
+        series_attrs={
+            label: col_id
+            for label in block.column_labels
+            if (col_id := block.resolve_label_exact(label)) is not None
+        },
+    )
+    expr = expr.bind_variables(bindings)
+
+    return block.project_exprs([expr], labels=[None], drop=True)
 
 
 def equals(block1: blocks.Block, block2: blocks.Block) -> bool:

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/core/bytecode.py

@@ -249,15 +249,12 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
     raise ValueError("No return value found")
 
 
-def dis_to_expr(func: Callable, unpack_mode: bool = False) -> expression.Expression:
+def py_to_expression(func: Callable) -> expression.Expression:
     """
     Try to convert a python function to a BigQuery expression.
 
-    Unpack mode is whether SQL columns are addressed as attributes of a single
-    python argument (e.g. row.col1), or as separate arguments (e.g. col1).
-
     This is "best effort" - if the function contains operations that cannot
     be converted to BigQuery expressions, it will raise an Exception.
     """
     py_expr = _compile_bytecode_to_py_expr(func)
-    return py_exprs.resolve_py_exprs(py_expr, unpack_mode=unpack_mode)
+    return py_exprs.resolve_py_exprs(py_expr)

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/core/compile/ibis_compiler/scalar_op_registry.py

@@ -922,35 +922,6 @@ def astype_op_impl(x: ibis_types.Value, op: ops.AsTypeOp):
         elif to_type == ibis_dtypes.time:
             return x_converted.time()
 
-    if to_type == ibis_dtypes.json:
-        if x.type() == ibis_dtypes.string:
-            return parse_json_in_safe(x) if op.safe else parse_json(x)
-        if x.type() == ibis_dtypes.bool:
-            x_bool = typing.cast(
-                ibis_types.StringValue,
-                bigframes.core.compile.ibis_types.cast_ibis_value(
-                    x, ibis_dtypes.string, safe=op.safe
-                ),
-            ).lower()
-            return parse_json_in_safe(x_bool) if op.safe else parse_json(x_bool)
-        if x.type() in (ibis_dtypes.int64, ibis_dtypes.float64):
-            x_str = bigframes.core.compile.ibis_types.cast_ibis_value(
-                x, ibis_dtypes.string, safe=op.safe
-            )
-            return parse_json_in_safe(x_str) if op.safe else parse_json(x_str)
-
-    if x.type() == ibis_dtypes.json:
-        if to_type == ibis_dtypes.int64:
-            return cast_json_to_int64_in_safe(x) if op.safe else cast_json_to_int64(x)
-        if to_type == ibis_dtypes.float64:
-            return (
-                cast_json_to_float64_in_safe(x) if op.safe else cast_json_to_float64(x)
-            )
-        if to_type == ibis_dtypes.bool:
-            return cast_json_to_bool_in_safe(x) if op.safe else cast_json_to_bool(x)
-        if to_type == ibis_dtypes.string:
-            return cast_json_to_string_in_safe(x) if op.safe else cast_json_to_string(x)
-
     # TODO: either inline this function, or push rest of this op into the function
     return bigframes.core.compile.ibis_types.cast_ibis_value(x, to_type, safe=op.safe)
 
@@ -1193,9 +1164,27 @@ def parse_json_op_impl(x: ibis_types.Value, op: ops.ParseJSON):
     return parse_json(json_str=x)
 
 
-@scalar_op_compiler.register_unary_op(ops.ToJSON)
-def to_json_op_impl(json_obj: ibis_types.Value):
-    return to_json(json_obj=json_obj)
+@scalar_op_compiler.register_unary_op(ops.ToJSON, pass_op=True)
+def to_json_op_impl(x: ibis_types.Value, op: ops.ToJSON):
+    if x.type() == ibis_dtypes.string:
+        return parse_json_in_safe(x) if op.safe else parse_json(x)
+    return x.isnull().ifelse(ibis.null().cast(ibis_dtypes.json), to_json(x))
+
+
+@scalar_op_compiler.register_unary_op(ops.JSONDecode, pass_op=True)
+def json_decode_op_impl(x: ibis_types.Value, op: ops.JSONDecode):
+    to_type = bigframes.core.compile.ibis_types.bigframes_dtype_to_ibis_dtype(
+        op.to_type
+    )
+    if to_type == ibis_dtypes.int64:
+        return cast_json_to_int64_in_safe(x) if op.safe else cast_json_to_int64(x)
+    if to_type == ibis_dtypes.float64:
+        return cast_json_to_float64_in_safe(x) if op.safe else cast_json_to_float64(x)
+    if to_type == ibis_dtypes.bool:
+        return cast_json_to_bool_in_safe(x) if op.safe else cast_json_to_bool(x)
+    if to_type == ibis_dtypes.string:
+        return cast_json_to_string_in_safe(x) if op.safe else cast_json_to_string(x)
+    raise TypeError(f"Cannot cast from JSON to type {to_type}")
 
 
 @scalar_op_compiler.register_unary_op(ops.ToJSONString)

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/core/compile/polars/compiler.py

@@ -138,11 +138,20 @@ if polars_installed:
         Should be extended to dispatch based on bigframes schema types.
         """
 
-        @functools.singledispatchmethod
+        _expr_types: dict[int, bigframes.dtypes.ExpressionType] = dataclasses.field(
+            default_factory=dict, init=False, compare=False
+        )
+
         def compile_expression(self, expression: ex.Expression) -> pl.Expr:
+            res = self._compile_expression(expression)
+            self._expr_types[id(res)] = expression.output_type
+            return res
+
+        @functools.singledispatchmethod
+        def _compile_expression(self, expression: ex.Expression) -> pl.Expr:
             raise NotImplementedError(f"Cannot compile expression: {expression}")
 
-        @compile_expression.register
+        @_compile_expression.register
         def _(
             self,
             expression: ex.ScalarConstantExpression,
@@ -159,21 +168,21 @@ if polars_installed:
 
             return pl.lit(value, _bigframes_dtype_to_polars_dtype(expression.dtype))
 
-        @compile_expression.register
+        @_compile_expression.register
         def _(
             self,
             expression: ex.DerefOp,
         ) -> pl.Expr:
             return pl.col(expression.id.sql)
 
-        @compile_expression.register
+        @_compile_expression.register
         def _(
             self,
             expression: ex.ResolvedDerefOp,
         ) -> pl.Expr:
             return pl.col(expression.id.sql)
 
-        @compile_expression.register
+        @_compile_expression.register
         def _(
             self,
             expression: ex.OpExpression,
@@ -478,10 +487,21 @@ if polars_installed:
             )
 
         @compile_op.register(json_ops.JSONDecode)
-        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+        def _(self, op: json_ops.JSONDecode, input: pl.Expr) -> pl.Expr:
             assert isinstance(op, json_ops.JSONDecode)
             return input.str.json_decode(_DTYPE_MAPPING[op.to_type])
 
+        @compile_op.register(json_ops.ToJSON)
+        def _(self, op: json_ops.ToJSON, input: pl.Expr) -> pl.Expr:
+            from_type = self._expr_types.get(id(input))
+            if from_type in (
+                bigframes.dtypes.STRING_DTYPE,
+                bigframes.dtypes.JSON_DTYPE,
+            ):
+                return input
+            else:
+                return input.cast(pl.String())
+
         @compile_op.register(arr_ops.ToArrayOp)
         def _(self, op: ops.ToArrayOp, *inputs: pl.Expr) -> pl.Expr:
             return pl.concat_list(*inputs)

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/core/compile/polars/lowering.py

@@ -26,7 +26,6 @@ from bigframes.operations import (
     comparison_ops,
     datetime_ops,
     generic_ops,
-    json_ops,
     numeric_ops,
     string_ops,
 )
@@ -412,9 +411,6 @@ def _coerce_comparables(
 def _lower_cast(cast_op: ops.AsTypeOp, arg: expression.Expression):
     if arg.output_type == cast_op.to_type:
         return arg
-
-    if arg.output_type == dtypes.JSON_DTYPE:
-        return json_ops.JSONDecode(cast_op.to_type).as_expr(arg)
     if (
         arg.output_type == dtypes.STRING_DTYPE
         and cast_op.to_type == dtypes.DATETIME_DTYPE

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/core/compile/sqlglot/expressions/generic_ops.py

@@ -36,12 +36,6 @@ def _(expr: TypedExpr, op: ops.AsTypeOp) -> sge.Expression:
     sg_to_type = sqlglot_types.from_bigframes_dtype(to_type)
     sg_expr = expr.expr
 
-    if to_type == dtypes.JSON_DTYPE:
-        return _cast_to_json(expr, op)
-
-    if from_type == dtypes.JSON_DTYPE:
-        return _cast_from_json(expr, op)
-
     if to_type == dtypes.INT_DTYPE:
         result = _cast_to_int(expr, op)
         if result is not None:
@@ -251,35 +245,6 @@ def _(*values: TypedExpr) -> sge.Expression:
 
 
 # Helper functions
-def _cast_to_json(expr: TypedExpr, op: ops.AsTypeOp) -> sge.Expression:
-    from_type = expr.dtype
-    sg_expr = expr.expr
-
-    if from_type == dtypes.STRING_DTYPE:
-        func_name = "SAFE.PARSE_JSON" if op.safe else "PARSE_JSON"
-        return sge.func(func_name, sg_expr)
-    if from_type in (dtypes.INT_DTYPE, dtypes.BOOL_DTYPE, dtypes.FLOAT_DTYPE):
-        sg_expr = sge.Cast(this=sg_expr, to="STRING")
-        return sge.func("PARSE_JSON", sg_expr)
-    raise TypeError(f"Cannot cast from {from_type} to {dtypes.JSON_DTYPE}")
-
-
-def _cast_from_json(expr: TypedExpr, op: ops.AsTypeOp) -> sge.Expression:
-    to_type = op.to_type
-    sg_expr = expr.expr
-    func_name = ""
-    if to_type == dtypes.INT_DTYPE:
-        func_name = "INT64"
-    elif to_type == dtypes.FLOAT_DTYPE:
-        func_name = "FLOAT64"
-    elif to_type == dtypes.BOOL_DTYPE:
-        func_name = "BOOL"
-    elif to_type == dtypes.STRING_DTYPE:
-        func_name = "STRING"
-    if func_name:
-        func_name = "SAFE." + func_name if op.safe else func_name
-        return sge.func(func_name, sg_expr)
-    raise TypeError(f"Cannot cast from {dtypes.JSON_DTYPE} to {to_type}")
 
 
 def _cast_to_int(expr: TypedExpr, op: ops.AsTypeOp) -> sge.Expression | None:

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/core/compile/sqlglot/expressions/json_ops.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import bigframes_vendored.sqlglot.expressions as sge
 
 import bigframes.core.compile.sqlglot.expression_compiler as expression_compiler
+from bigframes import dtypes
 from bigframes import operations as ops
 from bigframes.core.compile.sqlglot.expressions.typed_expr import TypedExpr
 
@@ -69,9 +70,39 @@ def _(expr: TypedExpr) -> sge.Expression:
     return sge.func("PARSE_JSON", expr.expr)
 
 
-@register_unary_op(ops.ToJSON)
-def _(expr: TypedExpr) -> sge.Expression:
-    return sge.func("TO_JSON", expr.expr)
+@register_unary_op(ops.ToJSON, pass_op=True)
+def _(expr: TypedExpr, op: ops.ToJSON) -> sge.Expression:
+    from_type = expr.dtype
+    sg_expr = expr.expr
+
+    # Parsing really should be a distinct operation from serialization, but
+    # this was the way things were intially launched.
+    if from_type == dtypes.STRING_DTYPE:
+        func_name = "SAFE.PARSE_JSON" if op.safe else "PARSE_JSON"
+        return sge.func(func_name, sg_expr)
+    else:
+        return sge.func(
+            "IF", sg_expr.is_(sge.Null()), sge.Null(), sge.func("TO_JSON", sg_expr)
+        )
+
+
+@register_unary_op(ops.JSONDecode, pass_op=True)
+def _(expr: TypedExpr, op: ops.JSONDecode) -> sge.Expression:
+    to_type = op.to_type
+    sg_expr = expr.expr
+    func_name = ""
+    if to_type == dtypes.INT_DTYPE:
+        func_name = "INT64"
+    elif to_type == dtypes.FLOAT_DTYPE:
+        func_name = "FLOAT64"
+    elif to_type == dtypes.BOOL_DTYPE:
+        func_name = "BOOL"
+    elif to_type == dtypes.STRING_DTYPE:
+        func_name = "STRING"
+    if func_name:
+        func_name = "SAFE." + func_name if op.safe else func_name
+        return sge.func(func_name, sg_expr)
+    raise TypeError(f"Cannot cast from {dtypes.JSON_DTYPE} to {to_type}")
 
 
 @register_unary_op(ops.ToJSONString)

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/core/compile/sqlglot/sql/base.py

@@ -69,6 +69,8 @@ def literal(value: typing.Any, dtype: dtypes.Dtype | None = None) -> sge.Express
         return sge.Null()
 
     if value is None:
+        if str(sqlglot_type).upper() == "NULL":
+            return sge.Null()
         return cast(sge.Null(), sqlglot_type)
     if dtypes.is_struct_like(dtype):
         items = [

{bigframes-2.43.0 → bigframes-2.44.0}/bigframes/core/py_expressions.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import dataclasses
 import itertools
 from types import ModuleType
-from typing import Callable, Hashable, Mapping, Tuple
+from typing import Callable, Hashable, Mapping, Optional, Tuple
 
 import bigframes.operations.python_op_maps as python_op_maps
 from bigframes import dtypes
@@ -27,6 +27,7 @@ from bigframes.core.expression import (
     OpExpression,
     UnboundVariableExpression,
     const,
+    deref,
 )
 from bigframes.operations import NUMPY_TO_BINOP, NUMPY_TO_OP, generic_ops, numeric_ops
 
@@ -310,7 +311,11 @@ class Call(Expression):
 
 
 # TODO: Mode that resolves free variable attrs as columns
-def resolve_py_exprs(expression: Expression, unpack_mode: bool = False) -> Expression:
+def resolve_py_exprs(
+    expression: Expression,
+    series_arg: Optional[str] = None,
+    series_attrs: Mapping[Hashable, str] | None = None,
+) -> Expression:
     """Replace all PyObject, attribute, call expressions. Bottom-up."""
 
     def resolve_expr_if_call(expression: Expression) -> Expression:
@@ -325,10 +330,15 @@ def resolve_py_exprs(expression: Expression, unpack_mode: bool = False) -> Expre
             if isinstance(expression.input, Module):
                 # resolves things like Math.pi
                 return PyObject(getattr(expression.input.module, expression.attr))
-            if not unpack_mode and isinstance(
-                expression.input, UnboundVariableExpression
+            # TODO: Resolve some series methods
+            if (
+                series_arg is not None
+                and series_attrs is not None
+                and isinstance(expression.input, UnboundVariableExpression)
+                and expression.input.id == series_arg
+                and expression.attr in series_attrs
             ):
-                return UnboundVariableExpression(expression.attr)
+                return deref(series_attrs[expression.attr])
         return expression
 
     def resolve_pyobjs(expression: Expression) -> Expression: