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

frogml_services_mock/mocks/integration_management_service.py

@@ -1,73 +0,0 @@
-import uuid
-from typing import Dict
-
-import grpc
-
-from frogml_proto.qwak.integration.integration_pb2 import Integration, IntegrationSpec
-from frogml_proto.qwak.integration.integration_service_pb2 import (
-    CreateIntegrationRequest,
-    CreateIntegrationResponse,
-    DeleteIntegrationRequest,
-    DeleteIntegrationResponse,
-    GetIntegrationRequest,
-    GetIntegrationResponse,
-    ListIntegrationRequest,
-    ListIntegrationsResponse,
-)
-from frogml_proto.qwak.integration.integration_service_pb2_grpc import (
-    IntegrationManagementServiceServicer,
-)
-from frogml_proto.qwak.integration.open_a_i_integration_pb2 import (
-    OpenAIApiKeySystemSecretDescriptor,
-    OpenAIIntegration,
-)
-
-
-class IntegrationManagementServiceMock(IntegrationManagementServiceServicer):
-    _integrations: Dict[str, Integration] = dict()
-
-    def clear(self):
-        self._integrations.clear()
-
-    def CreateIntegration(self, request: CreateIntegrationRequest, context):
-        """Create a new integration in account level"""
-        spec: IntegrationSpec = request.integration_spec
-        if spec.WhichOneof("spec") != "openai_integration_spec":
-            context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-            context.set_details("Method not implemented!")
-            raise NotImplementedError("Method not implemented!")
-
-        integration_id: str = str(uuid.uuid4())
-        integration_name: str = str(uuid.uuid4())
-        secret_name: str = str(uuid.uuid4())
-        api_key_secret_key: str = str(uuid.uuid4())
-
-        integration = Integration(
-            integration_id=integration_id,
-            name=integration_name,
-            openai_integration=OpenAIIntegration(
-                openai_api_key_system_secret_descriptor=OpenAIApiKeySystemSecretDescriptor(
-                    secret_name=secret_name, api_key_secret_key=api_key_secret_key
-                )
-            ),
-        )
-        self._integrations[integration_id] = integration
-        return CreateIntegrationResponse(
-            integration_id=integration_id, is_successful=True
-        )
-
-    def GetIntegration(self, request: GetIntegrationRequest, context):
-        """Get integration by id"""
-        return GetIntegrationResponse(
-            integration=self._integrations[request.integration_id]
-        )
-
-    def ListIntegrations(self, request: ListIntegrationRequest, context):
-        """List Integrations for account"""
-        return ListIntegrationsResponse(integrations=self._integrations.values())
-
-    def DeleteIntegration(self, request: DeleteIntegrationRequest, context):
-        """Delete Integration by id"""
-        if request.integration_id in self._integrations:
-            del self._integrations[request.integration_id]
-        return DeleteIntegrationResponse()

frogml_services_mock/mocks/internal_build_orchestrator_service.py

@@ -1,27 +0,0 @@
-from frogml_proto.qwak.builds.internal_builds_orchestrator_service_pb2 import (
-    BuildInitDetails,
-    InternalBuildModelRequest,
-    InternalBuildModelResponse,
-)
-from frogml_proto.qwak.builds.internal_builds_orchestrator_service_pb2_grpc import (
-    InternalBuildsOrchestratorServiceServicer,
-)
-from frogml_services_mock.mocks.utils.exception_handlers import (
-    raise_internal_grpc_error,
-)
-
-
-class InternalBuildOrchestratorServiceMock(InternalBuildsOrchestratorServiceServicer):
-    def __init__(self):
-        super(InternalBuildOrchestratorServiceMock, self).__init__()
-        self._builds_requests: dict[str:BuildInitDetails] = {}
-
-    def BuildModel(self, request: InternalBuildModelRequest, context):
-        """Build a serving model image"""
-        try:
-            self._builds_requests[
-                request.build_init_details.build_spec.build_properties.build_id
-            ] = request.build_init_details
-            return InternalBuildModelResponse()
-        except Exception as e:
-            raise_internal_grpc_error(context, e)

frogml_services_mock/mocks/jfrog_tenant_info_service_mock.py

