def _apply_feature_set(self, feature_set: FeatureSet):
self._connect_core()
feature_set._client = self
valid, message = feature_set.is_valid()
if not valid:
raise Exception(message)
try:
apply_fs_response = self._core_service_stub.ApplyFeatureSet(
ApplyFeatureSetRequest(feature_set=feature_set.to_proto()),
timeout=GRPC_CONNECTION_TIMEOUT_APPLY,
) # type: ApplyFeatureSetResponse
applied_fs = FeatureSet.from_proto(apply_fs_response.feature_set)
if apply_fs_response.status == ApplyFeatureSetResponse.Status.CREATED:
print(
f'Feature set updated/created: "{applied_fs.name}:{applied_fs.version}".'
)
feature_set._update_from_feature_set(applied_fs,
is_dirty=False)
return
if apply_fs_response.status == ApplyFeatureSetResponse.Status.NO_CHANGE:
print(f"No change detected in feature set {feature_set.name}")
return
except grpc.RpcError as e:
print(
format_grpc_exception("ApplyFeatureSet", e.code(),
e.details()))
def get_online_features(
self,
feature_ids: List[str],
entity_rows: List[GetOnlineFeaturesRequest.EntityRow],
) -> GetOnlineFeaturesResponse:
"""
Retrieves the latest online feature data from Feast Serving
:param feature_ids: List of feature Ids in the following format
[feature_set_name]:[version]:[feature_name]
example: ["feature_set_1:6:my_feature_1",
"feature_set_1:6:my_feature_2",]
:param entity_rows: List of GetFeaturesRequest.EntityRow where each row
contains entities. Timestamp should not be set for
online retrieval. All entity types within a feature
set must be provided for each entity key.
:return: Returns a list of maps where each item in the list contains
the latest feature values for the provided entities
"""
self._connect_serving()
try:
response = self._serving_service_stub.GetOnlineFeatures(
GetOnlineFeaturesRequest(
feature_sets=_build_feature_set_request(feature_ids),
entity_rows=entity_rows,
)) # type: GetOnlineFeaturesResponse
except grpc.RpcError as e:
print(
format_grpc_exception("GetOnlineFeatures", e.code(),
e.details()))
else:
return response
def get_feature_set(
self,
name: str,
version: int = None,
fail_if_missing: bool = False) -> Union[FeatureSet, None]:
"""
Retrieve a single feature set from Feast Core
:param name: (str) Name of feature set
:param version: (int) Version of feature set
:param fail_if_missing: (bool) Throws an exception if the feature set is not
found
:return: Returns a single feature set
"""
self._connect_core()
try:
get_feature_set_response = self._core_service_stub.GetFeatureSet(
GetFeatureSetRequest(
name=name.strip(),
version=str(version))) # type: GetFeatureSetResponse
feature_set = get_feature_set_response.feature_set
except grpc.RpcError as e:
print(format_grpc_exception("GetFeatureSet", e.code(),
e.details()))
else:
if feature_set is not None:
return FeatureSet.from_proto(feature_set)
if fail_if_missing:
raise Exception(
f'Could not find feature set with name "{name}" and '
f'version "{version}"')
def list_feature_sets(self) -> List[FeatureSet]:
"""
Retrieve a list of feature sets from Feast Core
Returns:
List of feature sets
"""
self._connect_core()
try:
# Get latest feature sets from Feast Core
feature_set_protos = self._core_service_stub.ListFeatureSets(
ListFeatureSetsRequest()) # type: ListFeatureSetsResponse
except grpc.RpcError as e:
raise Exception(
format_grpc_exception("ListFeatureSets", e.code(),
e.details()))
# Extract feature sets and return
feature_sets = []
for feature_set_proto in feature_set_protos.feature_sets:
feature_set = FeatureSet.from_proto(feature_set_proto)
feature_set._client = self
feature_sets.append(feature_set)
return feature_sets
def version(self):
"""
Returns version information from Feast Core and Feast Serving
:return: Dictionary containing Core and Serving versions and status
"""
self._connect_core()
self._connect_serving()
core_version = ""
serving_version = ""
core_status = "not connected"
serving_status = "not connected"
try:
core_version = self._core_service_stub.GetFeastCoreVersion(
GetFeastCoreVersionRequest(),
timeout=GRPC_CONNECTION_TIMEOUT_DEFAULT).version
core_status = "connected"
except grpc.RpcError as e:
print(
format_grpc_exception("GetFeastCoreVersion", e.code(),
e.details()))
try:
serving_version = self._serving_service_stub.GetFeastServingInfo(
GetFeastServingInfoRequest(),
timeout=GRPC_CONNECTION_TIMEOUT_DEFAULT).version
serving_status = "connected"
except grpc.RpcError as e:
print(
format_grpc_exception("GetFeastServingInfo", e.code(),
e.details()))
return {
"core": {
"url": self.core_url,
"version": core_version,
"status": core_status,
},
"serving": {
"url": self.serving_url,
"version": serving_version,
"status": serving_status,
},
}
def _apply_feature_set(self, feature_set: FeatureSet):
"""
Registers a single feature set with Feast
Args:
feature_set: Feature set that will be registered
"""
self._connect_core()
feature_set._client = self
valid, message = feature_set.is_valid()
if not valid:
raise Exception(message)
try:
# Convert the feature set to a request and send to Feast Core
apply_fs_response = self._core_service_stub.ApplyFeatureSet(
ApplyFeatureSetRequest(feature_set=feature_set.to_proto()),
timeout=GRPC_CONNECTION_TIMEOUT_APPLY,
) # type: ApplyFeatureSetResponse
# Extract the returned feature set
applied_fs = FeatureSet.from_proto(apply_fs_response.feature_set)
# If the feature set has changed, update the local copy
if apply_fs_response.status == ApplyFeatureSetResponse.Status.CREATED:
print(
f'Feature set updated/created: "{applied_fs.name}:{applied_fs.version}".'
)
# Deep copy from the returned feature set to the local feature set
feature_set._update_from_feature_set(applied_fs,
is_dirty=False)
return
# If no change has been applied, do nothing
if apply_fs_response.status == ApplyFeatureSetResponse.Status.NO_CHANGE:
print(f"No change detected in feature set {feature_set.name}")
return
except grpc.RpcError as e:
print(
format_grpc_exception("ApplyFeatureSet", e.code(),
e.details()))
def get_feature_set(self,
name: str,
version: int = None) -> Union[FeatureSet, None]:
"""
Retrieve a single feature set from Feast Core
:param name: Name of feature set
:param version: Version of feature set (int)
:return: Returns a single feature set
"""
self._connect_core()
# TODO: Version should only be integer or unset. Core should handle 'latest'
if version is None:
version = "latest"
elif isinstance(version, int):
version = str(version)
else:
raise ValueError(f"Version {version} is not of type integer.")
try:
get_feature_set_response = self._core_service_stub.GetFeatureSets(
GetFeatureSetsRequest(filter=GetFeatureSetsRequest.Filter(
feature_set_name=name.strip(), feature_set_version=version)
)) # type: GetFeatureSetsResponse
except grpc.RpcError as e:
print(
format_grpc_exception("GetFeatureSets", e.code(), e.details()))
else:
num_feature_sets_found = len(
list(get_feature_set_response.feature_sets))
if num_feature_sets_found == 0:
return None
if num_feature_sets_found > 1:
raise Exception(
f'Found {num_feature_sets_found} feature sets with name "{name}"'
f' and version "{version}": {list(get_feature_set_response.feature_sets)}'
)
return FeatureSet.from_proto(
get_feature_set_response.feature_sets[0])
def get_feature_set(
self,
name: str,
version: int = None,
fail_if_missing: bool = False) -> Union[FeatureSet, None]:
"""
Retrieves a feature set. If no version is specified then the latest
version will be returned.
Args:
name: Name of feature set
version: Version of feature set
fail_if_missing: Raise an error if feature set is not found
Returns:
Returns either the specified feature set, or None if not found
"""
self._connect_core()
try:
name = name.strip()
if version is None:
version = 0
get_feature_set_response = self._core_service_stub.GetFeatureSet(
GetFeatureSetRequest(
name=name, version=version)) # type: GetFeatureSetResponse
feature_set = get_feature_set_response.feature_set
except grpc.RpcError as e:
print(format_grpc_exception("GetFeatureSet", e.code(),
e.details()))
else:
if feature_set is not None:
return FeatureSet.from_proto(feature_set)
if fail_if_missing:
raise Exception(
f'Could not find feature set with name "{name}" and '
f'version "{version}"')
def get_batch_features(self, feature_ids: List[str],
entity_rows: pd.DataFrame) -> Job:
"""
Retrieves historical features from a Feast Serving deployment.
Args:
feature_ids: List of feature ids that will be returned for each entity.
Each feature id should have the following format "feature_set_name:version:feature_name".
entity_rows: Pandas dataframe containing entities and a 'datetime' column. Each entity in
a feature set must be present as a column in this dataframe. The datetime column must
contain timestamps in datetime64 format
Returns:
Feast batch retrieval job: feast.job.Job
Example usage:
============================================================
>>> from feast import Client
>>> from datetime import datetime
>>>
>>> feast_client = Client(core_url="localhost:6565", serving_url="localhost:6566")
>>> feature_ids = ["customer:1:bookings_7d"]
>>> entity_rows = pd.DataFrame(
>>> {
>>> "datetime": [pd.datetime.now() for _ in range(3)],
>>> "customer": [1001, 1002, 1003],
>>> }
>>> )
>>> feature_retrieval_job = feast_client.get_batch_features(feature_ids, entity_rows)
>>> df = feature_retrieval_job.to_dataframe()
>>> print(df)
"""
self._connect_serving()
try:
fs_request = _build_feature_set_request(feature_ids)
# Validate entity rows based on entities in Feast Core
self._validate_entity_rows_for_batch_retrieval(
entity_rows, fs_request)
# We want the timestamp column naming to be consistent with the
# rest of Feast
entity_rows.columns = [
"event_timestamp" if col == "datetime" else col
for col in entity_rows.columns
]
# Remove timezone from datetime column
if isinstance(
entity_rows["event_timestamp"].dtype,
pd.core.dtypes.dtypes.DatetimeTZDtype,
):
entity_rows["event_timestamp"] = pd.DatetimeIndex(
entity_rows["event_timestamp"]).tz_localize(None)
# Retrieve serving information to determine store type and staging location
serving_info = self._serving_service_stub.GetFeastServingInfo(
GetFeastServingInfoRequest(),
timeout=GRPC_CONNECTION_TIMEOUT_DEFAULT
) # type: GetFeastServingInfoResponse
if serving_info.type != FeastServingType.FEAST_SERVING_TYPE_BATCH:
raise Exception(
f'You are connected to a store "{self._serving_url}" which does not support batch retrieval'
)
# Export and upload entity row dataframe to staging location provided by Feast
staged_file = export_dataframe_to_staging_location(
entity_rows, serving_info.job_staging_location) # type: str
request = GetBatchFeaturesRequest(
feature_sets=fs_request,
dataset_source=DatasetSource(
file_source=DatasetSource.FileSource(
file_uris=[staged_file],
data_format=DataFormat.DATA_FORMAT_AVRO)),
)
# Retrieve Feast Job object to manage life cycle of retrieval
response = self._serving_service_stub.GetBatchFeatures(request)
return Job(response.job, self._serving_service_stub)
except grpc.RpcError as e:
print(
format_grpc_exception("GetBatchFeatures", e.code(),
e.details()))
