gllm-inference-binary 0.5.9__py3-none-any.whl

gllm_inference/model/em/google_em.pyi

@@ -0,0 +1,16 @@
+class GoogleEM:
+    '''Defines Google embedding model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import GoogleEM
+    from gllm_inference.em_invoker import GoogleEMInvoker
+
+    em_invoker = GoogleEMInvoker(GoogleEM.GEMINI_EMBEDDING_001)
+    result = await em_invoker.invoke("Hello, world!")
+    ```
+    '''
+    GEMINI_EMBEDDING_001: str
+    TEXT_EMBEDDING_004: str
+    TEXT_EMBEDDING_005: str
+    TEXT_MULTILINGUAL_EMBEDDING_002: str

gllm_inference/model/em/openai_em.pyi

@@ -0,0 +1,15 @@
+class OpenAIEM:
+    '''Defines OpenAI embedding model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import OpenAIEM
+    from gllm_inference.em_invoker import OpenAIEMInvoker
+
+    em_invoker = OpenAIEMInvoker(OpenAIEM.TEXT_EMBEDDING_3_SMALL)
+    result = await em_invoker.invoke("Hello, world!")
+    ```
+    '''
+    TEXT_EMBEDDING_3_SMALL: str
+    TEXT_EMBEDDING_3_LARGE: str
+    TEXT_EMBEDDING_ADA_002: str

gllm_inference/model/em/twelvelabs_em.pyi

@@ -0,0 +1,13 @@
+class TwelveLabsEM:
+    '''Defines TwelveLabs embedding model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import TwelveLabsEM
+    from gllm_inference.em_invoker import TwelveLabsEMInvoker
+
+    em_invoker = TwelveLabsEMInvoker(TwelveLabsEM.MARENGO_RETRIEVAL_2_7)
+    result = await em_invoker.invoke("Hello, world!")
+    ```
+    '''
+    MARENGO_RETRIEVAL_2_7: str

gllm_inference/model/em/voyage_em.pyi

@@ -0,0 +1,20 @@
+class VoyageEM:
+    '''Defines Voyage embedding model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import VoyageEM
+    from gllm_inference.em_invoker import VoyageEMInvoker
+
+    em_invoker = VoyageEMInvoker(VoyageEM.VOYAGE_3_5_LITE)
+    result = await em_invoker.invoke("Hello, world!")
+    ```
+    '''
+    VOYAGE_3_5: str
+    VOYAGE_3_5_LITE: str
+    VOYAGE_3_LARGE: str
+    VOYAGE_CODE_3: str
+    VOYAGE_FINANCE_2: str
+    VOYAGE_LAW_2: str
+    VOYAGE_CODE_2: str
+    VOYAGE_MULTIMODAL_3: str

gllm_inference/model/lm/anthropic_lm.pyi

@@ -0,0 +1,20 @@
+class AnthropicLM:
+    '''Defines Anthropic language model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import AnthropicLM
+    from gllm_inference.lm_invoker import AnthropicLMInvoker
+
+    lm_invoker = AnthropicLMInvoker(AnthropicLM.CLAUDE_SONNET_4)
+    response = await lm_invoker.invoke("Hello, world!")
+    ```
+    '''
+    CLAUDE_OPUS_4_1: str
+    CLAUDE_OPUS_4: str
+    CLAUDE_SONNET_4: str
+    CLAUDE_SONNET_3_7: str
+    CLAUDE_SONNET_3_5: str
+    CLAUDE_HAIKU_3_5: str
+    CLAUDE_OPUS_3: str
+    CLAUDE_HAIKU_3: str

gllm_inference/model/lm/google_lm.pyi

@@ -0,0 +1,17 @@
+class GoogleLM:
+    '''Defines Google language model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import GoogleLM
+    from gllm_inference.lm_invoker import GoogleLMInvoker
+
+    lm_invoker = GoogleLMInvoker(GoogleLM.GEMINI_2_5_FLASH)
+    response = await lm_invoker.invoke("Hello, world!")
+    ```
+    '''
+    GEMINI_2_5_PRO: str
+    GEMINI_2_5_FLASH: str
+    GEMINI_2_5_FLASH_LITE: str
+    GEMINI_2_0_FLASH: str
+    GEMINI_2_0_FLASH_LITE: str

gllm_inference/model/lm/openai_lm.pyi

@@ -0,0 +1,27 @@
+class OpenAILM:
+    '''Defines OpenAI language model names constants.
+
+    Usage example:
+    ```python
+    from gllm_inference.model import OpenAILM
+    from gllm_inference.lm_invoker import OpenAILMInvoker
+
+    lm_invoker = OpenAILMInvoker(OpenAILM.GPT_5_NANO)
+    response = await lm_invoker.invoke("Hello, world!")
+    ```
+    '''
+    GPT_5: str
+    GPT_5_MINI: str
+    GPT_5_NANO: str
+    GPT_4_1: str
+    GPT_4_1_MINI: str
+    GPT_4_1_NANO: str
+    GPT_4O: str
+    GPT_4O_MINI: str
+    O4_MINI: str
+    O4_MINI_DEEP_RESEARCH: str
+    O3: str
+    O3_PRO: str
+    O3_DEEP_RESEARCH: str
+    O1: str
+    O1_PRO: str

