"""Convert uuid.UUID objects and sets to JSON-serializable form."""

if isinstance(val, uuid_module.UUID):

return str(val)

if isinstance(val, set):

return [str(v) if isinstance(v, uuid_module.UUID) else v for v in val]

if isinstance(val, list):

return [str(v) if isinstance(v, uuid_module.UUID) else v for v in val]

"""Remote Online store config for remote online store"""

type: Literal["remote"] = "remote"

"""Online store type selector"""

path: StrictStr = "http://localhost:6566"

""" str: Path to metadata store.

cert: StrictStr = ""

""" str: Path to the public certificate when the online server starts in TLS(SSL) mode. This may be needed if the online server started with a self-signed certificate, typically this file ends with `*.crt`, `*.cer`, or `*.pem`.

# Connection pooling configuration

connection_pool_size: int = 50

""" int: Maximum number of connections to keep in the pool (default 50).

connection_idle_timeout: int = 300

""" int: Maximum time in seconds a session can be idle before being closed (default 300 = 5 minutes).

connection_retries: int = 3

"""

@staticmethod

def _proto_value_to_transport_value(proto_value: ValueProto) -> Any:

"""

val_attr = proto_value.WhichOneof("val")

if val_attr is None:

return None

# Keep JSON values as raw strings for correct DataFrame reconstruction.

# Parsing them into dicts causes PyArrow to infer struct columns on the

# server whose nested lists round-trip as numpy arrays, breaking

# json.dumps during proto conversion.

if val_attr == "json_val":

return getattr(proto_value, val_attr)

if val_attr == "json_list_val":

return list(getattr(proto_value, val_attr).val)

# Nested collection types use feast_value_type_to_python_type

# which handles recursive conversion of RepeatedValue protos.

if val_attr in ("list_val", "set_val"):

return feast_value_type_to_python_type(proto_value)

# Map/Struct types are converted to Python dicts by

# feast_value_type_to_python_type. Serialise them to JSON strings

# so the server-side DataFrame gets VARCHAR columns instead of

# PyArrow struct columns that can crash with complex nested types.

if val_attr in ("map_val", "struct_val"):

return json.dumps(feast_value_type_to_python_type(proto_value))

if val_attr in ("map_list_val", "struct_list_val"):

return [json.dumps(v) for v in feast_value_type_to_python_type(proto_value)]

# UUID types are stored as strings in proto — return them directly

# to avoid feast_value_type_to_python_type converting to uuid.UUID

# objects which are not JSON-serializable.

if val_attr in ("uuid_val", "time_uuid_val"):

return getattr(proto_value, val_attr)

if val_attr in ("uuid_list_val", "time_uuid_list_val"):

return list(getattr(proto_value, val_attr).val)

if val_attr in ("uuid_set_val", "time_uuid_set_val"):

return list(getattr(proto_value, val_attr).val)

return feast_value_type_to_python_type(proto_value)

def online_write_batch(

self,

config: RepoConfig,

table: FeatureView,

data: List[

Tuple[EntityKeyProto, Dict[str, ValueProto], datetime, Optional[datetime]]

],

progress: Optional[Callable[[int], Any]],

) -> None:

