frogml-core 0.0.1__py3-none-any.whl

frogml/llmops/generation/chat/openai/types/completion_create_params.py

@@ -0,0 +1,209 @@
+#
+#    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 dataclasses import dataclass
+from typing import Dict, Iterable, List, Optional, Union
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = [
+    "CompletionCreateParamsBase",
+    "CompletionCreateParamsNonStreaming",
+    "CompletionCreateParamsStreaming",
+]
+
+
+class CompletionCreateParamsBase(TypedDict, total=False):
+    model: Required[
+        Union[str, Literal["gpt-3.5-turbo-instruct", "davinci-002", "babbage-002"]]
+    ]
+    """ID of the model to use.
+
+    You can use the
+    [List models](https://platform.openai.com/docs/api-reference/models/list) API to
+    see all of your available models, or see our
+    [Model overview](https://platform.openai.com/docs/models/overview) for
+    descriptions of them.
+    """
+
+    prompt: Required[
+        Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None]
+    ]
+    """
+    The prompt(s) to generate completions for, encoded as a string, array of
+    strings, array of tokens, or array of token arrays.
+
+    Note that <|endoftext|> is the document separator that the model sees during
+    training, so if a prompt is not specified the model will generate as if from the
+    beginning of a new document.
+    """
+
+    best_of: Optional[int]
+    """
+    Generates `best_of` completions server-side and returns the "best" (the one with
+    the highest log probability per token). Results cannot be streamed.
+
+    When used with `n`, `best_of` controls the number of candidate completions and
+    `n` specifies how many to return – `best_of` must be greater than `n`.
+
+    **Note:** Because this parameter generates many completions, it can quickly
+    consume your token quota. Use carefully and ensure that you have reasonable
+    settings for `max_tokens` and `stop`.
+    """
+
+    echo: Optional[bool]
+    """Echo back the prompt in addition to the completion"""
+
+    frequency_penalty: Optional[float]
+    """Number between -2.0 and 2.0.
+
+    Positive values penalize new tokens based on their existing frequency in the
+    text so far, decreasing the model's likelihood to repeat the same line verbatim.
+
+    [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/text-generation/parameter-details)
+    """
+
+    logit_bias: Optional[Dict[str, int]]
+    """Modify the likelihood of specified tokens appearing in the completion.
+
+    Accepts a JSON object that maps tokens (specified by their token ID in the GPT
+    tokenizer) to an associated bias value from -100 to 100. You can use this
+    [tokenizer tool](/tokenizer?view=bpe) to convert text to token IDs.
+    Mathematically, the bias is added to the logits generated by the model prior to
+    sampling. The exact effect will vary per model, but values between -1 and 1
+    should decrease or increase likelihood of selection; values like -100 or 100
+    should result in a ban or exclusive selection of the relevant token.
+
+    As an example, you can pass `{"50256": -100}` to prevent the <|endoftext|> token
+    from being generated.
+    """
+
+    logprobs: Optional[int]
+    """
+    Include the log probabilities on the `logprobs` most likely output tokens, as
+    well the chosen tokens. For example, if `logprobs` is 5, the API will return a
+    list of the 5 most likely tokens. The API will always return the `logprob` of
+    the sampled token, so there may be up to `logprobs+1` elements in the response.
+
+    The maximum value for `logprobs` is 5.
+    """
+
+    max_tokens: Optional[int]
+    """
+    The maximum number of [tokens](/tokenizer) that can be generated in the
+    completion.
+
+    The token count of your prompt plus `max_tokens` cannot exceed the model's
+    context length.
+    [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken)
+    for counting tokens.
+    """
+
+    n: Optional[int]
+    """How many completions to generate for each prompt.
+
+    **Note:** Because this parameter generates many completions, it can quickly
+    consume your token quota. Use carefully and ensure that you have reasonable
+    settings for `max_tokens` and `stop`.
+    """
+
+    presence_penalty: Optional[float]
+    """Number between -2.0 and 2.0.
+
+    Positive values penalize new tokens based on whether they appear in the text so
+    far, increasing the model's likelihood to talk about new topics.
+
+    [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/text-generation/parameter-details)
+    """
+
+    seed: Optional[int]
+    """
+    If specified, our system will make a best effort to sample deterministically,
+    such that repeated requests with the same `seed` and parameters should return
+    the same result.
+
+    Determinism is not guaranteed, and you should refer to the `system_fingerprint`
+    response parameter to monitor changes in the backend.
+    """
+
+    stop: Union[Optional[str], List[str], None]
+    """Up to 4 sequences where the API will stop generating further tokens.
+
+    The returned text will not contain the stop sequence.
+    """
+
+    suffix: Optional[str]
+    """The suffix that comes after a completion of inserted text.
+
+    This parameter is only supported for `gpt-3.5-turbo-instruct`.
+    """
+
+    temperature: Optional[float]
+    """What sampling temperature to use, between 0 and 2.
+
+    Higher values like 0.8 will make the output more random, while lower values like
+    0.2 will make it more focused and deterministic.
+
+    We generally recommend altering this or `top_p` but not both.
+    """
+
+    top_p: Optional[float]
+    """
+    An alternative to sampling with temperature, called nucleus sampling, where the
+    model considers the results of the tokens with top_p probability mass. So 0.1
+    means only the tokens comprising the top 10% probability mass are considered.
+
+    We generally recommend altering this or `temperature` but not both.
+    """
+
+    user: str
+    """
+    A unique identifier representing your end-user, which can help OpenAI to monitor
+    and detect abuse.
+    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids).
+    """
+
+
+@dataclass
+class CompletionCreateParamsNonStreaming(CompletionCreateParamsBase):
+    stream: Optional[Literal[False]]
+    """Whether to stream back partial progress.
+
+    If set, tokens will be sent as data-only
+    [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format)
+    as they become available, with the stream terminated by a `data: [DONE]`
+    message.
+    [Example Python code](https://cookbook.openai.com/examples/how_to_stream_completions).
+    """
+
+
+@dataclass
+class CompletionCreateParamsStreaming(CompletionCreateParamsBase):
+    stream: Required[Literal[True]]
+    """Whether to stream back partial progress.
+
+    If set, tokens will be sent as data-only
+    [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format)
+    as they become available, with the stream terminated by a `data: [DONE]`
+    message.
+    [Example Python code](https://cookbook.openai.com/examples/how_to_stream_completions).
+    """
+
+
+CompletionCreateParams = Union[
+    CompletionCreateParamsNonStreaming, CompletionCreateParamsStreaming
+]

