only warm conflict

Author: jialuoo

bigframes/exceptions.py

@@ -41,10 +41,6 @@ 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.
 
@@ -107,6 +103,10 @@ class FunctionAxisOnePreviewWarning(PreviewWarning):
     """Remote Function and Managed UDF with axis=1 preview."""
 
 
+class FunctionConflictTypeHintWarning(UserWarning):
+    """Conflicting type hints in a BigFrames function."""
+
+
 def format_message(message: str, fill: bool = True):
     """Formats a warning message with ANSI color codes for the warning color.
 

bigframes/functions/_function_session.py

@@ -534,25 +534,25 @@ 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]
+                if _utils.has_conflict_input_type(py_sig, input_types):
+                    msg = bfe.format_message(
+                        "Conflicting input types detected, using the one from the decorator."
+                    )
+                    warnings.warn(msg, category=bfe.FunctionConflictTypeHintWarning)
                 py_sig = py_sig.replace(
                     parameters=[
                         par.replace(annotation=itype)
                         for par, itype in zip(py_sig.parameters.values(), input_types)
                     ]
                 )
             if output_type:
-                if _utils.has_output_type(py_sig):
+                if _utils.has_conflict_output_type(py_sig, output_type):
                     msg = bfe.format_message(
-                        "Redundant or conflicting return type detected, using the one from the decorator."
+                        "Conflicting return type detected, using the one from the decorator."
                     )
-                    warnings.warn(msg, category=bfe.FunctionRedundantTypeHintWarning)
+                    warnings.warn(msg, category=bfe.FunctionConflictTypeHintWarning)
                 py_sig = py_sig.replace(return_annotation=output_type)
 
             # Try to get input types via type annotations.
@@ -846,25 +846,25 @@ 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]
+                if _utils.has_conflict_input_type(py_sig, input_types):
+                    msg = bfe.format_message(
+                        "Conflicting input types detected, using the one from the decorator."
+                    )
+                    warnings.warn(msg, category=bfe.FunctionConflictTypeHintWarning)
                 py_sig = py_sig.replace(
                     parameters=[
                         par.replace(annotation=itype)
                         for par, itype in zip(py_sig.parameters.values(), input_types)
                     ]
                 )
             if output_type:
-                if _utils.has_output_type(py_sig):
+                if _utils.has_conflict_output_type(py_sig, output_type):
                     msg = bfe.format_message(
-                        "Redundant or conflicting return type detected, using the one from the decorator."
+                        "Conflicting return type detected, using the one from the decorator."
                     )
-                    warnings.warn(msg, category=bfe.FunctionRedundantTypeHintWarning)
+                    warnings.warn(msg, category=bfe.FunctionConflictTypeHintWarning)
                 py_sig = py_sig.replace(return_annotation=output_type)
 
             udf_sig = udf_def.UdfSignature.from_py_signature(py_sig)

bigframes/functions/_utils.py

@@ -18,7 +18,7 @@
 import json
 import sys
 import typing
-from typing import cast, Optional, Set
+from typing import Any, cast, Optional, Sequence, Set
 
 import cloudpickle
 import google.api_core.exceptions
@@ -272,14 +272,34 @@ def post_process(input):
     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():
+def has_conflict_input_type(
+    signature: inspect.Signature,
+    input_types: Sequence[Any],
+) -> bool:
+    """Checks if the parameters have any conflict with the input_types."""
+    params = list(signature.parameters.values())
+
+    if len(params) != len(input_types):
+        return True
+
+    # Check for conflicts type hints.
+    for i, param in enumerate(params):
         if param.annotation is not inspect.Parameter.empty:
-            return True
+            if param.annotation != input_types[i]:
+                return True
+
+    # No conflicts were found after checking all parameters.
     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
+def has_conflict_output_type(
+    signature: inspect.Signature,
+    output_type: Any,
+) -> bool:
+    """Checks if the return type annotation conflicts with the output_type."""
+    return_annotation = signature.return_annotation
+
+    if return_annotation is inspect.Parameter.empty:
+        return False
+
+    return return_annotation != output_type

tests/system/large/functions/test_managed_function.py

@@ -42,8 +42,9 @@ def test_managed_function_array_output(session, scalars_dfs, dataset_id):
             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"
+        # No following conflict warning when there is no redundant type hints.
+        input_type_warning = "Conflicting input types detected"
+        return_type_warning = "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
@@ -233,7 +234,7 @@ def add(x: int, y: int) -> int:
 def test_managed_function_series_combine_array_output(session, dataset_id, scalars_dfs):
     try:
 
-        # The type hints in this function's signature are redundant. The
+        # The type hints in this function's signature has conflicts. 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]:
@@ -256,9 +257,9 @@ def add_list(x, y: bool) -> list[bool]:
                 name=prefixer.create_prefix(),
             )(add_list)
 
-        input_type_warning = "Redundant or conflicting input types detected"
+        input_type_warning = "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"
+        return_type_warning = "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

tests/system/large/functions/test_remote_function.py

@@ -843,7 +843,7 @@ def test_remote_function_with_external_package_dependencies(
 ):
     try:
 
-        # The return type hint in this function's signature is redundant. The
+        # The return type hint in this function's signature has conflict. The
         # `output_type` argument from remote_function decorator takes precedence
         # and will be used instead.
         def pd_np_foo(x) -> None:
@@ -864,9 +864,9 @@ def pd_np_foo(x) -> None:
                 cloud_function_service_account="default",
             )(pd_np_foo)
 
-        input_type_warning = "Redundant or conflicting input types detected"
+        input_type_warning = "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"
+        return_type_warning = "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
@@ -2022,10 +2022,11 @@ def test_remote_function_unnamed_removed_w_session_cleanup():
         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)
+    # No following warning with only redundant type hints (no conflict).
+    input_type_warning = "Conflicting input types detected"
+    assert not any(input_type_warning in str(warning.message) for warning in record)
+    return_type_warning = "Conflicting return type detected"
+    assert not 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