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

frogml_core/llmops/generation/chat/openai/types/shared/function_parameters.py

@@ -1,20 +0,0 @@
-#
-#    Copyright 2024 OpenAI
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-from typing import Dict
-
-__all__ = ["FunctionParameters"]
-
-FunctionParameters = Dict[str, object]

frogml_core/llmops/generation/chat/openai/types/shared_params/__init__.py

@@ -1,2 +0,0 @@
-from .function_definition import FunctionDefinition as FunctionDefinition
-from .function_parameters import FunctionParameters as FunctionParameters

frogml_core/llmops/generation/chat/openai/types/shared_params/function_definition.py

@@ -1,49 +0,0 @@
-#
-#    Copyright 2024 OpenAI
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-from __future__ import annotations
-
-from typing_extensions import Required, TypedDict
-
-from ...types import shared_params
-
-__all__ = ["FunctionDefinition"]
-
-
-class FunctionDefinition(TypedDict, total=False):
-    name: Required[str]
-    """The name of the function to be called.
-
-    Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length
-    of 64.
-    """
-
-    description: str
-    """
-    A description of what the function does, used by the model to choose when and
-    how to call the function.
-    """
-
-    parameters: shared_params.FunctionParameters
-    """The parameters the functions accepts, described as a JSON Schema object.
-
-    See the
-    [guide](https://platform.openai.com/docs/guides/text-generation/function-calling)
-    for examples, and the
-    [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for
-    documentation about the format.
-
-    Omitting `parameters` defines a function with an empty parameter list.
-    """

frogml_core/llmops/generation/chat/openai/types/shared_params/function_parameters.py

@@ -1,22 +0,0 @@
-#
-#    Copyright 2024 OpenAI
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-from __future__ import annotations
-
-from typing import Dict
-
-__all__ = ["FunctionParameters"]
-
-FunctionParameters = Dict[str, object]

frogml_core/llmops/generation/streaming.py

@@ -1,26 +0,0 @@
-from abc import ABC
-from typing import Generic, TypeVar
-
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion_chunk import (
-    ChatCompletionChunk,
-)
-
-try:
-    from collections import Iterable
-
-    iterableABC = Iterable
-except ImportError:
-    from collections.abc import Iterable
-
-    iterableABC = Iterable
-
-
-_T = TypeVar("_T")
-
-
-class Stream(Generic[_T], ABC, iterableABC):
-    pass
-
-
-class ChatCompletionStream(Stream[ChatCompletionChunk], ABC):
-    pass

frogml_core/llmops/model/descriptor.py

@@ -1,40 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass, field
-from typing import Dict, Iterable, List, Optional, Union
-
-from typing_extensions import Literal
-
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion_tool_choice_option_param import (
-    ChatCompletionToolChoiceOptionParam,
-)
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion_tool_param import (
-    ChatCompletionToolParam,
-)
-
-
-class ModelDescriptor(ABC):
-    pass
-
-
-class ChatModelDescriptor(ModelDescriptor):
-    pass
-
-
-@dataclass
-class OpenAIChat(ChatModelDescriptor):
-    model_id: str
-    frequency_penalty: Optional[float] = field(default=None)
-    logit_bias: Optional[Dict[str, int]] = field(default=None)
-    logprobs: Optional[bool] = field(default=None)
-    max_tokens: Optional[int] = field(default=None)
-    n: Optional[int] = field(default=None)
-    presence_penalty: Optional[float] = field(default=None)
-    response_format: Literal["text", "json_object"] = "text"
-    seed: Optional[int] = field(default=None)
-    stop: Union[Optional[str], List[str], None] = field(default=None)
-    temperature: Optional[float] = field(default=None)
-    top_p: Optional[float] = field(default=None)
-    top_logprobs: Optional[int] = field(default=None)
-    tool_choice: Optional[ChatCompletionToolChoiceOptionParam] = field(default=None)
-    tools: Optional[Iterable[ChatCompletionToolParam]] = field(default=None)
-    user: Optional[str] = field(default=None)

frogml_core/llmops/prompt/base.py

