"""

val_attr = field_value_proto.WhichOneof("val")

if val_attr is None:

return None

val = getattr(field_value_proto, val_attr)

# Handle Map and MapList types FIRST (before generic list processing)

if val_attr == "map_val":

return _handle_map_value(val)

elif val_attr == "map_list_val":

return _handle_map_list_value(val)

# If it's a _LIST or _SET type extract the values.

if hasattr(val, "val"):

val = list(val.val)

# Convert UNIX_TIMESTAMP values to `datetime`

if val_attr == "unix_timestamp_list_val":

val = [

(

datetime.fromtimestamp(v, tz=timezone.utc)

if v != NULL_TIMESTAMP_INT_VALUE

else None

)

for v in val

]

elif val_attr == "unix_timestamp_set_val":

val = set(

[

(

datetime.fromtimestamp(v, tz=timezone.utc)

if v != NULL_TIMESTAMP_INT_VALUE

else None

)

for v in val

]

)

elif val_attr == "unix_timestamp_val":

val = (

datetime.fromtimestamp(val, tz=timezone.utc)

if val != NULL_TIMESTAMP_INT_VALUE

else None

)

# Convert _SET types to Python sets

elif val_attr.endswith("_set_val") and val_attr != "unix_timestamp_set_val":

val = set(val)

"""Handle Map proto message containing map<string, Value> val."""

result = {}

for key, value in map_message.val.items():

# Recursively handle the Value message

result[key] = feast_value_type_to_python_type(value)

"""Handle MapList proto message containing repeated Map val."""

result = []

for map_item in map_list_message.val:

# Handle each Map in the list

processed_map = _handle_map_value(map_item)

result.append(processed_map)

value_type_to_pandas_type: Dict[ValueType, str] = {

ValueType.FLOAT: "float",

ValueType.INT32: "int",

ValueType.INT64: "int",

ValueType.STRING: "str",

ValueType.DOUBLE: "float",

ValueType.BYTES: "bytes",

ValueType.BOOL: "bool",

ValueType.UNIX_TIMESTAMP: "datetime64[ns]",

}

if (

value_type.name == "MAP"

or value_type.name.endswith("_LIST")

or value_type.name.endswith("_SET")

):

return "object"

if value_type in value_type_to_pandas_type:

return value_type_to_pandas_type[value_type]

raise TypeError(

f"Casting to pandas type for type {value_type} failed. "

f"Type {value_type} not found"

name: str,

value: Optional[Any] = None,

recurse: bool = True,

type_name: Optional[str] = None,

) -> ValueType:

"""

type_name = (type_name or type(value).__name__).lower()

type_map = {

"int": ValueType.INT64,

"str": ValueType.STRING,

"string": ValueType.STRING, # pandas.StringDtype

"float": ValueType.DOUBLE,

"bytes": ValueType.BYTES,

"float64": ValueType.DOUBLE,

"float32": ValueType.FLOAT,

"int64": ValueType.INT64,

"uint64": ValueType.INT64,

"int32": ValueType.INT32,

"uint32": ValueType.INT32,

"int16": ValueType.INT32,

"uint16": ValueType.INT32,

"uint8": ValueType.INT32,

"int8": ValueType.INT32,

"bool_": ValueType.BOOL, # np.bool_

"bool": ValueType.BOOL,

"boolean": ValueType.BOOL,

"timedelta": ValueType.UNIX_TIMESTAMP,

"timestamp": ValueType.UNIX_TIMESTAMP,

"datetime": ValueType.UNIX_TIMESTAMP,

"datetime64[ns]": ValueType.UNIX_TIMESTAMP,

"datetime64[ns, tz]": ValueType.UNIX_TIMESTAMP, # special dtype of pandas

"datetime64[ns, utc]": ValueType.UNIX_TIMESTAMP,

"date": ValueType.UNIX_TIMESTAMP,

"category": ValueType.STRING,

}

if type_name in type_map:

return type_map[type_name]

