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

frogml_core/clients/model_management/client.py

@@ -1,139 +0,0 @@
-from typing import Optional
-
-import grpc
-from dependency_injector.wiring import Provide
-
-from frogml_core.utils.model_utils import get_model_id_from_model_name
-from frogml_proto.qwak.models.models_pb2 import (
-    CreateModelRequest,
-    DeleteModelRequest,
-    GetModelMetadataRequest,
-    GetModelRequest,
-    ListModelsMetadataRequest,
-    ListModelsRequest,
-    Model,
-    ModelSpec,
-)
-from frogml_proto.qwak.models.models_pb2_grpc import ModelsManagementServiceStub
-from frogml_core.exceptions import FrogmlException
-from frogml_core.inner.di_configuration import FrogmlContainer
-from frogml_proto.qwak.projects.jfrog_project_spec_pb2 import ModelRepositoryJFrogSpec
-
-
-class ModelsManagementClient:
-    """
-    Used for interacting with Feature Registry endpoints
-    """
-
-    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
-        self._models_management_service = ModelsManagementServiceStub(grpc_channel)
-
-    def get_model(self, model_id, exception_on_missing: bool = True) -> Optional[Model]:
-        try:
-            return self._models_management_service.GetModel(
-                GetModelRequest(model_id=model_id)
-            ).model
-
-        except grpc.RpcError as e:
-            if e.code() == grpc.StatusCode.NOT_FOUND and not exception_on_missing:
-                return None
-            raise FrogmlException(f"Failed to get model, error is {e.details()}")
-
-    def get_model_by_uuid(
-        self, model_uuid, exception_on_missing: bool = True
-    ) -> Optional[Model]:
-        try:
-            return self._models_management_service.GetModel(
-                GetModelRequest(model_uuid=model_uuid)
-            ).model
-
-        except grpc.RpcError as e:
-            if e.code() == grpc.StatusCode.NOT_FOUND and not exception_on_missing:
-                return None
-            raise FrogmlException(f"Failed to get model, error is {e.details()}")
-
-    def get_model_uuid(self, model_id):
-        model = self.get_model(model_id)
-        return model.uuid
-
-    def create_model(
-        self,
-        project_id: str,
-        model_name: str,
-        model_description: str,
-        jfrog_project_key: Optional[str] = None,
-    ):
-        try:
-            return self._models_management_service.CreateModel(
-                CreateModelRequest(
-                    model_spec=ModelSpec(
-                        model_named_id=get_model_id_from_model_name(model_name),
-                        display_name=model_name,
-                        project_id=project_id,
-                        model_description=model_description,
-                    ),
-                    jfrog_project_spec=ModelRepositoryJFrogSpec(
-                        jfrog_project_key=jfrog_project_key,
-                    ),
-                )
-            )
-
-        except grpc.RpcError as e:
-            raise FrogmlException(f"Failed to create model, error is {e}")
-
-    def delete_model(self, project_id, model_id):
-        try:
-            return self._models_management_service.DeleteModel(
-                DeleteModelRequest(model_id=model_id, project_id=project_id)
-            )
-
-        except grpc.RpcError as e:
-            raise FrogmlException(f"Failed to delete model, error is {e.details()}")
-
-    def is_model_exists(self, model_id: str) -> bool:
-        """Check if model exists in environment
-
-        Args:
-            model_id: the model id to check if exists.
-
-        Returns: if model exists.
-        """
-        try:
-            self._models_management_service.GetModel(
-                GetModelRequest(model_id=model_id)
-            ).model
-            return True
-        except grpc.RpcError as e:
-            if e.code() == grpc.StatusCode.NOT_FOUND:
-                return False
-            raise FrogmlException(
-                f"Failed to check if model {model_id} is exists, error is {e.details()}"
-            )
-
-    def list_models_metadata(self, project_id: str):
-        try:
-            return self._models_management_service.ListModelsMetadata(
-                ListModelsMetadataRequest(project_id=project_id)
-            )
-        except grpc.RpcError as e:
-            raise FrogmlException(
-                f"Failed to list models metadata, error is {e.details()}"
-            )
-
-    def list_models(self, project_id: str):
-        try:
-            return self._models_management_service.ListModels(
-                ListModelsRequest(project_id=project_id)
-            )
-        except grpc.RpcError as e:
-            raise FrogmlException(f"Failed to list models, error is {e.details()}")
-
-    def get_model_metadata(self, model_id: str):
-        try:
-            return self._models_management_service.GetModelMetadata(
-                GetModelMetadataRequest(model_id=model_id)
-            )
-        except grpc.RpcError as e:
-            raise FrogmlException(
-                f"Failed to get model metadata, error is {e.details()}"
-            )