"""

assert isinstance(config.online_store, RemoteOnlineStoreConfig)

config.online_store.__class__ = RemoteOnlineStoreConfig

columnar_data: Dict[str, List[Any]] = defaultdict(list)

# Iterate through each row to populate columnar data directly

for entity_key_proto, feature_values_proto, event_ts, created_ts in data:

# Populate entity key values

for join_key, entity_value_proto in zip(

entity_key_proto.join_keys, entity_key_proto.entity_values

):

val = feast_value_type_to_python_type(entity_value_proto)

columnar_data[join_key].append(_json_safe(val))

# Populate feature values – use transport-safe conversion that

# preserves JSON strings instead of parsing them into dicts.

for feature_name, feature_value_proto in feature_values_proto.items():

columnar_data[feature_name].append(

self._proto_value_to_transport_value(feature_value_proto)

)

# Populate timestamps

columnar_data["event_timestamp"].append(_to_naive_utc(event_ts).isoformat())

columnar_data["created"].append(

_to_naive_utc(created_ts).isoformat() if created_ts else None

)

req_body = {

"feature_view_name": table.name,

"df": columnar_data,

"allow_registry_cache": False,

}

response = post_remote_online_write(config=config, req_body=req_body)

if response.status_code != 200:

error_msg = f"Unable to write online store data using feature server API. Error_code={response.status_code}, error_message={response.text}"

logger.error(error_msg)

raise RuntimeError(error_msg)

if progress:

data_length = len(data)

logger.info(

f"Writing {data_length} rows to the remote store for feature view {table.name}."

)

progress(data_length)

def online_read(

self,

config: RepoConfig,

table: FeatureView,

entity_keys: List[EntityKeyProto],

requested_features: Optional[List[str]] = None,

) -> List[Tuple[Optional[datetime], Optional[Dict[str, ValueProto]]]]:

assert isinstance(config.online_store, RemoteOnlineStoreConfig)

config.online_store.__class__ = RemoteOnlineStoreConfig

req_body = self._construct_online_read_api_json_request(

entity_keys, table, requested_features

)

response = get_remote_online_features(config=config, req_body=req_body)

if response.status_code == 200:

logger.debug("Able to retrieve the online features from feature server.")

response_json = json.loads(response.text)

event_ts = self._get_event_ts(response_json)

# Build feature name -> ValueType mapping so we can reconstruct

# complex types (nested collections, sets, etc.) that cannot be

# inferred from raw JSON values alone.

feature_type_map: Dict[str, ValueType] = {

f.name: f.dtype.to_value_type() for f in table.features

}

# Iterating over results and converting the API results in column format to row format.

result_tuples: List[

Tuple[Optional[datetime], Optional[Dict[str, ValueProto]]]

] = []

for feature_value_index in range(len(entity_keys)):

feature_values_dict: Dict[str, ValueProto] = dict()

for index, feature_name in enumerate(

response_json["metadata"]["feature_names"]

):

if (

requested_features is not None

and feature_name in requested_features

):

if (

response_json["results"][index]["statuses"][

feature_value_index

]

== "PRESENT"

):

feature_value_type = feature_type_map.get(

feature_name, ValueType.UNKNOWN

)

message = python_values_to_proto_values(

[

response_json["results"][index]["values"][

feature_value_index

]

],

feature_value_type,

)

feature_values_dict[feature_name] = message[0]

else:

feature_values_dict[feature_name] = ValueProto()

result_tuples.append((event_ts, feature_values_dict))

return result_tuples

else:

error_msg = f"Unable to retrieve the online store data using feature server API. Error_code={response.status_code}, error_message={response.text}"

logger.error(error_msg)

raise RuntimeError(error_msg)

def retrieve_online_documents(

self,

config: RepoConfig,

table: FeatureView,

requested_features: Optional[List[str]],

embedding: Optional[List[float]],

top_k: int,

distance_metric: Optional[str] = "L2",

) -> List[

Tuple[

Optional[datetime],

Optional[EntityKeyProto],

Optional[ValueProto],

Optional[ValueProto],

Optional[ValueProto],

]

]:

assert isinstance(config.online_store, RemoteOnlineStoreConfig)

config.online_store.__class__ = RemoteOnlineStoreConfig

req_body = self._construct_online_documents_api_json_request(

table, requested_features, embedding, top_k, distance_metric

)

response = get_remote_online_documents(config=config, req_body=req_body)

if response.status_code == 200:

logger.debug("Able to retrieve the online documents from feature server.")

response_json = json.loads(response.text)

event_ts: Optional[datetime] = self._get_event_ts(response_json)

# Create feature name to index mapping for efficient lookup

feature_name_to_index = {

name: idx

for idx, name in enumerate(response_json["metadata"]["feature_names"])

}

vector_field_metadata = _get_feature_view_vector_field_metadata(table)

# Process each result row

num_results = len(response_json["results"][0]["values"])

result_tuples = []

for row_idx in range(num_results):

# Extract values using helper methods

feature_val = self._extract_requested_feature_value(

response_json, feature_name_to_index, requested_features, row_idx

)

vector_value = self._extract_vector_field_value(

response_json, feature_name_to_index, vector_field_metadata, row_idx

)

distance_val = self._extract_distance_value(

response_json, feature_name_to_index, "distance", row_idx

)

entity_key_proto = self._construct_entity_key_from_response(

response_json, row_idx, feature_name_to_index, table

)

result_tuples.append(

(

event_ts,

entity_key_proto,

feature_val,

vector_value,

distance_val,

)

)

return result_tuples

else:

error_msg = f"Unable to retrieve the online documents using feature server API. Error_code={response.status_code}, error_message={response.text}"

logger.error(error_msg)

raise RuntimeError(error_msg)

def retrieve_online_documents_v2(

self,

config: RepoConfig,

table: FeatureView,

requested_features: Optional[List[str]],

embedding: Optional[List[float]],

top_k: int,

distance_metric: Optional[str] = None,

query_string: Optional[str] = None,

include_feature_view_version_metadata: bool = False,

) -> List[

Tuple[

Optional[datetime],

Optional[EntityKeyProto],

Optional[Dict[str, ValueProto]],

]

]:

assert isinstance(config.online_store, RemoteOnlineStoreConfig)

config.online_store.__class__ = RemoteOnlineStoreConfig

req_body = self._construct_online_documents_v2_api_json_request(

table,

requested_features,

embedding,

top_k,

distance_metric,

query_string,

api_version=2,

)

response = get_remote_online_documents(config=config, req_body=req_body)

if response.status_code == 200:

logger.debug("Able to retrieve the online documents from feature server.")

response_json = json.loads(response.text)

event_ts: Optional[datetime] = self._get_event_ts(response_json)

# Create feature name to index mapping for efficient lookup

feature_name_to_index = {

name: idx

for idx, name in enumerate(response_json["metadata"]["feature_names"])

}

# Process each result row

num_results = (

len(response_json["results"][0]["values"])

if response_json["results"]

else 0

)

result_tuples = []

for row_idx in range(num_results):

# Build feature values dictionary for requested features

feature_values_dict = {}

if requested_features:

for feature_name in requested_features:

if feature_name in feature_name_to_index:

feature_idx = feature_name_to_index[feature_name]

if self._is_feature_present(

response_json, feature_idx, row_idx

):

feature_values_dict[feature_name] = (

self._extract_feature_value(

response_json, feature_idx, row_idx

)

)

else:

feature_values_dict[feature_name] = ValueProto()

# Construct entity key proto using existing helper method

entity_key_proto = self._construct_entity_key_from_response(

response_json, row_idx, feature_name_to_index, table

)

result_tuples.append(

(

event_ts,

entity_key_proto,

feature_values_dict if feature_values_dict else None,

)

)

return result_tuples

else:

error_msg = f"Unable to retrieve the online documents using feature server API. Error_code={response.status_code}, error_message={response.text}"

logger.error(error_msg)

raise RuntimeError(error_msg)

def _extract_requested_feature_value(

self,

response_json: dict,

feature_name_to_index: dict,

requested_features: Optional[List[str]],

row_idx: int,

) -> Optional[ValueProto]:

"""Extract the first available requested feature value."""

if not requested_features:

return ValueProto()

for feature_name in requested_features:

if feature_name in feature_name_to_index:

feature_idx = feature_name_to_index[feature_name]

if self._is_feature_present(response_json, feature_idx, row_idx):

return self._extract_feature_value(

response_json, feature_idx, row_idx

)

return ValueProto()

def _extract_vector_field_value(

self,

response_json: dict,

feature_name_to_index: dict,

vector_field_metadata,

row_idx: int,

) -> Optional[ValueProto]:

"""Extract vector field value from response."""

if (

not vector_field_metadata

or vector_field_metadata.name not in feature_name_to_index

):

return ValueProto()

vector_feature_idx = feature_name_to_index[vector_field_metadata.name]

if self._is_feature_present(response_json, vector_feature_idx, row_idx):

return self._extract_feature_value(

response_json, vector_feature_idx, row_idx

)

return ValueProto()

def _extract_distance_value(

self,

response_json: dict,

feature_name_to_index: dict,

distance_feature_name: str,

row_idx: int,

) -> Optional[ValueProto]:

"""Extract distance/score value from response."""

if not distance_feature_name:

return ValueProto()

distance_feature_idx = feature_name_to_index[distance_feature_name]

if self._is_feature_present(response_json, distance_feature_idx, row_idx):

distance_value = response_json["results"][distance_feature_idx]["values"][

row_idx

]

distance_val = ValueProto()

distance_val.float_val = float(distance_value)

return distance_val

return ValueProto()

def _is_feature_present(

self, response_json: dict, feature_idx: int, row_idx: int

) -> bool:

"""Check if a feature is present in the response."""

return response_json["results"][feature_idx]["statuses"][row_idx] == "PRESENT"

def _construct_online_read_api_json_request(

self,

entity_keys: List[EntityKeyProto],

table: FeatureView,

requested_features: Optional[List[str]] = None,

) -> dict:

api_requested_features = []

if requested_features is not None:

for requested_feature in requested_features:

api_requested_features.append(f"{table.name}:{requested_feature}")

entity_values = []

entity_key = ""

for row in entity_keys:

entity_key = row.join_keys[0]

entity_values.append(

getattr(row.entity_values[0], row.entity_values[0].WhichOneof("val"))

)

return {

"features": api_requested_features,

"entities": {entity_key: entity_values},

}

def _construct_online_documents_api_json_request(

self,

table: FeatureView,

requested_features: Optional[List[str]] = None,

embedding: Optional[List[float]] = None,

top_k: Optional[int] = None,

distance_metric: Optional[str] = "L2",

) -> dict:

api_requested_features = []

if requested_features is not None:

for requested_feature in requested_features:

api_requested_features.append(f"{table.name}:{requested_feature}")

return {

"features": api_requested_features,

"query": embedding,

"top_k": top_k,

"distance_metric": distance_metric,

}

def _construct_online_documents_v2_api_json_request(

self,

table: FeatureView,

requested_features: Optional[List[str]],

embedding: Optional[List[float]],

top_k: int,

distance_metric: Optional[str] = None,

query_string: Optional[str] = None,

api_version: Optional[int] = 2,

) -> dict:

api_requested_features = []

if requested_features is not None:

for requested_feature in requested_features:

api_requested_features.append(f"{table.name}:{requested_feature}")

return {

"features": api_requested_features,

"query": embedding,

"top_k": top_k,

"distance_metric": distance_metric,

"query_string": query_string,

"api_version": api_version,

}

def _get_event_ts(self, response_json) -> datetime:

event_ts = ""

if len(response_json["results"]) > 1:

event_ts = response_json["results"][1]["event_timestamps"][0]

return datetime.fromisoformat(event_ts.replace("Z", "+00:00"))

def _construct_entity_key_from_response(

self,

response_json: dict,

row_idx: int,

feature_name_to_index: dict,

table: FeatureView,

) -> Optional[EntityKeyProto]:

"""Construct EntityKeyProto from response data."""

# Use the feature view's join_keys to identify entity fields

entity_fields = [

join_key

for join_key in table.join_keys

if join_key in feature_name_to_index

]

if not entity_fields:

return None

entity_key_proto = EntityKeyProto()

entity_key_proto.join_keys.extend(entity_fields)

for entity_field in entity_fields:

if entity_field in feature_name_to_index:

feature_idx = feature_name_to_index[entity_field]

if self._is_feature_present(response_json, feature_idx, row_idx):

entity_value = self._extract_feature_value(

response_json, feature_idx, row_idx

)

entity_key_proto.entity_values.append(entity_value)

return entity_key_proto if entity_key_proto.entity_values else None

def _extract_feature_value(

self, response_json: dict, feature_idx: int, row_idx: int

) -> ValueProto:

"""Extract and convert a feature value to ValueProto."""

raw_value = response_json["results"][feature_idx]["values"][row_idx]

if raw_value is None:

return ValueProto()

proto_values = python_values_to_proto_values([raw_value])

return proto_values[0]

def update(

self,

config: RepoConfig,

tables_to_delete: Sequence[FeatureView],

tables_to_keep: Sequence[FeatureView],

entities_to_delete: Sequence[Entity],

entities_to_keep: Sequence[Entity],

partial: bool,

):

pass

def teardown(

self,

config: RepoConfig,

tables: Sequence[FeatureView],

entities: Sequence[Entity],

):

pass

async def close(self) -> None:

"""

HttpSessionManager.close_session()

session: requests.Session, config: RepoConfig, req_body: dict

) -> requests.Response:

if config.online_store.cert:

return session.post(

f"{config.online_store.path}/get-online-features",

json=req_body,

verify=config.online_store.cert,

)

else:

return session.post(

f"{config.online_store.path}/get-online-features", json=req_body

session: requests.Session, config: RepoConfig, req_body: dict

) -> requests.Response:

if config.online_store.cert:

return session.post(

f"{config.online_store.path}/retrieve-online-documents",

json=req_body,

verify=config.online_store.cert,

)

else:

return session.post(

f"{config.online_store.path}/retrieve-online-documents", json=req_body

session: requests.Session, config: RepoConfig, req_body: dict

) -> requests.Response:

url = f"{config.online_store.path}/write-to-online-store"

if config.online_store.cert:

return session.post(url, json=req_body, verify=config.online_store.cert)

else: