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

qwak/clients/feature_store/offline_serving_client.py

@@ -0,0 +1,251 @@
+import logging
+from typing import List, Optional
+
+import grpc
+from _qwak_proto.qwak.offline.serving.v1.feature_values_pb2 import (
+    FeaturesetFeatures as ProtoFeaturesetFeatures,
+)
+from _qwak_proto.qwak.offline.serving.v1.offline_serving_async_service_pb2 import (
+    FeatureValuesRequestStatus as ProtoFeatureValuesRequestStatus,
+    FileFormat as ProtoFileFormat,
+    GetFeatureValuesInRangeRequest as ProtoGetFeatureValuesInRangeRequest,
+    GetFeatureValuesInRangeResponse as ProtoGetFeatureValuesInRangeResponse,
+    GetFeatureValuesRequest as ProtoGetFeatureValuesRequest,
+    GetFeatureValuesResponse as ProtoGetFeatureValuesResponse,
+    GetFeatureValuesResultRequest as ProtoGetFeatureValuesResultRequest,
+    GetFeatureValuesResultResponse as ProtoGetFeatureValuesResultResponse,
+    GetFileUploadUrlRequest as ProtoGetFileUploadUrlRequest,
+    GetFileUploadUrlResponse as ProtoGetFileUploadUrlResponse,
+)
+from _qwak_proto.qwak.offline.serving.v1.offline_serving_async_service_pb2_grpc import (
+    FeatureStoreOfflineServingAsyncServiceStub,
+)
+from _qwak_proto.qwak.offline.serving.v1.options_pb2 import (
+    OfflineServingQueryOptions as ProtoOfflineServingQueryOptions,
+)
+from _qwak_proto.qwak.offline.serving.v1.population_pb2 import (
+    Population as ProtoPopulation,
+    PopulationFileUploadUrlType as ProtoPopulationFileUploadUrlType,
+    TimedPopulation as ProtoTimedPopulation,
+)
+from google.protobuf.timestamp_pb2 import Timestamp as ProtoTimestamp
+from qwak.clients.location_discovery import LocationDiscoveryClient
+from qwak.inner.tool.grpc.grpc_tools import create_grpc_channel
+from qwak.inner.tool.retry_utils import retry
+
+
+class FeatureValuesResultNotReadyException(Exception):
+    pass
+
+
+class FeatureValuesTimeoutException(Exception):
+    pass
+
+
+class FsOfflineServingClient:
+    """
+    Querying offline features store
+    """
+
+    def __init__(self, grpc_channel: Optional[grpc.Channel] = None):
+        self._client = self._create_client(grpc_channel)
+
+    @staticmethod
+    def _get_offline_serving_url() -> str:
+        """
+        Fetches the offline serving service URL from the LocationDiscoveryService.
+        """
+        return LocationDiscoveryClient().get_offline_serving().service_url
+
+    def _create_client(
+        self, grpc_channel: Optional[grpc.Channel] = None
+    ) -> FeatureStoreOfflineServingAsyncServiceStub:
+        if grpc_channel:
+            return FeatureStoreOfflineServingAsyncServiceStub(grpc_channel)
+
+        channel = create_grpc_channel(
+            url=self._get_offline_serving_url(),
+            enable_ssl=True,
+            status_for_retry=(
+                grpc.StatusCode.UNAVAILABLE,
+                grpc.StatusCode.CANCELLED,
+                grpc.StatusCode.DEADLINE_EXCEEDED,
+            ),
+        )
+        return FeatureStoreOfflineServingAsyncServiceStub(channel)
+
+    def get_population_file_upload_url(
+        self,
+    ) -> str:
+        """
+        Generating population file upload url
+        :return: pre-signed url to upload population data
+        """
+
+        request: ProtoGetFileUploadUrlRequest = ProtoGetFileUploadUrlRequest(
+            population=ProtoPopulationFileUploadUrlType()
+        )
+
+        response: ProtoGetFileUploadUrlResponse = self._client.GetFileUploadUrl(request)
+        return response.file_upload_url
+
+    def get_feature_values(
+        self,
+        features: List[ProtoFeaturesetFeatures],
+        population: ProtoTimedPopulation,
+        result_file_format: ProtoFileFormat,
+        options: ProtoOfflineServingQueryOptions,
+    ) -> str:
+        """
+        Getting offline feature values
+        :return: Request handle id to poll for result with
+        """
+        request: ProtoGetFeatureValuesRequest = ProtoGetFeatureValuesRequest(
+            features=features,
+            population=population,
+            result_file_format=result_file_format,
+            options=options,
+        )
+
+        response: ProtoGetFeatureValuesResponse = self._client.GetFeatureValues(request)
+        return response.request_id
+
+    def get_feature_values_in_range(
+        self,
+        features: ProtoFeaturesetFeatures,
+        lower_time_bound: ProtoTimestamp,
+        upper_time_bound: ProtoTimestamp,
+        result_file_format: ProtoFileFormat,
+        population: Optional[ProtoPopulation],
+        options: ProtoOfflineServingQueryOptions,
+    ) -> str:
+        """
+        Getting offline feature values
+        :return: Request handle id to poll for result with
+        """
+        request: ProtoGetFeatureValuesInRangeRequest = (
+            ProtoGetFeatureValuesInRangeRequest(
+                features=features,
+                lower_time_bound=lower_time_bound,
+                upper_time_bound=upper_time_bound,
+                result_file_format=result_file_format,
+                population=population,
+                options=options,
+            )
+        )
+
+        response: ProtoGetFeatureValuesInRangeResponse = (
+            self._client.GetFeatureValuesInRange(request)
+        )
+        return response.request_id
+
+    def get_result(self, request_handle: str) -> ProtoGetFeatureValuesResultResponse:
+        request: ProtoGetFeatureValuesResultRequest = (
+            ProtoGetFeatureValuesResultRequest(request_id=request_handle)
+        )
+
+        return self._client.GetFeatureValuesResult(request)
+
+    def _inner_poll(self, request_handle: str) -> ProtoGetFeatureValuesResultResponse:
+        """
+        This function receives request_handle amd polls for results.
+
+        Args:
+            request_handle: request_id for polling
+
+        Returns: if the request status is PENDING it throws FeatureValuesResultNotReadyException.
+                 else returns the Feature Values Result
+        """
+        response: ProtoGetFeatureValuesResultResponse = self.get_result(
+            request_handle=request_handle
+        )
+
+        if (
+            response.status
+            == ProtoFeatureValuesRequestStatus.FEATURE_VALUES_REQUEST_STATUS_PENDING
+        ):
+            logging.info("Feature Values query is still in progress...")
+            raise FeatureValuesResultNotReadyException()
+
+        return response
+
+    def poll_for_result(
+        self,
+        request_handle: str,
+        timeout_seconds: int = 60 * 60,
+        poll_interval_seconds: int = 10,
+    ) -> ProtoGetFeatureValuesResultResponse:
+        """
+        This function receives request_handle and polls for Feature Values Result.
+        it relies on _inner_poll() to raise FeatureValuesResultNotReadyException in case the result is not ready.
+        only once the desired amount of attempts completed it raises FeatureValuesTimeoutException
+        Args:
+            request_handle: request_id
+            timeout_seconds: total number of seconds for all attempts before timeout
+            poll_interval_seconds: sleep time between attempts
+
+        Returns: Feature Values Result or raises FeatureValuesTimeoutException if attempts exceeded timeout_seconds.
+
+        """
+        try:
+            result = retry(
+                f=self._inner_poll,
+                kwargs={"request_handle": request_handle},
+                exceptions=FeatureValuesResultNotReadyException,
+                attempts=int(timeout_seconds / poll_interval_seconds) + 1,
+                delay=poll_interval_seconds,
+            )
+        except FeatureValuesResultNotReadyException:
+            raise FeatureValuesTimeoutException(
+                f"Feature values query timed out. Qwak limits query execution time to {int(timeout_seconds / 60)} minutes"
+            )
+
+        return result
+
+    def get_feature_values_blocking(
+        self,
+        features: List[ProtoFeaturesetFeatures],
+        population: ProtoTimedPopulation,
+        result_file_format: ProtoFileFormat,
+        options: ProtoOfflineServingQueryOptions,
+        timeout_seconds: int = 60 * 60,
+        poll_interval_seconds: int = 10,
+    ) -> ProtoGetFeatureValuesResultResponse:
+        request_handle: str = self.get_feature_values(
+            features=features,
+            population=population,
+            result_file_format=result_file_format,
+            options=options,
+        )
+
+        return self.poll_for_result(
+            request_handle=request_handle,
+            timeout_seconds=timeout_seconds,
+            poll_interval_seconds=poll_interval_seconds,
+        )
+
+    def get_feature_values_in_range_blocking(
+        self,
+        features: ProtoFeaturesetFeatures,
+        lower_time_bound: ProtoTimestamp,
+        upper_time_bound: ProtoTimestamp,
+        result_file_format: ProtoFileFormat,
+        options: ProtoOfflineServingQueryOptions,
+        population: Optional[ProtoPopulation] = None,
+        timeout_seconds: int = 60 * 60,
+        poll_interval_seconds: int = 10,
+    ) -> ProtoGetFeatureValuesResultResponse:
+        request_handle: str = self.get_feature_values_in_range(
+            features=features,
+            lower_time_bound=lower_time_bound,
+            upper_time_bound=upper_time_bound,
+            population=population,
+            result_file_format=result_file_format,
+            options=options,
+        )
+
+        return self.poll_for_result(
+            request_handle=request_handle,
+            timeout_seconds=timeout_seconds,
+            poll_interval_seconds=poll_interval_seconds,
+        )