@@ -1,136 +0,0 @@
-import os
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import Callable, Dict, Optional, Union
-
-from cachetools import TTLCache, cached
-
-from frogml_core.exceptions import FrogmlException
-from frogml_core.llmops.generation.base import ModelResponse
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion import (
-    ChatCompletion,
-)
-from frogml_core.llmops.generation.streaming import ChatCompletionStream, Stream
-from frogml_core.llmops.model.descriptor import ChatModelDescriptor, ModelDescriptor
-from frogml_core.llmops.prompt.chat.template import ChatPromptTemplate
-from frogml_core.llmops.prompt.chat.value import ChatPromptValue
-from frogml_core.llmops.prompt.value import PromptValue
-from frogml_core.llmops.provider.chat import ChatCompletionProvider
-
-
-@dataclass
-class BasePrompt(ABC):
-    @abstractmethod
-    def render(self, variables: Dict[str, any]) -> PromptValue:
-        pass
-
-    @abstractmethod
-    def invoke(
-        self,
-        variables: Optional[Dict[str, any]] = None,
-        model_override: Optional[ModelDescriptor] = None,
-        stream: bool = False,
-    ) -> Union[ModelResponse, Stream]:
-        pass
-
-
-@dataclass
-class ChatPrompt(BasePrompt):
-    template: ChatPromptTemplate
-    model: Optional[ChatModelDescriptor]
-
-    def __post_init__(self):
-        self._validate()
-
-    def _validate(self):
-        if not isinstance(self.template, ChatPromptTemplate) or (
-            self.model and not isinstance(self.model, ChatModelDescriptor)
-        ):
-            raise ValueError("ChatPrompt initiated with non-chat type fields!")
-
-    def render(self, variables: Dict[str, any]) -> ChatPromptValue:
-        return self.template.render(variables=variables)
-
-    def invoke(
-        self,
-        variables: Optional[Dict[str, any]] = None,
-        model_override: Optional[ModelDescriptor] = None,
-        stream: bool = False,
-    ) -> Union[ChatCompletion, ChatCompletionStream]:
-        if not variables:
-            variables = dict()
-        if not self.model and not model_override:
-            raise FrogmlException(
-                "Can't invoke a prompt without a `ModelDescriptor`."
-                " Please provide one using the model_override "
-                "or create a ChatPrompt with a model."
-            )
-
-        return ChatCompletionProvider.invoke(
-            chat_prompt_value=self.render(variables=variables),
-            chat_model_descriptor=model_override if model_override else self.model,
-            stream=stream,
-        )
-
-
-@dataclass
-class RegisteredPrompt(BasePrompt):
-    name: str
-    prompt_description: str
-    version_description: str
-    version: int
-    _target_default_version: bool
-    prompt: BasePrompt
-    _cache: Callable[[str], "RegisteredPrompt"] = field(init=False, default=None)
-    _prompt_manager: "PromptManager" = None  # noqa
-
-    def _get_prompt_manager(self) -> "PromptManager":  # noqa
-        from frogml_core.llmops.prompt.manager import PromptManager
-
-        if not self._prompt_manager:
-            self._prompt_manager = PromptManager()
-        return self._prompt_manager
-
-    def _get_prompt_default_version_internal(self, name: str) -> "RegisteredPrompt":
-        return self._get_prompt_manager().get_prompt(name=name, version=None)
-
-    def _get_prompt_default_version(self, *, name: str) -> "RegisteredPrompt":
-        if not self._cache:
-            cache = cached(
-                cache=TTLCache(
-                    maxsize=1, ttl=float(os.environ.get("_PROMPT_CACHE_SECONDS", "60"))
-                ),
-                key=lambda *args, **kwargs: kwargs["name"],
-            )
-            self._cache = cache(self._get_prompt_default_version_internal)
-        return self._cache(name=name)  # noqa
-
-    def _handle_default_version_swap(self):
-        if self._target_default_version:
-            new_default_version_prompt: RegisteredPrompt = (
-                self._get_prompt_default_version(name=self.name)
-            )
-            self.prompt_description = new_default_version_prompt.prompt_description
-            if self.version != new_default_version_prompt.version:
-                self.version_description = (
-                    new_default_version_prompt.version_description
-                )
-                self.version = new_default_version_prompt.version
-                self.prompt = new_default_version_prompt.prompt
-
-    def render(self, variables: Dict[str, any]) -> PromptValue:
-        self._handle_default_version_swap()
-        return self.prompt.render(variables=variables)
-
-    def invoke(
-        self,
-        variables: Optional[Dict[str, any]] = None,
-        model_override: Optional[ModelDescriptor] = None,
-        stream: bool = False,
-    ) -> Union[ModelResponse, Stream]:
-        if not variables:
-            variables = dict()
-        self._handle_default_version_swap()
-        return self.prompt.invoke(
-            variables=variables, model_override=model_override, stream=stream
-        )

frogml_core/llmops/prompt/chat/message.py

@@ -1,24 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass, field
-
-from frogml_core.llmops.prompt.value import PromptValue
-
-
-@dataclass
-class BaseMessage(PromptValue, ABC):
-    content: str
-    role_name: str = field(
-        init=False,
-    )
-
-
-class AIMessage(BaseMessage):
-    role_name: str = "ai"
-
-
-class HumanMessage(BaseMessage):
-    role_name: str = "human"
-
-
-class SystemMessage(BaseMessage):
-    role_name: str = "system"

frogml_core/llmops/prompt/chat/template.py

@@ -1,113 +0,0 @@
-import re
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import Dict, List, Tuple, Union
-
-from frogml_core.llmops.prompt.chat.message import (
-    AIMessage,
-    BaseMessage,
-    HumanMessage,
-    SystemMessage,
-)
-from frogml_core.llmops.prompt.chat.value import ChatPromptValue
-from frogml_core.llmops.prompt.template import BasePromptTemplate, StringPromptTemplate
-
-
-@dataclass
-class BaseMessagePromptTemplate(BasePromptTemplate):
-    @abstractmethod
-    def render(self, variables: Dict[str, any]) -> BaseMessage:
-        pass
-
-
-@dataclass
-class BaseStringMessagePromptTemplate(BaseMessagePromptTemplate, ABC):
-    template: StringPromptTemplate = field(init=False)
-    role_name: str = field(init=False)
-
-    def __init__(self, template: str):
-        self.template = StringPromptTemplate(template=template)
-
-
-class AIMessagePromptTemplate(BaseStringMessagePromptTemplate):
-    role_name: str = "ai"
-
-    def render(self, variables: Dict[str, any]) -> BaseMessage:
-        return AIMessage(content=self.template.render(variables=variables).to_string())
-
-
-class HumanMessagePromptTemplate(BaseStringMessagePromptTemplate):
-    role_name: str = "human"
-
-    def render(self, variables: Dict[str, any]) -> BaseMessage:
-        return HumanMessage(
-            content=self.template.render(variables=variables).to_string()
-        )
-
-
-class SystemMessagePromptTemplate(BaseStringMessagePromptTemplate):
-    role_name: str = "system"
-
-    def render(self, variables: Dict[str, any]) -> BaseMessage:
-        return SystemMessage(
-            content=self.template.render(variables=variables).to_string()
-        )
-
-
-@dataclass
-class ChatPromptTemplate(BasePromptTemplate):
-    messages: List[Union[BaseMessage, BaseStringMessagePromptTemplate]]
-
-    def render(self, variables: Dict[str, any]) -> ChatPromptValue:
-        resulting_messages: List[BaseMessage] = list()
-
-        for message in self.messages:
-            if isinstance(message, BaseMessage):
-                resulting_messages.append(message)
-            elif isinstance(message, BaseStringMessagePromptTemplate):
-                resulting_messages.append(message.render(variables=variables))
-            else:
-                raise ValueError(
-                    f"Got unsupported message type: {repr(message)}. \n"
-                    "Supported messages are: "
-                    "AIMessagePromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate, \n"
-                    "AIMessage, HumanMessage, SystemMessage."
-                )
-
-        return ChatPromptValue(messages=resulting_messages)
-
-    def to_messages(self) -> List[Tuple[str, str]]:
-        """
-        Useful for integration with other libraries such as Langchain.
-
-        ```
-        ChatPromptTemplate(
-                messages=[
-                    SystemMessage("you are an assistant"),
-                    HumanMessagePromptTemplate("{{question}}")
-                ]
-            ).to_messages()
-
-        resulting in:
-
-        [("system", "you are an assistant"),
-        ("human", "{question}")]
-        ```
-
-        """
-
-        def strip_curly(string: str) -> str:
-            return re.sub(r"\{\{\s*([\w\s]+)\s*\}\}", repl=r"{\g<1>}", string=string)
-
-        if not self.messages:
-            return []
-
-        result: List[Tuple[str, str]] = []
-
-        for msg in self.messages:
-            if isinstance(msg, BaseMessage):
-                result.append((msg.role_name, msg.content))
-            elif isinstance(msg, BaseStringMessagePromptTemplate):
-                result.append((msg.role_name, strip_curly(msg.template.template)))
-
-        return result

