frogml-core 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

frogml_core/feature_store/online/client.py

@@ -0,0 +1,352 @@
+import logging
+import math
+from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple
+
+from frogml_proto.qwak.ecosystem.v0.ecosystem_pb2 import (
+    AuthenticatedUnifiedUserContext,
+)
+from frogml_proto.qwak.feature_store.serving.serving_pb2 import (
+    BatchFeature as ServingProtoBatchFeature,
+)
+from frogml_proto.qwak.feature_store.serving.serving_pb2 import (
+    BatchV1Feature as ServingProtoBatchV1Feature,
+)
+from frogml_proto.qwak.feature_store.serving.serving_pb2 import (
+    EntitiesHeader,
+    EntityToFeatures,
+    EntityValueRow,
+)
+from frogml_proto.qwak.feature_store.serving.serving_pb2 import (
+    Feature as ServingProtoFeature,
+)
+from frogml_proto.qwak.feature_store.serving.serving_pb2 import (
+    RequestedEntitiesMatrix,
+    RequestedEntitiesMatrixRequest,
+    RequestMetaData,
+)
+from frogml_proto.qwak.feature_store.serving.serving_pb2 import (
+    StreamingAggregationFeature as ServingProtoStreamingAggregationFeature,
+)
+from frogml_proto.qwak.feature_store.serving.serving_pb2 import (
+    StreamingFeature as ServingProtoStreamingFeature,
+)
+from frogml_proto.qwak.feature_store.serving.serving_pb2 import (
+    StreamingV1Feature as ServingProtoStreamingV1Feature,
+)
+from frogml_proto.qwak.feature_store.serving.serving_pb2_grpc import ServingServiceStub
+from frogml_core.clients.administration.eco_system.client import EcosystemClient
+from frogml_core.exceptions import FrogmlException
+from frogml_core.feature_store._common.feature_set_utils import (
+    BatchFeature,
+    BatchFeatureV1,
+    StreamingAggregationFeature,
+    StreamingFeature,
+    StreamingFeatureV1,
+)
+from frogml_core.feature_store.online import endpoint_utils
+from frogml_core.feature_store.online.endpoint_utils import EndpointConfig
+from frogml_core.inner.tool.grpc.grpc_tools import create_grpc_channel
+from frogml_core.model.schema import ModelSchema
+from frogml_core.model.schema_entities import BaseFeature, RequestInput
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    try:
+        import pandas as pd
+    except ImportError:
+        pass
+
+
+class OnlineClient:
+    """
+    Online Feature Serving client
+    """
+
+    def __init__(
+        self,
+        enable_ssl=True,
+        endpoint_url: Optional[str] = None,
+        metadata: Optional[Sequence[Tuple[str]]] = None,
+    ):
+        self._metadata = metadata
+
+        options = (
+            ("grpc.keepalive_timeout_ms", 1500),
+            ("grpc.client_idle_timeout_ms", 60 * 1000),
+        )
+
+        if endpoint_url is None:
+            user_context: AuthenticatedUnifiedUserContext = (
+                EcosystemClient().get_authenticated_user_context().user
+            )
+            conf: EndpointConfig = endpoint_utils.get_config_by_account_type(
+                user_context
+            )
+            endpoint_url = conf.endpoint_url
+            if conf.enable_ssl is not None:
+                enable_ssl = conf.enable_ssl
+
+            if conf.metadata is not None:
+                self._metadata = conf.metadata
+
+        channel = create_grpc_channel(
+            url=endpoint_url, enable_ssl=enable_ssl, options=options
+        )
+
+        self._serving_client: ServingServiceStub = ServingServiceStub(channel)
+
+    @staticmethod
+    def to_string_entities_values(values) -> List[str]:
+        return [str(value) for value in values]
+
+    def get_feature_values(
+        self,
+        schema: ModelSchema,
+        df: "pd.DataFrame",
+        model_name: str = "no-model",
+        *,
+        max_keys_per_request: int = 500,
+    ) -> "pd.DataFrame":
+        """
+        :param schema: a ModelSchema object - defines the entities, features and prediction (irelevant in this case).
+        :param df: a pandas data-frame with a column for each explicit feature needed
+                         and a column for each entity key defined in the schema.
+        :param model_name: the name of the model to retrieve the features for.
+        :param max_keys_per_request: the maximum number of keys per request to the backend
+        :return: a pandas data-frame - the feature values defined in the schema
+                                       of the requested entities in the df.
+
+        each row in the returned data-frame is constructed by retrieving the most recent requested feature values
+        of the entity key(s) for the specific entity value(s) defined in the df.
+
+        TODO: fix imports and align example
+        Examples:
+        >>> import pandas as pd
+        >>> from frogml_core.feature_store import OnlineClient
+        >>> from frogml_core.model.schema import (
+        >>>     ModelSchema, FeatureStoreInput
+        >>> )
+        >>>
+        >>> user_id = Entity(name='uuid', type=str)
+        >>>
+        >>> model_schema = ModelSchema(
+        >>>     entities=[
+        >>>         user_id
+        >>>     ],
+        >>>     inputs=[
+        >>>         FeatureStoreInput(entity=user_id, name='user_purchases.number_of_purchases'),
+        >>>         FeatureStoreInput(entity=user_id, name='user_purchases.avg_purchase_amount'),
+        >>>     ],
+        >>>     outputs=[
+        >>>         InferenceOutput(name="score", type=float)
+        >>>     ])
+        >>>
+        >>> online_client = OnlineClient()
+        >>>
+        >>> df = pd.DataFrame(columns=  ['uuid', 'explicit_feature_purchase_price'],
+        >>>                   data   =  [ '1'  ,                22                ])
+        >>>
+        >>> user_features = online_client.get_feature_values(
+        >>>                     model_schema,
+        >>>                     df)
+        >>>
+        >>> print(user_features.head())
+        >>>	#       user_purchases.number_of_purchases	user_purchases.avg_purchase_amount    otf_quad_price
+        >>> # 0	                    76	                              4.796842                     484
+        """
+        try:
+            import pandas as pd
+        except ImportError:
+            raise FrogmlException(
+                "Missing Pandas dependency required for querying the online feature store"
+            )
+
+        (
+            entity_features_compounds,
+            entities_with_index,
+            feature_set_names,
+        ) = self._create_entity_and_features_sets(
+            schema, pd.DataFrame(df.iloc[0]).transpose()
+        )
+
+        if not entity_features_compounds:
+            df_result = pd.DataFrame(
+                columns=[
+                    input_field.name
+                    for input_field in schema._inputs
+                    if isinstance(input_field, BaseFeature)
+                ]
+            )
+
+            return pd.concat([df, df_result], axis=1, join="inner")
+
+        entities_to_features = []
+        for entity_features_compound in entity_features_compounds.values():
+            entities_to_features.append(
+                EntityToFeatures(
+                    features=entity_features_compound.features,
+                    entity_name=entity_features_compound.entity_name,
+                )
+            )
+
+        ordered_entities_tuple = sorted(
+            entities_with_index, key=lambda entity: entity[1]
+        )
+        ordered_entities = [entity[0] for entity in ordered_entities_tuple]
+
+        request_chunks: List[
+            Tuple[RequestedEntitiesMatrix, pd.DataFrame]
+        ] = OnlineClient._split_entities(
+            entity_names=ordered_entities,
+            population_df=df,
+            max_entities_per_split=max_keys_per_request,
+        )
+
+        results: List[pd.DataFrame] = []
+        for matrix, population_df in request_chunks:
+            request = RequestedEntitiesMatrixRequest(
+                entity_values_matrix=matrix,
+                entities_to_features=entities_to_features,
+                request_meta_data=RequestMetaData(
+                    model_name=model_name,
+                    feature_set_names=list(feature_set_names),
+                    num_keys=len(population_df),
+                ),
+            )
+            try:
+                response_df_json, _ = self._serving_client.GetMultiFeatures.with_call(
+                    request, metadata=self._metadata
+                )
+                features_df: pd.DataFrame = pd.read_json(
+                    response_df_json.pandas_df_as_json, orient="split"
+                )
+                results.append(
+                    pd.concat(
+                        [population_df.reset_index(drop=True), features_df],
+                        axis=1,
+                        join="inner",
+                    )
+                )
+            except Exception as e:
+                raise FrogmlException(
+                    f"Failed to retrieve online feature values, got {repr(e)}"
+                )
+
+        res = pd.concat(results, axis=0)
+        res.index = df.index
+        return res
+
+    @staticmethod
+    def _split_entities(
+        entity_names: List[str],
+        population_df: "pd.DataFrame",
+        max_entities_per_split: int,
+    ) -> List[Tuple[RequestedEntitiesMatrix, "pd.DataFrame"]]:
+        entity_values: List[List[str]] = population_df[entity_names].values.tolist()
+
+        num_batches: int = math.ceil(len(entity_values) / max_entities_per_split)
+
+        res: List[Tuple[RequestedEntitiesMatrix, pd.DataFrame]] = []
+        for i in range(num_batches):
+            curr_entities: List[List[str]] = entity_values[
+                i * max_entities_per_split : (i + 1) * max_entities_per_split
+            ]
+            curr_population_df = population_df[
+                i * max_entities_per_split : (i + 1) * max_entities_per_split
+            ]
+            curr_entity_rows: List[EntityValueRow] = [
+                EntityValueRow(
+                    index=idx, entity_values=OnlineClient.to_string_entities_values(v)
+                )
+                for idx, v in enumerate(curr_entities)
+            ]
+
+            res.append(
+                (
+                    RequestedEntitiesMatrix(
+                        header=EntitiesHeader(entity_names=entity_names),
+                        rows=curr_entity_rows,
+                    ),
+                    curr_population_df,
+                )
+            )
+        return res
+
+    @staticmethod
+    def _create_entity_and_features_sets(schema: ModelSchema, df: "pd.DataFrame"):
+        entity_features_compounds = {}
+        list_of_df_columns = df.columns.to_list()
+        entities_and_indexes = []
+        feature_set_names = set()
+        for entity in schema._entities:
+            if entity.name not in df:
+                logger.error(
+                    f"Schema entity key '{entity.name}' does not exist in the request DataFrame"
+                )
+            else:
+                entity_features_compounds[entity.name] = EntityFeaturesCompound(
+                    entity.name, df[entity.name]
+                )
+                entities_and_indexes.append(
+                    (entity.name, list_of_df_columns.index(entity.name))
+                )
+
+        for feature in [
+            feature
+            for feature in schema._inputs
+            if not isinstance(feature, RequestInput)
+        ]:
+            if feature.entity.name not in entity_features_compounds:
+                logger.info(
+                    f"The entity: {feature.entity.name} of the Feature: {feature} does not exist in the entities list"
+                )
+
+            else:
+                if isinstance(feature, BatchFeatureV1):
+                    feature_proto = ServingProtoFeature(
+                        batch_v1_feature=ServingProtoBatchV1Feature(name=feature.name)
+                    )
+                elif isinstance(feature, BatchFeature):
+                    feature_proto = ServingProtoFeature(
+                        batch_feature=ServingProtoBatchFeature(name=feature.name)
+                    )
+                elif isinstance(feature, StreamingFeature):
+                    feature_proto = ServingProtoFeature(
+                        streaming_feature=ServingProtoStreamingFeature(
+                            name=feature.name
+                        )
+                    )
+                elif isinstance(feature, StreamingFeatureV1):
+                    feature_proto = ServingProtoFeature(
+                        streaming_v1_feature=ServingProtoStreamingV1Feature(
+                            name=feature.name
+                        )
+                    )
+                elif isinstance(feature, StreamingAggregationFeature):
+                    feature_proto = ServingProtoFeature(
+                        streaming_aggregation=ServingProtoStreamingAggregationFeature(
+                            name=feature.name
+                        )
+                    )
+                else:
+                    raise ValueError(
+                        f"Not support type for feature extraction - {type(feature)}"
+                    )
+
+                entity_features_compounds[feature.entity.name].add_feature(
+                    feature_proto
+                )
+                feature_set_names.add(feature.name.split(".")[0])
+
+        return entity_features_compounds, entities_and_indexes, feature_set_names
+
+
+class EntityFeaturesCompound:
+    def __init__(self, entity_name, entity_value):
+        self.entity_name = entity_name
+        self.entity_value = entity_value
+        self.features = []
+
+    def add_feature(self, feature):
+        self.features.append(feature)

frogml_core/feature_store/online/endpoint_utils.py

@@ -0,0 +1,65 @@
+import os
+from dataclasses import dataclass
+from typing import Optional, Sequence, Tuple
+
+from frogml_proto.qwak.administration.account.v1.account_pb2 import AccountType
+from frogml_proto.qwak.ecosystem.v0.ecosystem_pb2 import (
+    AuthenticatedUnifiedUserContext,
+)
+from frogml_core.exceptions import FrogmlException
+
+_ONLINE_SERVING_ENDPOINT_OVERRIDE_ENV_VAR = "ONLINE_SERVING_ENDPOINT"
+_default_endpoint_url = "fs-serving-webapp.frogml.svc.cluster.local:6577/com.frogml.ai.feature.store.serving.api.ServingService"
+
+
+@dataclass
+class EndpointConfig:
+    endpoint_url: str
+    metadata: Optional[Sequence[Tuple[str, str]]]
+    enable_ssl: Optional[bool]
+
+
+def _get_direct_endpoint(
+    user_context: AuthenticatedUnifiedUserContext,
+) -> EndpointConfig:
+    endpoint_url: str = os.environ.get(
+        _ONLINE_SERVING_ENDPOINT_OVERRIDE_ENV_VAR, _default_endpoint_url
+    )
+    # As of time of writing, feature-store is single env!
+    metadata = (
+        ("frogml-user-id", user_context.user_id),
+        ("frogml-account-id", user_context.account_details.id),
+        ("frogml-environment-id", user_context.account_details.default_environment_id),
+    )
+
+    return EndpointConfig(
+        endpoint_url=endpoint_url, metadata=metadata, enable_ssl=False
+    )
+
+
+def _get_edge_services_endpoint(
+    user_context: AuthenticatedUnifiedUserContext,
+) -> EndpointConfig:
+    environment_id: str = user_context.account_details.default_environment_id
+
+    if environment_id not in user_context.account_details.environment_by_id:
+        raise FrogmlException(
+            f"Configuration for environment [{environment_id}] was not found"
+        )
+
+    endpoint_url: str = user_context.account_details.environment_by_id[
+        environment_id
+    ].configuration.edge_services_url
+
+    return EndpointConfig(endpoint_url=endpoint_url, metadata=None, enable_ssl=None)
+
+
+def get_config_by_account_type(
+    user_context: AuthenticatedUnifiedUserContext,
+) -> EndpointConfig:
+    user_account_type: AccountType = user_context.account_details.type
+
+    if user_account_type == AccountType.HYBRID and "K8S_POD_NAME" in os.environ:
+        return _get_direct_endpoint(user_context)
+    else:
+        return _get_edge_services_endpoint(user_context)

