gllm-inference-binary 0.5.65__cp313-cp313-macosx_13_0_arm64.whl

gllm_inference/prompt_builder/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_inference.prompt_builder.prompt_builder import PromptBuilder as PromptBuilder
+
+__all__ = ['PromptBuilder']

gllm_inference/prompt_builder/format_strategy/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.prompt_builder.format_strategy.jinja_format_strategy import JinjaFormatStrategy as JinjaFormatStrategy
+from gllm_inference.prompt_builder.format_strategy.string_format_strategy import StringFormatStrategy as StringFormatStrategy
+
+__all__ = ['StringFormatStrategy', 'JinjaFormatStrategy']

gllm_inference/prompt_builder/format_strategy/format_strategy.pyi

@@ -0,0 +1,55 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC, abstractmethod
+from gllm_inference.schema.message import MessageContent as MessageContent
+
+class BasePromptFormattingStrategy(ABC, metaclass=abc.ABCMeta):
+    """Base class for prompt formatting strategies.
+
+    This class defines the interface for different prompt templating engines. Subclasses
+    implement specific formatting strategies to render templates with variable
+    substitution.
+
+    The strategy pattern allows the PromptBuilder to work with different templating engines
+    without changing its core logic.
+
+    Attributes:
+        key_defaults (dict[str, str]): The default values for the keys.
+    """
+    key_defaults: Incomplete
+    def __init__(self, key_defaults: dict[str, str] | None = None) -> None:
+        """Initialize the BasePromptFormattingStrategy.
+
+        Args:
+            key_defaults (dict[str, str] | None, optional): The default values for the keys. Defaults to None,
+                in which case no default values are used.
+        """
+    def format(self, template: str, variables_map: dict[str, str] | None = None, extra_contents: list[MessageContent] | None = None) -> list[str]:
+        """Format template with variables using the template method pattern.
+
+        This is a template method that defines the algorithm for formatting:
+        1. Merge key_defaults and variables_map
+        2. Render the template (delegated to subclass via _render_template)
+        3. Append extra_contents to the result
+
+        Args:
+            template (str): Template string to format.
+            variables_map (dict[str, str] | None, optional): Variables for substitution. Defaults to None.
+            extra_contents (list[MessageContent] | None, optional): Extra contents to format. Defaults to None.
+
+        Returns:
+            str: Formatted template string.
+        """
+    @abstractmethod
+    def extract_keys(self, template: str | None) -> set[str]:
+        """Extract variable keys from template.
+
+        Args:
+            template (str | None): Template string to extract keys from.
+
+        Returns:
+            set[str]: Set of variable keys found in template.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """

gllm_inference/prompt_builder/format_strategy/jinja_format_strategy.pyi

@@ -0,0 +1,45 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_builder.format_strategy.format_strategy import BasePromptFormattingStrategy as BasePromptFormattingStrategy
+from gllm_inference.schema import JinjaEnvType as JinjaEnvType
+from jinja2.sandbox import SandboxedEnvironment
+from typing import Any
+
+JINJA_DEFAULT_BLACKLISTED_FILTERS: list[str]
+JINJA_DEFAULT_SAFE_GLOBALS: dict[str, Any]
+JINJA_DANGEROUS_PATTERNS: list[str]
+PROMPT_BUILDER_VARIABLE_START_STRING: str
+PROMPT_BUILDER_VARIABLE_END_STRING: str
+
+class JinjaFormatStrategy(BasePromptFormattingStrategy):
+    """Jinja2 template engine for formatting prompts.
+
+    Attributes:
+        jinja_env (SandboxedEnvironment): The Jinja environment for rendering templates.
+        key_defaults (dict[str, str]): The default values for the keys.
+    """
+    jinja_env: Incomplete
+    def __init__(self, environment: JinjaEnvType | SandboxedEnvironment = ..., key_defaults: dict[str, str] | None = None) -> None:
+        """Initialize the JinjaFormatStrategy.
+
+        Args:
+            environment (JinjaEnvType | SandboxedEnvironment, optional): The environment for Jinja rendering.
+                It can be one of the following:
+                1. `JinjaEnvType.RESTRICTED`: Uses a minimal, restricted Jinja environment.
+                        Safest for most cases.
+                2. `JinjaEnvType.JINJA_DEFAULT`: Uses the full Jinja environment. Allows more powerful templating,
+                        but with fewer safety restrictions.
+                3. `SandboxedEnvironment` instance: A custom Jinja `SandboxedEnvironment` object provided by the
+                        user. Offers fine-grained control over template execution.
+                Defaults to `JinjaEnvType.RESTRICTED`
+            key_defaults (dict[str, str], optional): The default values for the keys. Defaults to None, in which
+                case no default values are used.
+        """
+    def extract_keys(self, template: str | None) -> set[str]:
+        """Extract keys from Jinja template using AST analysis.
+
+        Args:
+            template (str | None): The template to extract keys from.
+
+        Returns:
+            set[str]: The set of keys found in the template.
+        """

gllm_inference/prompt_builder/format_strategy/string_format_strategy.pyi

@@ -0,0 +1,20 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_builder.format_strategy.format_strategy import BasePromptFormattingStrategy as BasePromptFormattingStrategy
+
+KEY_EXTRACTOR_REGEX: Incomplete
+
+class StringFormatStrategy(BasePromptFormattingStrategy):
+    """String format strategy using str.format() method.
+
+    Attributes:
+        key_defaults (dict[str, str]): The default values for the keys.
+    """
+    def extract_keys(self, template: str | None) -> set[str]:
+        """Extract keys from a template.
+
+        Args:
+            template (str | None): The template to extract keys from.
+
+        Returns:
+            set[str]: The set of keys found in the template.
+        """

gllm_inference/prompt_builder/prompt_builder.pyi

@@ -0,0 +1,73 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_builder.format_strategy import JinjaFormatStrategy as JinjaFormatStrategy, StringFormatStrategy as StringFormatStrategy
+from gllm_inference.schema import HistoryFormatter as HistoryFormatter, JinjaEnvType as JinjaEnvType, Message as Message, MessageContent as MessageContent, MessageRole as MessageRole
+from jinja2.sandbox import SandboxedEnvironment as SandboxedEnvironment
+from typing import Any
+
+class PromptBuilder:
+    """A prompt builder class used in Gen AI applications.
+
+    Attributes:
+        system_template (str): The system prompt template. May contain placeholders enclosed in curly braces `{}`.
+        user_template (str): The user prompt template. May contain placeholders enclosed in curly braces `{}`.
+        prompt_key_set (set[str]): A set of expected keys that must be present in the prompt templates.
+        key_defaults (dict[str, str]): Default values for the keys in the prompt templates.
+        strategy (BasePromptFormattingStrategy): The format strategy to be used for formatting the prompt.
+        history_formatter (HistoryFormatter): The history formatter to be used for formatting the history.
+    """
+    key_defaults: Incomplete
+    system_template: Incomplete
+    user_template: Incomplete
+    history_formatter: Incomplete
+    strategy: Incomplete
+    prompt_key_set: Incomplete
+    def __init__(self, system_template: str = '', user_template: str = '', key_defaults: dict[str, str] | None = None, ignore_extra_keys: bool | None = None, history_formatter: HistoryFormatter | None = None, use_jinja: bool | None = False, jinja_env: JinjaEnvType | SandboxedEnvironment | None = None) -> None:
+        """Initializes a new instance of the PromptBuilder class.
+
+        Args:
+            system_template (str, optional): The system prompt template. May contain placeholders enclosed in curly
+                braces `{}`. Defaults to an empty string.
+            user_template (str, optional): The user prompt template. May contain placeholders enclosed in curly
+                braces `{}`. Defaults to an empty string.
+            key_defaults (dict[str, str] | None, optional): Default values for the keys in the prompt templates.
+                Applied when the corresponding keys are not provided in the runtime input.
+                Defaults to None, in which case no default values will be assigned to the keys.
+            ignore_extra_keys (bool | None, optional): Deprecated parameter. Will be removed in v0.6. Extra keys
+                will always raise a warning only instead of raising an error.
+            history_formatter (HistoryFormatter | None, optional): The history formatter to be used for formatting
+                the history. Defaults to None, in which case the history will be used as is.
+            use_jinja (bool, optional): Whether to use Jinja for rendering the prompt templates.
+                Defaults to False.
+            jinja_env (JinjaEnvType | SandboxedEnvironment, optional): The environment for Jinja rendering.
+                It can be one of the following:
+                1. `JinjaEnvType.RESTRICTED`: Uses a minimal, restricted Jinja environment.
+                        Safest for most cases.
+                2. `JinjaEnvType.JINJA_DEFAULT`: Uses the full Jinja environment. Allows more powerful templating,
+                        but with fewer safety restrictions.
+                3. `SandboxedEnvironment` instance: A custom Jinja `SandboxedEnvironment` object provided by the
+                        user. Offers fine-grained control over template execution.
+                Defaults to `JinjaEnvType.RESTRICTED`
+
+        Raises:
+            ValueError: If both `system_template` and `user_template` are empty.
+        """
+    def format(self, history: list[Message] | None = None, extra_contents: list[MessageContent] | None = None, **kwargs: Any) -> list[Message]:
+        """Formats the prompt templates into a list of messages.
+
+        This method processes each prompt template, replacing the placeholders in the template content with the
+        corresponding values from `kwargs`. If any required key is missing from `kwargs`, it raises a `ValueError`.
+        It also handles the provided history and extra contents. It formats the prompt as a list of messages.
+
+        Args:
+            history (list[Message] | None, optional): The history to be included in the prompt. Defaults to None.
+            extra_contents (list[MessageContent] | None, optional): The extra contents to be included in the user
+                message. Defaults to None.
+            **kwargs (Any): A dictionary of placeholder values to be injected into the prompt templates.
+                Values must be either a string or an object that can be serialized to a string.
+
+        Returns:
+            list[Message]: A list of formatted messages.
+
+        Raises:
+            ValueError: If a required key for the prompt template is missing from `kwargs`.
+        """

gllm_inference/prompt_formatter/__init__.pyi

@@ -0,0 +1,7 @@
+from gllm_inference.prompt_formatter.agnostic_prompt_formatter import AgnosticPromptFormatter as AgnosticPromptFormatter
+from gllm_inference.prompt_formatter.huggingface_prompt_formatter import HuggingFacePromptFormatter as HuggingFacePromptFormatter
+from gllm_inference.prompt_formatter.llama_prompt_formatter import LlamaPromptFormatter as LlamaPromptFormatter
+from gllm_inference.prompt_formatter.mistral_prompt_formatter import MistralPromptFormatter as MistralPromptFormatter
+from gllm_inference.prompt_formatter.openai_prompt_formatter import OpenAIPromptFormatter as OpenAIPromptFormatter
+
+__all__ = ['AgnosticPromptFormatter', 'HuggingFacePromptFormatter', 'LlamaPromptFormatter', 'MistralPromptFormatter', 'OpenAIPromptFormatter']

gllm_inference/prompt_formatter/agnostic_prompt_formatter.pyi

@@ -0,0 +1,49 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_formatter.prompt_formatter import BasePromptFormatter as BasePromptFormatter
+from gllm_inference.schema import MessageRole as MessageRole
+
+class AgnosticPromptFormatter(BasePromptFormatter):
+    '''A prompt formatter that formats prompt without any specific model formatting.
+
+    The `AgnosticPromptFormatter` class formats a prompt by joining the content of the prompt templates using a
+    specified separator. It is designed to work independently of specific model types.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+        message_separator (str): A string used to separate each message.
+
+    Usage:
+        The `AgnosticPromptFormatter` can be used to format a prompt for any model.
+        The `content_separator` and `message_separator` can be customized to define the format of the prompt.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = AgnosticPromptFormatter(
+            message_separator="\\n###\\n",
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        Hello---how are you?
+        ###
+        I\'m fine---thank you!
+        ###
+        What is the capital of France?
+        ```
+    '''
+    message_separator: Incomplete
+    def __init__(self, message_separator: str = '\n', content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the AgnosticPromptFormatter class.
+
+        Args:
+            message_separator (str, optional): A string used to separate each message. Defaults to "\\n".
+            content_separator (str, optional): A string used to separate each content in a message. Defaults to "\\n".
+        '''

gllm_inference/prompt_formatter/huggingface_prompt_formatter.pyi

@@ -0,0 +1,55 @@
+from gllm_inference.prompt_formatter.prompt_formatter import BasePromptFormatter as BasePromptFormatter
+from gllm_inference.schema import MessageRole as MessageRole
+
+TOKENIZER_LOAD_ERROR_MESSAGE: str
+
+class HuggingFacePromptFormatter(BasePromptFormatter):
+    '''A prompt formatter that formats prompt using HuggingFace model\'s specific formatting.
+
+    The `HuggingFacePromptFormatter` class is designed to format prompt using a HuggingFace model\'s specific formatting.
+    It does so by using the model\'s tokenizer\'s `apply_chat_template` method.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+        tokenizer (PreTrainedTokenizer): The HuggingFace model tokenizer used for chat templating.
+
+    Usage:
+        The `HuggingFacePromptFormatter` can be used to format a prompt using a HuggingFace model\'s specific formatting.
+        The `content_separator` and `model_name_or_path` can be customized to define the format of the prompt.
+        The `model_name_or_path` defines the name of the HuggingFace model whose tokenizer will be used to format
+        the prompt using the `apply_chat_template` method.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = HuggingFacePromptFormatter(
+            model_name_or_path="mistralai/Mistral-7B-Instruct-v0.1",
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        <s>[INST] Hello---how are you? [/INST]I\'m fine---thank you!</s> [INST] What is the capital of France? [/INST]
+        ```
+
+    Using a gated model:
+        If you\'re trying to access the prompt builder template of a gated model, you\'d need to:
+        1. Request access to the gated repo using your HuggingFace account.
+        2. Login to HuggingFace in your system. This can be done as follows:
+           2.1. Install huggingface-hub: ```pip install huggingface-hub```
+           2.2. Login to HuggingFace: ```huggingface-cli login```
+           2.3. Enter your HuggingFace token.
+    '''
+    def __init__(self, model_name_or_path: str, content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the HuggingFacePromptFormatter class.
+
+        Args:
+            model_name_or_path (str): The model name or path of the HuggingFace model tokenizer to be loaded.
+            content_separator (str, optional): A string used to separate each content in a message. Defaults to "\\n".
+        '''

gllm_inference/prompt_formatter/llama_prompt_formatter.pyi

@@ -0,0 +1,59 @@
+from gllm_inference.prompt_formatter import HuggingFacePromptFormatter as HuggingFacePromptFormatter
+
+class LlamaPromptFormatter(HuggingFacePromptFormatter):
+    '''A prompt formatter that formats prompt using Llama model\'s specific formatting.
+
+    The `LlamaPromptFormatter` class is designed to format prompt using a Llama model\'s specific formatting.
+    It does so by using the model\'s tokenizer\'s `apply_chat_template` method.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+        tokenizer (PreTrainedTokenizer): The HuggingFace model tokenizer used for chat templating.
+
+    Usage:
+        The `LlamaPromptFormatter` can be used to format a prompt using a Llama model\'s specific formatting.
+        The `content_separator` and `model_name` can be customized to define the format of the prompt.
+        The `model_name` defines the name of the HuggingFace model whose tokenizer will be used to format
+        the prompt using the `apply_chat_template` method.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = LlamaPromptFormatter(
+            model_name_or_path="meta-llama/Meta-Llama-3.1-8B-Instruct",
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        <|begin_of_text|><|start_header_id|>user<|end_header_id|>
+
+        Hello---how are you?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+
+        I\'m fine---thank you!<|eot_id|><|start_header_id|>user<|end_header_id|>
+
+        What is the capital of France?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+        ```
+
+    Using a gated model:
+        If you\'re trying to access the prompt builder template of a gated model, you\'d need to:
+        1. Request access to the gated repo using your HuggingFace account.
+        2. Login to HuggingFace in your system. This can be done as follows:
+           2.1. Install huggingface-hub: ```pip install huggingface-hub```
+           2.2. Login to HuggingFace: ```huggingface-cli login```
+           2.3. Enter your HuggingFace token.
+    '''
+    def __init__(self, model_name: str = 'Meta-Llama-3.1-8B-Instruct', content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the LlamaPromptFormatter class.
+
+        Args:
+            model_name (str, optional): The name of the Llama model tokenizer to be loaded. Defaults to
+                `Meta-Llama-3.1-8B-Instruct`.
+            content_separator (str, optional): A string used to separate each content in a message. Defaults to "\\n".
+        '''

gllm_inference/prompt_formatter/mistral_prompt_formatter.pyi

@@ -0,0 +1,53 @@
+from gllm_inference.prompt_formatter import HuggingFacePromptFormatter as HuggingFacePromptFormatter
+
+class MistralPromptFormatter(HuggingFacePromptFormatter):
+    '''A prompt formatter that formats prompt using Mistral model\'s specific formatting.
+
+    The `MistralPromptFormatter` class is designed to format prompt using a Mistral model\'s specific formatting.
+    It does so by using the model\'s tokenizer\'s `apply_chat_template` method.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+        tokenizer (PreTrainedTokenizer): The HuggingFace model tokenizer used for chat templating.
+
+    Usage:
+        The `MistralPromptFormatter` can be used to format a prompt using a Mistral model\'s specific formatting.
+        The `content_separator` and `model_name` can be customized to define the format of the prompt.
+        The `model_name` defines the name of the HuggingFace model whose tokenizer will be used to format
+        the prompt using the `apply_chat_template` method.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = MistralPromptFormatter(
+            model_name_or_path="mistralai/Mistral-7B-Instruct-v0.1",
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        <s>[INST] Hello---how are you? [/INST]I\'m fine---thank you!</s> [INST] What is the capital of France? [/INST]
+        ```
+
+    Using a gated model:
+        If you\'re trying to access the prompt builder template of a gated model, you\'d need to:
+        1. Request access to the gated repo using your HuggingFace account.
+        2. Login to HuggingFace in your system. This can be done as follows:
+           2.1. Install huggingface-hub: ```pip install huggingface-hub```
+           2.2. Login to HuggingFace: ```huggingface-cli login```
+           2.3. Enter your HuggingFace token.
+    '''
+    def __init__(self, model_name: str = 'Mistral-7B-Instruct-v0.3', content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the MistralPromptFormatter class.
+
+        Args:
+            model_name (str, optional): The name of the Mistral model tokenizer to be loaded. Defaults to
+                `Mistral-7B-Instruct-v0.3`.
+            content_separator (str, optional): A string used to separate each content in a message. Defaults to "\\n".
+        '''

gllm_inference/prompt_formatter/openai_prompt_formatter.pyi

@@ -0,0 +1,35 @@
+from gllm_inference.prompt_formatter.prompt_formatter import BasePromptFormatter as BasePromptFormatter
+from gllm_inference.schema import MessageRole as MessageRole
+
+class OpenAIPromptFormatter(BasePromptFormatter):
+    '''A prompt formatter that formats prompt with OpenAI\'s specific formatting.
+
+    The `OpenAIPromptFormatter` class formats a prompt by utilizing OpenAI\'s specific formatting.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+
+    Usage:
+        The `OpenAIPromptFormatter` can be used to format a prompt for OpenAI\'s models.
+        The `content_separator` can be customized to define the format of the prompt.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = OpenAIPromptFormatter(
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        User: Hello---how are you?
+        Assistant: I\'m fine---thank you!
+        User: What is the capital of France?
+        ```
+    '''

gllm_inference/prompt_formatter/prompt_formatter.pyi

@@ -0,0 +1,30 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC
+from gllm_inference.schema import Message as Message, MessageContent as MessageContent, MessageRole as MessageRole
+
+class BasePromptFormatter(ABC, metaclass=abc.ABCMeta):
+    """A base class for prompt formatters used in Gen AI applications.
+
+    The prompt formatter class is used to format a prompt into a string with specific formatting.
+
+    Attributes:
+        content_separator (str): The separator to be used between the string in a single message.
+    """
+    content_separator: Incomplete
+    def __init__(self, content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the BasePromptFormatter class.
+
+        Args:
+            content_separator (str, optional): The separator to be used between the string in a single message.
+                Defaults to "\\n".
+        '''
+    def format(self, messages: list[Message]) -> str:
+        """Formats the prompt as a string.
+
+        Args:
+            messages (list[Message]): The messages to be formatted as a string.
+
+        Returns:
+            str: The formatted messages as a string.
+        """

gllm_inference/realtime_chat/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_inference.realtime_chat.google_realtime_chat import GoogleRealtimeChat as GoogleRealtimeChat
+
+__all__ = ['GoogleRealtimeChat']