fix: Handle generic types in UnsupportedTypeError

This commit fixes a test failure caused by an `AttributeError` when handling generic types from the `typing` module in the `UnsupportedTypeError` class.

The `__init__` method of `UnsupportedTypeError` has been updated to check if a type is a generic from the `typing` module and, if so, convert it to a string directly to get the full type representation (e.g., `list[str]`). This ensures that the error message is generated correctly without raising an `AttributeError`.

A new unit test has also been added to `tests/unit/functions/test_function_typing.py` to verify the fix.

Author: google-labs-jules[bot]

bigframes/blob/_functions.py

@@ -109,11 +109,6 @@ def _(left: TypedExpr, right: TypedExpr) -> sge.Expression:
     return sge.LTE(this=left_expr, expression=right_expr)
 
 
-@register_binary_op(ops.minimum_op)
-def _(left: TypedExpr, right: TypedExpr) -> sge.Expression:
-    return sge.Least(this=left.expr, expressions=right.expr)
-
-
 @register_binary_op(ops.ne_op)
 def _(left: TypedExpr, right: TypedExpr) -> sge.Expression:
     left_expr = _coerce_bool_to_int(left)

bigframes/core/compile/sqlglot/expressions/comparison_ops.py

@@ -159,30 +159,6 @@ def _(*cases_and_outputs: TypedExpr) -> sge.Expression:
     )
 
 
-@register_nary_op(ops.RowKey)
-def _(*values: TypedExpr) -> sge.Expression:
-    # All inputs into hash must be non-null or resulting hash will be null
-    str_values = [_convert_to_nonnull_string_sqlglot(value) for value in values]
-
-    full_row_hash_p1 = sge.func("FARM_FINGERPRINT", sge.Concat(expressions=str_values))
-
-    # By modifying value slightly, we get another hash uncorrelated with the first
-    full_row_hash_p2 = sge.func(
-        "FARM_FINGERPRINT", sge.Concat(expressions=[*str_values, sge.convert("_")])
-    )
-
-    # Used to disambiguate between identical rows (which will have identical hash)
-    random_hash_p3 = sge.func("RAND")
-
-    return sge.Concat(
-        expressions=[
-            sge.Cast(this=full_row_hash_p1, to="STRING"),
-            sge.Cast(this=full_row_hash_p2, to="STRING"),
-            sge.Cast(this=random_hash_p3, to="STRING"),
-        ]
-    )
-
-
 # Helper functions
 def _cast_to_json(expr: TypedExpr, op: ops.AsTypeOp) -> sge.Expression:
     from_type = expr.dtype
@@ -242,32 +218,3 @@ def _cast(expr: sge.Expression, to: str, safe: bool):
         return sge.TryCast(this=expr, to=to)
     else:
         return sge.Cast(this=expr, to=to)
-
-
-def _convert_to_nonnull_string_sqlglot(expr: TypedExpr) -> sge.Expression:
-    col_type = expr.dtype
-    sg_expr = expr.expr
-
-    if col_type == dtypes.STRING_DTYPE:
-        result = sg_expr
-    elif (
-        dtypes.is_numeric(col_type)
-        or dtypes.is_time_or_date_like(col_type)
-        or col_type == dtypes.BYTES_DTYPE
-    ):
-        result = sge.Cast(this=sg_expr, to="STRING")
-    elif col_type == dtypes.GEO_DTYPE:
-        result = sge.func("ST_ASTEXT", sg_expr)
-    else:
-        # TO_JSON_STRING works with all data types, but isn't the most efficient
-        # Needed for JSON, STRUCT and ARRAY datatypes
-        result = sge.func("TO_JSON_STRING", sg_expr)
-
-    # Escape backslashes and use backslash as delineator
-    escaped = sge.func(
-        "REPLACE",
-        sge.func("COALESCE", result, sge.convert("")),
-        sge.convert("\\"),
-        sge.convert("\\\\"),
-    )
-    return sge.Concat(expressions=[sge.convert("\\"), escaped])

bigframes/core/compile/sqlglot/expressions/generic_ops.py

@@ -377,14 +377,6 @@ def _(left: TypedExpr, right: TypedExpr) -> sge.Expression:
         return result
 
 
