qwak-core 0.1.37__py3-none-any.whl → 0.5.19__py3-none-any.whl

qwak/llmops/generation/chat/openai/types/model.py

@@ -0,0 +1,35 @@
+#
+#    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 dataclasses import dataclass
+
+from typing_extensions import Literal
+
+__all__ = ["Model"]
+
+
+@dataclass
+class Model:
+    id: str
+    """The model identifier, which can be referenced in the API endpoints."""
+
+    created: int
+    """The Unix timestamp (in seconds) when the model was created."""
+
+    object: Literal["model"]
+    """The object type, which is always "model"."""
+
+    owned_by: str
+    """The organization that owns the model."""

qwak/llmops/generation/chat/openai/types/shared/__init__.py

@@ -0,0 +1,3 @@
+from .error_object import ErrorObject as ErrorObject
+from .function_definition import FunctionDefinition as FunctionDefinition
+from .function_parameters import FunctionParameters as FunctionParameters

qwak/llmops/generation/chat/openai/types/shared/error_object.py

@@ -0,0 +1,27 @@
+#
+#    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 dataclasses import dataclass
+from typing import Optional
+
+__all__ = ["ErrorObject"]
+
+
+@dataclass
+class ErrorObject:
+    type: str
+    message: str
+    param: Optional[str] = None
+    code: Optional[str] = None

qwak/llmops/generation/chat/openai/types/shared/function_definition.py

@@ -0,0 +1,49 @@
+#
+#    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 dataclasses import dataclass
+from typing import Optional
+
+from .function_parameters import FunctionParameters
+
+__all__ = ["FunctionDefinition"]
+
+
+@dataclass
+class FunctionDefinition:
+    name: 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: Optional[str] = None
+    """
+    A description of what the function does, used by the model to choose when and
+    how to call the function.
+    """
+
+    parameters: Optional[FunctionParameters] = None
+    """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.
+    """

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

@@ -0,0 +1,20 @@
+#
+#    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]

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

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

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

@@ -0,0 +1,49 @@
+#
+#    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.
+    """

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

@@ -0,0 +1,22 @@
+#
+#    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]

qwak/llmops/generation/streaming.py

@@ -0,0 +1,26 @@
+from abc import ABC
+from typing import Generic, TypeVar
+
+from qwak.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

qwak/llmops/model/descriptor.py

@@ -0,0 +1,39 @@
+from abc import ABC
+from dataclasses import dataclass, field
+from typing import Dict, Iterable, List, Optional, Union
+
+from qwak.llmops.generation.chat.openai.types.chat.chat_completion_tool_choice_option_param import (
+    ChatCompletionToolChoiceOptionParam,
+)
+from qwak.llmops.generation.chat.openai.types.chat.chat_completion_tool_param import (
+    ChatCompletionToolParam,
+)
+from typing_extensions import Literal
+
+
+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)

qwak/llmops/prompt/base.py

@@ -0,0 +1,133 @@
+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 qwak.exceptions import QwakException
+from qwak.llmops.generation.base import ModelResponse
+from qwak.llmops.generation.chat.openai.types.chat.chat_completion import ChatCompletion
+from qwak.llmops.generation.streaming import ChatCompletionStream, Stream
+from qwak.llmops.model.descriptor import ChatModelDescriptor, ModelDescriptor
+from qwak.llmops.prompt.chat.template import ChatPromptTemplate
+from qwak.llmops.prompt.chat.value import ChatPromptValue
+from qwak.llmops.prompt.value import PromptValue
+from qwak.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 QwakException(
+                "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 qwak.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
+        )

qwak/llmops/prompt/chat/message.py

@@ -0,0 +1,24 @@
+from abc import ABC
+from dataclasses import dataclass, field
+
+from qwak.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"

qwak/llmops/prompt/chat/template.py

@@ -0,0 +1,113 @@
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple, Union
+
+from qwak.llmops.prompt.chat.message import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+)
+from qwak.llmops.prompt.chat.value import ChatPromptValue
+from qwak.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

qwak/llmops/prompt/chat/value.py

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