fix issues

Author: TrevorBergeron

bigframes/core/compile/ibis_compiler/scalar_op_registry.py

@@ -1037,7 +1037,7 @@ def timedelta_floor_op_impl(x: ibis_types.NumericValue):
 @scalar_op_compiler.register_unary_op(ops.RemoteFunctionOp, pass_op=True)
 def remote_function_op_impl(x: ibis_types.Value, op: ops.RemoteFunctionOp):
     udf_sig = op.function_def.signature
-    ibis_py_sig = ((arg.py_type for arg in udf_sig.inputs), udf_sig.output.py_type)
+    ibis_py_sig = (tuple(arg.py_type for arg in udf_sig.inputs), udf_sig.output.py_type)
 
     @ibis_udf.scalar.builtin(
         name=str(op.function_def.routine_ref), signature=ibis_py_sig
@@ -1056,7 +1056,7 @@ def binary_remote_function_op_impl(
     x: ibis_types.Value, y: ibis_types.Value, op: ops.BinaryRemoteFunctionOp
 ):
     udf_sig = op.function_def.signature
-    ibis_py_sig = ((arg.py_type for arg in udf_sig.inputs), udf_sig.output.py_type)
+    ibis_py_sig = (tuple(arg.py_type for arg in udf_sig.inputs), udf_sig.output.py_type)
 
     @ibis_udf.scalar.builtin(
         name=str(op.function_def.routine_ref), signature=ibis_py_sig
@@ -1073,7 +1073,7 @@ def nary_remote_function_op_impl(
     *operands: ibis_types.Value, op: ops.NaryRemoteFunctionOp
 ):
     udf_sig = op.function_def.signature
-    ibis_py_sig = ((arg.py_type for arg in udf_sig.inputs), udf_sig.output.py_type)
+    ibis_py_sig = (tuple(arg.py_type for arg in udf_sig.inputs), udf_sig.output.py_type)
     arg_names = tuple(arg.name for arg in udf_sig.inputs)
 
     @ibis_udf.scalar.builtin(

bigframes/functions/_function_client.py

@@ -641,7 +641,7 @@ def provision_bq_remote_function(
         cloud_function_name = get_cloud_function_name(
             cloud_func_spec,
             session_id=self._session.session_id if (name is None) else None,
-            uniq_suffix=random_suffix if reuse is False else None,
+            uniq_suffix=random_suffix if (not reuse) else None,
         )
 
         cf_endpoint = self.get_cloud_function_endpoint(cloud_function_name)
@@ -659,32 +659,29 @@ def provision_bq_remote_function(
             max_batching_rows=max_batching_rows,
             signature=func_signature,
         )
-        # Override value-derived name if reuse is False, or if name is explicitly provided.
-        # If reuse is False, then attach a unique suffix to the intended
-        # function name to make it unique.
-        rf_name = get_bigframes_function_name(
+        remote_function_name = name or get_bigframes_function_name(
             intended_rf_spec,
-            self._session.session_id if (name is None) else None,
-            random_suffix if reuse is False else None,
+            self._session.session_id,
+            random_suffix if (not reuse) else None,
         )
 
         if reuse:
-            existing_rf_spec = self.get_remote_function_specs(rf_name)
+            existing_rf_spec = self.get_remote_function_specs(remote_function_name)
             # Create the BQ remote function in following circumstances:
             # 1. It does not exist
             # 2. It exists but the existing remote function has different
             #    configuration than intended
             created_new = False
             if not existing_rf_spec or (existing_rf_spec != intended_rf_spec):
-                self.create_bq_remote_function(rf_name, intended_rf_spec)
+                self.create_bq_remote_function(remote_function_name, intended_rf_spec)
                 created_new = True
             else:
-                logger.info(f"Remote function {rf_name} already exists.")
+                logger.info(f"Remote function {remote_function_name} already exists.")
 
-            return rf_name, cloud_function_name, created_new
+            return remote_function_name, cloud_function_name, created_new
         else:
-            self.create_bq_remote_function(rf_name, intended_rf_spec)
-            return rf_name, cloud_function_name, True
+            self.create_bq_remote_function(remote_function_name, intended_rf_spec)
+            return remote_function_name, cloud_function_name, True
 
     def get_remote_function_specs(
         self, remote_function_name: str

bigframes/functions/udf_def.py

@@ -106,7 +106,9 @@ def bf_type(self) -> bigframes.dtypes.Dtype:
 
     @property
     def sql_type(self) -> str:
-        return function_typing.sdk_type_from_python_type(self._py_type).type_kind.name
+        type_kind = function_typing.sdk_type_from_python_type(self._py_type)
+        assert type_kind is not None
+        return type_kind.name
 
     def stable_hash(self) -> bytes:
         hash_val = hashlib.md5()
@@ -131,9 +133,7 @@ def py_type(self) -> Type[list[Any]]:
     # TODO: Specify emulating type and mapping expressions between said types
     @property
     def bf_type(self) -> bigframes.dtypes.Dtype:
-        return bigframes.dtypes.list_type(
-            function_typing.sdk_type_to_bf_type(self.inner_dtype)
-        )
+        return bigframes.dtypes.list_type(self.inner_dtype.bf_type)
 
     @property
     def emulating_type(self) -> DirectScalarType:
@@ -259,14 +259,6 @@ def from_routine(cls, routine: bigquery.Routine) -> UdfSignature:
                     "a type is supported as python output type.",
                 )
 
-        if (
-            return_type.sql_type
-            not in function_typing.RF_SUPPORTED_IO_BIGQUERY_TYPEKINDS
-        ):
-            raise ValueError(
-                f"Remote function must have one of the following supported output types: {function_typing.RF_SUPPORTED_IO_BIGQUERY_TYPEKINDS}"
-            )
-
         ## Handle input types
         udf_fields = []
         for argument in routine.arguments:
@@ -335,15 +327,6 @@ def with_devirtualize(self) -> BigqueryUdf:
     @classmethod
     def from_routine(cls, routine: bigquery.Routine) -> BigqueryUdf:
         signature = UdfSignature.from_routine(routine)
-
-        if (
-            signature.output.sql_type is None
-            or signature.output.sql_type
-            not in function_typing.RF_SUPPORTED_IO_BIGQUERY_TYPEKINDS
-        ):
-            raise ValueError(
-                f"Remote function must have one of the following supported output types: {function_typing.RF_SUPPORTED_IO_BIGQUERY_TYPEKINDS}"
-            )
         return cls(routine.reference, signature=signature)