@@ -1,42 +0,0 @@
-from datetime import datetime
-from typing import Dict
-
-from google.protobuf.timestamp_pb2 import Timestamp
-
-from frogml_core.exceptions import FrogmlNotFoundException
-from frogml_proto.qwak.ecosystem.jfrog.v0.jfrog_tenant_info_service_pb2 import (
-    GetJFrogTenantInfoRequest,
-    GetJFrogTenantInfoResponse,
-)
-from frogml_proto.qwak.ecosystem.jfrog.v0.jfrog_tenant_info_service_pb2_grpc import (
-    JFrogTenantInfoServiceServicer,
-)
-from frogml_proto.qwak.ecosystem.jfrog.v0.jfrog_tenant_pb2 import JFrogTenantInfo
-from frogml_proto.qwak.jfrog.gateway.v0.repository_pb2 import RepositorySpec
-from frogml_services_mock.mocks.utils.exception_handlers import (
-    raise_not_found_grpc_error,
-)
-
-timestamp = Timestamp()
-timestamp.FromDatetime(datetime.now())
-
-
-class JFrogTenantInfoServiceMock(JFrogTenantInfoServiceServicer):
-    def __init__(self):
-        super(JFrogTenantInfoServiceMock, self).__init__()
-        self.repositories: Dict[str, RepositorySpec] = {}
-        self.should_raise_exception: bool = False
-        self.platform_url: str = "mock.jfrog.io"
-
-    def GetJFrogTenantInfo(
-        self, request: GetJFrogTenantInfoRequest, context
-    ) -> GetJFrogTenantInfoResponse:
-        if self.should_raise_exception:
-            raise_not_found_grpc_error(
-                context,
-                FrogmlNotFoundException(f"JFrog tenant info not found"),
-            )
-
-        return GetJFrogTenantInfoResponse(
-            tenant_info=JFrogTenantInfo(platform_url=self.platform_url)
-        )

frogml_services_mock/mocks/job_registry_service_api.py

@@ -1,74 +0,0 @@
-import grpc
-
-from frogml_proto.qwak.feature_store.jobs.v1.job_pb2 import JobRecord, JobState
-from frogml_proto.qwak.feature_store.jobs.v1.job_service_pb2 import (
-    ApplyJobRequest,
-    ApplyJobResponse,
-    GetLatestJobRequest,
-    GetLatestJobResponse,
-    GetLatestSuccessfulJobRequest,
-    GetLatestSuccessfulJobResponse,
-)
-from frogml_proto.qwak.feature_store.jobs.v1.job_service_pb2_grpc import (
-    JobServiceServicer,
-)
-from frogml_services_mock.mocks.utils.exception_handlers import (
-    raise_internal_grpc_error,
-)
-
-
-def _sort_by_running_id(job: JobRecord):
-    return job.run_id
-
-
-class JobRegistryServiceApiMock(JobServiceServicer):
-    def __init__(self):
-        self._job_records: dict[str:[JobRecord]] = {}
-        self._running_id = 0
-        super(JobRegistryServiceApiMock, self).__init__()
-
-    def given_job(self, feature_set_id, job_id, job_state):
-        new_job = JobRecord(
-            job_id=job_id, featureset_id=feature_set_id, job_state=job_state
-        )
-        self._running_id += 1
-        new_job.run_id = self._running_id
-
-        self._job_records[new_job.featureset_id] = self._job_records.get(
-            new_job.featureset_id, list()
-        ) + [new_job]
-
-    def GetLatestJob(self, request: GetLatestJobRequest, context):
-        """
-        Get latest job
-        """
-        try:
-            records: list[JobRecord] = self._job_records.get(request.featureset_id)
-            if records:
-                records.sort(key=_sort_by_running_id, reverse=True)
-                return GetLatestJobResponse(job=records[0])
-            else:
-                context.set_code(grpc.StatusCode.NOT_FOUND)
-                context.set_details("Received a non existing job record")
-                return GetLatestSuccessfulJobResponse()
-        except Exception as e:
-            raise_internal_grpc_error(context, e)
-
-    def GetLatestSuccessfulJob(self, request: GetLatestSuccessfulJobRequest, context):
-        """
-        Get latest successful job
-        """
-        try:
-            records: list[JobRecord] = self._job_records.get(request.featureset_id)
-            if records:
-                records.sort(key=_sort_by_running_id, reverse=True)
-                for job in records:
-                    if job.job_state == JobState.COMPLETED:
-                        return GetLatestSuccessfulJobResponse(job=job)
-                return GetLatestSuccessfulJobResponse()
-            else:
-                context.set_code(grpc.StatusCode.NOT_FOUND)
-                context.set_details("Received a non existing feature job record")
-                return GetLatestSuccessfulJobResponse()
-        except Exception as e:
-            raise_internal_grpc_error(context, e)