# Handle pandas "object" dtype by inspecting the actual value

if type_name == "object" and value is not None:

# Check the actual type of the value

actual_type = type(value).__name__.lower()

if actual_type == "str":

return ValueType.STRING

# Check if it's a dictionary (could be a Map)

elif actual_type == "dict":

return ValueType.MAP

# If it's a different type wrapped in object, try to infer from the value

elif actual_type in type_map:

return type_map[actual_type]

if isinstance(value, np.ndarray) and str(value.dtype) in type_map:

item_type = type_map[str(value.dtype)]

return ValueType[item_type.name + "_LIST"]

if isinstance(value, (list, np.ndarray)):

# Check if it's a list of maps

if value and isinstance(value[0], dict):

return ValueType.MAP_LIST

# if the value's type is "ndarray" and we couldn't infer from "value.dtype"

# this is most probably array of "object",

# so we need to iterate over objects and try to infer type of each item

if not recurse:

raise ValueError(

f"Value type for field {name} is {type(value)} but "

f"recursion is not allowed. Array types can only be one level "

f"deep."

)

# This is the final type which we infer from the list

common_item_value_type = None

for item in value:

if isinstance(item, ProtoValue):

current_item_value_type: ValueType = _proto_value_to_value_type(item)

else:

# Get the type from the current item, only one level deep

current_item_value_type = python_type_to_feast_value_type(

name=name, value=item, recurse=False

)

# Validate whether the type stays consistent

if (

common_item_value_type

and not common_item_value_type == current_item_value_type

):

raise ValueError(

f"List value type for field {name} is inconsistent. "

f"{common_item_value_type} different from "

f"{current_item_value_type}."

)

common_item_value_type = current_item_value_type

if common_item_value_type is None:

return ValueType.UNKNOWN

return ValueType[common_item_value_type.name + "_LIST"]

# Check if it's a set (Set type)

if isinstance(value, set):

if not recurse:

raise ValueError(

f"Value type for field {name} is {type(value)} but "

f"recursion is not allowed. Set types can only be one level "

f"deep."

)

# Infer the type from set elements

common_set_item_type = None

for item in value:

if isinstance(item, ProtoValue):

current_set_item_type: ValueType = _proto_value_to_value_type(item)

else:

# Get the type from the current item, only one level deep

current_set_item_type = python_type_to_feast_value_type(

name=name, value=item, recurse=False

)

# Validate whether the type stays consistent

if (

common_set_item_type

and not common_set_item_type == current_set_item_type

):

raise ValueError(

f"Set value type for field {name} is inconsistent. "

f"{common_set_item_type} different from "

f"{current_set_item_type}."

)

common_set_item_type = current_set_item_type

if common_set_item_type is None:

return ValueType.UNKNOWN

return ValueType[common_set_item_type.name + "_SET"]

# Check if it's a dictionary (Map type)

if isinstance(value, dict):

return ValueType.MAP

raise ValueError(

f"Value with native type {type_name} cannot be converted into Feast value type"

name: str, values: Any, recurse: bool = True

) -> ValueType:

inferred_dtype = ValueType.UNKNOWN

for row in values:

current_dtype = python_type_to_feast_value_type(

name, value=row, recurse=recurse

)

if inferred_dtype is ValueType.UNKNOWN:

inferred_dtype = current_dtype

else:

if current_dtype != inferred_dtype and current_dtype not in (

ValueType.UNKNOWN,

ValueType.NULL,

):

raise TypeError(

f"Input entity {name} has mixed types, {current_dtype} and {inferred_dtype}. That is not allowed. "

)

if inferred_dtype in (ValueType.UNKNOWN, ValueType.NULL):

raise ValueError(

f"field {name} cannot have all null values for type inference."

)

