bigframes 2.47.0__tar.gz → 2.48.0__tar.gz

{bigframes-2.47.0/bigframes.egg-info → bigframes-2.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bigframes
-Version: 2.47.0
+Version: 2.48.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.47.0 → bigframes-2.48.0}/bigframes/core/bytecode.py

@@ -87,18 +87,26 @@ _JUMP_IF_TRUE_OPNAMES = {
     "POP_JUMP_BACKWARD_IF_TRUE",
 }
 
+_JUMP_IF_NONE_OPNAMES = {
+    "POP_JUMP_IF_NONE",
+    "POP_JUMP_FORWARD_IF_NONE",
+    "POP_JUMP_BACKWARD_IF_NONE",
+}
+
+_JUMP_IF_NOT_NONE_OPNAMES = {
+    "POP_JUMP_IF_NOT_NONE",
+    "POP_JUMP_FORWARD_IF_NOT_NONE",
+    "POP_JUMP_BACKWARD_IF_NOT_NONE",
+}
+
 _CONDITIONAL_JUMP_OPNAMES = (
     _JUMP_IF_FALSE_OPNAMES
     | _JUMP_IF_TRUE_OPNAMES
+    | _JUMP_IF_NONE_OPNAMES
+    | _JUMP_IF_NOT_NONE_OPNAMES
     | {
         "JUMP_IF_FALSE_OR_POP",
         "JUMP_IF_TRUE_OR_POP",
-        "POP_JUMP_IF_NONE",
-        "POP_JUMP_IF_NOT_NONE",
-        "POP_JUMP_FORWARD_IF_NONE",
-        "POP_JUMP_FORWARD_IF_NOT_NONE",
-        "POP_JUMP_BACKWARD_IF_NONE",
-        "POP_JUMP_BACKWARD_IF_NOT_NONE",
     }
 )
 
@@ -424,7 +432,10 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                         and (inst.arg & 1)
                     )
                     if is_method_lookup:
-                        if isinstance(target, py_exprs.Module):
+                        if isinstance(target, py_exprs.Module) or (
+                            isinstance(target, py_exprs.PyObject)
+                            and isinstance(target.value, type)
+                        ):
                             stack.append(_NULL)
                         else:
                             stack.append(target)
@@ -443,6 +454,66 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                         )
                     )
 
+                case "FORMAT_SIMPLE":
+                    if not stack:
+                        raise ValueError("Stack is empty")
+                    value = stack.pop()
+                    stack.append(py_exprs.Call(py_exprs.PyObject(str), (value,)))
+
+                case "CONVERT_VALUE":
+                    flags = inst.arg
+                    assert flags is not None
+                    value = stack.pop()
+                    if flags == 1:
+                        stack.append(py_exprs.Call(py_exprs.PyObject(str), (value,)))
+                    else:
+                        raise NotImplementedError(
+                            "repr() and ascii() conversions are not supported"
+                        )
+
+                case "FORMAT_VALUE":
+                    flags = inst.arg
+                    assert flags is not None
+                    if (flags & 0x04) == 0x04:
+                        stack.pop()
+                        raise NotImplementedError(
+                            "Formatting with specifier is not supported"
+                        )
+
+                    value = stack.pop()
+                    conversion = flags & 0x03
+                    if conversion == 0 or conversion == 1:
+                        stack.append(py_exprs.Call(py_exprs.PyObject(str), (value,)))
+                    else:
+                        raise NotImplementedError(
+                            "repr() and ascii() conversions are not supported"
+                        )
+
+                case "FORMAT_WITH_SPEC":
+                    raise NotImplementedError(
+                        "Formatting with specifier is not supported"
+                    )
+
+                case "BUILD_STRING":
+                    count = inst.arg
+                    assert count is not None
+                    if len(stack) < count:
+                        raise ValueError(
+                            "Stack has fewer elements than BUILD_STRING count"
+                        )
+
+                    if count == 0:
+                        stack.append(py_exprs.PyObject(""))
+                    else:
+                        strings = [stack.pop() for _ in range(count)][::-1]
+                        result = strings[0]
+                        for s in strings[1:]:
+                            result = py_exprs.Call(
+                                py_exprs.PyObject(operator.add),
+                                (result, s),
+                            )
+                        stack.append(result)
+
                 case "COPY":
                     idx = inst.arg
                     if idx is None or idx < 1 or len(stack) < idx:
@@ -533,6 +604,42 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                         )
                     )
 
