frogml-core 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

frogml_core/inner/tool/run_config/base.py

@@ -0,0 +1,127 @@
+from abc import ABC, abstractmethod
+from logging import Logger
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from marshmallow import RAISE, Schema
+from marshmallow_dataclass import class_schema
+from yaml import SafeLoader, dump, load
+
+from frogml_core.exceptions import FrogmlException, LoadConfigurationException
+
+from .utils import ConfigCliMap, rgetattr, rsetattr
+
+ERROR_OPENING_YAML_FILE_MSG = "Error opening the config file"
+ERROR_PARSING_YAML_FILE_MSG = "Error parsing the config file's yaml"
+ERROR_IN_CONFIG_MSG = "Error loading the config"
+
+
+class FrogmlConfigBase(ABC):
+    """Base frogml config object."""
+
+    @property
+    @abstractmethod
+    def _config_mapping(self) -> List[ConfigCliMap]:
+        """Config mapping, Return a list of ConfigCliMap object in order to create the mapping.
+
+        Returns:
+            list: List of ConfigCliMap to apply.
+        """
+        pass
+
+    def merge_cli_argument(
+        self, sections: Tuple[str, ...] = (), **kwargs: Dict[str, Any]
+    ):
+        """Merge and validate cli arguments by supplied mapping.
+
+        Args:
+            sections: Sections to validate.
+            **kwargs: argument from cli.
+
+        Raises:
+            FrogmlException: In case that the argument is not valid.
+        """
+        for prop_map in self._config_mapping:
+            value = kwargs.get(prop_map.key)
+            if value is not None:
+                if isinstance(value, (list, tuple)):
+                    new_value = list(rgetattr(self, prop_map.prop))
+                    new_value.extend(value)
+                    value = new_value
+                rsetattr(self, prop_map.prop, value)
+            if (
+                not sections
+                or any(
+                    list(
+                        map(
+                            lambda section, _prop_map=prop_map: _prop_map.prop.startswith(
+                                section
+                            ),
+                            sections,
+                        )
+                    )
+                )
+                or "." not in prop_map.prop
+            ):
+                config_value = rgetattr(self, prop_map.prop)
+                if not prop_map.validation_func(config_value, prop_map.is_required):
+                    raise FrogmlException(
+                        f"{prop_map.key} argument contain invalid argument: "
+                        f"{value or config_value}"
+                    )
+        self._post_merge_cli()
+
+    @abstractmethod
+    def _post_merge_cli(self):
+        """Actions to perform after merging cli argument in to properties"""
+        pass
+
+
+class YamlConfigMixin(object):
+    @classmethod
+    def from_yaml(
+        cls, yaml_path: str, unknown: str = RAISE, logger: Optional[Logger] = None
+    ) -> Any:
+        """Create instance of class from yaml and class scheme.
+
+        Args:
+            yaml_path (str): Yaml path.
+
+        Returns:
+            object: Instance of created class.
+        """
+        if not yaml_path:
+            return cls()
+        Schema.Meta.unknown = unknown
+        schema = class_schema(cls)
+        try:
+            yaml_content = Path(yaml_path).read_text()
+        except Exception as e:
+            if logger:
+                logger.error(f"Error opening the config file {yaml_path}")
+            raise LoadConfigurationException(ERROR_OPENING_YAML_FILE_MSG) from e
+
+        try:
+            yaml_parsed = load(stream=yaml_content, Loader=SafeLoader)
+        except Exception as e:
+            if logger:
+                logger.exception(ERROR_PARSING_YAML_FILE_MSG, e)
+            raise LoadConfigurationException(ERROR_PARSING_YAML_FILE_MSG) from e
+
+        try:
+            return schema(unknown=unknown).load(yaml_parsed)
+        except Exception as e:
+            if logger:
+                logger.exception(ERROR_IN_CONFIG_MSG, e)
+            raise LoadConfigurationException(ERROR_IN_CONFIG_MSG) from e
+
+    def to_yaml(self) -> str:
+        """Convert class by scheme to yaml.
+
+        Returns:
+            str: Class as yaml string by scheme.
+        """
+        loaded_type = type(self)
+        schema = class_schema(loaded_type)
+
+        return dump(schema().dump(self))

frogml_core/llmops/generation/_steaming.py

@@ -0,0 +1,78 @@
+import json
+from typing import Iterator, Type, TypeVar
+
+import requests
+from dacite import Config, from_dict
+
+from frogml_core.exceptions.frogml_decode_exception import FrogmlDecodeException
+from frogml_core.exceptions.frogml_external_exception import FrogmlExternalException
+from frogml_core.llmops.generation.streaming import Stream
+
+_SSEvent = TypeVar("_SSEvent")
+
+
+class BaseSSEDecoder(Stream[_SSEvent]):
+    _response: requests.Response
+    _iterator: Iterator[_SSEvent]
+
+    def __init__(self, response: requests.Response, parse_to: Type[_SSEvent]):
+        if response.encoding is None:
+            response.encoding = "utf-8"
+
+        self._parse_to = parse_to
+
+        self._response = response
+        self._iterator = self.__decode(response=response)
+
+    def _is_chunk_empty(self, chunk: str) -> bool:
+        return not chunk or chunk == "" or chunk.startswith(":") or chunk == ":"
+
+    def _raise_on_chunk_error(self, chunk: str):
+        is_error: bool = False
+        try:
+            maybe_error = json.loads(chunk)
+            if "error" in maybe_error:
+                is_error = True
+        except Exception:  # nosec
+            pass
+
+        if chunk.strip().startswith("error"):
+            is_error = True
+
+        if is_error:
+            raise FrogmlExternalException(message=chunk)
+
+    def __decode(self, response: requests.Response) -> Iterator[_SSEvent]:
+        chunk: str
+        for chunk in response.iter_lines(chunk_size=None, decode_unicode=True):
+            if self._is_chunk_empty(chunk=chunk):
+                continue
+
+            self._raise_on_chunk_error(chunk=chunk)
+
+            try:
+                if chunk.strip().startswith("[DONE]"):
+                    break
+
+                _, _, content = chunk.partition(":")
+
+                if content.strip().startswith("[DONE]"):
+                    break
+
+                yield self._parse_event(event=content)
+            except Exception as e:
+                raise FrogmlDecodeException(f"Failed to decode event: {chunk}") from e
+
+    def __iter__(self) -> Iterator[_SSEvent]:
+        for chunk in self._iterator:
+            yield chunk
+
+    def __next__(self) -> _SSEvent:
+        return self._iterator.__next__()
+
+    def _parse_event(self, event: str) -> _SSEvent:
+        return from_dict(
+            data_class=self._parse_to,
+            data=json.loads(event),
+            config=Config(check_types=False),
+        )

frogml_core/llmops/generation/chat/openai/types/chat/chat_completion.py

@@ -0,0 +1,88 @@
+#
+#    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 List, Optional
+
+from typing_extensions import Literal
+
+from frogml_core.llmops.generation.base import ModelResponse
+
+from ..completion_usage import CompletionUsage
+from .chat_completion_message import ChatCompletionMessage
+from .chat_completion_token_logprob import ChatCompletionTokenLogprob
+
+__all__ = ["ChatCompletion", "Choice", "ChoiceLogprobs"]
+
+
+@dataclass
+class ChoiceLogprobs:
+    content: Optional[List[ChatCompletionTokenLogprob]] = None
+    """A list of message content tokens with log probability information."""
+
+
+@dataclass
+class Choice:
+    finish_reason: Literal[
+        "stop", "length", "tool_calls", "content_filter", "function_call"
+    ]
+    """The reason the model stopped generating tokens.
+
+    This will be `stop` if the model hit a natural stop point or a provided stop
+    sequence, `length` if the maximum number of tokens specified in the request was
+    reached, `content_filter` if content was omitted due to a flag from our content
+    filters, `tool_calls` if the model called a tool, or `function_call`
+    (deprecated) if the model called a function.
+    """
+
+    index: int
+    """The index of the choice in the list of choices."""
+
+    message: ChatCompletionMessage
+    """A chat completion message generated by the model."""
+
+    logprobs: Optional[ChoiceLogprobs] = None
+    """Log probability information for the choice."""
+
+
+@dataclass
+class ChatCompletion(ModelResponse):
+    id: str
+    """A unique identifier for the chat completion."""
+
+    choices: List[Choice]
+    """A list of chat completion choices.
+
+    Can be more than one if `n` is greater than 1.
+    """
+
+    created: int
+    """The Unix timestamp (in seconds) of when the chat completion was created."""
+
+    model: str
+    """The model used for the chat completion."""
+
+    object: Literal["chat.completion"]
+    """The object type, which is always `chat.completion`."""
+
+    system_fingerprint: Optional[str] = None
+    """This fingerprint represents the backend configuration that the model runs with.
+
+    Can be used in conjunction with the `seed` request parameter to understand when
+    backend changes have been made that might impact determinism.
+    """
+
+    usage: Optional[CompletionUsage] = None
+    """Usage statistics for the completion request."""

frogml_core/llmops/generation/chat/openai/types/chat/chat_completion_chunk.py

@@ -0,0 +1,153 @@
+#
+#    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 List, Optional
+
+from typing_extensions import Literal
+
+from frogml_core.llmops.generation.base import ModelResponse
+
+from .chat_completion_token_logprob import ChatCompletionTokenLogprob
+
+__all__ = [
+    "ChatCompletionChunk",
+    "Choice",
+    "ChoiceDelta",
+    "ChoiceDeltaFunctionCall",
+    "ChoiceDeltaToolCall",
+    "ChoiceDeltaToolCallFunction",
+    "ChoiceLogprobs",
+]
+
+
+@dataclass
+class ChoiceDeltaFunctionCall:
+    arguments: Optional[str] = None
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: Optional[str] = None
+    """The name of the function to call."""
+
+
+@dataclass
+class ChoiceDeltaToolCallFunction:
+    arguments: Optional[str] = None
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: Optional[str] = None
+    """The name of the function to call."""
+
+
+@dataclass
+class ChoiceDeltaToolCall:
+    index: int
+
+    id: Optional[str] = None
+    """The ID of the tool call."""
+
+    function: Optional[ChoiceDeltaToolCallFunction] = None
+
+    type: Optional[Literal["function"]] = None
+    """The type of the tool. Currently, only `function` is supported."""
+
+
+@dataclass
+class ChoiceDelta:
+    content: Optional[str] = None
+    """The contents of the chunk message."""
+
+    function_call: Optional[ChoiceDeltaFunctionCall] = None
+    """Deprecated and replaced by `tool_calls`.
+
+    The name and arguments of a function that should be called, as generated by the
+    model.
+    """
+
+    role: Optional[Literal["system", "user", "assistant", "tool"]] = None
+    """The role of the author of this message."""
+
+    tool_calls: Optional[List[ChoiceDeltaToolCall]] = None
+
+
+@dataclass
+class ChoiceLogprobs:
+    content: Optional[List[ChatCompletionTokenLogprob]] = None
+    """A list of message content tokens with log probability information."""
+
+
+@dataclass
+class Choice:
+    delta: ChoiceDelta
+    """A chat completion delta generated by streamed model responses."""
+
+    index: int
+    """The index of the choice in the list of choices."""
+
+    finish_reason: Optional[
+        Literal["stop", "length", "tool_calls", "content_filter", "function_call"]
+    ] = None
+    """The reason the model stopped generating tokens.
+
+    This will be `stop` if the model hit a natural stop point or a provided stop
+    sequence, `length` if the maximum number of tokens specified in the request was
+    reached, `content_filter` if content was omitted due to a flag from our content
+    filters, `tool_calls` if the model called a tool, or `function_call`
+    (deprecated) if the model called a function.
+    """
+
+    logprobs: Optional[ChoiceLogprobs] = None
+    """Log probability information for the choice."""
+
+
+@dataclass
+class ChatCompletionChunk(ModelResponse):
+    id: str
+    """A unique identifier for the chat completion. Each chunk has the same ID."""
+
+    choices: List[Choice]
+    """A list of chat completion choices.
+
+    Can be more than one if `n` is greater than 1.
+    """
+
+    created: int
+    """The Unix timestamp (in seconds) of when the chat completion was created.
+
+    Each chunk has the same timestamp.
+    """
+
+    model: str
+    """The model to generate the completion."""
+
+    object: Literal["chat.completion.chunk"]
+    """The object type, which is always `chat.completion.chunk`."""
+
+    system_fingerprint: Optional[str] = None
+    """
+    This fingerprint represents the backend configuration that the model runs with.
+    Can be used in conjunction with the `seed` request parameter to understand when
+    backend changes have been made that might impact determinism.
+    """

frogml_core/llmops/generation/streaming.py

@@ -0,0 +1,26 @@
+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

@@ -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_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

@@ -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_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

@@ -0,0 +1,24 @@
+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"