frogml-core 0.0.116__py3-none-any.whl → 0.0.118__py3-none-any.whl

frogml_core/feature_store/online/client.py

@@ -1,355 +0,0 @@
-import logging
-import math
-from io import StringIO
-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: bool = True,
-        endpoint_url: Optional[str] = None,
-        metadata: Optional[Sequence[Tuple[str]]] = None,
-    ):
-        self._metadata: Optional[Sequence[Tuple[str]]] = metadata
-        self._enable_ssl: bool = enable_ssl
-        self._endpoint_url: Optional[str] = endpoint_url
-
-        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.
-
-        Examples:
-        >>> import pandas as pd
-        >>> from frogml_core.feature_store.online.client import OnlineClient
-        >>> from frogml_core.model.schema import (
-        >>>     ModelSchema, FeatureStoreInput
-        >>> )
-        >>> from frogml_core.model.schema_entities import Entity, InferenceOutput
-        >>>
-        >>> 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(
-                    StringIO(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

@@ -1,65 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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  # noqa: F842
-        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

@@ -1,82 +0,0 @@
-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(),
-        )