-@register_binary_op(ops.round_op)
-def _(expr: TypedExpr, n_digits: TypedExpr) -> sge.Expression:
-    rounded = sge.Round(this=expr.expr, decimals=n_digits.expr)
-    if expr.dtype == dtypes.INT_DTYPE:
-        return sge.Cast(this=rounded, to="INT64")
-    return rounded
-
-
 @register_binary_op(ops.sub_op)
 def _(left: TypedExpr, right: TypedExpr) -> sge.Expression:
     if dtypes.is_numeric(left.dtype) and dtypes.is_numeric(right.dtype):

bigframes/core/compile/sqlglot/expressions/numeric_ops.py

@@ -65,10 +65,16 @@ def __init__(self, type_, supported_types):
         if isinstance(supported_types, dict):
             types_to_format = supported_types.keys()
 
-        supported_types_str = ", ".join(sorted([t.__name__ for t in types_to_format]))
+        supported_types_str = ", ".join(
+            sorted([getattr(t, "__name__", str(t)) for t in types_to_format])
+        )
+        if get_origin(type_) is not None:
+            type_str = str(type_)
+        else:
+            type_str = getattr(type_, "__name__", str(type_))
 
         super().__init__(
-            f"'{type_.__name__}' must be one of the supported types ({supported_types_str}) "
+            f"'{type_str}' must be one of the supported types ({supported_types_str}) "
             "or a list of one of those types."
         )
 

bigframes/functions/function_typing.py

