frogml-core 0.0.1__py3-none-any.whl

frogml_services_mock/mocks/instance_template_management_service.py

@@ -0,0 +1,150 @@
+from _frogml_proto.qwak.instance_template.instance_template_pb2 import (
+    InstanceTemplateSpec,
+    InstanceType,
+)
+from _frogml_proto.qwak.instance_template.instance_template_service_pb2 import (
+    GetInstanceTemplateRequest,
+    GetInstanceTemplateResponse,
+    ListInstanceTemplatesRequest,
+    ListInstanceTemplatesResponse,
+)
+from _frogml_proto.qwak.instance_template.instance_template_service_pb2_grpc import (
+    InstanceTemplateManagementServiceServicer,
+)
+from _frogml_proto.qwak.user_application.common.v0.resources_pb2 import (
+    CpuResources,
+    GpuResources,
+    GpuType,
+    MemoryUnit,
+    NodeOptimizationType,
+    PodComputeResources,
+)
+from frogml.exceptions import FrogmlException
+from frogml_services_mock.mocks.utils.exception_handlers import (
+    raise_internal_grpc_error,
+)
+
+
+def _create_instance_template_cpu(
+    instance_id: str,
+    name: str,
+    order: int,
+    cpu: float,
+    memory_amount: int,
+    aws_supported: bool = True,
+    gcp_supported: bool = True,
+) -> InstanceTemplateSpec:
+    return InstanceTemplateSpec(
+        id=instance_id,
+        display_name=name,
+        order=order,
+        enabled=True,
+        aws_supported=aws_supported,
+        gcp_supported=gcp_supported,
+        pod_compute_resources=PodComputeResources(
+            optimization_type=NodeOptimizationType.NODE_OPTIMIZATION_NONE,
+            cpu_resources=CpuResources(
+                cpu=cpu,
+                memory_amount=memory_amount,
+                memory_units=MemoryUnit.GIB,
+            ),
+        ),
+        instance_type=InstanceType.INSTANCE_TYPE_CPU,
+    )
+
+
+def _create_instance_template_gpu(
+    instance_id: str,
+    name: str,
+    order: int,
+    gpu: int,
+    gpu_type: GpuType,
+    cpu: float,
+    memory_amount: int,
+    aws_supported: bool = True,
+    gcp_supported: bool = True,
+) -> InstanceTemplateSpec:
+    return InstanceTemplateSpec(
+        id=instance_id,
+        display_name=name,
+        order=order,
+        enabled=True,
+        aws_supported=aws_supported,
+        gcp_supported=gcp_supported,
+        pod_compute_resources=PodComputeResources(
+            optimization_type=NodeOptimizationType.NODE_OPTIMIZATION_NONE,
+            gpu_resources=GpuResources(
+                gpu_amount=gpu,
+                gpu_type=gpu_type,
+            ),
+            cpu_resources=CpuResources(
+                cpu=cpu,
+                memory_amount=memory_amount,
+                memory_units=MemoryUnit.GIB,
+            ),
+        ),
+        instance_type=InstanceType.INSTANCE_TYPE_GPU,
+    )
+
+
+class InstanceTemplateManagementServiceMock(InstanceTemplateManagementServiceServicer):
+    INSTANCES = {
+        "small": _create_instance_template_cpu("small", "Small", 1, 1, 8),
+        "medium": _create_instance_template_cpu("medium", "Medium", 2, 2, 16),
+        "large": _create_instance_template_cpu("large", "Large", 3, 4, 32),
+        "xlarge": _create_instance_template_cpu("xlarge", "XLarge", 4, 8, 64),
+        "g5_xlarge": _create_instance_template_gpu(
+            "g5_xlarge", "G5 XLarge", 1, 1, GpuType.NVIDIA_A10G, 1, 8
+        ),
+        "g5_2xlarge": _create_instance_template_gpu(
+            "g5_2xlarge", "G5 2XLarge", 2, 2, GpuType.NVIDIA_A10G, 2, 16
+        ),
+        "g5_4xlarge": _create_instance_template_gpu(
+            "g5_4xlarge", "G5 4XLarge", 2, 4, GpuType.NVIDIA_A10G, 4, 32
+        ),
+        "aws_only": _create_instance_template_gpu(
+            "aws_only",
+            "Aws Only",
+            2,
+            4,
+            GpuType.NVIDIA_A10G,
+            4,
+            32,
+            aws_supported=True,
+            gcp_supported=False,
+        ),
+        "gcp_only": _create_instance_template_gpu(
+            "gcp_only",
+            "GCP Only",
+            2,
+            4,
+            GpuType.NVIDIA_A10G,
+            4,
+            32,
+            aws_supported=False,
+            gcp_supported=True,
+        ),
+    }
+
+    def ListInstanceTemplates(
+        self, request: ListInstanceTemplatesRequest, context
+    ) -> ListInstanceTemplatesResponse:
+        try:
+            return ListInstanceTemplatesResponse(
+                instance_template_list=list(self.INSTANCES.values())
+            )
+        except Exception as e:
+            raise_internal_grpc_error(context, e)
+
+    def GetInstanceTemplate(
+        self, request: GetInstanceTemplateRequest, context
+    ) -> GetInstanceTemplateResponse:
+        try:
+            if request.id in self.INSTANCES:
+                return GetInstanceTemplateResponse(
+                    instance_template=self.INSTANCES[request.id]
+                )
+            else:
+                raise FrogmlException("Instance template not found")
+        except Exception as e:
+            raise_internal_grpc_error(context, e)

frogml_services_mock/mocks/integration_management_service.py

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

@@ -0,0 +1,27 @@
+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/job_registry_service_api.py

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

@@ -0,0 +1,41 @@
+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/logging_service.py

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

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