frogml_services_mock/mocks/kube_captain_service_api.py

@@ -1,41 +0,0 @@
-from frogml_proto.qwak.kube_deployment_captain.kube_deployment_captain_service_pb2 import (
-    DeployFeatureSetResponse,
-    DeployStreamingAggregationCompactionResponse,
-)
-from frogml_proto.qwak.kube_deployment_captain.kube_deployment_captain_service_pb2_grpc import (
-    KubeDeploymentCaptainServicer,
-)
-from frogml_services_mock.mocks.utils.exception_handlers import (
-    raise_internal_grpc_error,
-)
-
-
-class KubeCaptainServiceApiMock(KubeDeploymentCaptainServicer):
-    def __init__(self):
-        self._last_deploy_streaming_aggregation_compaction_request = None
-        super(KubeCaptainServiceApiMock, self).__init__()
-
-    def reset_service(self):
-        self._last_deploy_streaming_aggregation_compaction_request = None
-
-    def DeployStreamingAggregationCompaction(self, request, context):
-        """deploy streaming aggregation compaction"""
-        try:
-            self._last_deploy_streaming_aggregation_compaction_request = request
-            return DeployStreamingAggregationCompactionResponse()
-        except Exception as e:
-            raise_internal_grpc_error(context, e)
-
-    def DeployStreamingOfflineFeatureSetV1(self, request, context):
-        """deploy streaming offline feature set"""
-        try:
-            return DeployFeatureSetResponse()
-        except Exception as e:
-            raise_internal_grpc_error(context, e)
-
-    def DeployBatchFeatureSetV1(self, request, context):
-        """deploy batch feature set"""
-        try:
-            return DeployFeatureSetResponse()
-        except Exception as e:
-            raise_internal_grpc_error(context, e)

frogml_services_mock/mocks/location_discovery_service_api.py

@@ -1,104 +0,0 @@
-from typing import Dict, Optional
-
-import grpc
-from frogml_proto.qwak.service_discovery.service_discovery_location_pb2 import (
-    ServiceLocationDescriptor,
-)
-from frogml_proto.qwak.service_discovery.service_discovery_location_service_pb2 import (
-    GetServingUrlRequestResponse,
-)
-from frogml_proto.qwak.service_discovery.service_discovery_location_service_pb2_grpc import (
-    LocationDiscoveryServiceServicer,
-)
-
-
-class LocationDiscoveryServiceApiMock(LocationDiscoveryServiceServicer):
-    """
-    Mock implementation of the LocationDiscoveryService for testing SDK behavior.
-    Allows setting mock responses and optional error codes for each endpoint.
-    """
-
-    def __init__(self):
-        super().__init__()
-        self._responses: Dict[str, Optional[ServiceLocationDescriptor]] = {}
-        self._error_codes: Dict[str, grpc.StatusCode] = {}
-
-    def _set_mock(
-        self,
-        key: str,
-        response: Optional[ServiceLocationDescriptor],
-        error_code: grpc.StatusCode = grpc.StatusCode.NOT_FOUND,
-    ):
-        self._responses[key] = response
-        self._error_codes[key] = error_code
-
-    def _handle(
-        self, key: str, context: grpc.ServicerContext
-    ) -> GetServingUrlRequestResponse:
-        response = self._responses.get(key)
-        if response:
-            return GetServingUrlRequestResponse(location=response)
-        context.set_code(self._error_codes.get(key, grpc.StatusCode.NOT_FOUND))
-        context.set_details(f"No mock response set for {key}")
-        return GetServingUrlRequestResponse()
-
-    # Setters
-    def set_get_offline_serving_url_response(
-        self,
-        response: Optional[ServiceLocationDescriptor],
-        error_code: grpc.StatusCode = grpc.StatusCode.NOT_FOUND,
-    ):
-        self._set_mock("offline", response, error_code)
-
-    def set_get_distribution_manager_url_response(
-        self,
-        response: Optional[ServiceLocationDescriptor],
-        error_code: grpc.StatusCode = grpc.StatusCode.NOT_FOUND,
-    ):
-        self._set_mock("distribution", response, error_code)
-
-    def set_get_analytics_engine_url_response(
-        self,
-        response: Optional[ServiceLocationDescriptor],
-        error_code: grpc.StatusCode = grpc.StatusCode.NOT_FOUND,
-    ):
-        self._set_mock("analytics", response, error_code)
-
-    def set_get_metrics_gateway_url_response(
-        self,
-        response: Optional[ServiceLocationDescriptor],
-        error_code: grpc.StatusCode = grpc.StatusCode.NOT_FOUND,
-    ):
-        self._set_mock("metrics", response, error_code)
-
-    def set_get_features_operator_url_response(
-        self,
-        response: Optional[ServiceLocationDescriptor],
-        error_code: grpc.StatusCode = grpc.StatusCode.NOT_FOUND,
-    ):
-        self._set_mock("features", response, error_code)
-
-    def set_get_hosting_gateway_url_response(
-        self,
-        response: Optional[ServiceLocationDescriptor],
-        error_code: grpc.StatusCode = grpc.StatusCode.NOT_FOUND,
-    ):
-        self._set_mock("hosting", response, error_code)
-
-    def GetOfflineServingUrl(self, request, context):
-        return self._handle("offline", context)
-
-    def GetDistributionManagerUrl(self, request, context):
-        return self._handle("distribution", context)
-
-    def GetAnalyticsEngineUrl(self, request, context):
-        return self._handle("analytics", context)
-
-    def GetMetricsGatewayUrl(self, request, context):
-        return self._handle("metrics", context)
-
-    def GetFeaturesOperatorUrl(self, request, context):
-        return self._handle("features", context)
-
-    def GetHostingGatewayUrl(self, request, context):
-        return self._handle("hosting", context)