frogml_core/llmops/prompt/chat/value.py

@@ -1,10 +0,0 @@
-from dataclasses import dataclass
-from typing import List
-
-from frogml_core.llmops.prompt.chat.message import BaseMessage
-from frogml_core.llmops.prompt.value import PromptValue
-
-
-@dataclass
-class ChatPromptValue(PromptValue):
-    messages: List[BaseMessage]

frogml_core/llmops/prompt/manager.py

@@ -1,138 +0,0 @@
-from typing import Optional
-
-from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import Prompt as ProtoPrompt
-from frogml_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
-    PromptVersion as ProtoPromptVersion,
-)
-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_core.clients.prompt_manager.prompt_manager_client import PromptManagerClient
-from frogml_core.clients.prompt_manager.prompt_proto_mapper import PromptProtoMapper
-from frogml_core.exceptions import FrogmlException
-from frogml_core.llmops.prompt.base import BasePrompt, ChatPrompt, RegisteredPrompt
-
-
-class PromptManager:
-    _prompt_manager_client: PromptManagerClient
-
-    def __init__(self):
-        self._prompt_manager_client = PromptManagerClient()
-
-    def register(
-        self,
-        name: str,
-        prompt: BasePrompt,
-        prompt_description: Optional[str] = None,
-        version_description: Optional[str] = None,
-    ) -> RegisteredPrompt:
-        """
-        Registers a new prompt in Qwak platform. Name must be unique
-         and conform to ^[a-z0-9](?:[-_]?[a-z0-9]+)+$
-        """
-        if not isinstance(prompt, ChatPrompt):
-            raise FrogmlException(f"Got unsupported prompt type: {prompt}")
-
-        version_spec: ProtoPromptVersionSpec = PromptProtoMapper.to_prompt_version_spec(
-            version_description=version_description,
-            prompt_template=prompt.template,
-            model_descriptor=prompt.model,
-        )
-
-        registered_prompt: ProtoPrompt = self._prompt_manager_client.create_prompt(
-            name=name, prompt_description=prompt_description, version_spec=version_spec
-        )
-
-        return PromptProtoMapper.from_prompt(
-            name=registered_prompt.name,
-            prompt_description=registered_prompt.prompt_spec.description,
-            version_description=registered_prompt.default_version_definition.version_spec.description,
-            version=registered_prompt.default_version_definition.version_number,
-            target_default_version=True,
-            prompt_version_definition=registered_prompt.default_version_definition,
-        )
-
-    def update(
-        self,
-        name: str,
-        prompt: BasePrompt,
-        version_description: Optional[str] = None,
-        set_default: bool = False,
-    ) -> RegisteredPrompt:
-        """
-        Creates a new version for an existing prompt, prompt name must already exist.
-        `set_default` set to True if this version is to become the default one immediately.
-        """
-        if not isinstance(prompt, ChatPrompt):
-            raise FrogmlException(f"Got unsupported prompt type: {prompt}")
-
-        version_spec: ProtoPromptVersionSpec = PromptProtoMapper.to_prompt_version_spec(
-            version_description=version_description,
-            prompt_template=prompt.template,
-            model_descriptor=prompt.model,
-        )
-
-        prompt_version: ProtoPromptVersion = (
-            self._prompt_manager_client.create_prompt_version(
-                name=name, version_spec=version_spec, set_default=set_default
-            )
-        )
-
-        version_for_get_request = (
-            None
-            if set_default
-            else prompt_version.prompt_version_definition.version_number
-        )
-        return self.get_prompt(name=name, version=version_for_get_request)
-
-    def set_default(self, name: str, version: int):
-        """
-        Set a version of a registered prompt named: `name`, as the default version
-        """
-        self._prompt_manager_client.set_default_prompt_version(
-            name=name, version=version
-        )
-
-    def delete_prompt(self, name: str):
-        """
-        Delete all version of a prompt, by name
-        """
-        self._prompt_manager_client.delete_prompt(name=name)
-
-    def delete_prompt_version(self, name: str, version: int):
-        """
-        Deletes a specific version of a registered prompt
-        """
-        self._prompt_manager_client.delete_prompt_version(name=name, version=version)
-
-    def get_prompt(self, name: str, version: Optional[int] = None) -> RegisteredPrompt:
-        """
-        Get a registered prompt by name. To get the default version omit the `version` param, else
-        fetch the specified version.
-        """
-
-        prompt_default_version: ProtoPrompt = (
-            self._prompt_manager_client.get_prompt_by_name(name=name)
-        )
-        prompt_version_definition: ProtoPromptVersionDefinition = (
-            prompt_default_version.default_version_definition
-        )
-        if version:
-            prompt_version: ProtoPromptVersion = (
-                self._prompt_manager_client.get_prompt_version_by_name(
-                    name=name, version=version
-                )
-            )
-            prompt_version_definition = prompt_version.prompt_version_definition
-
-        return PromptProtoMapper.from_prompt(
-            name=prompt_default_version.name,
-            prompt_description=prompt_default_version.prompt_spec.description,
-            version_description=prompt_version_definition.version_spec.description,
-            version=prompt_version_definition.version_number,
-            target_default_version=not bool(version),
-            prompt_version_definition=prompt_version_definition,
-        )