+                case "IS_OP":
+                    if len(stack) < 2:
+                        raise ValueError("Stack has < 2 elements")
+                    right = stack.pop()
+                    left = stack.pop()
+                    invert = inst.arg
+
+                    def is_none_const(expr) -> bool:
+                        if isinstance(expr, py_exprs.PyObject) and expr.value is None:
+                            return True
+                        if (
+                            isinstance(expr, expression.ScalarConstantExpression)
+                            and expr.value is None
+                        ):
+                            return True
+                        return False
+
+                    if is_none_const(right):
+                        op = (
+                            generic_ops.isnull_op
+                            if not invert
+                            else generic_ops.notnull_op
+                        )
+                        stack.append(py_exprs.Call(py_exprs.PyObject(op), (left,)))
+                    elif is_none_const(left):
+                        op = (
+                            generic_ops.isnull_op
+                            if not invert
+                            else generic_ops.notnull_op
+                        )
+                        stack.append(py_exprs.Call(py_exprs.PyObject(op), (right,)))
+                    else:
+                        raise NotImplementedError(
+                            "Identity comparison (is/is not) is only supported for None"
+                        )
+
                 case "COMPARE_OP":
                     if len(stack) < 2:
                         raise ValueError("Stack has < 2 elements")
@@ -728,6 +835,53 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                     jumped = True
                     break
 
+                case name if (
+                    name in _JUMP_IF_NONE_OPNAMES or name in _JUMP_IF_NOT_NONE_OPNAMES
+                ):
+                    if not stack:
+                        raise ValueError("Stack is empty")
+                    cond_expr = stack.pop()
+                    cond_bool = py_exprs.Call(
+                        py_exprs.PyObject(generic_ops.isnull_op),
+                        (cond_expr,),
+                    )
+
+                    dest = inst.argval
+                    next_offset = next_offsets.get(inst.offset)
+
+                    if opname in _JUMP_IF_NONE_OPNAMES:
+                        not_cond_bool = py_exprs.Call(
+                            py_exprs.PyObject(operator.not_), (cond_bool,)
+                        )
+                        edge_conditions[(offset, dest)] = py_exprs.Call(
+                            py_exprs.PyObject(operator.and_),
+                            (reach_cond, cond_bool),
+                        )
+                        edge_stacks[(offset, dest)] = stack.copy()
+                        if next_offset is not None:
+                            edge_conditions[(offset, next_offset)] = py_exprs.Call(
+                                py_exprs.PyObject(operator.and_),
+                                (reach_cond, not_cond_bool),
+                            )
+                            edge_stacks[(offset, next_offset)] = stack.copy()
+                    else:  # opname in _JUMP_IF_NOT_NONE_OPNAMES
+                        not_cond_bool = py_exprs.Call(
+                            py_exprs.PyObject(operator.not_), (cond_bool,)
+                        )
+                        edge_conditions[(offset, dest)] = py_exprs.Call(
+                            py_exprs.PyObject(operator.and_),
+                            (reach_cond, not_cond_bool),
+                        )
+                        edge_stacks[(offset, dest)] = stack.copy()
+                        if next_offset is not None:
+                            edge_conditions[(offset, next_offset)] = py_exprs.Call(
+                                py_exprs.PyObject(operator.and_),
+                                (reach_cond, cond_bool),
+                            )
+                            edge_stacks[(offset, next_offset)] = stack.copy()
+                    jumped = True
+                    break
+
                 case name if name in _ALL_JUMP_OPNAMES:
                     raise ValueError(f"Unsupported jump opcode: {opname}")
 

{bigframes-2.47.0 → bigframes-2.48.0}/bigframes/core/compile/polars/compiler.py

@@ -454,6 +454,54 @@ if polars_installed:
             else:
                 return pl.any_horizontal(*(input.str.ends_with(pat) for pat in op.pat))
 
+        @compile_op.register(string_ops.CapitalizeOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.CapitalizeOp)
+            return (
+                input.str.slice(0, 1).str.to_uppercase()
+                + input.str.slice(1).str.to_lowercase()
+            )
+
+        @compile_op.register(string_ops.IsAlnumOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsAlnumOp)
+            return input.str.contains(r"^[a-zA-Z0-9]+$")
+
+        @compile_op.register(string_ops.IsAlphaOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsAlphaOp)
+            return input.str.contains(r"^[a-zA-Z]+$")
+
+        @compile_op.register(string_ops.IsDigitOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsDigitOp)
+            return input.str.contains(r"^[0-9]+$")
+
+        @compile_op.register(string_ops.IsSpaceOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsSpaceOp)
+            return input.str.contains(r"^\s+$")
+
+        @compile_op.register(string_ops.IsDecimalOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsDecimalOp)
+            return input.str.contains(r"^[0-9]+$")
+
+        @compile_op.register(string_ops.IsNumericOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsNumericOp)
+            return input.str.contains(r"^[0-9]+$")
+
+        @compile_op.register(string_ops.IsLowerOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsLowerOp)
+            return input.str.contains(r"[a-z]") & ~input.str.contains(r"[A-Z]")
+
+        @compile_op.register(string_ops.IsUpperOp)
+        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+            assert isinstance(op, string_ops.IsUpperOp)
+            return input.str.contains(r"[A-Z]") & ~input.str.contains(r"[a-z]")
+
         @compile_op.register(freq_ops.FloorDtOp)
         def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
             assert isinstance(op, freq_ops.FloorDtOp)

