fix: add warnings for duplicated or conflicting type hints in bigframes function

Author: jialuoo

bigframes/exceptions.py

@@ -41,6 +41,10 @@ class PreviewWarning(Warning):
     """The feature is in preview."""
 
 
+class FunctionRedundantTypeHintWarning(UserWarning):
+    """Redundant or conflicting type hints in a BigFrames function."""
+
+
 class NullIndexPreviewWarning(PreviewWarning):
     """Unused. Kept for backwards compatibility.
 

bigframes/functions/_function_session.py

@@ -534,6 +534,11 @@ def wrapper(func):
                 **signature_kwargs,
             )
             if input_types is not None:
+                if _utils.has_input_type(py_sig):
+                    msg = bfe.format_message(
+                        "Redundant or conflicting input types detected, using the one from the decorator."
+                    )
+                    warnings.warn(msg, category=bfe.FunctionRedundantTypeHintWarning)
                 if not isinstance(input_types, collections.abc.Sequence):
                     input_types = [input_types]
                 py_sig = py_sig.replace(
@@ -543,6 +548,11 @@ def wrapper(func):
                     ]
                 )
             if output_type:
+                if _utils.has_output_type(py_sig):
+                    msg = bfe.format_message(
+                        "Redundant or conflicting return type detected, using the one from the decorator."
+                    )
+                    warnings.warn(msg, category=bfe.FunctionRedundantTypeHintWarning)
                 py_sig = py_sig.replace(return_annotation=output_type)
 
             # Try to get input types via type annotations.
@@ -836,6 +846,11 @@ def wrapper(func):
                 **signature_kwargs,
             )
             if input_types is not None:
+                if _utils.has_input_type(py_sig):
+                    msg = bfe.format_message(
+                        "Redundant or conflicting input types detected, using the one from the decorator."
+                    )
+                    warnings.warn(msg, category=bfe.FunctionRedundantTypeHintWarning)
                 if not isinstance(input_types, collections.abc.Sequence):
                     input_types = [input_types]
                 py_sig = py_sig.replace(
@@ -845,6 +860,11 @@ def wrapper(func):
                     ]
                 )
             if output_type:
+                if _utils.has_output_type(py_sig):
+                    msg = bfe.format_message(
+                        "Redundant or conflicting return type detected, using the one from the decorator."
+                    )
+                    warnings.warn(msg, category=bfe.FunctionRedundantTypeHintWarning)
                 py_sig = py_sig.replace(return_annotation=output_type)
 
             udf_sig = udf_def.UdfSignature.from_py_signature(py_sig)

bigframes/functions/_utils.py

@@ -14,6 +14,7 @@
 
 
 import hashlib
+import inspect
 import json
 import sys
 import typing
@@ -269,3 +270,16 @@ def post_process(input):
         return bbq.json_extract_string_array(input, value_dtype=result_dtype)
 
     return post_process
+
+
+def has_input_type(signature: inspect.Signature) -> bool:
+    """Checks if any parameter in the signature has a type annotation."""
+    for param in signature.parameters.values():
+        if param.annotation is not inspect.Parameter.empty:
+            return True
+    return False
+
+
+def has_output_type(signature: inspect.Signature) -> bool:
+    """Checks if the signature has a return type annotation."""
+    return signature.return_annotation is not inspect.Parameter.empty

tests/system/large/functions/test_managed_function.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import warnings
+
 import google.api_core.exceptions
 import pandas
 import pyarrow
@@ -31,12 +33,21 @@
 def test_managed_function_array_output(session, scalars_dfs, dataset_id):
     try:
 
-        @session.udf(
-            dataset=dataset_id,
-            name=prefixer.create_prefix(),
+        with warnings.catch_warnings(record=True) as record:
+
+            @session.udf(
+                dataset=dataset_id,
+                name=prefixer.create_prefix(),
+            )
+            def featurize(x: int) -> list[float]:
+                return [float(i) for i in [x, x + 1, x + 2]]
+
+        input_type_warning = "Redundant or conflicting input types detected."
+        return_type_warning = "Redundant or conflicting return type detected"
+        assert not any(input_type_warning in str(warning.message) for warning in record)
+        assert not any(
+            return_type_warning in str(warning.message) for warning in record
         )
-        def featurize(x: int) -> list[float]:
-            return [float(i) for i in [x, x + 1, x + 2]]
 
         scalars_df, scalars_pandas_df = scalars_dfs
 
@@ -222,7 +233,10 @@ def add(x: int, y: int) -> int:
 def test_managed_function_series_combine_array_output(session, dataset_id, scalars_dfs):
     try:
 
-        def add_list(x: int, y: int) -> list[int]:
+        # The type hints in this function's signature are redundant. The
+        # `input_types` and `output_type` arguments from udf decorator take
+        # precedence and will be used instead.
+        def add_list(x, y: bool) -> list[bool]:
             return [x, y]
 
         scalars_df, scalars_pandas_df = scalars_dfs
@@ -234,9 +248,18 @@ def add_list(x: int, y: int) -> list[int]:
         # Make sure there are NA values in the test column.
         assert any([pandas.isna(val) for val in bf_df[int_col_name_with_nulls]])
 
-        add_list_managed_func = session.udf(
-            dataset=dataset_id, name=prefixer.create_prefix()
-        )(add_list)
+        with warnings.catch_warnings(record=True) as record:
+            add_list_managed_func = session.udf(
+                input_types=[int, int],
+                output_type=list[int],
+                dataset=dataset_id,
+                name=prefixer.create_prefix(),
+            )(add_list)
+
+        input_type_warning = "Redundant or conflicting input types detected"
+        assert any(input_type_warning in str(warning.message) for warning in record)
+        return_type_warning = "Redundant or conflicting return type detected"
+        assert any(return_type_warning in str(warning.message) for warning in record)
 
         # After filtering out nulls the managed function application should work
         # similar to pandas.

tests/system/large/functions/test_remote_function.py

@@ -843,22 +843,31 @@ def test_remote_function_with_external_package_dependencies(
 ):
     try:
 
-        def pd_np_foo(x):
+        # The return type hint in this function's signature is redundant. The
+        # `output_type` argument from remote_function decorator takes precedence
+        # and will be used instead.
+        def pd_np_foo(x) -> None:
             import numpy as mynp
             import pandas as mypd
 
             return mypd.Series([x, mynp.sqrt(mynp.abs(x))]).sum()
 
-        # Create the remote function with the name provided explicitly
-        pd_np_foo_remote = session.remote_function(
-            input_types=[int],
-            output_type=float,
-            dataset=dataset_id,
-            bigquery_connection=bq_cf_connection,
-            reuse=False,
-            packages=["numpy", "pandas >= 2.0.0"],
-            cloud_function_service_account="default",
-        )(pd_np_foo)
+        with warnings.catch_warnings(record=True) as record:
+            # Create the remote function with the name provided explicitly
+            pd_np_foo_remote = session.remote_function(
+                input_types=[int],
+                output_type=float,
+                dataset=dataset_id,
+                bigquery_connection=bq_cf_connection,
+                reuse=False,
+                packages=["numpy", "pandas >= 2.0.0"],
+                cloud_function_service_account="default",
+            )(pd_np_foo)
+
+        input_type_warning = "Redundant or conflicting input types detected"
+        assert not any(input_type_warning in str(warning.message) for warning in record)
+        return_type_warning = "Redundant or conflicting return type detected"
+        assert any(return_type_warning in str(warning.message) for warning in record)
 
         # The behavior of the created remote function should be as expected
         scalars_df, scalars_pandas_df = scalars_dfs
@@ -1999,10 +2008,24 @@ def test_remote_function_unnamed_removed_w_session_cleanup():
     # create a clean session
     session = bigframes.connect()
 
-    # create an unnamed remote function in the session
-    @session.remote_function(reuse=False, cloud_function_service_account="default")
-    def foo(x: int) -> int:
-        return x + 1
+    with warnings.catch_warnings(record=True) as record:
+        # create an unnamed remote function in the session.
+        # The type hints in this function's signature are redundant. The
+        # `input_types` and `output_type` arguments from remote_function
+        # decorator take precedence and will be used instead.
+        @session.remote_function(
+            input_types=[int],
+            output_type=int,
+            reuse=False,
+            cloud_function_service_account="default",
+        )
+        def foo(x: int) -> int:
+            return x + 1
+
+    input_type_warning = "Redundant or conflicting input types detected"
+    assert any(input_type_warning in str(warning.message) for warning in record)
+    return_type_warning = "Redundant or conflicting return type detected"
+    assert any(return_type_warning in str(warning.message) for warning in record)
 
     # ensure that remote function artifacts are created
     assert foo.bigframes_remote_function is not None