fix: handle string arrays in materialization

Signed-off-by: Alan Gauthier <alan.gauthier@jobteaser.com>

Author: alan-gauthier-jt

sdk/python/feast/type_map.py

@@ -694,7 +694,7 @@ def _validate_collection_item_types(
     """
     if sample is None:
         return
-    if all(type(item) in valid_types for item in sample):
+    if all(type(item) in valid_types for item in sample if item is not None):
         return
 
     # to_numpy() upcasts INT32/INT64 with NULL to Float64 automatically
@@ -705,6 +705,8 @@ def _validate_collection_item_types(
         ValueType.INT64_SET,
     ]
     for item in sample:
+        if item is None:
+            continue  # None elements are sanitized downstream by _to_proto_safe_list
         if type(item) not in valid_types:
             if feast_value_type in int_collection_types:
                 # Check if the float values are due to NULL upcast
@@ -823,6 +825,21 @@ def convert_set_to_list(value: Any) -> Any:
     ]
 
 
+def _to_proto_safe_list(value: Any) -> Any:
+    """Convert an array/list column value to a proto-safe Python list.
+
+    Arrow/Athena returns Array(String) columns as numpy.ndarray (object dtype).
+    Protobuf StringList rejects ndarrays and None elements, so we:
+    1. Call .tolist() to get a plain Python list
+    2. Replace any None elements with empty string
+    """
+    if isinstance(value, np.ndarray):
+        value = value.tolist()
+    if isinstance(value, list):
+        return [x if x is not None else "" for x in value]
+    return value
+
+
 def _convert_list_values_to_proto(
     feast_value_type: ValueType,
     values: List[Any],
@@ -901,8 +918,11 @@ def _convert_list_values_to_proto(
         ]
 
     # Generic list conversion
+    # Arrow/Athena deserializes Array(String) columns as numpy.ndarray (object dtype).
+    # _to_proto_safe_list converts to a plain Python list and removes None elements,
+    # both of which protobuf StringList rejects.
     return [
-        ProtoValue(**{field_name: proto_type(val=value)})  # type: ignore[arg-type]
+        ProtoValue(**{field_name: proto_type(val=_to_proto_safe_list(value))})  # type: ignore[arg-type]
         if value is not None
         else ProtoValue()
         for value in values

sdk/python/tests/unit/test_type_map.py

@@ -1953,3 +1953,136 @@ def test_non_empty_array_treated_as_null_unix_timestamp(self):
             "non-empty array in UNIX_TIMESTAMP scalar column should produce null"
         )
         assert result[1].unix_timestamp_val == int(ts.timestamp())
+
+
+class TestArrowArrayStringListMaterialization:
+    """Regression tests for Array(String) columns from Arrow/Athena materialization.
+
+    Arrow/Athena deserializes Array(String) feature columns as numpy.ndarray with
+    object dtype. Two bugs were triggered:
+
+    1. ValueError: "The truth value of an empty array is ambiguous"
+       — when an empty ndarray reached the scalar null-check `elif not pd.isnull(value)`.
+
+    2. TypeError: "bad argument type for built-in operation"
+       — when proto_type(val=<ndarray>) was called; protobuf rejects ndarrays.
+
+    Both are fixed by _to_proto_safe_list, which converts ndarrays to plain Python
+    lists and replaces any None elements (from nullable Arrow columns) with "".
+    """
+
+    def test_to_proto_safe_list_ndarray(self):
+        """ndarray is converted to a plain Python list."""
+        from feast.type_map import _to_proto_safe_list
+
+        arr = np.array(["foo", "bar"], dtype=object)
+        result = _to_proto_safe_list(arr)
+        assert result == ["foo", "bar"]
+        assert isinstance(result, list)
+
+    def test_to_proto_safe_list_empty_ndarray(self):
+        """Empty ndarray is converted to an empty list."""
+        from feast.type_map import _to_proto_safe_list
+
+        arr = np.array([], dtype=object)
+        result = _to_proto_safe_list(arr)
+        assert result == []
+        assert isinstance(result, list)
+
+    def test_to_proto_safe_list_ndarray_with_none(self):
+        """None elements inside an ndarray are replaced with empty string."""
+        from feast.type_map import _to_proto_safe_list
+
+        arr = np.array(["foo", None, "baz"], dtype=object)
+        result = _to_proto_safe_list(arr)
+        assert result == ["foo", "", "baz"]
+
+    def test_to_proto_safe_list_plain_list(self):
+        """Plain Python lists pass through unchanged (no None replacement needed)."""
+        from feast.type_map import _to_proto_safe_list
+
+        lst = ["foo", "bar"]
+        result = _to_proto_safe_list(lst)
+        assert result == ["foo", "bar"]
+
+    def test_to_proto_safe_list_plain_list_with_none(self):
+        """None elements in a plain list are also replaced."""
+        from feast.type_map import _to_proto_safe_list
+
+        lst = ["foo", None]
+        result = _to_proto_safe_list(lst)
+        assert result == ["foo", ""]
+
+    def test_to_proto_safe_list_scalar_passthrough(self):
+        """Non-list, non-ndarray values are returned unchanged."""
+        from feast.type_map import _to_proto_safe_list
+
+        assert _to_proto_safe_list("hello") == "hello"
+        assert _to_proto_safe_list(None) is None
+        assert _to_proto_safe_list(42) == 42
+
+    def test_string_list_from_ndarray(self):
+        """STRING_LIST column with ndarray values materializes without TypeError."""
+        values = [
+            np.array(["foo", "bar"], dtype=object),
+            np.array(["baz"], dtype=object),
+        ]
+        protos = python_values_to_proto_values(values, ValueType.STRING_LIST)
+        assert len(protos) == 2
+        assert list(protos[0].string_list_val.val) == ["foo", "bar"]
+        assert list(protos[1].string_list_val.val) == ["baz"]
+
+    def test_string_list_from_empty_ndarray(self):
+        """Empty ndarray in a STRING_LIST column must not raise ValueError."""
+        values = [
+            np.array([], dtype=object),
+            np.array(["foo"], dtype=object),
+        ]
+        protos = python_values_to_proto_values(values, ValueType.STRING_LIST)
+        assert list(protos[0].string_list_val.val) == []
+        assert list(protos[1].string_list_val.val) == ["foo"]
+
+    def test_string_list_from_ndarray_with_none_elements(self):
+        """None elements inside an ndarray must not cause TypeError in protobuf."""
+        values = [
+            np.array(["foo", None, "baz"], dtype=object),
+        ]
+        protos = python_values_to_proto_values(values, ValueType.STRING_LIST)
+        # None is replaced with empty string
+        assert list(protos[0].string_list_val.val) == ["foo", "", "baz"]
+
+    def test_string_list_null_row_produces_empty_proto(self):
+        """A None row (missing user) produces an empty ProtoValue."""
+        from feast.protos.feast.types.Value_pb2 import Value as ProtoValue
+
+        values = [
+            None,
+            np.array(["foo"], dtype=object),
+        ]
+        protos = python_values_to_proto_values(values, ValueType.STRING_LIST)
+        assert protos[0] == ProtoValue()
+        assert list(protos[1].string_list_val.val) == ["foo"]
+
+    def test_mixed_batch_simulating_athena_chunk(self):
+        """Simulate a real Athena chunk: mix of ndarray, empty ndarray, and None rows.
+
+        This is the exact scenario that triggered the TypeError during
+        string_list_features materialization.
+        """
+        from feast.protos.feast.types.Value_pb2 import Value as ProtoValue
+
+        # tags / labels column from Athena
+        values = [
+            np.array(["foo", "bar"], dtype=object),  # normal entity
+            np.array([], dtype=object),  # entity with no values set
+            None,  # missing entity (NULL row)
+            np.array(["baz"], dtype=object),  # normal entity
+            np.array(["qux", None], dtype=object),  # entity with partial null
+        ]
+        protos = python_values_to_proto_values(values, ValueType.STRING_LIST)
+
+        assert list(protos[0].string_list_val.val) == ["foo", "bar"]
+        assert list(protos[1].string_list_val.val) == []
+        assert protos[2] == ProtoValue()
+        assert list(protos[3].string_list_val.val) == ["baz"]
+        assert list(protos[4].string_list_val.val) == ["qux", ""]