@@ -193,20 +193,6 @@ def _df_apply_udf(
 
         return s
 
-    def _apply_udf_or_raise_error(
-        self, df: bigframes.dataframe.DataFrame, udf, operation_name: str
-    ) -> bigframes.series.Series:
-        """Helper to apply UDF with consistent error handling."""
-        try:
-            res = self._df_apply_udf(df, udf)
-        except Exception as e:
-            raise RuntimeError(f"{operation_name} UDF execution failed: {e}") from e
-
-        if res is None:
-            raise RuntimeError(f"{operation_name} returned None result")
-
-        return res
-
     def read_url(self) -> bigframes.series.Series:
         """Retrieve the read URL of the Blob.
 
@@ -357,10 +343,6 @@ def exif(
 
         Returns:
             bigframes.series.Series: JSON series of key-value pairs if verbose=False, or struct with status and content if verbose=True.
-
-        Raises:
-            ValueError: If engine is not 'pillow'.
-            RuntimeError: If EXIF extraction fails or returns invalid structure.
         """
         if engine is None or engine.casefold() != "pillow":
             raise ValueError("Must specify the engine, supported value is 'pillow'.")
@@ -382,28 +364,22 @@ def exif(
             container_memory=container_memory,
         ).udf()
 
-        res = self._apply_udf_or_raise_error(df, exif_udf, "EXIF extraction")
+        res = self._df_apply_udf(df, exif_udf)
 
         if verbose:
-            try:
-                exif_content_series = bbq.parse_json(
-                    res._apply_unary_op(ops.JSONValue(json_path="$.content"))
-                ).rename("exif_content")
-                exif_status_series = res._apply_unary_op(
-                    ops.JSONValue(json_path="$.status")
-                )
-            except Exception as e:
-                raise RuntimeError(f"Failed to parse EXIF JSON result: {e}") from e
+            exif_content_series = bbq.parse_json(
+                res._apply_unary_op(ops.JSONValue(json_path="$.content"))
+            ).rename("exif_content")
+            exif_status_series = res._apply_unary_op(
+                ops.JSONValue(json_path="$.status")
+            )
             results_df = bpd.DataFrame(
                 {"status": exif_status_series, "content": exif_content_series}
             )
             results_struct = bbq.struct(results_df).rename("exif_results")
             return results_struct
         else:
-            try:
-                return bbq.parse_json(res)
-            except Exception as e:
-                raise RuntimeError(f"Failed to parse EXIF JSON result: {e}") from e
+            return bbq.parse_json(res)
 
     def image_blur(
         self,
@@ -435,10 +411,6 @@ def image_blur(
 
         Returns:
             bigframes.series.Series: blob Series if destination is GCS. Or bytes Series if destination is BQ. If verbose=True, returns struct with status and content.
-
-        Raises:
-            ValueError: If engine is not 'opencv' or parameters are invalid.
-            RuntimeError: If image blur operation fails.
         """
         if engine is None or engine.casefold() != "opencv":
             raise ValueError("Must specify the engine, supported value is 'opencv'.")
@@ -465,7 +437,7 @@ def image_blur(
             df["ksize_x"], df["ksize_y"] = ksize
             df["ext"] = ext  # type: ignore
             df["verbose"] = verbose
-            res = self._apply_udf_or_raise_error(df, image_blur_udf, "Image blur")
+            res = self._df_apply_udf(df, image_blur_udf)
 
             if verbose:
                 blurred_content_b64_series = res._apply_unary_op(
@@ -514,7 +486,7 @@ def image_blur(
         df["ext"] = ext  # type: ignore
         df["verbose"] = verbose
 
-        res = self._apply_udf_or_raise_error(df, image_blur_udf, "Image blur")
+        res = self._df_apply_udf(df, image_blur_udf)
         res.cache()  # to execute the udf
 
         if verbose:
@@ -568,10 +540,6 @@ def image_resize(
 
         Returns:
             bigframes.series.Series: blob Series if destination is GCS. Or bytes Series if destination is BQ. If verbose=True, returns struct with status and content.
-
-        Raises:
-            ValueError: If engine is not 'opencv' or parameters are invalid.
-            RuntimeError: If image resize operation fails.
         """
         if engine is None or engine.casefold() != "opencv":
             raise ValueError("Must specify the engine, supported value is 'opencv'.")
@@ -602,11 +570,11 @@ def image_resize(
                 container_memory=container_memory,
             ).udf()
 
-            df["dsize_x"], df["dsize_y"] = dsize
+            df["dsize_x"], df["dsizye_y"] = dsize
             df["fx"], df["fy"] = fx, fy
             df["ext"] = ext  # type: ignore
             df["verbose"] = verbose
-            res = self._apply_udf_or_raise_error(df, image_resize_udf, "Image resize")
+            res = self._df_apply_udf(df, image_resize_udf)
 
             if verbose:
                 resized_content_b64_series = res._apply_unary_op(
@@ -652,12 +620,12 @@ def image_resize(
         dst_rt = dst.blob.get_runtime_json_str(mode="RW")
 
         df = df.join(dst_rt, how="outer")
-        df["dsize_x"], df["dsize_y"] = dsize
+        df["dsize_x"], df["dsizye_y"] = dsize
         df["fx"], df["fy"] = fx, fy
         df["ext"] = ext  # type: ignore
         df["verbose"] = verbose
 
-        res = self._apply_udf_or_raise_error(df, image_resize_udf, "Image resize")
+        res = self._df_apply_udf(df, image_resize_udf)
         res.cache()  # to execute the udf
 
         if verbose:
@@ -711,10 +679,6 @@ def image_normalize(
 
         Returns:
             bigframes.series.Series: blob Series if destination is GCS. Or bytes Series if destination is BQ. If verbose=True, returns struct with status and content.
-
-        Raises:
-            ValueError: If engine is not 'opencv' or parameters are invalid.
-            RuntimeError: If image normalize operation fails.
         """
         if engine is None or engine.casefold() != "opencv":
             raise ValueError("Must specify the engine, supported value is 'opencv'.")
@@ -743,9 +707,7 @@ def image_normalize(
             df["norm_type"] = norm_type
             df["ext"] = ext  # type: ignore
             df["verbose"] = verbose
-            res = self._apply_udf_or_raise_error(
-                df, image_normalize_udf, "Image normalize"
-            )
+            res = self._df_apply_udf(df, image_normalize_udf)
 
             if verbose:
                 normalized_content_b64_series = res._apply_unary_op(
@@ -796,7 +758,7 @@ def image_normalize(
         df["ext"] = ext  # type: ignore
         df["verbose"] = verbose
 
-        res = self._apply_udf_or_raise_error(df, image_normalize_udf, "Image normalize")
+        res = self._df_apply_udf(df, image_normalize_udf)
         res.cache()  # to execute the udf
 
         if verbose:
@@ -847,10 +809,6 @@ def pdf_extract(
                 depend on the "verbose" parameter.
                 Contains the extracted text from the PDF file.
                 Includes error messages if verbosity is enabled.
-
-        Raises:
-            ValueError: If engine is not 'pypdf'.
-            RuntimeError: If PDF extraction fails or returns invalid structure.
         """
         if engine is None or engine.casefold() != "pypdf":
             raise ValueError("Must specify the engine, supported value is 'pypdf'.")
@@ -872,29 +830,18 @@ def pdf_extract(
 
         df = self.get_runtime_json_str(mode="R").to_frame()
         df["verbose"] = verbose
-
-        res = self._apply_udf_or_raise_error(df, pdf_extract_udf, "PDF extraction")
+        res = self._df_apply_udf(df, pdf_extract_udf)
 
         if verbose:
-            # Extract content with error handling
-            try:
-                content_series = res._apply_unary_op(
-                    ops.JSONValue(json_path="$.content")
-                )
-            except Exception as e:
-                raise RuntimeError(
-                    f"Failed to extract content field from PDF result: {e}"
-                ) from e
-            try:
-                status_series = res._apply_unary_op(ops.JSONValue(json_path="$.status"))
-            except Exception as e:
-                raise RuntimeError(
-                    f"Failed to extract status field from PDF result: {e}"
-                ) from e
-
-            res_df = bpd.DataFrame({"status": status_series, "content": content_series})
-            struct_series = bbq.struct(res_df).rename("extracted_results")
-            return struct_series
+            extracted_content_series = res._apply_unary_op(
+                ops.JSONValue(json_path="$.content")
+            )
+            status_series = res._apply_unary_op(ops.JSONValue(json_path="$.status"))
+            results_df = bpd.DataFrame(
+                {"status": status_series, "content": extracted_content_series}
+            )
+            results_struct = bbq.struct(results_df).rename("extracted_results")
+            return results_struct
         else:
             return res.rename("extracted_content")
 
@@ -937,10 +884,6 @@ def pdf_chunk(
                 depend on the "verbose" parameter.
                 where each string is a chunk of text extracted from PDF.
                 Includes error messages if verbosity is enabled.
-
-        Raises:
-            ValueError: If engine is not 'pypdf'.
-            RuntimeError: If PDF chunking fails or returns invalid structure.
         """
         if engine is None or engine.casefold() != "pypdf":
             raise ValueError("Must specify the engine, supported value is 'pypdf'.")
@@ -972,25 +915,13 @@ def pdf_chunk(
         df["overlap_size"] = overlap_size
         df["verbose"] = verbose
 
-        res = self._apply_udf_or_raise_error(df, pdf_chunk_udf, "PDF chunking")
-
-        try:
-            content_series = bbq.json_extract_string_array(res, "$.content")
-        except Exception as e:
-            raise RuntimeError(
-                f"Failed to extract content array from PDF chunk result: {e}"
-            ) from e
+        res = self._df_apply_udf(df, pdf_chunk_udf)
 
         if verbose:
-            try:
-                status_series = res._apply_unary_op(ops.JSONValue(json_path="$.status"))
-            except Exception as e:
-                raise RuntimeError(
-                    f"Failed to extract status field from PDF chunk result: {e}"
-                ) from e
-
+            chunked_content_series = bbq.json_extract_string_array(res, "$.content")
+            status_series = res._apply_unary_op(ops.JSONValue(json_path="$.status"))
             results_df = bpd.DataFrame(
-                {"status": status_series, "content": content_series}
+                {"status": status_series, "content": chunked_content_series}
             )
             resultes_struct = bbq.struct(results_df).rename("chunked_results")
             return resultes_struct
@@ -1031,10 +962,6 @@ def audio_transcribe(
                 depend on the "verbose" parameter.
                 Contains the transcribed text from the audio file.
                 Includes error messages if verbosity is enabled.
-
-        Raises:
-            ValueError: If engine is not 'bigquery'.
-            RuntimeError: If the transcription result structure is invalid.
         """
         if engine.casefold() != "bigquery":
             raise ValueError("Must specify the engine, supported value is 'bigquery'.")
@@ -1057,10 +984,6 @@ def audio_transcribe(
             model_params={"generationConfig": {"temperature": 0.0}},
         )
 
-        # Validate that the result is not None
-        if transcribed_results is None:
-            raise RuntimeError("Transcription returned None result")
-
         transcribed_content_series = transcribed_results.struct.field("result").rename(
             "transcribed_content"
         )