type_map = {

"UNKNOWN": ValueType.UNKNOWN,

"BYTES": ValueType.BYTES,

"STRING": ValueType.STRING,

"INT32": ValueType.INT32,

"INT64": ValueType.INT64,

"DOUBLE": ValueType.DOUBLE,

"FLOAT": ValueType.FLOAT,

"FLOAT32": ValueType.FLOAT,

"BOOL": ValueType.BOOL,

"NULL": ValueType.NULL,

"UNIX_TIMESTAMP": ValueType.UNIX_TIMESTAMP,

"BYTES_LIST": ValueType.BYTES_LIST,

"STRING_LIST": ValueType.STRING_LIST,

"INT32_LIST ": ValueType.INT32_LIST,

"INT64_LIST": ValueType.INT64_LIST,

"DOUBLE_LIST": ValueType.DOUBLE_LIST,

"FLOAT_LIST": ValueType.FLOAT_LIST,

"BOOL_LIST": ValueType.BOOL_LIST,

"UNIX_TIMESTAMP_LIST": ValueType.UNIX_TIMESTAMP_LIST,

}

ValueType, Tuple[ListType, str, List[Type]]

] = {

ValueType.FLOAT_LIST: (

FloatList,

"float_list_val",

[np.float32, np.float64, float],

),

ValueType.DOUBLE_LIST: (

DoubleList,

"double_list_val",

[np.float64, np.float32, float],

),

ValueType.INT32_LIST: (Int32List, "int32_list_val", [np.int64, np.int32, int]),

ValueType.INT64_LIST: (Int64List, "int64_list_val", [np.int64, np.int32, int]),

ValueType.UNIX_TIMESTAMP_LIST: (

Int64List,

"int64_list_val",

[np.datetime64, np.int64, np.int32, int, datetime, Timestamp],

),

ValueType.STRING_LIST: (StringList, "string_list_val", [np.str_, str]),

ValueType.BOOL_LIST: (BoolList, "bool_list_val", [np.bool_, bool]),

ValueType.BYTES_LIST: (BytesList, "bytes_list_val", [np.bytes_, bytes]),

ValueType, Tuple[SetType, str, List[Type]]

] = {

ValueType.FLOAT_SET: (

FloatSet,

"float_set_val",

[np.float32, np.float64, float],

),

ValueType.DOUBLE_SET: (

DoubleSet,

"double_set_val",

[np.float64, np.float32, float],

),

ValueType.INT32_SET: (Int32Set, "int32_set_val", [np.int64, np.int32, int]),

ValueType.INT64_SET: (Int64Set, "int64_set_val", [np.int64, np.int32, int]),

ValueType.UNIX_TIMESTAMP_SET: (

Int64Set,

"unix_timestamp_set_val",

[np.datetime64, np.int64, np.int32, int, datetime, Timestamp],

),

ValueType.STRING_SET: (StringSet, "string_set_val", [np.str_, str]),

ValueType.BOOL_SET: (BoolSet, "bool_set_val", [np.bool_, bool]),

ValueType.BYTES_SET: (BytesSet, "bytes_set_val", [np.bytes_, bytes]),

ValueType, Tuple[str, Any, Optional[Set[Type]]]

] = {

ValueType.INT32: ("int32_val", lambda x: int(x), None),

ValueType.INT64: (

"int64_val",

lambda x: (

int(x.timestamp())

if isinstance(x, pd._libs.tslibs.timestamps.Timestamp)

else int(x)

),

None,

),

ValueType.FLOAT: ("float_val", lambda x: float(x), None),

ValueType.DOUBLE: (

"double_val",

lambda x: x,

{float, np.float64, int, np.int_, decimal.Decimal},

),

ValueType.STRING: ("string_val", lambda x: str(x), None),

ValueType.BYTES: ("bytes_val", lambda x: x, {bytes}),

ValueType.IMAGE_BYTES: ("bytes_val", lambda x: x, {bytes}),

ValueType.BOOL: ("bool_val", lambda x: x, {bool, np.bool_, int, np.int_}),

values: Sequence[Any],

) -> Sequence[Union[int, np.int_]]:

# Fast path for Numpy array.

if isinstance(values, np.ndarray) and isinstance(values.dtype, np.datetime64):

if values.ndim != 1:

raise ValueError("Only 1 dimensional arrays are supported.")

return cast(Sequence[np.int_], values.astype("datetime64[s]").astype(np.int_))

int_timestamps = []

for value in values:

if isinstance(value, datetime):

int_timestamps.append(int(value.timestamp()))

elif isinstance(value, Timestamp):

int_timestamps.append(int(value.ToSeconds()))

elif isinstance(value, np.datetime64):

int_timestamps.append(value.astype("datetime64[s]").astype(np.int_)) # type: ignore[attr-defined]

elif isinstance(value, type(np.nan)):

int_timestamps.append(NULL_TIMESTAMP_INT_VALUE)

else:

int_timestamps.append(int(value))

feast_value_type: ValueType, values: List[Any]

) -> List[ProtoValue]:

"""

# Feature can be set but None is still valid

if feast_value_type not in PYTHON_SET_VALUE_TYPE_TO_PROTO_VALUE:

return []

set_proto_type, set_field_name, set_valid_types = (

PYTHON_SET_VALUE_TYPE_TO_PROTO_VALUE[feast_value_type]

)

# Convert set to list for proto (proto doesn't have native set type)

# We store unique values in a repeated field

def convert_set_to_list(value):

if value is None:

return None

# If it's already a set, convert to list

if isinstance(value, set):

return list(value)

# If it's a list/tuple/ndarray, remove duplicates

elif isinstance(value, (list, tuple, np.ndarray)):

return list(set(value))

else:

return value

converted_values = [convert_set_to_list(v) for v in values]

sample = next(filter(_non_empty_value, converted_values), None)

# Bytes to array type conversion

if isinstance(sample, (bytes, bytearray)):

# Bytes of an array containing elements of bytes not supported

if feast_value_type == ValueType.BYTES_SET:

raise _type_err(sample, ValueType.BYTES_SET)

json_sample = json.loads(sample)

if isinstance(json_sample, list):

json_values = [

json.loads(value) if value is not None else None

for value in converted_values

]

if feast_value_type == ValueType.BOOL_SET:

json_values = [

[bool(item) for item in list_item]

if list_item is not None

else None

for list_item in json_values

]

return [

(

ProtoValue(**{set_field_name: set_proto_type(val=v)}) # type: ignore

if v is not None

else ProtoValue()

)

for v in json_values

]

raise _type_err(sample, set_valid_types[0])

if sample is not None and not all(type(item) in set_valid_types for item in sample):

for item in sample:

if type(item) not in set_valid_types:

if feast_value_type in [

ValueType.INT32_SET,

ValueType.INT64_SET,

]:

if not any(np.isnan(item) for item in sample):

logger.error("Set of Int32 or Int64 type has NULL values.")

raise _type_err(item, set_valid_types[0])

if feast_value_type == ValueType.UNIX_TIMESTAMP_SET:

result = []

for value in converted_values:

if value is not None:

result.append(

ProtoValue(

unix_timestamp_set_val=Int64Set(

val=_python_datetime_to_int_timestamp(value) # type: ignore

)

)

)

else:

result.append(ProtoValue())

return result

if feast_value_type == ValueType.BOOL_SET:

result = []

for value in converted_values:

if value is not None:

result.append(

ProtoValue(

**{

set_field_name: set_proto_type(

val=[bool(e) for e in value] # type: ignore

)

}

)

)

else:

result.append(ProtoValue())

return result

return [

(

ProtoValue(**{set_field_name: set_proto_type(val=value)}) # type: ignore

if value is not None

else ProtoValue()

)

for value in converted_values

feast_value_type: ValueType, values: List[Any]

) -> List[ProtoValue]:

"""

# Handle Map and MapList types first

if feast_value_type == ValueType.MAP:

return [

ProtoValue(map_val=_python_dict_to_map_proto(value))

if value is not None

else ProtoValue()

for value in values

]