{bigframes-2.47.0 → bigframes-2.48.0}/bigframes/core/logging/log_adapter.py

@@ -172,14 +172,14 @@ def method_logger(method=None, /, *, custom_base_name: Optional[str] = None):
                 base_name = custom_base_name
 
             full_method_name = f"{base_name.lower()}-{api_method_name}"
-            # Track directly called methods
-            if len(_call_stack) == 0:
-                session = _find_session(*args, **kwargs)
-                add_api_method(full_method_name, session=session)
-
             _call_stack.append(full_method_name)
 
             try:
+                # Track directly called methods
+                if len(_call_stack) == 1:
+                    session = _find_session(*args, **kwargs)
+                    add_api_method(full_method_name, session=session)
+
                 return method(*args, **kwargs)
             except (NotImplementedError, TypeError) as e:
                 # Log method parameters that are implemented in pandas but either missing (TypeError)
@@ -220,12 +220,12 @@ def property_logger(prop):
             property_name = prop.__name__
             full_property_name = f"{class_name.lower()}-{property_name.lower()}"
 
-            if len(_call_stack) == 0:
-                session = _find_session(*args, **kwargs)
-                add_api_method(full_property_name, session=session)
-
             _call_stack.append(full_property_name)
             try:
+                if len(_call_stack) == 1:
+                    session = _find_session(*args, **kwargs)
+                    add_api_method(full_property_name, session=session)
+
                 return prop(*args, **kwargs)
             finally:
                 _call_stack.pop()
@@ -309,7 +309,9 @@ def _is_session_initialized(session):
     Because the method logger could get called before Session.__init__ has a
     chance to run, we use the globals in that case.
     """
-    return hasattr(session, "_api_methods_lock") and hasattr(session, "_api_methods")
+    return hasattr(session, "_api_methods_lock") and isinstance(
+        getattr(session, "_api_methods", None), list
+    )
 
 
 def _find_session(*args, **kwargs):
@@ -317,13 +319,13 @@ def _find_session(*args, **kwargs):
     # imports log_adapter.
     from bigframes.session import Session
 
-    session = args[0] if args else None
-    if (
-        session is not None
-        and isinstance(session, Session)
-        and _is_session_initialized(session)
-    ):
-        return session
+    for arg in args:
+        if isinstance(arg, Session) and _is_session_initialized(arg):
+            return arg
+        if hasattr(arg, "__dict__") and "_block" in arg.__dict__:
+            session = getattr(arg, "_session", None)
+            if isinstance(session, Session) and _is_session_initialized(session):
+                return session
 
     session = kwargs.get("session")
     if (

{bigframes-2.47.0 → bigframes-2.48.0}/bigframes/core/py_expressions.py

@@ -547,6 +547,13 @@ def resolve_call(
             if fn in _CALLABLE_TO_OP:
                 op = _CALLABLE_TO_OP[fn]
                 return OpExpression(op, call.inputs)
+        elif isinstance(callable.input, PyObject) and isinstance(
+            callable.input.value, type
+        ):
+            fn = getattr(callable.input.value, attr, None)
+            if fn in python_op_maps.PYTHON_TO_BIGFRAMES:
+                op = python_op_maps.PYTHON_TO_BIGFRAMES[fn]
+                return OpExpression(op, call.inputs)
         else:
             # Method call on an expression (e.g. df.col.sum() or s.mean())
             try:

{bigframes-2.47.0 → bigframes-2.48.0}/bigframes/dataframe.py

@@ -753,7 +753,7 @@ class DataFrame:
         # https://github.com/googleapis/python-bigquery-dataframes/issues/728
         # and
         # https://nedbatchelder.com/blog/201010/surprising_getattr_recursion.html
-        if key == "_block":
+        if "_block" not in self.__dict__ or key == "_block":
             raise AttributeError(key)
 
         if key in self._block.column_labels: