frogml-core 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

frogml_core/clients/prompt_manager/prompt_proto_mapper.py

@@ -0,0 +1,264 @@
+from typing import List, Optional
+
+from frogml_proto.qwak.model_descriptor.open_ai_descriptor_pb2 import (
+    OpenAIModelDescriptor as ProtoOpenAIModelDescriptor,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    AIPromptMessageRole as ProtoAIPromptMessageRole,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    ChatMessage as ProtoChatMessage,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    ChatMessageTemplate as ProtoChatMessageTemplate,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    ChatPromptTemplate as ProtoChatPromptTemplate,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    HumanPromptMessageRole as ProtoHumanPromptMessageRole,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptMessageRole as ProtoPromptMessageRole,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptModelDescriptor as ProtoPromptModelDescriptor,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptOpenAIProvider as ProtoPromptOpenAIProvider,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptTemplate as ProtoPromptTemplate,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptVersionDefinition as ProtoPromptVersionDefinition,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptVersionSpec as ProtoPromptVersionSpec,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    SystemPromptMessageRole as ProtoSystemPromptMessageRole,
+)
+from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    TextTemplate as ProtoTextTemplate,
+)
+from frogml_core.clients.prompt_manager.model_descriptor_mapper import (
+    ModelDescriptorMapper,
+)
+from frogml_core.exceptions import FrogmlException
+from frogml_core.llmops.model.descriptor import ChatModelDescriptor, ModelDescriptor
+from frogml_core.llmops.prompt.base import BasePrompt, ChatPrompt, RegisteredPrompt
+from frogml_core.llmops.prompt.chat.message import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+)
+from frogml_core.llmops.prompt.chat.template import (
+    AIMessagePromptTemplate,
+    BaseStringMessagePromptTemplate,
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    SystemMessagePromptTemplate,
+)
+from frogml_core.llmops.prompt.template import BasePromptTemplate
+
+
+class PromptProtoMapper:
+    @staticmethod
+    def from_chat_prompt_template(
+        chat_prompt_template: ProtoChatPromptTemplate,
+    ) -> ChatPromptTemplate:
+        messages: List[BaseStringMessagePromptTemplate] = []
+        for chat_message in chat_prompt_template.chat_messages:
+            template: str = chat_message.template.text_template.template
+            role_type: str = chat_message.role.WhichOneof("role")
+            if role_type == "human_role":
+                messages.append(HumanMessagePromptTemplate(template=template))
+            elif role_type == "system_role":
+                messages.append(SystemMessagePromptTemplate(template=template))
+            elif role_type == "ai_role":
+                messages.append(AIMessagePromptTemplate(template=template))
+            else:
+                raise FrogmlException(
+                    f"Got unsupported chat message type: {repr(chat_message)}"
+                )
+
+        return ChatPromptTemplate(messages=messages)
+
+    @staticmethod
+    def from_prompt_template(
+        prompt_template: ProtoPromptTemplate,
+    ) -> BasePromptTemplate:
+        if prompt_template.WhichOneof("type") == "chat_prompt_template":
+            return PromptProtoMapper.from_chat_prompt_template(
+                chat_prompt_template=prompt_template.chat_prompt_template
+            )
+        else:
+            raise FrogmlException(
+                f"Got unsupported prompt template: {repr(prompt_template)}"
+            )
+
+    @staticmethod
+    def to_prompt_model_descriptor(
+        model_descriptor: ModelDescriptor,
+    ) -> ProtoPromptModelDescriptor:
+        proto_model_descriptor = ModelDescriptorMapper.to_model_descriptor(
+            model_descriptor=model_descriptor
+        )
+        if isinstance(proto_model_descriptor, ProtoOpenAIModelDescriptor):
+            return ProtoPromptModelDescriptor(
+                open_ai_provider=ProtoPromptOpenAIProvider(
+                    open_ai_model_descriptor=proto_model_descriptor
+                )
+            )
+
+        raise FrogmlException(
+            f"Got unsupported model descriptor: {repr(model_descriptor)}"
+        )
+
+    @staticmethod
+    def _prompt_template_to_chat_message(
+        msg: BaseStringMessagePromptTemplate,
+    ) -> ProtoChatMessage:
+        role: ProtoPromptMessageRole
+        text_template: str = msg.template.template
+
+        if isinstance(msg, SystemMessagePromptTemplate):
+            role = ProtoPromptMessageRole(system_role=ProtoSystemPromptMessageRole())
+        elif isinstance(msg, HumanMessagePromptTemplate):
+            role = ProtoPromptMessageRole(human_role=ProtoHumanPromptMessageRole())
+        elif isinstance(msg, AIMessagePromptTemplate):
+            role = ProtoPromptMessageRole(ai_role=ProtoAIPromptMessageRole())
+        else:
+            raise FrogmlException(f"Got unsupported prompt template role: {repr(msg)}")
+
+        return ProtoChatMessage(
+            role=role,
+            template=ProtoChatMessageTemplate(
+                text_template=ProtoTextTemplate(template=text_template)
+            ),
+        )
+
+    @staticmethod
+    def _base_message_to_chat_message(msg: BaseMessage) -> ProtoChatMessage:
+        role: ProtoPromptMessageRole
+        text_template: str = msg.content
+
+        if isinstance(msg, AIMessage):
+            role = ProtoPromptMessageRole(ai_role=ProtoAIPromptMessageRole())
+        elif isinstance(msg, HumanMessage):
+            role = ProtoPromptMessageRole(human_role=ProtoHumanPromptMessageRole())
+        elif isinstance(msg, SystemMessage):
+            role = ProtoPromptMessageRole(system_role=ProtoSystemPromptMessageRole())
+        else:
+            raise FrogmlException(f"Got unsupported prompt template role: {repr(msg)}")
+
+        return ProtoChatMessage(
+            role=role,
+            template=ProtoChatMessageTemplate(
+                text_template=ProtoTextTemplate(template=text_template)
+            ),
+        )
+
+    @staticmethod
+    def to_proto_chat_prompt_template(
+        prompt_template: ChatPromptTemplate,
+    ) -> ProtoPromptTemplate:
+        chat_messages: List[ProtoChatMessage] = []
+
+        for msg in prompt_template.messages:
+            if isinstance(msg, BaseStringMessagePromptTemplate):
+                chat_messages.append(
+                    PromptProtoMapper._prompt_template_to_chat_message(msg=msg)
+                )
+            elif isinstance(msg, BaseMessage):
+                chat_messages.append(
+                    PromptProtoMapper._base_message_to_chat_message(msg=msg)
+                )
+
+        return ProtoPromptTemplate(
+            chat_prompt_template=ProtoChatPromptTemplate(chat_messages=chat_messages)
+        )
+
+    @staticmethod
+    def to_proto_prompt_template(
+        prompt_template: BasePromptTemplate,
+    ) -> ProtoPromptTemplate:
+        if isinstance(prompt_template, ChatPromptTemplate):
+            return PromptProtoMapper.to_proto_chat_prompt_template(
+                prompt_template=prompt_template
+            )
+
+        raise FrogmlException(
+            f"Got unsupported prompt template: {repr(prompt_template)}"
+        )
+
+    @staticmethod
+    def to_prompt_version_spec(
+        version_description: str,
+        prompt_template: BasePromptTemplate,
+        model_descriptor: Optional[ModelDescriptor],
+    ) -> ProtoPromptVersionSpec:
+        prompt_model_descriptor: Optional[ProtoPromptModelDescriptor] = None
+
+        if model_descriptor:
+            prompt_model_descriptor: ProtoPromptModelDescriptor = (
+                PromptProtoMapper.to_prompt_model_descriptor(
+                    model_descriptor=model_descriptor
+                )
+            )
+
+        proto_prompt_template: ProtoPromptTemplate = (
+            PromptProtoMapper.to_proto_prompt_template(prompt_template=prompt_template)
+        )
+
+        return ProtoPromptVersionSpec(
+            description=version_description,
+            prompt_template=proto_prompt_template,
+            model_descriptor=prompt_model_descriptor,
+        )
+
+    @staticmethod
+    def from_prompt_version_definition(
+        prompt_version_def: ProtoPromptVersionDefinition,
+    ) -> BasePrompt:
+        model_descriptor: Optional[ModelDescriptor] = None
+        prompt_template: ProtoPromptTemplate = (
+            prompt_version_def.version_spec.prompt_template
+        )
+        base_prompt_template: BasePromptTemplate = (
+            PromptProtoMapper.from_prompt_template(prompt_template)
+        )
+
+        if prompt_version_def.version_spec.HasField("model_descriptor"):
+            model_descriptor: ModelDescriptor = (
+                ModelDescriptorMapper.from_prompt_model_descriptor(
+                    model_descriptor=prompt_version_def.version_spec.model_descriptor
+                )
+            )
+
+        if isinstance(base_prompt_template, ChatPromptTemplate) and (
+            not model_descriptor or isinstance(model_descriptor, ChatModelDescriptor)
+        ):
+            return ChatPrompt(template=base_prompt_template, model=model_descriptor)
+
+    @staticmethod
+    def from_prompt(
+        name: str,
+        prompt_description: str,
+        version_description: str,
+        version: int,
+        target_default_version: bool,
+        prompt_version_definition: ProtoPromptVersionDefinition,
+    ) -> RegisteredPrompt:
+        return RegisteredPrompt(
+            name=name,
+            prompt_description=prompt_description,
+            version_description=version_description,
+            version=version,
+            _target_default_version=target_default_version,
+            prompt=PromptProtoMapper.from_prompt_version_definition(
+                prompt_version_def=prompt_version_definition
+            ),
+        )

frogml_core/clients/secret_service/client.py

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

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

frogml_core/clients/user_application_instance/client.py

@@ -0,0 +1,177 @@
+from typing import Optional
+
+import grpc
+from dependency_injector.wiring import Provide
+
+from frogml_proto.qwak.admiral.user_application_instance.v0.user_application_instance_pb2 import (
+    CreateOptions,
+    Identifier,
+    RevisionRestriction,
+    UpdateSpecOptions,
+)
+from frogml_proto.qwak.admiral.user_application_instance.v0.user_application_instance_service_pb2 import (
+    CreateUserApplicationInstanceRequest,
+    CreateUserApplicationInstanceResponse,
+    DeleteUserApplicationInstanceRequest,
+    DeleteUserApplicationInstanceResponse,
+    GetUserApplicationInstanceRequest,
+    GetUserApplicationInstanceResponse,
+    UpdateUserApplicationInstanceSpecRequest,
+    UpdateUserApplicationInstanceSpecResponse,
+)
+from frogml_proto.qwak.admiral.user_application_instance.v0.user_application_instance_service_pb2_grpc import (
+    UserApplicationInstanceServiceStub,
+)
+from frogml_proto.qwak.user_application.v0.user_application_pb2 import Spec, Type
+from frogml_core.exceptions import FrogmlException, FrogmlNotFoundException
+from frogml_core.inner.di_configuration import FrogmlContainer
+
+
+class UserApplicationInstanceClient:
+    """
+    Used for interacting with Feature Registry endpoints
+    """
+
+    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
+        self._user_application_instance_service = UserApplicationInstanceServiceStub(
+            grpc_channel
+        )
+
+    def create_user_application_instance(
+        self,
+        kind_sem_version: Optional[str],
+        account_id: str,
+        environment_id: str,
+        name: str,
+        type: Type,
+        spec: Spec,
+    ) -> CreateUserApplicationInstanceResponse:
+        """
+        Create user application instance
+        """
+        try:
+            identifier = Identifier(
+                account_id=account_id,
+                environment_id=environment_id,
+                name=name,
+                type=type,
+            )
+
+            create_options = CreateOptions(
+                identifier=identifier, spec=spec, kind_sem_version=kind_sem_version
+            )
+            create_user_application_instance_request = (
+                CreateUserApplicationInstanceRequest(create_options=create_options)
+            )
+
+            return (
+                self._user_application_instance_service.CreateUserApplicationInstance(
+                    create_user_application_instance_request
+                )
+            )
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to create user application instance, error is {repr(e)}"
+            )
+
+    def update_user_application_instance(
+        self,
+        current_spec_revision: Optional[int],
+        account_id: str,
+        environment_id: str,
+        name: str,
+        type: Type,
+        spec: Spec,
+    ) -> UpdateUserApplicationInstanceSpecResponse:
+        """
+        Update user application instance
+        """
+        try:
+            identifier = Identifier(
+                account_id=account_id,
+                environment_id=environment_id,
+                name=name,
+                type=type,
+            )
+
+            revision_restriction = RevisionRestriction(
+                current_spec_revision=current_spec_revision
+            )
+            update_options = UpdateSpecOptions(
+                identifier=identifier,
+                spec=spec,
+                revision_restriction=revision_restriction,
+            )
+            update_user_application_instance_request = (
+                UpdateUserApplicationInstanceSpecRequest(update_options=update_options)
+            )
+
+            return self._user_application_instance_service.UpdateUserApplicationInstanceSpec(
+                update_user_application_instance_request
+            )
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to update user application instance, error is {repr(e)}"
+            )
+
+    def delete_user_application_instance(
+        self,
+        account_id: str,
+        environment_id: str,
+        name: str,
+        type: Type,
+    ) -> DeleteUserApplicationInstanceResponse:
+        """
+        Delete user application instance
+        """
+        try:
+            identifier = Identifier(
+                account_id=account_id,
+                environment_id=environment_id,
+                name=name,
+                type=type,
+            )
+            delete_user_application_instance_request = (
+                DeleteUserApplicationInstanceRequest(identifier=identifier)
+            )
+            return (
+                self._user_application_instance_service.DeleteUserApplicationInstance(
+                    delete_user_application_instance_request
+                )
+            )
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to delete user application instance, error is {repr(e)}"
+            )
+
+    def get_user_application_instance(
+        self,
+        account_id: str,
+        environment_id: str,
+        name: str,
+        type: Type,
+    ) -> GetUserApplicationInstanceResponse:
+        """
+        Get user application instance
+        """
+        try:
+            identifier = Identifier(
+                account_id=account_id,
+                environment_id=environment_id,
+                name=name,
+                type=type,
+            )
+            get_user_application_request = GetUserApplicationInstanceRequest(
+                identifier=identifier
+            )
+            return self._user_application_instance_service.GetUserApplicationInstance(
+                get_user_application_request
+            )
+        except grpc.RpcError as e:
+            if e.args[0].code == grpc.StatusCode.NOT_FOUND:
+                raise FrogmlNotFoundException(
+                    f"User application instance  Resource was not found, error is {repr(e)}"
+                )
+            raise FrogmlException(
+                f"Failed to get user application instance, error is {repr(e)}"
+            )

