frogml-core 0.0.113__py3-none-any.whl → 0.0.114__py3-none-any.whl

frogml_core/clients/prompt_manager/prompt_manager_client.py

@@ -1,190 +0,0 @@
-import grpc
-from dependency_injector.wiring import Provide, inject
-
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    CreatePromptRequest as ProtoCreatePromptRequest,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    CreatePromptResponse as ProtoCreatePromptResponse,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    CreatePromptVersionRequest as ProtoCreatePromptVersionRequest,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    CreatePromptVersionResponse as ProtoCreatePromptVersionResponse,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    DeletePromptRequest as ProtoDeletePromptRequest,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    DeletePromptVersionRequest as ProtoDeletePromptVersionRequest,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    GetPromptByNameRequest as ProtoGetPromptByNameRequest,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    GetPromptByNameResponse as ProtoGetPromptByNameResponse,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    GetPromptVersionByPromptNameRequest as ProtoGetPromptVersionByPromptNameRequest,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    GetPromptVersionByPromptNameResponse as ProtoGetPromptVersionByPromptNameResponse,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
-    SetDefaultPromptVersionRequest as ProtoSetDefaultPromptVersionRequest,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2_grpc import (
-    PromptManagerServiceStub,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import Prompt as ProtoPrompt
-from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import PromptSpec as ProtoPromptSpec
-from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
-    PromptVersion as ProtoPromptVersion,
-)
-from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
-    PromptVersionSpec as ProtoPromptVersionSpec,
-)
-from frogml_core.exceptions import FrogmlException
-from frogml_core.inner.di_configuration import FrogmlContainer
-
-
-class PromptManagerClient:
-    @inject
-    def __init__(self, grpc_channel=Provide[FrogmlContainer.core_grpc_channel]):
-        self._grpc_client: PromptManagerServiceStub = PromptManagerServiceStub(
-            grpc_channel
-        )
-
-    def create_prompt(
-        self,
-        name: str,
-        prompt_description: str,
-        version_spec: ProtoPromptVersionSpec,
-    ) -> ProtoPrompt:
-        request = ProtoCreatePromptRequest(
-            prompt_name=name,
-            prompt_spec=ProtoPromptSpec(description=prompt_description),
-            prompt_version_spec=version_spec,
-        )
-        try:
-            response: ProtoCreatePromptResponse = self._grpc_client.CreatePrompt(
-                request
-            )
-            return response.prompt
-        except grpc.RpcError as error:
-            call: grpc.Call = error  # noqa
-            if call.code() == grpc.StatusCode.ALREADY_EXISTS:
-                raise FrogmlException(f"Prompt with name: {name} already exists")
-            elif call.code() == grpc.StatusCode.INVALID_ARGUMENT:
-                raise FrogmlException(
-                    f"Got an illegal prompt specification: {call.details()}"
-                )
-            else:
-                raise FrogmlException(f"Internal Error: {call.details()}")
-
-    def create_prompt_version(
-        self,
-        name: str,
-        version_spec: ProtoPromptVersionSpec,
-        set_default: bool,
-    ) -> ProtoPromptVersion:
-        request = ProtoCreatePromptVersionRequest(
-            prompt_name=name, prompt_version_spec=version_spec, set_default=set_default
-        )
-        try:
-            response: ProtoCreatePromptVersionResponse = (
-                self._grpc_client.CreatePromptVersion(request)
-            )
-            return response.prompt_version
-        except grpc.RpcError as error:
-            call: grpc.Call = error  # noqa
-            if call.code() == grpc.StatusCode.NOT_FOUND:
-                raise FrogmlException(
-                    f"Can not update prompt: '{name}', prompt was not found"
-                )
-            elif call.code() == grpc.StatusCode.INVALID_ARGUMENT:
-                raise FrogmlException(
-                    f"Got an illegal prompt specification: {call.details()}"
-                )
-            else:
-                raise FrogmlException(f"Internal Error: {call.details()}")
-
-    def delete_prompt(self, name: str):
-        try:
-            self._grpc_client.DeletePrompt(ProtoDeletePromptRequest(prompt_name=name))
-        except grpc.RpcError as error:
-            call: grpc.Call = error  # noqa
-            if call.code() == grpc.StatusCode.NOT_FOUND:
-                raise FrogmlException(f"Prompt named '{name}' was not found")
-            else:
-                raise FrogmlException(f"Internal Error: {call.details()}")
-
-    def delete_prompt_version(self, name: str, version: int):
-        try:
-            self._grpc_client.DeletePromptVersion(
-                ProtoDeletePromptVersionRequest(
-                    prompt_name=name, version_number=version
-                )
-            )
-        except grpc.RpcError as error:
-            call: grpc.Call = error  # noqa
-            if call.code() == grpc.StatusCode.NOT_FOUND:
-                raise FrogmlException(str(call.details()))
-            elif call.code() == grpc.StatusCode.FAILED_PRECONDITION:
-                raise FrogmlException(
-                    f"Cannot delete the default version '{version}' of a prompt '{name}',"
-                    f" please set another version as the default to delete this version."
-                )
-            else:
-                raise FrogmlException(f"Internal Error: {call.details()}")
-
-    def get_prompt_by_name(self, name: str) -> ProtoPrompt:
-        """
-        Get prompt's default version
-        """
-        try:
-            response: ProtoGetPromptByNameResponse = self._grpc_client.GetPromptByName(
-                ProtoGetPromptByNameRequest(prompt_name=name)
-            )
-            return response.prompt
-        except grpc.RpcError as error:
-            call: grpc.Call = error  # noqa
-            if call.code() == grpc.StatusCode.NOT_FOUND:
-                raise FrogmlException(str(call.details()))
-            else:
-                raise FrogmlException(f"Internal Error: {call.details()}")
-
-    def get_prompt_version_by_name(self, name: str, version: int) -> ProtoPromptVersion:
-        """
-        Get prompt specific version
-        """
-        try:
-            response: ProtoGetPromptVersionByPromptNameResponse = (
-                self._grpc_client.GetPromptVersionByPromptName(
-                    ProtoGetPromptVersionByPromptNameRequest(
-                        prompt_name=name, version_number=version
-                    )
-                )
-            )
-            return response.prompt_version
-        except grpc.RpcError as error:
-            call: grpc.Call = error  # noqa
-            if call.code() == grpc.StatusCode.NOT_FOUND:
-                raise FrogmlException(str(call.details()))
-            else:
-                raise FrogmlException(f"Internal Error: {call.details()}")
-
-    def set_default_prompt_version(self, name: str, version: int):
-        try:
-            self._grpc_client.SetDefaultPromptVersion(
-                ProtoSetDefaultPromptVersionRequest(
-                    prompt_name=name, version_number=version
-                )
-            )
-        except grpc.RpcError as error:
-            call: grpc.Call = error  # noqa
-            if call.code() == grpc.StatusCode.NOT_FOUND:
-                raise FrogmlException(str(call.details()))
-            else:
-                raise FrogmlException(f"Internal Error: {call.details()}")

frogml_core/clients/prompt_manager/prompt_proto_mapper.py

@@ -1,264 +0,0 @@
-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/vector_store/__init__.py

@@ -1,2 +0,0 @@
-from .management_client import VectorManagementClient
-from .serving_client import VectorServingClient

frogml_core/clients/vector_store/management_client.py

@@ -1,127 +0,0 @@
-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()}"
-            )