qwak-core 0.1.37__py3-none-any.whl → 0.5.19__py3-none-any.whl

qwak/feature_store/online/client.py

@@ -1,6 +1,8 @@
 import logging
-from typing import TYPE_CHECKING, List, Optional
+import math
+from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple
 
+from _qwak_proto.qwak.ecosystem.v0.ecosystem_pb2 import AuthenticatedUnifiedUserContext
 from _qwak_proto.qwak.feature_store.serving.serving_pb2 import (
     BatchFeature as ServingProtoBatchFeature,
     BatchV1Feature as ServingProtoBatchV1Feature,
@@ -8,15 +10,25 @@ from _qwak_proto.qwak.feature_store.serving.serving_pb2 import (
     EntityToFeatures,
     EntityValueRow,
     Feature as ServingProtoFeature,
-    MultiFeatureValuesResponse,
     RequestedEntitiesMatrix,
     RequestedEntitiesMatrixRequest,
     RequestMetaData,
+    StreamingAggregationFeature as ServingProtoStreamingAggregationFeature,
+    StreamingFeature as ServingProtoStreamingFeature,
+    StreamingV1Feature as ServingProtoStreamingV1Feature,
 )
 from _qwak_proto.qwak.feature_store.serving.serving_pb2_grpc import ServingServiceStub
 from qwak.clients.administration.eco_system.client import EcosystemClient
 from qwak.exceptions import QwakException
-from qwak.feature_store._common.feature_set_utils import BatchFeature, BatchFeatureV1
+from qwak.feature_store._common.feature_set_utils import (
+    BatchFeature,
+    BatchFeatureV1,
+    StreamingAggregationFeature,
+    StreamingFeature,
+    StreamingFeatureV1,
+)
+from qwak.feature_store.online import endpoint_utils
+from qwak.feature_store.online.endpoint_utils import EndpointConfig
 from qwak.inner.tool.grpc.grpc_tools import create_grpc_channel
 from qwak.model.schema import ModelSchema
 from qwak.model.schema_entities import BaseFeature, RequestInput
@@ -35,42 +47,59 @@ class OnlineClient:
     Online Feature Serving client
     """
 
-    def __init__(self, enable_ssl=True, endpoint_url: Optional[str] = None):
+    def __init__(
+        self,
+        enable_ssl=True,
+        endpoint_url: Optional[str] = None,
+        metadata: Optional[Sequence[Tuple[str]]] = None,
+    ):
+        self._metadata = metadata
+        self._enable_ssl = enable_ssl
+        self._endpoint_url = endpoint_url
+
         options = (
             ("grpc.keepalive_timeout_ms", 1500),
             ("grpc.client_idle_timeout_ms", 60 * 1000),
         )
 
         if endpoint_url is None:
-            user_context = EcosystemClient().get_authenticated_user_context().user
-            environment_id = user_context.account_details.default_environment_id
-
-            if environment_id not in user_context.account_details.environment_by_id:
-                raise QwakException(
-                    f"Configuration for environment [{environment_id}] was not found"
-                )
+            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
 
-            endpoint_url = user_context.account_details.environment_by_id[
-                environment_id
-            ].configuration.edge_services_url
+            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(channel)
+        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"
+        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.
 
@@ -139,9 +168,7 @@ class OnlineClient:
             return pd.concat([df, df_result], axis=1, join="inner")
 
         entities_to_features = []
-        number_of_keys_to_extract = 0
         for entity_features_compound in entity_features_compounds.values():
-            number_of_keys_to_extract += len(entity_features_compound.features)
             entities_to_features.append(
                 EntityToFeatures(
                     features=entity_features_compound.features,
@@ -153,40 +180,101 @@ class OnlineClient:
             entities_with_index, key=lambda entity: entity[1]
         )
         ordered_entities = [entity[0] for entity in ordered_entities_tuple]
-        entities_values = df[ordered_entities].values.tolist()
 
-        entities_values_req = []
-        for index, values in enumerate(entities_values):
-            list_of_string_values = self.to_string_entities_values(values)
-            entities_values_req.append(
-                EntityValueRow(index=index, entity_values=list_of_string_values)
+        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,
             )
-
-        requested_entities_matrix = RequestedEntitiesMatrix(
-            header=EntitiesHeader(entity_names=ordered_entities),
-            rows=entities_values_req,
         )
 
-        feature_value_requests = RequestedEntitiesMatrixRequest(
-            entity_values_matrix=requested_entities_matrix,
-            entities_to_features=entities_to_features,
-            request_meta_data=RequestMetaData(
-                model_name=model_name,
-                feature_set_names=list(feature_set_names),
-                num_keys=number_of_keys_to_extract,
-            ),
-        )
-
-        try:
-            response_df_json: MultiFeatureValuesResponse = (
-                self._serving_client.GetMultiFeatures(feature_value_requests)
+        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),
+                ),
             )
-            result_df = pd.read_json(response_df_json.pandas_df_as_json, orient="split")
-            return pd.concat(
-                [df.reset_index(drop=True), result_df], axis=1, join="inner"
+            try:
+                response_df_json, _ = self._serving_client.GetMultiFeatures.with_call(
+                    request, metadata=self._metadata
+                )
+                try:
+                    # Try orjson first (fastest - 6x speedup)
+                    import orjson
+
+                    parsed_data = orjson.loads(response_df_json.pandas_df_as_json)
+                    features_df: pd.DataFrame = pd.DataFrame(
+                        data=parsed_data["data"],
+                        columns=parsed_data["columns"],
+                        index=parsed_data["index"],
+                    )
+                except ImportError:
+                    # Fallback: Direct json.loads + DataFrame (2x speedup, no deps)
+                    import json
+
+                    parsed_data = json.loads(response_df_json.pandas_df_as_json)
+                    features_df: pd.DataFrame = pd.DataFrame(
+                        data=parsed_data["data"],
+                        columns=parsed_data["columns"],
+                        index=parsed_data["index"],
+                    )
+                results.append(
+                    pd.concat(
+                        [population_df.reset_index(drop=True), features_df],
+                        axis=1,
+                        join="inner",
+                    )
+                )
+            except Exception as e:
+                raise QwakException(
+                    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,
+                )
             )
-        except Exception as e:
-            raise QwakException(f"Failed to get online features results. Error is: {e}")
+        return res
 
     @staticmethod
     def _create_entity_and_features_sets(schema: ModelSchema, df: "pd.DataFrame"):
@@ -226,6 +314,24 @@ class OnlineClient:
                     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)}"

qwak/feature_store/online/endpoint_utils.py

@@ -0,0 +1,63 @@
+import os
+from dataclasses import dataclass
+from typing import Optional, Sequence, Tuple
+
+from _qwak_proto.qwak.administration.account.v1.account_pb2 import AccountType
+from _qwak_proto.qwak.ecosystem.v0.ecosystem_pb2 import AuthenticatedUnifiedUserContext
+from qwak.exceptions import QwakException
+
+_ONLINE_SERVING_ENDPOINT_OVERRIDE_ENV_VAR = "ONLINE_SERVING_ENDPOINT"
+_default_endpoint_url = "fs-serving-webapp.qwak.svc.cluster.local:6577/com.qwak.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 = (
+        ("qwak-user-id", user_context.user_id),
+        ("qwak-account-id", user_context.account_details.id),
+        ("qwak-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 QwakException(
+            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)

qwak/feature_store/sinks/base.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from _qwak_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

qwak/feature_store/sinks/kafka.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+from _qwak_proto.qwak.feature_store.sinks.sink_pb2 import (
+    KafkaSink as ProtoKafkaSink,
+    StreamingSink as ProtoStreamingSink,
+)
+from _qwak_proto.qwak.feature_store.sources.streaming_pb2 import (
+    MessageFormat as ProtoMessageFormat,
+)
+from qwak.exceptions import QwakException
+from qwak.feature_store.data_sources.streaming.kafka.authentication import (
+    BaseAuthentication,
+)
+from qwak.feature_store.sinks.base import BaseSink
+from qwak.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 QwakException(
+                "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

qwak/feature_store/sinks/streaming/attachment.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from _qwak_proto.qwak.feature_store.sinks.sink_pb2 import (
+    OfflineStreamingAttachmentPoint as ProtoOfflineStreamingAttachmentPoint,
+    OnlineStreamingAttachmentPoint as ProtoOnlineStreamingAttachmentPoint,
+    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()
+        )

qwak/feature_store/sinks/streaming/factory.py

@@ -0,0 +1,60 @@
+from typing import cast
+
+from _qwak_proto.qwak.feature_store.sinks.sink_pb2 import (
+    KafkaSink as ProtoKafkaSink,
+    StreamingAttachmentPoint as ProtoStreamingAttachmentPoint,
+    StreamingSink as ProtoStreamingSink,
+)
+from qwak.feature_store.data_sources.streaming.kafka.authentication import (
+    BaseAuthentication,
+)
+from qwak.feature_store.sinks.base import BaseSink
+from qwak.feature_store.sinks.kafka import (
+    KafkaSink,
+    MessageFormat as KafkaMessageFormat,
+)
+from qwak.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}"
+            )

qwak/feature_store/validations/validation_decorators.py

@@ -0,0 +1,70 @@
+from functools import wraps
+
+from qwak.exceptions import QwakException
+from qwak.feature_store.validations.validation_response import SuccessValidationResponse
+
+
+def silence_backend_specific_validation_exceptions(*error_messages_to_silence):
+    """
+    A decorator that catches specific backend validation exceptions and returns a standardized
+    validation success response encapsulating the exception details. Used to skip the validation
+    process for certain backend exceptions. hopefully will be removed soon after validations will be supported on
+    all environment types.
+
+    Parameters:
+        *error_messages_to_silence: Variable length argument list
+            Messages that, if present in the exception message, should trigger the
+            standardized validation success response instead of propagating the exception.
+
+    Returns:
+        function
+            The wrapped function that will catch specified backend validation exceptions
+            and return a standardized validation success response if any of the specified
+            error messages are found in the exception message.
+
+    Usage:
+    ------
+    @silence_backend_specific_validation_exceptions(
+        "Validating DataSource is not supported for self-hosted environments",
+        "Validating DataSource is not supported for SAAS environments"
+    )
+    def validate_data_source():
+        # Your function implementation
+
+    When 'validate_data_source_blocking' raises a QwakException containing one of the specified error messages,
+    it will return a SuccessValidationResponse, including the
+    exception's representation in stderr and in the sample as a dataframe with a warning column.
+    If the exception message does not contain any of the specified error messages, the exception is raised normally.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, silence_specific_exceptions: bool = True, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except QwakException as e:
+                is_to_silent_error = silence_specific_exceptions and any(
+                    error_message in repr(e)
+                    for error_message in error_messages_to_silence
+                )
+                if not is_to_silent_error:
+                    raise e
+
+                try:
+                    import pandas as pd
+                except ImportError as exc:
+                    raise QwakException("Missing required Pandas dependency") from exc
+
+                return (
+                    SuccessValidationResponse(
+                        sample=pd.DataFrame({"errors": [repr(e)]}),
+                        features=[],
+                        stdout="",
+                        stderr=repr(e),
+                    ),
+                    None,
+                )
+
+        return wrapper
+
+    return decorator

qwak/feature_store/validations/validation_options.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+from _qwak_proto.qwak.features_operator.v3.features_operator_async_service_pb2 import (
+    DataSourceValidationOptions as ProtoDataSourceValidationOptions,
+    FeatureSetValidationOptions as ProtoFeatureSetValidationOptions,
+    ValidationTimeRange as ProtoValidationTimeRange,
+)
+from google.protobuf.timestamp_pb2 import Timestamp as ProtoTimestamp
+from qwak.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(),
+        )