gllm_inference/output_parser/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_inference.output_parser.json_output_parser import JSONOutputParser as JSONOutputParser
+
+__all__ = ['JSONOutputParser']

gllm_inference/output_parser/json_output_parser.pyi

@@ -0,0 +1,60 @@
+from gllm_inference.output_parser.output_parser import BaseOutputParser as BaseOutputParser
+from typing import Any
+
+class JSONOutputParser(BaseOutputParser[dict[str, Any]]):
+    '''An output parser that parses a json object from the language model output.
+
+    The `JSONOutputParser` class searches for the first opening curly brace `{` and the last closing curly brace `}`
+    in the language model\'s output to identify and extract a JSON object. It then parses the extracted substring into
+    a Python dictionary. This method relies on finding a well-formed JSON structure enclosed by the first and last
+    curly braces in the string. If the result contains additional curly braces outside the JSON object, or if there
+    are multiple JSON objects, this parser will not function correctly and will raise a `ValueError`.
+
+    Example:
+    If the result is:
+    ```
+    "Here is the data: {\\"key\\": \\"value\\"} and some other text."
+    ```
+    The parser will extract the `{"key": "value"}` JSON object.
+
+    However, if the result contains multiple JSON objects or nested data, such as:
+    ```
+    "Here are two JSONs: {\\"key1\\": \\"value1\\"} and {\\"key2\\": \\"value2\\"}"
+    ```
+    The parser will not handle this correctly, as it only extracts the content between the first `{` and the last `}`.
+    '''
+    def parse(self, result: str) -> dict[str, Any]:
+        '''Parses the raw output string to extract and decode a JSON object.
+
+        This method searches the provided string for the first opening curly brace `{` and the last closing curly
+        brace `}` to identify a JSON object. It extracts the substring between these braces and attempts to parse it
+        as a JSON object. The method raises a `ValueError` if no valid JSON structure is found or if the JSON is
+        malformed.
+
+        Note:
+            This approach relies on the first `{` and the last `}` in the string. It will fail if:
+            - The result contains curly braces outside the intended JSON object.
+            - There are multiple JSON objects within the string, as it only processes the first and last braces.
+
+        Example:
+            If the result is:
+            ```
+            "Here is the data: {\\"key\\": \\"value\\"} and some other text."
+            ```
+            The parser will extract and return the `{"key": "value"}` object.
+
+            However, if the result is:
+            ```
+            "Here are two JSONs: {\\"key1\\": \\"value1\\"} and {\\"key2\\": \\"value2\\"}"
+            ```
+            The parser will incorrectly attempt to parse everything between the first `{` and the last `}`.
+
+        Args:
+            result (str): The raw output string from the language model.
+
+        Returns:
+            dict[str, Any]: The parsed JSON object as a Python dictionary.
+
+        Raises:
+            ValueError: If no valid JSON object is found or if the JSON string is invalid.
+        '''

gllm_inference/output_parser/output_parser.pyi

@@ -0,0 +1,27 @@
+import abc
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+T = TypeVar('T')
+
+class BaseOutputParser(ABC, Generic[T], metaclass=abc.ABCMeta):
+    """A base class for output parsers used in Gen AI applications.
+
+    The `BaseOutputParser` class defines the interface for parsing the output of language models.
+    Subclasses must implement the `parse` method to process and extract meaningful data from the raw output.
+    """
+    @abstractmethod
+    def parse(self, result: str) -> T:
+        """Parses the raw output string from the language model.
+
+        This abstract method must be implemented by subclasses to define how the result is parsed and processed.
+
+        Args:
+            result (str): The raw output string from the language model.
+
+        Returns:
+            T: The parsed result of type T.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """

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/prompt_builder.pyi

@@ -0,0 +1,56 @@
+from _typeshed import Incomplete
+from gllm_inference.schema import Message as Message, MessageContent as MessageContent, MessageRole as MessageRole
+from typing import Any
+
+KEY_EXTRACTOR_REGEX: Incomplete
+
+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.
+    """
+    system_template: Incomplete
+    user_template: Incomplete
+    prompt_key_set: Incomplete
+    key_defaults: Incomplete
+    def __init__(self, system_template: str = '', user_template: str = '', key_defaults: dict[str, str] | None = None, ignore_extra_keys: bool | 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.
+
+        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 formatted list of 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/request_processor/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.request_processor.lm_request_processor import LMRequestProcessor as LMRequestProcessor
+from gllm_inference.request_processor.uses_lm_mixin import UsesLM as UsesLM
+
+__all__ = ['LMRequestProcessor', 'UsesLM']