if feast_value_type == ValueType.MAP_LIST:

return [

ProtoValue(map_list_val=_python_list_to_map_list_proto(value))

if value is not None

else ProtoValue()

for value in values

]

# ToDo: make a better sample for type checks (more than one element)

sample = next(filter(_non_empty_value, values), None) # first not empty value

# Detect list type and handle separately

if "list" in feast_value_type.name.lower():

# Feature can be list but None is still valid

if feast_value_type in PYTHON_LIST_VALUE_TYPE_TO_PROTO_VALUE:

proto_type, field_name, valid_types = PYTHON_LIST_VALUE_TYPE_TO_PROTO_VALUE[

feast_value_type

]

# Bytes to array type conversion

if isinstance(sample, (bytes, bytearray)):

# Bytes of an array containing elements of bytes not supported

if feast_value_type == ValueType.BYTES_LIST:

raise _type_err(sample, ValueType.BYTES_LIST)

json_sample = json.loads(sample)

if isinstance(json_sample, list):

json_values = [json.loads(value) for value in values]

if feast_value_type == ValueType.BOOL_LIST:

json_values = [

[bool(item) for item in list_item]

for list_item in json_values

]

return [

ProtoValue(**{field_name: proto_type(val=v)}) # type: ignore

for v in json_values

]

raise _type_err(sample, valid_types[0])

if sample is not None and not all(

type(item) in valid_types for item in sample

):

# to_numpy() in utils._convert_arrow_to_proto() upcasts values of type Array of INT32 or INT64 with NULL values to Float64 automatically.

for item in sample:

if type(item) not in valid_types:

if feast_value_type in [

ValueType.INT32_LIST,

ValueType.INT64_LIST,

]:

if not any(np.isnan(item) for item in sample):

logger.error(

"Array of Int32 or Int64 type has NULL values. to_numpy() upcasts to Float64 automatically."

)

raise _type_err(item, valid_types[0])

if feast_value_type == ValueType.UNIX_TIMESTAMP_LIST:

result = []

for value in values:

if value is not None:

# ProtoValue does actually accept `np.int_` but the typing complains.

result.append(

ProtoValue(

unix_timestamp_list_val=Int64List(

val=_python_datetime_to_int_timestamp(value) # type: ignore

)

)

)

else:

result.append(ProtoValue())

return result

if feast_value_type == ValueType.BOOL_LIST:

# ProtoValue does not support conversion of np.bool_ so we need to convert it to support np.bool_.

result = []

for value in values:

if value is not None:

result.append(

ProtoValue(

**{field_name: proto_type(val=[bool(e) for e in value])} # type: ignore

)

)

else:

result.append(ProtoValue())

return result

return [

(

ProtoValue(**{field_name: proto_type(val=value)}) # type: ignore

if value is not None

else ProtoValue()

)

for value in values

]

# Detect set type and handle separately

if "set" in feast_value_type.name.lower():

return _python_set_to_proto_values(feast_value_type, values)

# Handle scalar types below

else:

if sample is None:

# all input values are None

return [ProtoValue()] * len(values)

if feast_value_type == ValueType.UNIX_TIMESTAMP:

int_timestamps = _python_datetime_to_int_timestamp(values)

# ProtoValue does actually accept `np.int_` but the typing complains.

return [ProtoValue(unix_timestamp_val=ts) for ts in int_timestamps] # type: ignore

(

field_name,

func,

valid_scalar_types,

) = PYTHON_SCALAR_VALUE_TYPE_TO_PROTO_VALUE[feast_value_type]

if valid_scalar_types:

if (sample == 0 or sample == 0.0) and feast_value_type != ValueType.BOOL:

# Numpy convert 0 to int. However, in the feature view definition, the type of column may be a float.

# So, if value is 0, type validation must pass if scalar_types are either int or float.

allowed_types = {np.int64, int, np.float64, float, decimal.Decimal}

assert type(sample) in allowed_types, (

f"Type `{type(sample)}` not in {allowed_types}"

)

