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

frogml_core/clients/prompt_manager/model_descriptor_mapper.py

@@ -1,196 +0,0 @@
-from typing import List, Optional, Union
-
-from google.protobuf import json_format
-from google.protobuf.struct_pb2 import ListValue, Struct
-
-from frogml_proto.qwak.model_descriptor.open_ai_descriptor_pb2 import (
-    OpenAICapabilities as ProtoOpenAICapabilities,
-)
-from frogml_proto.qwak.model_descriptor.open_ai_descriptor_pb2 import (
-    OpenAIChatAPI as ProtoOpenAIChatAPI,
-)
-from frogml_proto.qwak.model_descriptor.open_ai_descriptor_pb2 import (
-    OpenAIChatModelParams as ProtoOpenAIChatModelParams,
-)
-from frogml_proto.qwak.model_descriptor.open_ai_descriptor_pb2 import (
-    OpenAIModelDescriptor as ProtoOpenAIModelDescriptor,
-)
-from frogml_proto.qwak.model_descriptor.open_ai_descriptor_pb2 import (
-    ToolChoice as ProtoToolChoice,
-)
-from frogml_proto.qwak.model_descriptor.open_ai_descriptor_pb2 import (
-    Tools as ProtoTools,
-)
-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_core.exceptions import FrogmlException
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion_named_tool_choice_param import (
-    ChatCompletionNamedToolChoiceParam,
-)
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion_tool_param import (
-    ChatCompletionToolParam,
-)
-from frogml_core.llmops.model.descriptor import ModelDescriptor, OpenAIChat
-
-
-class ModelDescriptorMapper:
-    @staticmethod
-    def _from_tool_choice(
-        openai_chat_params: ProtoOpenAIChatModelParams,
-    ) -> Optional[Union[str, ChatCompletionNamedToolChoiceParam]]:
-        _tool_choice: Optional[Union[str, ChatCompletionNamedToolChoiceParam]] = None
-        if openai_chat_params.HasField("tool_choice"):
-            if openai_chat_params.tool_choice.WhichOneof("value_type") == "json":
-                _tool_choice = json_format.MessageToDict(
-                    openai_chat_params.tool_choice.json
-                )
-            elif openai_chat_params.tool_choice.WhichOneof("value_type") == "literal":
-                _tool_choice = openai_chat_params.tool_choice.literal
-        return _tool_choice
-
-    @staticmethod
-    def from_openai_chat_capability(
-        model_id: str, openai_chat_params: ProtoOpenAIChatModelParams
-    ) -> OpenAIChat:
-        p = openai_chat_params
-        _tool_choice: Union[str, ChatCompletionNamedToolChoiceParam] = (
-            ModelDescriptorMapper._from_tool_choice(
-                openai_chat_params=openai_chat_params
-            )
-        )
-        _tools: List[ChatCompletionToolParam] = []
-
-        if p.HasField("tools_spec"):
-            for tool in p.tools_spec.tools:
-                _tools.append(json_format.MessageToDict(tool))
-
-        return OpenAIChat(
-            model_id=model_id,
-            frequency_penalty=(
-                p.frequency_penalty if p.HasField("frequency_penalty") else None
-            ),
-            logit_bias=(
-                {k: int(v) for k, v in p.logit_bias.items()}
-                if p.HasField("logit_bias")
-                else None
-            ),
-            logprobs=p.logprobs if p.HasField("logprobs") else None,
-            max_tokens=p.max_tokens if p.HasField("max_tokens") else None,
-            n=p.n if p.HasField("n") else None,
-            presence_penalty=(
-                p.presence_penalty if p.HasField("presence_penalty") else None
-            ),
-            response_format=(
-                p.response_format if p.HasField("response_format") else None
-            ),  # noqa
-            seed=p.seed if p.HasField("seed") else None,
-            stop=[_ for _ in p.stop] if p.HasField("stop") else None,
-            temperature=p.temperature if p.HasField("temperature") else None,
-            top_p=p.top_p if p.HasField("top_p") else None,
-            top_logprobs=p.top_logprobs if p.HasField("top_logprobs") else None,
-            user=p.user if p.HasField("user") else None,
-            tool_choice=_tool_choice if p.HasField("tool_choice") else None,
-            tools=_tools if p.HasField("tools_spec") else None,
-        )
-
-    @staticmethod
-    def from_prompt_openai_provider(
-        open_ai_provider: ProtoPromptOpenAIProvider,
-    ) -> ModelDescriptor:
-        descriptor: ProtoOpenAIModelDescriptor = (
-            open_ai_provider.open_ai_model_descriptor
-        )
-        model_id: str = descriptor.model_id
-
-        if descriptor.capabilities.WhichOneof("optional_chat"):
-            return ModelDescriptorMapper.from_openai_chat_capability(
-                model_id=model_id,
-                openai_chat_params=descriptor.capabilities.chat_api.chat_params,
-            )
-        else:
-            raise FrogmlException(
-                f"Got unsupported openai capability: {repr(open_ai_provider)}"
-            )
-
-    @staticmethod
-    def from_prompt_model_descriptor(
-        model_descriptor: ProtoPromptModelDescriptor,
-    ) -> ModelDescriptor:
-        if model_descriptor.WhichOneof("model_provider") == "open_ai_provider":
-            return ModelDescriptorMapper.from_prompt_openai_provider(
-                model_descriptor.open_ai_provider
-            )
-        else:
-            raise FrogmlException(
-                f"Got unsupported model descriptor: {repr(model_descriptor)}"
-            )
-
-    @staticmethod
-    def to_openai_chat(model_descriptor: OpenAIChat) -> ProtoOpenAIModelDescriptor:
-        d: OpenAIChat = model_descriptor
-        logit_bias_struct = Struct()
-
-        logit_bias_struct.update(d.logit_bias) if d.logit_bias else None
-
-        stop_list_value = ListValue()
-        stop_list_value.extend(d.stop) if d.stop else None
-        tool_choice_proto: ProtoToolChoice
-
-        if isinstance(d.tool_choice, str):
-            tool_choice_proto = ProtoToolChoice(literal=d.tool_choice)
-        elif d.tool_choice is not None:
-            tool_choice_struct = Struct()
-            tool_choice_struct.update(d.tool_choice)
-            tool_choice_proto = ProtoToolChoice(json=tool_choice_struct)
-
-        tools_structs = []
-        if d.tools:
-            for tool in d.tools:
-                s = Struct()
-                s.update(tool)
-                tools_structs.append(s)
-
-        tools_proto = ProtoTools(tools=tools_structs)
-
-        model_capabilities = ProtoOpenAICapabilities(
-            chat_api=ProtoOpenAIChatAPI(
-                chat_params=ProtoOpenAIChatModelParams(
-                    frequency_penalty=d.frequency_penalty,
-                    logit_bias=logit_bias_struct if d.logit_bias else None,
-                    logprobs=d.logprobs,
-                    max_tokens=d.max_tokens,
-                    n=d.n,
-                    presence_penalty=d.presence_penalty,
-                    response_format=(
-                        d.response_format if d.response_format else None
-                    ),  # noqa
-                    seed=d.seed,
-                    stop=stop_list_value if d.stop else None,
-                    temperature=d.temperature,
-                    tool_choice=tool_choice_proto if d.tool_choice else None,
-                    tools_spec=tools_proto if d.tools else None,
-                    top_logprobs=d.top_logprobs,
-                    top_p=d.top_p,
-                    user=d.user,
-                )
-            )
-        )
-
-        return ProtoOpenAIModelDescriptor(
-            model_id=model_descriptor.model_id, capabilities=model_capabilities
-        )
-
-    @staticmethod
-    def to_model_descriptor(
-        model_descriptor: ModelDescriptor,
-    ) -> Union[ProtoOpenAIModelDescriptor]:
-        if isinstance(model_descriptor, OpenAIChat):
-            return ModelDescriptorMapper.to_openai_chat(model_descriptor)
-
-        raise FrogmlException(
-            f"Got unsupported model descriptor: {repr(model_descriptor)}"
-        )

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