frogml_core/feature_store/sinks/base.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from frogml_proto.qwak.feature_store.sinks.sink_pb2 import (
+    StreamingSink as ProtoStreamingSink,
+)
+
+
+@dataclass
+class BaseSink(ABC):
+    name: str
+
+    @abstractmethod
+    def to_proto_streaming_sink(self) -> ProtoStreamingSink:
+        pass
+
+    def __post_init__(self):
+        pass

frogml_core/feature_store/sinks/kafka.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+from frogml_proto.qwak.feature_store.sinks.sink_pb2 import KafkaSink as ProtoKafkaSink
+from frogml_proto.qwak.feature_store.sinks.sink_pb2 import (
+    StreamingSink as ProtoStreamingSink,
+)
+from frogml_proto.qwak.feature_store.sources.streaming_pb2 import (
+    MessageFormat as ProtoMessageFormat,
+)
+from frogml_core.exceptions import FrogmlException
+from frogml_core.feature_store.data_sources.streaming.kafka.authentication import (
+    BaseAuthentication,
+)
+from frogml_core.feature_store.sinks.base import BaseSink
+from frogml_core.feature_store.sinks.streaming.attachment import (
+    StreamingAttachmentPoint,
+)
+
+
+class MessageFormat(Enum):
+    JSON = ProtoMessageFormat.JSON
+
+
+@dataclass
+class KafkaSink(BaseSink):
+    topic: str
+    bootstrap_servers: str
+    message_format: MessageFormat
+    auth_configuration: BaseAuthentication
+    attachment_point: Optional[StreamingAttachmentPoint]
+
+    def _to_proto_kafka_sink(self) -> ProtoKafkaSink:
+        return ProtoKafkaSink(
+            topic=self.topic,
+            bootstrap_servers=self.bootstrap_servers,
+            message_format=self.message_format.value,
+            auth_config=self.auth_configuration._to_proto(),
+        )
+
+    def to_proto_streaming_sink(self) -> ProtoStreamingSink:
+        if self.attachment_point is None:
+            raise FrogmlException(
+                "A Sink must have an attachment point configured in order for it to be used as a streaming sink"
+            )
+
+        proto_kafka_sink: ProtoKafkaSink = self._to_proto_kafka_sink()
+
+        return ProtoStreamingSink(
+            name=self.name,
+            kafka_sink=proto_kafka_sink,
+            attachment_point=self.attachment_point._to_proto(),
+        )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self._validate()
+
+    def _validate(self):
+        pass