frogml_core/clients/model_version_manager/client.py

@@ -1,224 +0,0 @@
-from platform import python_version
-from typing import List, Optional, Dict, Union, Tuple
-
-from dependency_injector.wiring import Provide
-from grpc import RpcError
-
-from frogml_core.exceptions import FrogmlException
-from frogml_core.inner.di_configuration import FrogmlContainer
-from frogml_core.utils.model_utils import get_model_id_from_model_name
-from frogml_core.utils.proto_utils import ProtoUtils
-from frogml_proto.jfml.model_version.v1.artifact_pb2 import Artifact as ArtifactProto
-from frogml_proto.jfml.model_version.v1.model_repository_spec_pb2 import (
-    ModelRepositorySpec,
-)
-from frogml_proto.jfml.model_version.v1.model_version_framework_pb2 import (
-    ModelVersionFramework,
-)
-from frogml_proto.jfml.model_version.v1.model_version_manager_service_pb2 import (
-    CreateModelVersionRequest,
-    CreateModelVersionResponse,
-)
-from frogml_proto.jfml.model_version.v1.model_version_manager_service_pb2_grpc import (
-    ModelVersionManagerServiceStub,
-)
-from frogml_proto.jfml.model_version.v1.model_version_pb2 import (
-    ModelVersionSpec,
-    MlBomData,
-    ParameterValue,
-    MetricValue,
-)
-from frogml_storage.models.entity_manifest import Artifact
-
-
-class ModelVersionManagerClient:
-    """
-    Used for interacting with the model version manager's endpoints
-    """
-
-    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
-        self.__model_version_manager_stub = ModelVersionManagerServiceStub(grpc_channel)
-
-    @staticmethod
-    def __build_mlbom_data_kwargs(
-        model_artifact: List[ArtifactProto],
-        code_artifacts: Optional[List[ArtifactProto]] = None,
-        dependency_artifacts: Optional[List[ArtifactProto]] = None,
-        metrics: Optional[Dict[str, str]] = None,
-        parameters: Optional[Dict[str, str]] = None,
-    ) -> Dict[
-        str, Union[List[ArtifactProto], Dict[str, Union[ParameterValue, MetricValue]]]
-    ]:
-        kwargs = {"model_artifact": model_artifact}
-
-        if dependency_artifacts:
-            kwargs["dependency_artifacts"] = dependency_artifacts
-
-        if code_artifacts:
-            kwargs["code_artifacts"] = code_artifacts
-
-        if parameters:
-            kwargs["parameters"] = {
-                key: ParameterValue(value=str(value))
-                for key, value in parameters.items()
-            }
-
-        if metrics:
-            kwargs["metrics"] = {
-                key: MetricValue(value=str(value)) for key, value in metrics.items()
-            }
-
-        return kwargs
-
-    def __build_create_model_version_request(
-        self,
-        project_key: str,
-        repository_key: str,
-        model_name: str,
-        model_version_name: str,
-        model_version_framework: ModelVersionFramework,
-        dry_run: bool,
-        model_artifacts: List[ArtifactProto],
-        dependency_artifacts: Optional[List[ArtifactProto]] = None,
-        code_artifacts: Optional[List[ArtifactProto]] = None,
-        parameters: Optional[Dict[str, str]] = None,
-        metrics: Optional[Dict[str, str]] = None,
-    ) -> CreateModelVersionRequest:
-        kwargs: dict = self.__build_mlbom_data_kwargs(
-            model_artifacts, code_artifacts, dependency_artifacts, metrics, parameters
-        )
-
-        return CreateModelVersionRequest(
-            dry_run=dry_run,
-            model_version=ModelVersionSpec(
-                repository_spec=ModelRepositorySpec(
-                    project_key=project_key,
-                    repository_key=repository_key,
-                    model_id=get_model_id_from_model_name(model_name),
-                    model_name=model_name,
-                ),
-                name=model_version_name,
-                framework=model_version_framework,
-                python_version=python_version(),
-            ),
-            ml_bom_data=MlBomData(**kwargs),
-        )
-
-    def validate_create_model_version(
-        self,
-        project_key: str,
-        repository_key: str,
-        model_name: str,
-        model_version_name: str,
-        model_version_framework: ModelVersionFramework,
-        model_artifact: List[Artifact],
-        dependency_artifacts: Optional[List[Artifact]] = None,
-        code_artifacts: Optional[List[Artifact]] = None,
-        parameters: Optional[Dict[str, str]] = None,
-        metrics: Optional[Dict[str, str]] = None,
-    ):
-        try:
-            (
-                code_artifacts_proto,
-                dependency_artifacts_proto,
-                model_artifact_proto,
-            ) = self.convert_artifacts(
-                model_artifact, dependency_artifacts, code_artifacts
-            )
-
-            create_model_request = self.__build_create_model_version_request(
-                project_key=project_key,
-                repository_key=repository_key,
-                model_name=model_name,
-                model_version_name=model_version_name,
-                model_version_framework=model_version_framework,
-                dry_run=True,
-                model_artifacts=model_artifact_proto,
-                dependency_artifacts=dependency_artifacts_proto,
-                code_artifacts=code_artifacts_proto,
-                parameters=parameters,
-                metrics=metrics,
-            )
-            self.__model_version_manager_stub.CreateModelVersion(create_model_request)
-        except RpcError as e:
-            message = f"Failed to validate model version, details [{e.details()}]"
-            raise FrogmlException(message)
-
-        except Exception as e:
-            message = f"Failed to validate model version, details [{e}]"
-            raise FrogmlException(message)
-
-    def create_model_version(
-        self,
-        project_key: str,
-        repository_key: str,
-        model_name: str,
-        model_version_name: str,
-        model_version_framework: ModelVersionFramework,
-        model_artifact: List[Artifact],
-        dependency_artifacts: Optional[List[Artifact]] = None,
-        code_artifacts: Optional[List[Artifact]] = None,
-        parameters: Optional[Dict[str, str]] = None,
-        metrics: Optional[Dict[str, str]] = None,
-    ) -> CreateModelVersionResponse:
-        try:
-            (
-                code_artifacts_proto,
-                dependency_artifacts_proto,
-                model_artifact_proto,
-            ) = self.convert_artifacts(
-                model_artifact, dependency_artifacts, code_artifacts
-            )
-
-            create_model_request = self.__build_create_model_version_request(
-                project_key=project_key,
-                repository_key=repository_key,
-                model_name=model_name,
-                model_version_name=model_version_name,
-                model_version_framework=model_version_framework,
-                dry_run=False,
-                model_artifacts=model_artifact_proto,
-                dependency_artifacts=dependency_artifacts_proto,
-                code_artifacts=code_artifacts_proto,
-                parameters=parameters,
-                metrics=metrics,
-            )
-            create_model_version_response: CreateModelVersionResponse = (
-                self.__model_version_manager_stub.CreateModelVersion(
-                    create_model_request
-                )
-            )
-
-            return create_model_version_response
-        except RpcError as e:
-            message = f"Failed to validate model version, details [{e.details()}]"
-            raise FrogmlException(message)
-
-        except Exception as e:
-            message = f"Failed to validate model version, details [{e}]"
-            raise FrogmlException(message)
-
-    @staticmethod
-    def convert_artifacts(
-        model_artifact: List[Artifact],
-        dependency_artifacts: Optional[List[Artifact]] = None,
-        code_artifacts: Optional[List[Artifact]] = None,
-    ) -> Tuple[
-        Optional[List[ArtifactProto]],
-        Optional[List[ArtifactProto]],
-        List[ArtifactProto],
-    ]:
-        model_artifact_proto: List[ArtifactProto] = (
-            ProtoUtils.convert_artifacts_to_artifacts_proto(model_artifact)
-        )
-        dependency_artifacts_proto = (
-            ProtoUtils.convert_artifacts_to_artifacts_proto(dependency_artifacts)
-            if dependency_artifacts
-            else None
-        )
-        code_artifacts_proto = (
-            ProtoUtils.convert_artifacts_to_artifacts_proto(code_artifacts)
-            if code_artifacts
-            else None
-        )
-        return code_artifacts_proto, dependency_artifacts_proto, model_artifact_proto