else:

assert type(sample) in valid_scalar_types, (

f"Type `{type(sample)}` not in {valid_scalar_types}"

)

if feast_value_type == ValueType.BOOL:

# ProtoValue does not support conversion of np.bool_ so we need to convert it to support np.bool_.

return [

(

ProtoValue(

**{

field_name: func(

bool(value) if type(value) is np.bool_ else value # type: ignore

)

}

)

if not pd.isnull(value)

else ProtoValue()

)

for value in values

]

if feast_value_type in PYTHON_SCALAR_VALUE_TYPE_TO_PROTO_VALUE:

out = []

for value in values:

if isinstance(value, ProtoValue):

out.append(value)

elif not pd.isnull(value):

out.append(ProtoValue(**{field_name: func(value)}))

else:

out.append(ProtoValue())

return out

"""Convert a Python dictionary to a Map proto message."""

map_proto = Map()

for key, value in python_dict.items():

# Handle None values explicitly

if value is None:

map_proto.val[key].CopyFrom(

ProtoValue()

) # Empty ProtoValue represents None

continue

if isinstance(value, dict):

# Nested map

nested_map_proto = _python_dict_to_map_proto(value)

map_proto.val[key].CopyFrom(ProtoValue(map_val=nested_map_proto))

elif isinstance(value, list) and value and isinstance(value[0], dict):

# List of maps (MapList)

map_list_proto = _python_list_to_map_list_proto(value)

map_proto.val[key].CopyFrom(ProtoValue(map_list_val=map_list_proto))

else:

# Handle scalar values and regular lists

# Let python_values_to_proto_values infer the type

proto_values = python_values_to_proto_values([value], ValueType.UNKNOWN)

map_proto.val[key].CopyFrom(proto_values[0])

"""Convert a Python list of dictionaries to a MapList proto message."""

map_list_proto = MapList()

for item in python_list:

if isinstance(item, dict):

map_proto = _python_dict_to_map_proto(item)

map_list_proto.val.append(map_proto)

else:

raise ValueError(f"MapList can only contain dictionaries, got {type(item)}")

values: List[Any], feature_type: ValueType = ValueType.UNKNOWN

) -> List[ProtoValue]:

value_type = feature_type

sample = next(filter(_non_empty_value, values), None) # first not empty value

if sample is not None and feature_type == ValueType.UNKNOWN:

if isinstance(sample, (list, np.ndarray)):

value_type = (

feature_type

if len(sample) == 0

else python_type_to_feast_value_type("", sample)

)

else:

value_type = python_type_to_feast_value_type("", sample)

if value_type == ValueType.UNKNOWN:

raise TypeError("Couldn't infer value type from empty value")

proto_values = _python_value_to_proto_value(value_type, values)

if len(proto_values) != len(values):

raise ValueError(

f"Number of proto values {len(proto_values)} does not match number of values {len(values)}"

)

"int32_val": ValueType.INT32,

"int64_val": ValueType.INT64,

"double_val": ValueType.DOUBLE,

"float_val": ValueType.FLOAT,

"string_val": ValueType.STRING,

"bytes_val": ValueType.BYTES,

"bool_val": ValueType.BOOL,

"unix_timestamp_val": ValueType.UNIX_TIMESTAMP,

"int32_list_val": ValueType.INT32_LIST,

"int64_list_val": ValueType.INT64_LIST,

"double_list_val": ValueType.DOUBLE_LIST,

"float_list_val": ValueType.FLOAT_LIST,

"string_list_val": ValueType.STRING_LIST,

"bytes_list_val": ValueType.BYTES_LIST,

"bool_list_val": ValueType.BOOL_LIST,

"unix_timestamp_list_val": ValueType.UNIX_TIMESTAMP_LIST,

"map_val": ValueType.MAP,

"map_list_val": ValueType.MAP_LIST,

"int32_set_val": ValueType.INT32_SET,

"int64_set_val": ValueType.INT64_SET,