frogml_core/feature_store/sinks/streaming/attachment.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from frogml_proto.qwak.feature_store.sinks.sink_pb2 import (
+    OfflineStreamingAttachmentPoint as ProtoOfflineStreamingAttachmentPoint,
+)
+from frogml_proto.qwak.feature_store.sinks.sink_pb2 import (
+    OnlineStreamingAttachmentPoint as ProtoOnlineStreamingAttachmentPoint,
+)
+from frogml_proto.qwak.feature_store.sinks.sink_pb2 import (
+    StreamingAttachmentPoint as ProtoStreamingAttachmentPoint,
+)
+
+
+class StreamingAttachmentPoint(ABC):
+    @abstractmethod
+    def _to_proto(self) -> ProtoStreamingAttachmentPoint:
+        pass
+
+
+@dataclass
+class OfflineStreamingAttachmentPoint(StreamingAttachmentPoint):
+    def _to_proto(self) -> ProtoStreamingAttachmentPoint:
+        return ProtoStreamingAttachmentPoint(
+            offline_streaming_attachment_point=ProtoOfflineStreamingAttachmentPoint()
+        )
+
+
+@dataclass
+class OnlineStreamingAttachmentPoint(StreamingAttachmentPoint):
+    def _to_proto(self) -> ProtoStreamingAttachmentPoint:
+        return ProtoStreamingAttachmentPoint(
+            online_streaming_attachment_point=ProtoOnlineStreamingAttachmentPoint()
+        )