frogml_core/clients/project/client.py

@@ -1,72 +0,0 @@
-from typing import Optional
-
-import grpc
-from dependency_injector.wiring import Provide, inject
-
-from frogml_proto.qwak.projects.jfrog_project_spec_pb2 import ModelRepositoryJFrogSpec
-from frogml_proto.qwak.projects.projects_pb2 import (
-    CreateProjectRequest,
-    DeleteProjectRequest,
-    GetProjectRequest,
-    ListProjectsRequest,
-)
-from frogml_proto.qwak.projects.projects_pb2_grpc import ProjectsManagementServiceStub
-from frogml_core.exceptions import FrogmlException
-from frogml_core.inner.di_configuration import FrogmlContainer
-
-
-class ProjectsManagementClient:
-    """
-    Used for interacting with Project Management endpoints
-    """
-
-    @inject
-    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
-        self._projects_management_service = ProjectsManagementServiceStub(grpc_channel)
-
-    def list_projects(self):
-        try:
-            return self._projects_management_service.ListProjects(ListProjectsRequest())
-
-        except grpc.RpcError as e:
-            raise FrogmlException(f"Failed to list projects, error is {e.details()}")
-
-    def create_project(
-        self,
-        project_name: str,
-        project_description: str,
-        jfrog_project_key: Optional[str] = None,
-    ):
-        try:
-            return self._projects_management_service.CreateProject(
-                CreateProjectRequest(
-                    project_name=project_name,
-                    project_description=project_description,
-                    jfrog_spec=ModelRepositoryJFrogSpec(
-                        jfrog_project_key=jfrog_project_key,
-                    ),
-                )
-            )
-
-        except grpc.RpcError as e:
-            raise FrogmlException(f"Failed to create project, error is {e.details()}")
-
-    def delete_project(self, project_id):
-        try:
-            return self._projects_management_service.DeleteProject(
-                DeleteProjectRequest(project_id=project_id)
-            )
-
-        except grpc.RpcError as e:
-            raise FrogmlException(f"Failed to delete project, error is {e.details()}")
-
-    def get_project(self, project_id: str = "", project_name: str = ""):
-        try:
-            return self._projects_management_service.GetProject(
-                GetProjectRequest(project_id=project_id, project_name=project_name)
-            )
-
-        except grpc.RpcError as e:
-            raise FrogmlException(
-                f"Failed to fetch models associated with project id {project_id}, error is {e.details()}"
-            )