frogml_services_mock/mocks/logging_service.py

@@ -1,203 +0,0 @@
-from collections import defaultdict
-from enum import Enum
-from typing import Dict, List
-
-from frogml_proto.qwak.logging.log_line_pb2 import LogLine
-from frogml_proto.qwak.logging.log_reader_service_pb2 import (
-    ReadLogsRequest,
-    ReadLogsResponse,
-)
-from frogml_proto.qwak.logging.log_reader_service_pb2_grpc import (
-    LogReaderServiceServicer,
-)
-from frogml_proto.qwak.logging.log_source_pb2 import (
-    InferenceExecutionSource,
-    LogSource,
-    ModelRuntimeSource,
-    RemoteBuildSource,
-    StreamingAggregationFeatureSetSource,
-    StreamingFeatureSetSource,
-)
-
-
-class Source(Enum):
-    MODEL_RUNTIME = 1
-    REMOTE_BUILD = 2
-    INFERENCE_EXECUTION = 3
-    STREAMING_AGGREGATION = 4
-    STREAMING_FEATURE_SET = 5
-
-
-class MockLogLine:
-    def __init__(self, log_line: LogLine, metadata: Dict[str, any]):
-        self.log_line = log_line
-        self.metadata = metadata
-
-
-class LoggingServiceApiMock(LogReaderServiceServicer):
-    def __init__(self):
-        self._logs: Dict[Source, List[MockLogLine]] = defaultdict(list)
-        super(LoggingServiceApiMock, self).__init__()
-
-    def ReadLogs(self, request: ReadLogsRequest, context) -> ReadLogsResponse:
-        source_to_use = self.__get_source_from_request(request.source)
-        logs = []
-        if source_to_use == Source.MODEL_RUNTIME:
-            logs = self.__read_model_runtime_logs(request)
-        elif source_to_use == Source.INFERENCE_EXECUTION:
-            logs = self.__read_inference_execution_logs(request)
-        elif source_to_use == Source.REMOTE_BUILD:
-            logs = self.__read_remote_build_logs(request)
-        elif source_to_use == Source.STREAMING_AGGREGATION:
-            logs = self.__read_streaming_aggregation_logs(request)
-        elif source_to_use == Source.STREAMING_FEATURE_SET:
-            logs = self.__read_streaming_feature_set_logs(request)
-
-        if request.after_offset:
-            logs = list(
-                filter(
-                    lambda mocked_log: mocked_log.metadata.get("offset")
-                    >= request.after_offset,
-                    logs,
-                )
-            )
-        if request.before_offset:
-            logs = list(
-                filter(
-                    lambda mocked_log: mocked_log.metadata.get("offset")
-                    < request.before_offset,
-                    logs,
-                )
-            )
-        logs.sort(
-            key=lambda mocked_log: (
-                mocked_log.metadata.get("offset") is None,
-                mocked_log.metadata.get("offset"),
-            ),
-            reverse=True,
-        )
-
-        has_next_page = False
-        if request.max_number_of_results > 0:
-            has_next_page = len(logs) > request.max_number_of_results
-            logs = logs[: request.max_number_of_results]
-        try:
-            first_offset = min(
-                list(map(lambda mocked_log: mocked_log.metadata.get("offset"), logs))
-            )
-            last_offset = max(
-                list(map(lambda mocked_log: mocked_log.metadata.get("offset"), logs))
-            )
-        except Exception:
-            first_offset = "0"
-            last_offset = "0"
-
-        return ReadLogsResponse(
-            log_line=list(map(lambda mocked_log: mocked_log.log_line, logs)),
-            first_offset=first_offset,
-            last_offset=last_offset,
-            has_next_page=has_next_page,
-        )
-
-    @staticmethod
-    def _get_source(source: LogSource):
-        if type(source) is ModelRuntimeSource:
-            return Source.MODEL_RUNTIME
-        elif type(source) is RemoteBuildSource:
-            return Source.REMOTE_BUILD
-        elif type(source) is InferenceExecutionSource:
-            return Source.INFERENCE_EXECUTION
-        elif type(source) is StreamingFeatureSetSource:
-            return Source.STREAMING_AGGREGATION
-        elif type(source) is StreamingAggregationFeatureSetSource:
-            return Source.STREAMING_FEATURE_SET
-        else:
-            raise Exception("Unknown source")
-
-    @staticmethod
-    def __get_source_from_request(source: LogSource):
-        request_source = source.WhichOneof("source")
-        if request_source == "model_runtime":
-            return Source.MODEL_RUNTIME
-        elif request_source == "remote_build":
-            return Source.REMOTE_BUILD
-        elif request_source == "inference_execution":
-            return Source.INFERENCE_EXECUTION
-        elif request_source == "streaming_aggregation_feature_set":
-            return Source.STREAMING_AGGREGATION
-        elif request_source == "streaming_feature_set":
-            return Source.STREAMING_FEATURE_SET
-        else:
-            raise Exception("Unknown source")
-
-    def __read_model_runtime_logs(self, request: ReadLogsRequest) -> List[MockLogLine]:
-        logs: List[MockLogLine] = self._logs[Source.MODEL_RUNTIME]
-        if request.source.model_runtime.deployment_id:
-            logs = list(
-                filter(
-                    lambda mocked_log: mocked_log.metadata.get("deployment_id")
-                    == request.source.model_runtime.deployment_id,
-                    logs,
-                )
-            )
-        elif request.source.model_runtime.build_id:
-            logs = list(
-                filter(
-                    lambda mocked_log: mocked_log.metadata.get("build_id")
-                    == request.source.model_runtime.build_id,
-                    logs,
-                )
-            )
-
-        return logs
-
-    def __read_inference_execution_logs(self, request) -> List[MockLogLine]:
-        logs: List[MockLogLine] = self._logs[Source.INFERENCE_EXECUTION]
-        if request.source.inference_execution.inference_job_id:
-            logs = list(
-                filter(
-                    lambda mocked_log: mocked_log.metadata.get("inference_job_id")
-                    == request.source.inference_execution.inference_job_id,
-                    logs,
-                )
-            )
-        elif request.source.inference_execution.inference_task_id:
-            logs = list(
-                filter(
-                    lambda mocked_log: mocked_log.metadata.get("inference_task_id")
-                    == request.source.inference_execution.inference_task_id,
-                    logs,
-                )
-            )
-
-        return logs
-
-    def __read_remote_build_logs(self, request) -> List[MockLogLine]:
-        logs: List[MockLogLine] = self._logs[Source.REMOTE_BUILD]
-        if request.source.remote_build.build_id:
-            logs = list(
-                filter(
-                    lambda mocked_log: mocked_log.metadata.get("build_id")
-                    == request.source.remote_build.build_id,
-                    logs,
-                )
-            )
-        if request.source.remote_build.phase_ids:
-            logs = list(
-                filter(
-                    lambda mocked_log: mocked_log.metadata.get("phase_id")
-                    in request.source.remote_build.phase_ids,
-                    logs,
-                )
-            )
-
-        return logs
-
-    def __read_streaming_aggregation_logs(self, request):
-        raise Exception("Unimplemented")
-
-    def __read_streaming_feature_set_logs(self, request):
-        raise Exception("Unimplemented")
-
-    def add_mock_logs(self, source: LogSource, rows: List[MockLogLine]):
-        self._logs[self._get_source(source)].extend(rows)