frogml_core/feature_store/sinks/streaming/factory.py

@@ -0,0 +1,60 @@
+from typing import cast
+
+from frogml_proto.qwak.feature_store.sinks.sink_pb2 import KafkaSink as ProtoKafkaSink
+from frogml_proto.qwak.feature_store.sinks.sink_pb2 import (
+    StreamingAttachmentPoint as ProtoStreamingAttachmentPoint,
+)
+from frogml_proto.qwak.feature_store.sinks.sink_pb2 import (
+    StreamingSink as ProtoStreamingSink,
+)
+from frogml_core.feature_store.data_sources.streaming.kafka.authentication import (
+    BaseAuthentication,
+)
+from frogml_core.feature_store.sinks.base import BaseSink
+from frogml_core.feature_store.sinks.kafka import KafkaSink
+from frogml_core.feature_store.sinks.kafka import MessageFormat as KafkaMessageFormat
+from frogml_core.feature_store.sinks.streaming.attachment import (
+    OfflineStreamingAttachmentPoint,
+    OnlineStreamingAttachmentPoint,
+    StreamingAttachmentPoint,
+)
+
+
+class StreamingSinkFactory:
+    @staticmethod
+    def get_streaming_sink(proto_streaming_sink: ProtoStreamingSink) -> BaseSink:
+        sink_type = proto_streaming_sink.WhichOneof("sink_type")
+
+        auth_conf: BaseAuthentication
+        if sink_type == "kafka_sink":
+            proto_kafka_sink: ProtoKafkaSink = proto_streaming_sink.kafka_sink
+            auth_configuration: BaseAuthentication = cast(
+                BaseAuthentication,
+                BaseAuthentication._from_proto(proto_kafka_sink.auth_config),
+            )
+            return KafkaSink(
+                name=proto_streaming_sink.name,
+                topic=proto_kafka_sink.topic,
+                bootstrap_servers=proto_kafka_sink.bootstrap_servers,
+                message_format=KafkaMessageFormat(proto_kafka_sink.message_format),
+                auth_configuration=auth_configuration,
+                attachment_point=StreamingSinkFactory._get_attachment_point(
+                    proto_streaming_sink.attachment_point
+                ),
+            )
+
+    @staticmethod
+    def _get_attachment_point(
+        proto_attachment_point: ProtoStreamingAttachmentPoint,
+    ) -> StreamingAttachmentPoint:
+        attachment_point_type = proto_attachment_point.WhichOneof(
+            "attachment_point_type"
+        )
+        if attachment_point_type == "online_streaming_attachment_point":
+            return OnlineStreamingAttachmentPoint()
+        elif attachment_point_type == "offline_streaming_attachment_point":
+            return OfflineStreamingAttachmentPoint()
+        else:
+            raise ValueError(
+                f"Unidentified streaming attachment point type: {attachment_point_type}"
+            )