frogml_core/clients/vector_store/management_client.py

@@ -0,0 +1,127 @@
+from typing import List, Optional
+
+import grpc
+from dependency_injector.wiring import Provide, inject
+
+from frogml_proto.qwak.vectors.v1.collection.collection_pb2 import (
+    VectorCollection,
+    VectorCollectionMetric,
+    VectorCollectionSpec,
+    VectorCollectionVectorizer,
+)
+from frogml_proto.qwak.vectors.v1.collection.collection_service_pb2 import (
+    CreateCollectionRequest,
+    DeleteCollectionByIdRequest,
+    DeleteCollectionByNameRequest,
+    GetCollectionByIdRequest,
+    GetCollectionByNameRequest,
+    ListCollectionsRequest,
+)
+from frogml_proto.qwak.vectors.v1.collection.collection_service_pb2_grpc import (
+    VectorCollectionServiceStub,
+)
+from frogml_core.exceptions import FrogmlException
+from frogml_core.inner.di_configuration import FrogmlContainer
+
+
+class VectorManagementClient:
+    @inject
+    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
+        self._vector_management_service: VectorCollectionServiceStub = (
+            VectorCollectionServiceStub(grpc_channel)
+        )
+
+    def create_collection(
+        self,
+        name: str,
+        dimension: int,
+        description: str = None,
+        metric: VectorCollectionMetric = VectorCollectionMetric.COLLECTION_METRIC_L2_SQUARED,
+        vectorizer: Optional[str] = None,
+        multi_tenant: bool = False,
+    ) -> VectorCollection:
+        """
+        Create a collection
+        """
+        try:
+            return self._vector_management_service.CreateCollection(
+                CreateCollectionRequest(
+                    collection_spec=VectorCollectionSpec(
+                        name=name,
+                        description=description,
+                        vectorizer=VectorCollectionVectorizer(
+                            qwak_model_name=vectorizer
+                        ),
+                        metric=metric,
+                        dimension=dimension,
+                        multi_tenancy_enabled=multi_tenant,
+                    )
+                )
+            ).vector_collection
+
+        except grpc.RpcError as e:
+            raise FrogmlException(f"Failed to create collection: {e.details()}")
+
+    def list_collections(self) -> List[VectorCollection]:
+        """
+        List all vector collections
+        """
+        try:
+            return self._vector_management_service.ListCollections(
+                ListCollectionsRequest()
+            ).vector_collections
+
+        except grpc.RpcError as e:
+            raise FrogmlException(f"Failed to list collections: {e.details()}")
+
+    def get_collection_by_name(self, name: str) -> VectorCollection:
+        """
+        Get vector collection by name
+        """
+        try:
+            return self._vector_management_service.GetCollectionByName(
+                GetCollectionByNameRequest(name=name)
+            ).vector_collection
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to get collection by name '{name}': {e.details()}"
+            )
+
+    def get_collection_by_id(self, id: str) -> VectorCollection:
+        """
+        Get vector collection by id
+        """
+        try:
+            return self._vector_management_service.GetCollectionById(
+                GetCollectionByIdRequest(id=id)
+            ).vector_collection
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to get collection by id '{id}': {e.details()}"
+            )
+
+    def delete_collection_by_id(self, id: str) -> None:
+        """
+        Delete vector collection by id
+        """
+        try:
+            self._vector_management_service.DeleteCollectionById(
+                DeleteCollectionByIdRequest(id=id)
+            )
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to delete collection by id '{id}': {e.details()}"
+            )
+
+    def delete_collection_by_name(self, name: str) -> None:
+        """
+        Delete vector collection by id
+        """
+        try:
+            self._vector_management_service.DeleteCollectionByName(
+                DeleteCollectionByNameRequest(name=name)
+            )
+        except grpc.RpcError as e:
+            raise FrogmlException(
+                f"Failed to delete collection by name '{name}': {e.details()}"
+            )