qwak/clients/feature_store/operator_client.py

@@ -1,4 +1,3 @@
-from pathlib import Path
 from typing import Optional
 
 from _qwak_proto.qwak.feature_store.features.feature_set_pb2 import FeatureSetSpec
@@ -20,6 +19,7 @@ from _qwak_proto.qwak.features_operator.v3.features_operator_pb2 import (
 )
 from dependency_injector.wiring import Provide
 from qwak.inner.di_configuration import QwakContainer
+from qwak.inner.tool.grpc.grpc_try_wrapping import grpc_try_catch_wrapper
 from qwak.inner.tool.retry_utils import retry
 
 
@@ -39,6 +39,9 @@ class FeaturesOperatorClient:
     def __init__(self, grpc_channel=Provide[QwakContainer.core_grpc_channel]):
         self._v3_client = FeaturesOperatorAsyncServiceStub(grpc_channel)
 
+    @grpc_try_catch_wrapper(
+        "Failed to validate DataSource", reraise_non_grpc_error_original_exception=True
+    )
     def validate_data_source(
         self,
         data_source_spec: DataSourceSpec,
@@ -57,10 +60,13 @@ class FeaturesOperatorClient:
         response: ValidationResponse = self._v3_client.ValidateDataSource(request)
         return response.request_id
 
+    @grpc_try_catch_wrapper(
+        "Failed to validate FeatureSet", reraise_non_grpc_error_original_exception=True
+    )
     def validate_featureset(
         self,
         featureset_spec: FeatureSetSpec,
-        resource_path: Optional[Path] = None,
+        resource_path: Optional[str] = None,
         num_samples: int = 10,
         validation_options: Optional[FeatureSetValidationOptions] = None,
     ) -> str:
@@ -68,7 +74,6 @@ class FeaturesOperatorClient:
         Validates and fetches a sample from the featureset
         :return: Request handle id to poll for result with
         """
-        resource_path = str(resource_path) if resource_path is not None else None
         request: ValidateFeatureSetRequest = ValidateFeatureSetRequest(
             feature_set_spec=featureset_spec,
             num_samples=num_samples,
@@ -79,7 +84,15 @@ class FeaturesOperatorClient:
         response: ValidationResponse = self._v3_client.ValidateFeatureSet(request)
         return response.request_id
 
+    @grpc_try_catch_wrapper(
+        "Failed to fetch validation result",
+        reraise_non_grpc_error_original_exception=True,
+    )
     def get_result(self, request_handle: str) -> GetValidationResultResponse:
+        """
+        Try to fetch the validation result using the given request handle.
+        :return: the validation result
+        """
         request: GetValidationResultRequest = GetValidationResultRequest(
             request_id=request_handle
         )
@@ -106,6 +119,10 @@ class FeaturesOperatorClient:
         timeout_seconds: int = 5 * 60,
         poll_interval_seconds: int = 3,
     ) -> GetValidationResultResponse:
+        """
+        Retry wrapper on 'get_result' method that polls for the validation result
+        :return: the validation result
+        """
         try:
             result = retry(
                 f=self._inner_poll,
@@ -144,7 +161,7 @@ class FeaturesOperatorClient:
     def validate_featureset_blocking(
         self,
         featureset_spec: FeatureSetSpec,
-        resource_path: Optional[Path] = None,
+        resource_path: Optional[str] = None,
         num_samples: int = 10,
         timeout_seconds: int = 5 * 60,
         poll_interval_seconds: int = 3,

qwak/clients/file_versioning/client.py

@@ -2,8 +2,12 @@ from pathlib import Path
 from typing import Optional
 
 import grpc
-from _qwak_proto.qwak.file_versioning.file_versioning_pb2 import FileTagSpec
+from _qwak_proto.qwak.file_versioning.file_versioning_pb2 import (
+    FileTagFilter,
+    FileTagSpec,
+)
 from _qwak_proto.qwak.file_versioning.file_versioning_service_pb2 import (
+    GetModelFileTagsRequest,
     RegisterFileTagRequest,
 )
 from _qwak_proto.qwak.file_versioning.file_versioning_service_pb2_grpc import (
@@ -56,3 +60,17 @@ class FileVersioningManagementClient:
                 )
             else:
                 raise e
+
+    def get_model_file_tags(
+        self, model_id: str, build_id: str, file_tag_filter: FileTagFilter = None
+    ):
+        try:
+            return self._file_management_service.GetModelFileTags(
+                GetModelFileTagsRequest(
+                    model_id=model_id, build_id=build_id, filter=file_tag_filter
+                )
+            )
+        except grpc.RpcError as e:
+            raise QwakException(
+                f"Failed to list model file tags, error is {e.details()}"
+            )

qwak/clients/file_versioning/file_tag_filter.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass, field
+from enum import Enum
+
+from _qwak_proto.qwak.file_versioning.file_versioning_pb2 import (
+    FileTagFilter as FileTagFilterProto,
+)
+
+
+class FileTagFilerType(Enum):
+    FILE_TAG_FILTER_TYPE_INVALID = 0
+    FILE_TAG_FILTER_TYPE_CONTAINS = 1
+    FILE_TAG_FILTER_TYPE_PREFIX = 2
+
+
+@dataclass
+class FileTagFilter:
+    value: str = field(default=None)
+    type: FileTagFilerType = field(
+        default=FileTagFilerType.FILE_TAG_FILTER_TYPE_INVALID
+    )
+
+    def to_proto(self):
+        if self.type is FileTagFilerType.FILE_TAG_FILTER_TYPE_CONTAINS:
+            return FileTagFilterProto(
+                tag_contains=self.value,
+            )
+        elif self.type is FileTagFilerType.FILE_TAG_FILTER_TYPE_PREFIX:
+            return FileTagFilterProto(
+                tag_prefix=self.value,
+            )
+        else:
+            return None

qwak/clients/instance_template/client.py

@@ -39,29 +39,30 @@ class InstanceTemplateManagementClient:
             )
             return result.instance_template
         except grpc.RpcError as e:
-            print(e)
             raise QwakException(
-                GET_INSTANCE_TEMPLATE_ERROR_FORMAT.format(e=e.details())
+                GET_INSTANCE_TEMPLATE_ERROR_FORMAT.format(
+                    e=e.details(), error_code=e.code()
+                )
             )
         except Exception as e:
-            print(e)
             raise QwakException(GET_INSTANCE_TEMPLATE_ERROR_FORMAT.format(e=e))
 
     def list_instance_templates(self) -> List[InstanceTemplateSpec]:
         try:
-            result: ListInstanceTemplatesResponse = self._instance_template_service.ListInstanceTemplates(
-                ListInstanceTemplatesRequest(
-                    optional_instance_filter=InstanceFilter(
-                        instance_type_filter=InstanceTypeFilter.INSTANCE_TYPE_FILTER_ALL
+            result: ListInstanceTemplatesResponse = (
+                self._instance_template_service.ListInstanceTemplates(
+                    ListInstanceTemplatesRequest(
+                        optional_instance_filter=InstanceFilter(
+                            instance_type_filter=InstanceTypeFilter.INSTANCE_TYPE_FILTER_ALL
+                        )
                     )
                 )
             )
             return list(result.instance_template_list)
         except grpc.RpcError as e:
-            print(e)
             raise QwakException(
-                GET_INSTANCE_TEMPLATE_ERROR_FORMAT.format(e=e.details())
+                GET_INSTANCE_TEMPLATE_ERROR_FORMAT.format(e=e.details()),
+                status_code=e.code(),
             )
         except Exception as e:
-            print(e)
             raise QwakException(GET_INSTANCE_TEMPLATE_ERROR_FORMAT.format(e=e))

qwak/clients/integration_management/integration_manager_client.py

@@ -0,0 +1,34 @@
+from typing import List
+
+from _qwak_proto.qwak.integration.integration_pb2 import Integration
+from _qwak_proto.qwak.integration.integration_service_pb2 import (
+    GetIntegrationRequest,
+    GetIntegrationResponse,
+    ListIntegrationRequest,
+    ListIntegrationsResponse,
+)
+from _qwak_proto.qwak.integration.integration_service_pb2_grpc import (
+    IntegrationManagementServiceStub,
+)
+from dependency_injector.wiring import Provide, inject
+from qwak.inner.di_configuration import QwakContainer
+
+
+class IntegrationManagerClient:
+    @inject
+    def __init__(self, grpc_channel=Provide[QwakContainer.core_grpc_channel]):
+        self._grpc_client: IntegrationManagementServiceStub = (
+            IntegrationManagementServiceStub(grpc_channel)
+        )
+
+    def list_integrations(self) -> List[Integration]:
+        response: ListIntegrationsResponse = self._grpc_client.ListIntegrations(
+            ListIntegrationRequest()
+        )
+        return response.integrations
+
+    def get_by_id(self, integration_id: str) -> Integration:
+        response: GetIntegrationResponse = self._grpc_client.GetIntegration(
+            GetIntegrationRequest(integration_id=integration_id)
+        )
+        return response.integration

qwak/clients/integration_management/integration_utils.py

@@ -0,0 +1,27 @@
+from typing import List
+
+from _qwak_proto.qwak.integration.integration_pb2 import Integration
+from qwak.clients.integration_management.integration_manager_client import (
+    IntegrationManagerClient,
+)
+from qwak.clients.integration_management.openai.openai_system_secret import (
+    OpenAIApiKeySystemSecret,
+)
+
+
+class IntegrationUtils:
+    def __init__(self):
+        self._client: IntegrationManagerClient = IntegrationManagerClient()
+
+    def get_openai_api_keys(self) -> List[OpenAIApiKeySystemSecret]:
+        all_integrations: List[Integration] = self._client.list_integrations()
+
+        openai_integration: List[Integration] = [
+            i for i in all_integrations if i.WhichOneof("type") == "openai_integration"
+        ]
+
+        openai_secrets: List[OpenAIApiKeySystemSecret] = [
+            OpenAIApiKeySystemSecret.from_proto(proto=o) for o in openai_integration
+        ]
+
+        return [s for s in openai_secrets if s is not None]

qwak/clients/integration_management/openai/openai_system_secret.py

@@ -0,0 +1,56 @@
+from base64 import b64decode
+from dataclasses import dataclass
+from typing import Optional
+
+from _qwak_proto.qwak.admiral.secret.v0.secret_pb2 import SystemSecretValue
+from _qwak_proto.qwak.integration.integration_pb2 import Integration
+from _qwak_proto.qwak.integration.open_a_i_integration_pb2 import (
+    OpenAIApiKeySystemSecretDescriptor,
+    OpenAIIntegration,
+)
+from qwak.clients.administration.eco_system.eco_system_utils import EcosystemUtils
+from qwak.clients.system_secret.system_secret_client import SystemSecretClient
+
+
+@dataclass
+class OpenAIApiKeySystemSecret:
+    integration_id: str
+    integration_name: str
+    secret_name: str
+    secret_key: str
+
+    @classmethod
+    def from_proto(cls, proto: Integration) -> Optional["OpenAIApiKeySystemSecret"]:
+        if proto.WhichOneof("type") != "openai_integration":
+            raise ValueError(f"Got wrong type of integration: {proto}")
+        openai_integration: OpenAIIntegration = proto.openai_integration
+
+        if (
+            openai_integration.WhichOneof("auth")
+            != "openai_api_key_system_secret_descriptor"
+        ):
+            return None
+
+        system_secret: OpenAIApiKeySystemSecretDescriptor = (
+            openai_integration.openai_api_key_system_secret_descriptor
+        )
+
+        return cls(
+            integration_id=proto.integration_id,
+            integration_name=proto.name,
+            secret_name=system_secret.secret_name,
+            secret_key=system_secret.api_key_secret_key,
+        )
+
+    def get_api_key(self) -> str:
+        system_secret_client = SystemSecretClient()
+        default_environment_id: str = EcosystemUtils().get_default_environment_id()
+        system_secret: SystemSecretValue = system_secret_client.get_system_secret(
+            name=self.secret_name, env_id=default_environment_id
+        )
+
+        if system_secret.WhichOneof("value") != "opaque_pair":
+            raise ValueError("Got unsupported system secret value type")
+
+        encoded_api_key: str = system_secret.opaque_pair.pairs.get(key=self.secret_key)
+        return b64decode(encoded_api_key).decode("utf-8")

qwak/clients/kube_deployment_captain/client.py

@@ -176,7 +176,9 @@ class KubeDeploymentClient:
         job_run_id: int,
     ) -> DeployStreamingAggregationCompactionResponse:
         try:
-            streaming_aggregation_compaction_deploy_request: DeployStreamingAggregationCompactionRequest = DeployStreamingAggregationCompactionRequest(
+            streaming_aggregation_compaction_deploy_request: (
+                DeployStreamingAggregationCompactionRequest
+            ) = DeployStreamingAggregationCompactionRequest(
                 feature_set_deployment=FeatureSetDeployment(
                     featureset_name=feature_set_name,
                     featureset_id=feature_set_id,

qwak/clients/location_discovery/__init__.py

@@ -0,0 +1 @@
+from .client import LocationDiscoveryClient

qwak/clients/location_discovery/client.py

@@ -0,0 +1,73 @@
+from typing import Callable
+
+import grpc
+from _qwak_proto.qwak.service_discovery.service_discovery_location_pb2 import (
+    ServiceLocationDescriptor,
+)
+from _qwak_proto.qwak.service_discovery.service_discovery_location_service_pb2 import (
+    GetServingUrlRequest as ProtoGetServingUrlRequest,
+    GetServingUrlRequestResponse as ProtoGetServingUrlRequestResponse,
+)
+from _qwak_proto.qwak.service_discovery.service_discovery_location_service_pb2_grpc import (
+    LocationDiscoveryServiceStub,
+)
+from dependency_injector.wiring import Provide
+from qwak.exceptions import QwakException
+from qwak.inner.di_configuration import QwakContainer
+
+
+class LocationDiscoveryClient:
+    """
+    Client for querying service locations from the LocationDiscoveryService.
+    """
+
+    def __init__(self, grpc_channel=Provide[QwakContainer.core_grpc_channel]):
+        self._service = LocationDiscoveryServiceStub(grpc_channel)
+
+    @staticmethod
+    def _get_location(
+        method: Callable[
+            [ProtoGetServingUrlRequest], ProtoGetServingUrlRequestResponse
+        ],
+    ) -> ServiceLocationDescriptor:
+        """
+        Calls a specific RPC and extracts the service location descriptor.
+
+        Args:
+            method: The gRPC method to call.
+
+        Returns:
+            ServiceLocationDescriptor: Contains service_url and location metadata.
+        """
+        try:
+            request = ProtoGetServingUrlRequest()
+            response = method(request)
+            return response.location
+        except grpc.RpcError as e:
+            raise QwakException(
+                f"Failed to retrieve service location. Error is: {e.details()}"
+            ) from e
+
+    def get_offline_serving(self) -> ServiceLocationDescriptor:
+        """Fetches the offline serving service location."""
+        return self._get_location(self._service.GetOfflineServingUrl)
+
+    def get_distribution_manager(self) -> ServiceLocationDescriptor:
+        """Fetches the distribution manager service location."""
+        return self._get_location(self._service.GetDistributionManagerUrl)
+
+    def get_analytics_engine(self) -> ServiceLocationDescriptor:
+        """Fetches the analytics engine service location."""
+        return self._get_location(self._service.GetAnalyticsEngineUrl)
+
+    def get_metrics_gateway(self) -> ServiceLocationDescriptor:
+        """Fetches the metrics gateway service location."""
+        return self._get_location(self._service.GetMetricsGatewayUrl)
+
+    def get_features_operator(self) -> ServiceLocationDescriptor:
+        """Fetches the features operator service location."""
+        return self._get_location(self._service.GetFeaturesOperatorUrl)
+
+    def get_hosting_gateway(self) -> ServiceLocationDescriptor:
+        """Fetches the hosting gateway service location."""
+        return self._get_location(self._service.GetHostingGatewayUrl)