frogml_core/clients/secret_service/client.py

@@ -1,96 +0,0 @@
-from typing import Optional
-
-import grpc
-
-from frogml_proto.qwak.secret_service.secret_service_pb2 import (
-    DeleteSecretRequest,
-    GetSecretRequest,
-    SetSecretRequest,
-)
-from frogml_proto.qwak.secret_service.secret_service_pb2_grpc import SecretServiceStub
-from frogml_core.clients.administration.eco_system.client import EcosystemClient
-from frogml_core.exceptions import FrogmlException
-from frogml_core.inner.tool.grpc.grpc_tools import create_grpc_channel
-
-
-class SecretServiceClient:
-    """
-    gRPC client of the secret service
-    """
-
-    def __init__(
-        self,
-        edge_services_url: Optional[str] = None,
-        enable_ssl: bool = True,
-        grpc_channel: Optional[grpc.Channel] = None,
-        environment_id: Optional[str] = None,
-    ):
-        if not grpc_channel:
-            edge_services_url = self.__get_endpoint_url(
-                edge_services_url, environment_id
-            )
-            grpc_channel = create_grpc_channel(
-                url=edge_services_url,
-                enable_ssl=enable_ssl,
-                status_for_retry=(
-                    grpc.StatusCode.UNAVAILABLE,
-                    grpc.StatusCode.DEADLINE_EXCEEDED,
-                    grpc.StatusCode.INTERNAL,
-                ),
-                backoff_options={"init_backoff_ms": 250},
-            )
-        self._secret_service = SecretServiceStub(grpc_channel)
-
-    @staticmethod
-    def __get_endpoint_url(endpoint_url=None, environment_id=None):
-        if endpoint_url is None:
-            user_context = EcosystemClient().get_authenticated_user_context().user
-            if environment_id is None:
-                environment_id = user_context.environment_details.id
-
-            # If the environment id is not found, try to use the default environment id
-            if environment_id not in user_context.account_details.environment_by_id:
-                environment_id = user_context.account_details.default_environment_id
-
-            if environment_id not in user_context.account_details.environment_by_id:
-                raise FrogmlException(
-                    f"Configuration for environment [{environment_id}] was not found"
-                )
-
-            endpoint_url = user_context.account_details.environment_by_id[
-                environment_id
-            ].configuration.edge_services_url
-
-        return endpoint_url
-
-    def get_secret(self, name) -> str:
-        try:
-            request = GetSecretRequest(name=name)
-            return self._secret_service.GetSecret(request).value
-        except grpc.RpcError as e:
-            if e.code() == grpc.StatusCode.NOT_FOUND:
-                raise FrogmlException(
-                    f"Secret [{name}] not found", status_code=e.code()
-                )
-            else:
-                raise FrogmlException(
-                    f"Failed to get secret, name: [{name}], error code is [{e.code()}], error message is [{e.details()}]"
-                )
-
-    def set_secret(self, name, value) -> None:
-        try:
-            request = SetSecretRequest(name=name, value=value)
-            self._secret_service.SetSecret(request)
-        except grpc.RpcError as e:
-            raise FrogmlException(
-                f"Failed to set secret, name: [{name}], error code is [{e.code()}], error is [{e.details()}]"
-            )
-
-    def delete_secret(self, name) -> None:
-        try:
-            request = DeleteSecretRequest(name=name)
-            self._secret_service.DeleteSecret(request)
-        except grpc.RpcError as e:
-            raise FrogmlException(
-                f"Failed to delete secret, name: [{name}], error is [{e.details()}]"
-            )

frogml_core/clients/system_secret/system_secret_client.py

@@ -1,31 +0,0 @@
-from dependency_injector.wiring import Provide, inject
-
-from frogml_proto.qwak.admiral.secret.v0.secret_pb2 import (
-    EnvironmentSecretIdentifier,
-    SystemSecretValue,
-)
-from frogml_proto.qwak.admiral.secret.v0.system_secret_service_pb2 import (
-    GetSystemSecretRequest,
-    GetSystemSecretResponse,
-)
-from frogml_proto.qwak.admiral.secret.v0.system_secret_service_pb2_grpc import (
-    SystemSecretServiceStub,
-)
-from frogml_core.inner.di_configuration import FrogmlContainer
-
-
-class SystemSecretClient:
-    @inject
-    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
-        self._grpc_client: SystemSecretServiceStub = SystemSecretServiceStub(
-            grpc_channel
-        )
-
-    def get_system_secret(self, name: str, env_id: str) -> SystemSecretValue:
-        response: GetSystemSecretResponse = self._grpc_client.GetSystemSecret(
-            GetSystemSecretRequest(
-                identifier=EnvironmentSecretIdentifier(name=name, environment_id=env_id)
-            )
-        )
-
-        return response.secret_definition.spec.value