"double_set_val": ValueType.DOUBLE_SET,

"float_set_val": ValueType.FLOAT_SET,

"string_set_val": ValueType.STRING_SET,

"bytes_set_val": ValueType.BYTES_SET,

"bool_set_val": ValueType.BOOL_SET,

"unix_timestamp_set_val": ValueType.UNIX_TIMESTAMP_SET,

"""

proto_str = proto_value.WhichOneof("val")

if proto_str is None:

return ValueType.UNKNOWN

is_list = False

if pa_type_as_str.startswith("list<item: "):

is_list = True

pa_type_as_str = pa_type_as_str.replace("list<item: ", "").replace(">", "")

if pa_type_as_str.startswith("timestamp"):

value_type = ValueType.UNIX_TIMESTAMP

else:

type_map = {

"int32": ValueType.INT32,

"int64": ValueType.INT64,

"double": ValueType.DOUBLE,

"float": ValueType.FLOAT,

"string": ValueType.STRING,

"binary": ValueType.BYTES,

"bool": ValueType.BOOL,

"null": ValueType.NULL,

"list<element: double>": ValueType.DOUBLE_LIST,

"list<element: int64>": ValueType.INT64_LIST,

"list<element: int32>": ValueType.INT32_LIST,

"list<element: str>": ValueType.STRING_LIST,

"list<element: bool>": ValueType.BOOL_LIST,

"list<element: bytes>": ValueType.BYTES_LIST,

"list<element: float>": ValueType.FLOAT_LIST,

}

value_type = type_map[pa_type_as_str]

if is_list:

value_type = ValueType[value_type.name + "_LIST"]

is_list = False

if bq_type_as_str.startswith("ARRAY<"):

is_list = True

bq_type_as_str = bq_type_as_str[6:-1]

type_map: Dict[str, ValueType] = {

"DATETIME": ValueType.UNIX_TIMESTAMP,

"TIMESTAMP": ValueType.UNIX_TIMESTAMP,

"INTEGER": ValueType.INT64,

"NUMERIC": ValueType.INT64,

"INT64": ValueType.INT64,

"STRING": ValueType.STRING,

"FLOAT": ValueType.DOUBLE,

"FLOAT64": ValueType.DOUBLE,

"BYTES": ValueType.BYTES,

"BOOL": ValueType.BOOL,

"BOOLEAN": ValueType.BOOL, # legacy sql data type

"NULL": ValueType.NULL,

}

value_type = type_map.get(bq_type_as_str, ValueType.STRING)

if is_list:

value_type = ValueType[value_type.name + "_LIST"]

type_map = {

"bigint": ValueType.FLOAT,

"binary": ValueType.BYTES,

"bit": ValueType.BOOL,

"char": ValueType.STRING,

"date": ValueType.UNIX_TIMESTAMP,

"datetime": ValueType.UNIX_TIMESTAMP,

"datetimeoffset": ValueType.UNIX_TIMESTAMP,

"float": ValueType.FLOAT,

"int": ValueType.INT32,

"nchar": ValueType.STRING,

"nvarchar": ValueType.STRING,

"nvarchar(max)": ValueType.STRING,

"real": ValueType.FLOAT,

"smallint": ValueType.INT32,

"tinyint": ValueType.INT32,

"varbinary": ValueType.BYTES,

"varchar": ValueType.STRING,

"None": ValueType.NULL,

# skip date, geometry, hllsketch, time, timetz

}

if mssql_type_as_str.lower() not in type_map:

raise ValueError(f"Mssql type not supported by feast {mssql_type_as_str}")

# PyArrow types: https://arrow.apache.org/docs/python/api/datatypes.html

# MS Sql types: https://docs.microsoft.com/en-us/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-ver16

pa_type_as_str = str(pa_type).lower()

if pa_type_as_str.startswith("timestamp"):

if "tz=" in pa_type_as_str:

return "datetime2"

else:

return "datetime"

if pa_type_as_str.startswith("date"):