frogml_core/llmops/prompt/template.py

@@ -1,24 +0,0 @@
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Dict
-
-from frogml_core.llmops.prompt.value import PromptValue, StringPromptValue
-
-
-@dataclass
-class BasePromptTemplate(ABC):
-    @abstractmethod
-    def render(self, variables: Dict[str, any]) -> PromptValue:
-        pass
-
-
-@dataclass
-class StringPromptTemplate(BasePromptTemplate):
-    template: str
-
-    def render(self, variables: Dict[str, any]) -> StringPromptValue:
-        from chevron import renderer
-
-        return StringPromptValue(
-            text=renderer.render(template=self.template, data=variables, warn=True)
-        )

frogml_core/llmops/prompt/value.py

@@ -1,14 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass
-
-
-class PromptValue(ABC):
-    pass
-
-
-@dataclass
-class StringPromptValue(PromptValue):
-    text: str
-
-    def to_string(self) -> str:
-        return self.text

frogml_core/llmops/provider/chat.py

@@ -1,44 +0,0 @@
-from functools import lru_cache
-from typing import Union
-
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion import (
-    ChatCompletion,
-)
-from frogml_core.llmops.generation.streaming import ChatCompletionStream
-from frogml_core.llmops.model.descriptor import ChatModelDescriptor, OpenAIChat
-from frogml_core.llmops.prompt.chat.value import ChatPromptValue
-from frogml_core.llmops.provider.openai.provider import OpenAIProvider
-
-
-class ChatCompletionProvider:
-    @staticmethod
-    @lru_cache(maxsize=None)
-    def _get_openai_provider():
-        return OpenAIProvider()
-
-    @staticmethod
-    def invoke(
-        chat_prompt_value: ChatPromptValue,
-        chat_model_descriptor: ChatModelDescriptor,
-        stream: bool = False,
-    ) -> Union[ChatCompletion, ChatCompletionStream]:
-        if isinstance(chat_model_descriptor, OpenAIChat):
-            return ChatCompletionProvider._invoke_openai_chat(
-                chat_prompt_value=chat_prompt_value,
-                chat_model_descriptor=chat_model_descriptor,
-                stream=stream,
-            )
-        else:
-            raise ValueError("Can't invoke prompt and model combination!")
-
-    @staticmethod
-    def _invoke_openai_chat(
-        chat_prompt_value: ChatPromptValue,
-        chat_model_descriptor: OpenAIChat,
-        stream: bool = False,
-    ) -> Union[ChatCompletion, ChatCompletionStream]:
-        return ChatCompletionProvider._get_openai_provider().create_chat_completion(
-            chat_prompt_value=chat_prompt_value,
-            chat_model_descriptor=chat_model_descriptor,
-            stream=stream,
-        )