frogml_services_mock/mocks/model_management_service.py

@@ -1,115 +0,0 @@
-import uuid
-from typing import Dict
-
-import grpc
-
-from frogml_proto.qwak.models.models_pb2 import (
-    CreateModelRequest,
-    CreateModelResponse,
-    DeleteModelRequest,
-    DeleteModelResponse,
-    GetModelMetadataResponse,
-    GetModelRequest,
-    GetModelResponse,
-    ListModelsMetadataResponse,
-    ListModelsResponse,
-    Model,
-    ModelMetadata,
-    ModelSpec,
-    ModelStatus,
-)
-from frogml_proto.qwak.models.models_pb2_grpc import ModelsManagementServiceServicer
-from frogml_services_mock.mocks.utils.exception_handlers import (
-    raise_internal_grpc_error,
-)
-
-
-class ModelsManagementServiceMock(ModelsManagementServiceServicer):
-    def __init__(self):
-        super(ModelsManagementServiceMock, self).__init__()
-        self.models: Dict[str, Model] = dict()
-        self.models_by_uuid: Dict[str, Model] = dict()
-
-    def CreateModel(self, request: CreateModelRequest, context) -> CreateModelResponse:
-        try:
-            formatted_model_id = request.model_spec.model_named_id.lower().replace(
-                "-", "_"
-            )
-            created_model = self.model_spec_to_model(
-                request.model_spec, formatted_model_id
-            )
-
-            self.models[formatted_model_id] = created_model
-            self.models_by_uuid[created_model.uuid] = created_model
-
-            return CreateModelResponse(model_id=formatted_model_id)
-        except Exception as e:
-            raise_internal_grpc_error(context, e)
-
-    def GetModel(self, request: GetModelRequest, context) -> GetModelResponse:
-        try:
-            if request.model_id:
-                if request.model_id not in self.models:
-                    context.set_code(grpc.StatusCode.NOT_FOUND)
-                    details = f"Model id {request.model_id} not found"
-                    context.set_details(details)
-                    raise grpc.RpcError(details)
-                else:
-                    model: Model = self.models[request.model_id]
-            else:
-                if request.model_uuid not in self.models_by_uuid:
-                    context.set_code(grpc.StatusCode.NOT_FOUND)
-                    details = f"Model uuid {request.model_uuid} not found"
-                    context.set_details(details)
-                    raise grpc.RpcError(details)
-                else:
-                    model: Model = self.models_by_uuid[request.model_uuid]
-
-            return GetModelResponse(model=model)
-        except grpc.RpcError as e:
-            raise e
-        except Exception as e:
-            raise_internal_grpc_error(context, e)
-
-    def DeleteModel(self, request: DeleteModelRequest, context) -> DeleteModelResponse:
-        try:
-            del self.models[request.model_id]
-            return DeleteModelResponse()
-        except Exception as e:
-            raise_internal_grpc_error(context, e)
-
-    def GetModelMetadata(self, request, context):
-        try:
-            if request.model_id == "throw_exception":
-                raise Exception("This is a test exception")
-            model = self.models[request.model_id]
-            return GetModelMetadataResponse(model_metadata=ModelMetadata(model=model))
-        except Exception as e:
-            raise_internal_grpc_error(context, e)
-
-    def ListModels(self, request, context):
-        models = [
-            model
-            for _, model in self.models.items()
-            if model.project_id == request.project_id
-        ]
-        return ListModelsResponse(models=models)
-
-    def ListModelsMetadata(self, request, context):
-        models = [
-            ModelMetadata(model=model)
-            for _, model in self.models.items()
-            if model.project_id == request.project_id
-        ]
-        return ListModelsMetadataResponse(model_metadata=models)
-
-    @staticmethod
-    def model_spec_to_model(model_spec: ModelSpec, formatted_model_id: str):
-        return Model(
-            model_id=formatted_model_id,
-            display_name=model_spec.display_name,
-            model_status=ModelStatus.ACTIVE,
-            model_description=model_spec.model_description,
-            project_id=model_spec.project_id,
-            uuid=str(uuid.uuid4()),
-        )