frogml/llmops/generation/chat/openai/types/completion_usage.py

@@ -0,0 +1,30 @@
+#
+#    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.
+
+__all__ = ["CompletionUsage"]
+
+from dataclasses import dataclass
+
+
+@dataclass
+class CompletionUsage:
+    completion_tokens: int
+    """Number of tokens in the generated completion."""
+
+    prompt_tokens: int
+    """Number of tokens in the prompt."""
+
+    total_tokens: int
+    """Total number of tokens used in the request (prompt + completion)."""

frogml/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."""

frogml/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

frogml/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

frogml/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.
+    """

frogml/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]

frogml/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

frogml/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.
+    """

frogml/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]

frogml/llmops/generation/streaming.py

@@ -0,0 +1,26 @@
+from abc import ABC
+from typing import Generic, TypeVar
+
+from frogml.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/llmops/model/descriptor.py

@@ -0,0 +1,40 @@
+from abc import ABC
+from dataclasses import dataclass, field
+from typing import Dict, Iterable, List, Optional, Union
+
+from typing_extensions import Literal
+
+from frogml.llmops.generation.chat.openai.types.chat.chat_completion_tool_choice_option_param import (
+    ChatCompletionToolChoiceOptionParam,
+)
+from frogml.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/llmops/prompt/base.py

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