frogml_core/feature_store/validations/validation_options.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+from google.protobuf.timestamp_pb2 import Timestamp as ProtoTimestamp
+
+from frogml_proto.qwak.features_operator.v3.features_operator_async_service_pb2 import (
+    DataSourceValidationOptions as ProtoDataSourceValidationOptions,
+)
+from frogml_proto.qwak.features_operator.v3.features_operator_async_service_pb2 import (
+    FeatureSetValidationOptions as ProtoFeatureSetValidationOptions,
+)
+from frogml_proto.qwak.features_operator.v3.features_operator_async_service_pb2 import (
+    ValidationTimeRange as ProtoValidationTimeRange,
+)
+from frogml_core.utils.datetime_utils import datetime_to_pts
+
+
+@dataclass
+class ValidationTimeRange:
+    lower_time_bound: Optional[datetime] = None
+    upper_time_bound: Optional[datetime] = None
+
+    def to_proto(self) -> ProtoValidationTimeRange:
+        lower_time_bound_proto: Optional[ProtoTimestamp] = None
+        upper_time_bound_proto: Optional[ProtoTimestamp] = None
+
+        if self.lower_time_bound:
+            lower_time_bound_proto = datetime_to_pts(self.lower_time_bound)
+        if self.upper_time_bound:
+            upper_time_bound_proto = datetime_to_pts(self.upper_time_bound)
+
+        return ProtoValidationTimeRange(
+            lower_time_bound=lower_time_bound_proto,
+            upper_time_bound=upper_time_bound_proto,
+        )
+
+
+@dataclass
+class DataSourceValidationOptions:
+    time_range: Optional[ValidationTimeRange] = field(
+        default_factory=lambda: ValidationTimeRange()
+    )
+
+    def __init__(
+        self,
+        lower_time_bound: Optional[datetime] = None,
+        upper_time_bound: Optional[datetime] = None,
+    ):
+        self.time_range = ValidationTimeRange(
+            lower_time_bound=lower_time_bound, upper_time_bound=upper_time_bound
+        )
+
+    def to_proto(self) -> ProtoDataSourceValidationOptions:
+        return ProtoDataSourceValidationOptions(
+            validation_time_range=self.time_range.to_proto()
+        )
+
+
+@dataclass
+class FeatureSetValidationOptions:
+    time_range: Optional[ValidationTimeRange] = field(
+        default_factory=lambda: ValidationTimeRange()
+    )
+    data_source_limit: Optional[int] = None
+
+    def __init__(
+        self,
+        lower_time_bound: Optional[datetime] = None,
+        upper_time_bound: Optional[datetime] = None,
+        data_source_limit: Optional[int] = None,
+    ):
+        self.time_range = ValidationTimeRange(
+            lower_time_bound=lower_time_bound, upper_time_bound=upper_time_bound
+        )
+        self.data_source_limit = data_source_limit
+
+    def to_proto(self) -> ProtoFeatureSetValidationOptions:
+        return ProtoFeatureSetValidationOptions(
+            data_source_limit=self.data_source_limit,
+            validation_time_range=self.time_range.to_proto(),
+        )