fix: base64-encode bytes_val and bytes_list_val for JSON serialization

abhijeet-dhumal · abhijeet-dhumal · commit ecce3cf709e6 · 2026-05-27T21:39:27.000+05:30
bytes_val returned raw bytes which cause json.dumps TypeError when
JSONResponse serializes the response. Base64-encode these values to
match standard protobuf JSON encoding for bytes fields.

Fixes Nikhil's review comment: bytes_val is still problem since you
are using JSONResponse.

Signed-off-by: abhijeet-dhumal &lt;abhijeetdhumal652@gmail.com&gt;
diff --git a/sdk/python/feast/feature_server_utils.py b/sdk/python/feast/feature_server_utils.py
@@ -4,6 +4,7 @@
 Values are serialized as native Python types (not wrapped dicts).
 """
 
+import base64
 import logging
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional
@@ -67,14 +68,18 @@ def convert_response_to_dict(response: GetOnlineFeaturesResponse) -> Dict[str, A
 
 
 def _value_to_native(v: Value) -> Optional[Any]:
-    """Convert a Value proto to native Python type (matches proto_json.patch() format).
+    """Convert a Value proto to a JSON-serializable Python type.
 
-    Note: proto_json.patch() modifies MessageToDict to return raw bytes instead of
-    base64 encoding, so we return raw bytes here to match that behavior.
+    bytes_val and bytes_list_val are base64-encoded (RFC 4648) so that
+    JSONResponse can serialize them without TypeError. This matches standard
+    protobuf JSON encoding for bytes fields and is safe for all HTTP clients.
     """
     which = v.WhichOneof("val")
     if which is None or which == "null_val":
         return None
+    # bytes must be base64-encoded for JSON serialization
+    elif which == "bytes_val":
+        return base64.b64encode(v.bytes_val).decode("ascii")
     # RepeatedValue — nested Values that must be recursively converted
     elif which in ("list_val", "set_val"):
         return [_value_to_native(nested) for nested in getattr(v, which).val]
@@ -94,13 +99,17 @@ def _value_to_native(v: Value) -> Optional[Any]:
             "scalar_map_val is not yet supported by convert_response_to_dict; value will be None"
         )
         return None
-    # All simple list/set types (.val is a repeated scalar field)
+    # bytes_list_val / bytes_set_val — base64-encode each element
+    elif which in ("bytes_list_val", "bytes_set_val"):
+        return [base64.b64encode(b).decode("ascii") for b in getattr(v, which).val]
+    # All other list/set types have scalar .val fields
     elif "_list_" in which or "_set_" in which:
         return list(getattr(v, which).val)
     else:
         return getattr(v, which)
 
 
+
 def _timestamp_to_str(ts) -> str:
     """Convert protobuf Timestamp to RFC 3339 format with Z suffix.
 
diff --git a/sdk/python/tests/unit/test_feature_server_utils.py b/sdk/python/tests/unit/test_feature_server_utils.py
@@ -21,6 +21,7 @@
 Related issue: https://github.com/feast-dev/feast/issues/6013
 """
 
+import base64
 import json
 import time
 
@@ -104,7 +105,7 @@ def test_bytes_val(self):
         data = b"\x00\x01\x02\x03"
         v = Value(bytes_val=data)
         result = _value_to_native(v)
-        assert result == data
+        assert result == base64.b64encode(data).decode("ascii")
 
     def test_double_list_val(self):
         v = Value(double_list_val=DoubleList(val=[1.1, 2.2, 3.3]))
@@ -144,7 +145,10 @@ def test_unix_timestamp_val(self):
     def test_bytes_list_val(self):
         v = Value(bytes_list_val=BytesList(val=[b"\x00\x01", b"\x02\x03"]))
         result = _value_to_native(v)
-        assert result == [b"\x00\x01", b"\x02\x03"]
+        assert result == [
+            base64.b64encode(b"\x00\x01").decode("ascii"),
+            base64.b64encode(b"\x02\x03").decode("ascii"),
+        ]
 
     def test_unix_timestamp_list_val(self):
         v = Value(unix_timestamp_list_val=Int64List(val=[1609459200, 1609545600]))
@@ -458,7 +462,6 @@ def test_double_val_precision(self):
         the only difference is how many trailing digits appear in the JSON string.
         This is an intentional trade-off for speed and is safe for all ML feature values.
         """
-        import json
         import struct
 
         # Use a value with many significant digits
@@ -496,20 +499,25 @@ def test_set_types_return_flat_list(self):
         assert isinstance(values[0], list), "set type should be a flat list"
         assert set(values[0]) == {"a", "b", "c"}
 
-    def test_bytes_values_match_patched_message_to_dict(self):
-        """Ensure bytes serialization matches proto_json.patch() format (raw bytes)."""
+    def test_bytes_val_is_base64_encoded(self):
+        """bytes_val is base64-encoded so JSONResponse can serialize it.
+
+        This intentionally differs from proto_json.patch() which returns raw bytes.
+        Raw bytes are not JSON-serializable; base64 is the standard protobuf JSON
+        encoding for bytes fields and is safe for all HTTP clients.
+        """
         response = GetOnlineFeaturesResponse()
         fv = response.results.add()
-        fv.values.append(Value(bytes_val=b"\x00\x01\x02\xff"))
+        data = b"\x00\x01\x02\xff"
+        fv.values.append(Value(bytes_val=data))
         fv.statuses.append(FieldStatus.PRESENT)
 
-        fast_result = convert_response_to_dict(response)
-        standard_result = MessageToDict(response, preserving_proto_field_name=True)
+        result = convert_response_to_dict(response)
+        encoded = result["results"][0]["values"][0]
 
-        assert (
-            fast_result["results"][0]["values"]
-            == standard_result["results"][0]["values"]
-        )
+        assert encoded == base64.b64encode(data).decode("ascii")
+        # Must be JSON-serializable
+        assert json.dumps(encoded)
 
 
 class TestJsonSerializability:
