gllm-inference-binary 0.5.55__cp312-cp312-macosx_13_0_arm64.whl

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,69 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_builder.format_strategy import JinjaFormatStrategy as JinjaFormatStrategy, StringFormatStrategy as StringFormatStrategy
+from gllm_inference.schema import 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.
+    """
+    key_defaults: Incomplete
+    system_template: Incomplete
+    user_template: 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, use_jinja: bool = False, jinja_env: JinjaEnvType | SandboxedEnvironment = ...) -> 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.
+            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']

gllm_inference/realtime_chat/google_realtime_chat.pyi

@@ -0,0 +1,205 @@
+import asyncio
+import logging
+from _typeshed import Incomplete
+from gllm_inference.constants import GOOGLE_SCOPES as GOOGLE_SCOPES
+from gllm_inference.realtime_chat.input_streamer import KeyboardInputStreamer as KeyboardInputStreamer
+from gllm_inference.realtime_chat.input_streamer.input_streamer import BaseInputStreamer as BaseInputStreamer
+from gllm_inference.realtime_chat.output_streamer import ConsoleOutputStreamer as ConsoleOutputStreamer
+from gllm_inference.realtime_chat.output_streamer.output_streamer import BaseOutputStreamer as BaseOutputStreamer
+from gllm_inference.realtime_chat.realtime_chat import BaseRealtimeChat as BaseRealtimeChat
+from pydantic import BaseModel
+from typing import Literal
+
+DEFAULT_POST_OUTPUT_AUDIO_DELAY: float
+LIVE_CONNECT_CONFIG: Incomplete
+
+class GoogleIOStreamerState(BaseModel):
+    '''[BETA] Defines the state of the GoogleIOStreamer with thread-safe properties.
+
+    Attributes:
+        is_streaming_output (bool): Whether the output is streaming.
+        console_mode (Literal["input", "user", "assistant"]): The current console mode.
+        terminated (bool): Whether the conversation is terminated.
+    '''
+    is_streaming_output: bool
+    console_mode: Literal['input', 'user', 'assistant']
+    terminated: bool
+    async def set_streaming_output(self, value: bool) -> None:
+        """Thread-safe setter for is_streaming_output.
+
+        Args:
+            value (bool): The value to set for is_streaming_output.
+        """
+    async def get_streaming_output(self) -> bool:
+        """Thread-safe getter for is_streaming_output.
+
+        Returns:
+            bool: The value of is_streaming_output.
+        """
+    async def set_console_mode(self, value: Literal['input', 'user', 'assistant']) -> None:
+        '''Thread-safe setter for console_mode.
+
+        Args:
+            value (Literal["input", "user", "assistant"]): The value to set for console_mode.
+        '''
+    async def get_console_mode(self) -> Literal['input', 'user', 'assistant']:
+        '''Thread-safe getter for console_mode.
+
+        Returns:
+            Literal["input", "user", "assistant"]: The value of console_mode.
+        '''
+    async def set_terminated(self, value: bool) -> None:
+        """Thread-safe setter for terminated.
+
+        Args:
+            value (bool): The value to set for terminated.
+        """
+    async def get_terminated(self) -> bool:
+        """Thread-safe getter for terminated.
+
+        Returns:
+            bool: The value of terminated.
+        """
+
+class GoogleIOStreamer:
+    """[BETA] Defines the GoogleIOStreamer.
+
+    This class manages the realtime conversation lifecycle.
+    It handles the IO operations between the model and the input/output streamers.
+
+    Attributes:
+        session (AsyncSession): The session of the GoogleIOStreamer.
+        task_group (asyncio.TaskGroup): The task group of the GoogleIOStreamer.
+        input_queue (asyncio.Queue): The input queue of the GoogleIOStreamer.
+        output_queue (asyncio.Queue): The output queue of the GoogleIOStreamer.
+        input_streamers (list[BaseInputStreamer]): The input streamers of the GoogleIOStreamer.
+        output_streamers (list[BaseOutputStreamer]): The output streamers of the GoogleIOStreamer.
+        post_output_audio_delay (float): The delay in seconds to post the output audio.
+    """
+    session: AsyncSession
+    task_group: Incomplete
+    input_queue: Incomplete
+    output_queue: Incomplete
+    state: Incomplete
+    input_streamers: Incomplete
+    output_streamers: Incomplete
+    post_output_audio_delay: Incomplete
+    def __init__(self, session: AsyncSession, task_group: asyncio.TaskGroup, input_queue: asyncio.Queue, output_queue: asyncio.Queue, input_streamers: list[BaseInputStreamer], output_streamers: list[BaseOutputStreamer], post_output_audio_delay: float, logger: logging.Logger) -> None:
+        """Initializes a new instance of the GoogleIOStreamer class.
+
+        Args:
+            session (AsyncSession): The session of the GoogleIOStreamer.
+            task_group (asyncio.TaskGroup): The task group of the GoogleIOStreamer.
+            input_queue (asyncio.Queue): The input queue of the GoogleIOStreamer.
+            output_queue (asyncio.Queue): The output queue of the GoogleIOStreamer.
+            input_streamers (list[BaseInputStreamer]): The input streamers of the GoogleIOStreamer.
+            output_streamers (list[BaseOutputStreamer]): The output streamers of the GoogleIOStreamer.
+            post_output_audio_delay (float): The delay in seconds to post the output audio.
+            logger (logging.Logger): The logger of the GoogleIOStreamer.
+        """
+    async def start(self) -> None:
+        """Processes the realtime conversation.
+
+        This method is used to start the realtime conversation.
+        It initializes the input and output streamers, creates the necessary tasks, and starts the conversation.
+        When the conversation is terminated, it cleans up the input and output streamers.
+        """
+
+class GoogleRealtimeChat(BaseRealtimeChat):
+    '''[BETA] A realtime chat module to interact with Gemini Live models.
+
+    Warning:
+        The \'GoogleRealtimeChat\' class is currently in beta and may be subject to changes in the future.
+        It is intended only for quick prototyping in local environments.
+        Please avoid using it in production environments.
+
+    Attributes:
+        model_name (str): The name of the language model.
+        client_params (dict[str, Any]): The Google client instance init parameters.
+
+    Basic usage:
+        The `GoogleRealtimeChat` can be used as started as follows:
+        ```python
+        realtime_chat = GoogleRealtimeChat(model_name="gemini-live-2.5-flash-preview")
+        await realtime_chat.invoke()
+        ```
+
+    Custom IO streamers:
+        The `GoogleRealtimeChat` can be used with custom IO streamers.
+        ```python
+        input_streamers = [KeyboardInputStreamer(), LinuxMicInputStreamer()]
+        output_streamers = [ConsoleOutputStreamer(), LinuxSpeakerOutputStreamer()]
+        realtime_chat = GoogleRealtimeChat(model_name="gemini-live-2.5-flash-preview")
+        await realtime_chat.start(input_streamers=input_streamers, output_streamers=output_streamers)
+        ```
+
+        In the above example, we added a capability to use a Linux system microphone and speaker,
+        allowing realtime audio input and output to the model.
+
+    Authentication:
+        The `GoogleRealtimeChat` can use either Google Gen AI or Google Vertex AI.
+
+        Google Gen AI is recommended for quick prototyping and development.
+        It requires a Gemini API key for authentication.
+
+        Usage example:
+        ```python
+        realtime_chat = GoogleRealtimeChat(
+            model_name="gemini-live-2.5-flash-preview",
+            api_key="your_api_key"
+        )
+        ```
+
+        Google Vertex AI is recommended to build production-ready applications.
+        It requires a service account JSON file for authentication.
+
+        Usage example:
+        ```python
+        realtime_chat = GoogleRealtimeChat(
+            model_name="gemini-live-2.5-flash-preview",
+            credentials_path="path/to/service_account.json"
+        )
+        ```
+
+        If neither `api_key` nor `credentials_path` is provided, Google Gen AI will be used by default.
+        The `GOOGLE_API_KEY` environment variable will be used for authentication.
+    '''
+    model_name: Incomplete
+    client_params: Incomplete
+    def __init__(self, model_name: str, api_key: str | None = None, credentials_path: str | None = None, project_id: str | None = None, location: str = 'us-central1') -> None:
+        '''Initializes a new instance of the GoogleRealtimeChat class.
+
+        Args:
+            model_name (str): The name of the model to use.
+            api_key (str | None, optional): Required for Google Gen AI authentication. Cannot be used together
+                with `credentials_path`. Defaults to None.
+            credentials_path (str | None, optional): Required for Google Vertex AI authentication. Path to the service
+                account credentials JSON file. Cannot be used together with `api_key`. Defaults to None.
+            project_id (str | None, optional): The Google Cloud project ID for Vertex AI. Only used when authenticating
+                with `credentials_path`. Defaults to None, in which case it will be loaded from the credentials file.
+            location (str, optional): The location of the Google Cloud project for Vertex AI. Only used when
+                authenticating with `credentials_path`. Defaults to "us-central1".
+
+        Note:
+            If neither `api_key` nor `credentials_path` is provided, Google Gen AI will be used by default.
+            The `GOOGLE_API_KEY` environment variable will be used for authentication.
+        '''
+    async def start(self, input_streamers: list[BaseInputStreamer] | None = None, output_streamers: list[BaseOutputStreamer] | None = None, post_output_audio_delay: float = ...) -> None:
+        """Starts the realtime conversation using the provided input and output streamers.
+
+        This method is used to start the realtime conversation using a `GoogleIOStreamer`.
+        The streamers are responsible for handling the input and output of the conversation.
+
+        Args:
+            input_streamers (list[BaseInputStreamer] | None, optional): The input streamers to use.
+                Defaults to None, in which case a `KeyboardInputStreamer` will be used.
+            output_streamers (list[BaseOutputStreamer] | None, optional): The output streamers to use.
+                Defaults to None, in which case a `ConsoleOutputStreamer` will be used.
+            post_output_audio_delay (float, optional): The delay in seconds to post the output audio.
+                Defaults to 0.5 seconds.
+
+        Raises:
+            ValueError: If the `input_streamers` or `output_streamers` is an empty list.
+            ValueError: If the `post_output_audio_delay` is not greater than 0.
+            Exception: If the conversation fails to process.
+        """

gllm_inference/realtime_chat/input_streamer/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.realtime_chat.input_streamer.keyboard_input_streamer import KeyboardInputStreamer as KeyboardInputStreamer
+from gllm_inference.realtime_chat.input_streamer.linux_mic_input_streamer import LinuxMicInputStreamer as LinuxMicInputStreamer
+
+__all__ = ['KeyboardInputStreamer', 'LinuxMicInputStreamer']