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

gllm_inference/request_processor/lm_request_processor.pyi

@@ -0,0 +1,92 @@
+from _typeshed import Incomplete
+from gllm_core.event import EventEmitter as EventEmitter
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
+from gllm_inference.output_parser.output_parser import BaseOutputParser as BaseOutputParser
+from gllm_inference.prompt_builder.prompt_builder import PromptBuilder as PromptBuilder
+from gllm_inference.schema import LMOutput as LMOutput, Message as Message, MessageContent as MessageContent, ResponseSchema as ResponseSchema, ToolCall as ToolCall, ToolResult as ToolResult
+from langchain_core.tools import Tool as Tool
+from typing import Any
+
+class LMRequestProcessor:
+    """A request processor to perform language models inference.
+
+    The `LMRequestProcessor` class handles the process of building a prompt, invoking a language model, and optionally
+    parsing the output. It combines a prompt builder, language model invoker, and an optional output parser to manage
+    the inference process in Gen AI applications.
+
+    Attributes:
+        prompt_builder (PromptBuilder): The prompt builder used to format the prompt.
+        lm_invoker (BaseLMInvoker): The language model invoker that handles the model inference.
+        output_parser (BaseOutputParser | None): The optional parser to process the model's output, if any.
+        tool_dict (dict[str, Tool]): A dictionary of tools provided to the language model to enable tool calling,
+            if any. The dictionary maps the tool name to the tools themselves.
+    """
+    prompt_builder: Incomplete
+    lm_invoker: Incomplete
+    output_parser: Incomplete
+    tool_dict: Incomplete
+    def __init__(self, prompt_builder: PromptBuilder, lm_invoker: BaseLMInvoker, output_parser: BaseOutputParser | None = None) -> None:
+        """Initializes a new instance of the LMRequestProcessor class.
+
+        Args:
+            prompt_builder (PromptBuilder): The prompt builder used to format the prompt.
+            lm_invoker (BaseLMInvoker): The language model invoker that handles the model inference.
+            output_parser (BaseOutputParser, optional): An optional parser to process the model's output.
+                Defaults to None.
+        """
+    def set_tools(self, tools: list[Tool]) -> None:
+        """Sets the tools for the LM invoker.
+
+        This method sets the tools for the LM invoker. Any existing tools will be replaced.
+
+        Args:
+            tools (list[Tool]): The list of tools to be used.
+        """
+    def clear_tools(self) -> None:
+        """Clears the tools for the LM invoker.
+
+        This method clears the tools for the LM invoker.
+        """
+    def set_response_schema(self, response_schema: ResponseSchema | None) -> None:
+        """Sets the response schema for the LM invoker.
+
+        This method sets the response schema for the LM invoker. Any existing response schema will be replaced.
+
+        Args:
+            response_schema (ResponseSchema | None): The response schema to be used.
+        """
+    def clear_response_schema(self) -> None:
+        """Clears the response schema for the LM invoker.
+
+        This method clears the response schema for the LM invoker.
+        """
+    async def process(self, prompt_kwargs: dict[str, Any] | None = None, history: list[Message] | None = None, extra_contents: list[MessageContent] | None = None, hyperparameters: dict[str, Any] | None = None, event_emitter: EventEmitter | None = None, auto_execute_tools: bool = True, max_lm_calls: int = 5) -> Any:
+        """Processes a language model inference request.
+
+        This method processes the language model inference request as follows:
+        1. Assembling the prompt using the provided keyword arguments.
+        2. Invoking the language model with the assembled prompt and optional hyperparameters.
+        3. If `auto_execute_tools` is True, the method will automatically execute tools if the LM output includes
+           tool calls.
+        4. Optionally parsing the model's output using the output parser if provided. If the model output is an
+           LMOutput object, the output parser will process the `response` attribute of the LMOutput object.
+
+        Args:
+            prompt_kwargs (dict[str, Any], optional): A dictionary of arguments used to format the prompt.
+                Defaults to None, in which case no arguments will be passed to the prompt builder.
+            history (list[Message] | None, optional): A list of conversation history to be included in the prompt.
+                Defaults to None.
+            extra_contents (list[MessageContent] | None, optional): A list of extra contents to be included in the
+                user message. Defaults to None.
+            hyperparameters (dict[str, Any] | None, optional): A dictionary of hyperparameters for the model invocation.
+                Defaults to None.
+            event_emitter (EventEmitter | None, optional): An event emitter for streaming model outputs.
+                Defaults to None.
+            auto_execute_tools (bool, optional): Whether to automatically execute tools if the LM invokes output
+                tool calls. Defaults to True.
+            max_lm_calls (int, optional): The maximum number of times the language model can be invoked
+                when `auto_execute_tools` is True. Defaults to 5.
+
+        Returns:
+            Any: The result of the language model invocation, optionally parsed by the output parser.
+        """

gllm_inference/request_processor/uses_lm_mixin.pyi

@@ -0,0 +1,50 @@
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
+from gllm_inference.output_parser.output_parser import BaseOutputParser as BaseOutputParser
+from gllm_inference.prompt_builder.prompt_builder import PromptBuilder as PromptBuilder
+from gllm_inference.request_processor.lm_request_processor import LMRequestProcessor as LMRequestProcessor
+from typing import Any
+
+class UsesLM:
+    '''A mixin to initialize classes that use LMRequestProcessor by providing the components directly.
+
+    This mixin should be extended by classes that use LMRequestProcessor. Extending this mixin allows the class to
+    create an instance of itself by providing the LMRequestProcessor components directly.
+
+    For example:
+    ```python
+    class LMBasedComponent(BaseComponent, UsesLM):
+        def __init__(self, lm_request_processor: LMRequestProcessor, custom_kwarg: str):
+            self.lm_request_processor = lm_request_processor
+            self.custom_kwarg = custom_kwarg
+    ```
+
+    Then, the class can be instantiated with the following:
+    ```python
+    component = LMBasedComponent.from_lm_components(
+        prompt_builder,
+        lm_invoker,
+        output_parser,
+        **{"custom_kwarg": "custom_value"},
+    )
+    ```
+
+    Note:
+        Classes that extend this mixin must have a constructor that accepts the LMRequestProcessor instance as its
+        first argument.
+    '''
+    @classmethod
+    def from_lm_components(cls, prompt_builder: PromptBuilder, lm_invoker: BaseLMInvoker, output_parser: BaseOutputParser | None = None, **kwargs: Any):
+        """Creates an instance by initializing LMRequestProcessor with given components.
+
+        This method is a shortcut to initialize the class by providing the LMRequestProcessor components directly.
+
+        Args:
+            prompt_builder (PromptBuilder): The prompt builder used to format the prompt.
+            lm_invoker (BaseLMInvoker): The language model invoker that handles the model inference.
+            output_parser (BaseOutputParser, optional): An optional parser to process the model's output.
+                Defaults to None.
+            **kwargs (Any): Additional keyword arguments to be passed to the class constructor.
+
+        Returns:
+            An instance of the class that mixes in this mixin.
+        """

gllm_inference/schema/__init__.pyi

@@ -0,0 +1,13 @@
+from gllm_inference.schema.attachment import Attachment as Attachment
+from gllm_inference.schema.code_exec_result import CodeExecResult as CodeExecResult
+from gllm_inference.schema.enums import AttachmentType as AttachmentType, EmitDataType as EmitDataType, MessageRole as MessageRole
+from gllm_inference.schema.lm_output import LMOutput as LMOutput
+from gllm_inference.schema.message import Message as Message
+from gllm_inference.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
+from gllm_inference.schema.reasoning import Reasoning as Reasoning
+from gllm_inference.schema.token_usage import TokenUsage as TokenUsage
+from gllm_inference.schema.tool_call import ToolCall as ToolCall
+from gllm_inference.schema.tool_result import ToolResult as ToolResult
+from gllm_inference.schema.type_alias import EMContent as EMContent, ErrorResponse as ErrorResponse, MessageContent as MessageContent, ResponseSchema as ResponseSchema, Vector as Vector
+
+__all__ = ['Attachment', 'AttachmentType', 'CodeExecResult', 'EMContent', 'EmitDataType', 'ErrorResponse', 'MessageContent', 'LMOutput', 'ModelId', 'ModelProvider', 'Message', 'MessageRole', 'Reasoning', 'ResponseSchema', 'TokenUsage', 'ToolCall', 'ToolResult', 'Vector']

gllm_inference/schema/attachment.pyi

@@ -0,0 +1,88 @@
+from _typeshed import Incomplete
+from gllm_inference.constants import HEX_REPR_LENGTH as HEX_REPR_LENGTH
+from pydantic import BaseModel
+
+logger: Incomplete
+
+class Attachment(BaseModel):
+    """Defines a file attachment schema.
+
+    Attributes:
+        data (bytes): The content data of the file attachment.
+        filename (str): The filename of the file attachment.
+        mime_type (str): The mime type of the file attachment.
+        extension (str): The extension of the file attachment.
+        url (str | None): The URL of the file attachment. Defaults to None.
+    """
+    data: bytes
+    filename: str
+    mime_type: str
+    extension: str
+    url: str | None
+    @classmethod
+    def from_bytes(cls, bytes: bytes, filename: str | None = None) -> Attachment:
+        """Creates an Attachment from bytes.
+
+        Args:
+            bytes (bytes): The bytes of the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the extension.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_base64(cls, base64_data: str, filename: str | None = None) -> Attachment:
+        """Creates an Attachment from a base64 string.
+
+        Args:
+            base64_data (str): The base64 string of the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the mime type.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_data_url(cls, data_url: str, filename: str | None = None) -> Attachment:
+        """Creates an Attachment from a data URL (data:[mime/type];base64,[bytes]).
+
+        Args:
+            data_url (str): The data URL of the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the mime type.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_url(cls, url: str, filename: str | None = None) -> Attachment:
+        """Creates an Attachment from a URL.
+
+        Args:
+            url (str): The URL of the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the URL.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_path(cls, path: str, filename: str | None = None) -> Attachment:
+        """Creates an Attachment from a path.
+
+        Args:
+            path (str): The path to the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the path.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    def write_to_file(self, path: str | None = None) -> None:
+        """Writes the Attachment to a file.
+
+        Args:
+            path (str | None, optional): The path to the file. Defaults to None,
+                in which case the filename will be used as the path.
+        """

gllm_inference/schema/code_exec_result.pyi

@@ -0,0 +1,14 @@
+from gllm_inference.schema.attachment import Attachment as Attachment
+from pydantic import BaseModel
+
+class CodeExecResult(BaseModel):
+    """Defines a code execution result when a language model is configured to execute code.
+
+    Attributes:
+        id (str): The ID of the code execution. Defaults to an empty string.
+        code (str): The executed code. Defaults to an empty string.
+        output (list[str | Attachment]): The output of the executed code. Defaults to an empty list.
+    """
+    id: str
+    code: str
+    output: list[str | Attachment]

gllm_inference/schema/enums.pyi

@@ -0,0 +1,24 @@
+from enum import StrEnum
+
+class AttachmentType(StrEnum):
+    """Defines valid attachment types."""
+    AUDIO = 'audio'
+    DOCUMENT = 'document'
+    IMAGE = 'image'
+    VIDEO = 'video'
+
+class EmitDataType(StrEnum):
+    """Defines valid data types for emitting events."""
+    ACTIVITY = 'activity'
+    CODE = 'code'
+    CODE_START = 'code_start'
+    CODE_END = 'code_end'
+    THINKING = 'thinking'
+    THINKING_START = 'thinking_start'
+    THINKING_END = 'thinking_end'
+
+class MessageRole(StrEnum):
+    """Defines valid message roles."""
+    SYSTEM = 'system'
+    USER = 'user'
+    ASSISTANT = 'assistant'

gllm_inference/schema/lm_output.pyi

@@ -0,0 +1,36 @@
+from gllm_core.schema import Chunk as Chunk
+from gllm_inference.schema.code_exec_result import CodeExecResult as CodeExecResult
+from gllm_inference.schema.reasoning import Reasoning as Reasoning
+from gllm_inference.schema.token_usage import TokenUsage as TokenUsage
+from gllm_inference.schema.tool_call import ToolCall as ToolCall
+from pydantic import BaseModel
+from typing import Any
+
+class LMOutput(BaseModel):
+    """Defines the output of a language model.
+
+    Attributes:
+        response (str): The text response. Defaults to an empty string.
+        tool_calls (list[ToolCall]): The tool calls, if the language model decides to invoke tools.
+            Defaults to an empty list.
+        structured_output (dict[str, Any] | BaseModel | None): The structured output, if a response schema is defined
+            for the language model. Defaults to None.
+        token_usage (TokenUsage | None): The token usage analytics, if requested. Defaults to None.
+        duration (float | None): The duration of the invocation in seconds, if requested. Defaults to None.
+        finish_details (dict[str, Any]): The details about how the generation finished, if requested.
+            Defaults to an empty dictionary.
+        reasoning (list[Reasoning]): The reasoning, if the language model is configured to output reasoning.
+            Defaults to an empty list.
+        citations (list[Chunk]): The citations, if the language model outputs citations. Defaults to an empty list.
+        code_exec_results (list[CodeExecResult]): The code execution results, if the language model decides to
+            execute code. Defaults to an empty list.
+    """
+    response: str
+    tool_calls: list[ToolCall]
+    structured_output: dict[str, Any] | BaseModel | None
+    token_usage: TokenUsage | None
+    duration: float | None
+    finish_details: dict[str, Any]
+    reasoning: list[Reasoning]
+    citations: list[Chunk]
+    code_exec_results: list[CodeExecResult]

gllm_inference/schema/message.pyi

@@ -0,0 +1,52 @@
+from gllm_inference.schema.enums import MessageRole as MessageRole
+from gllm_inference.schema.type_alias import MessageContent as MessageContent
+from pydantic import BaseModel
+from typing import Any
+
+class Message(BaseModel):
+    """Defines a message schema to be used as inputs for a language model.
+
+    Attributes:
+        role (MessageRole): The role of the message.
+        contents (list[MessageContent]): The contents of the message.
+        metadata (dict[str, Any]): The metadata of the message.
+    """
+    role: MessageRole
+    contents: list[MessageContent]
+    metadata: dict[str, Any]
+    @classmethod
+    def system(cls, contents: MessageContent | list[MessageContent], metadata: dict[str, Any] | None = None) -> Message:
+        """Create a system message.
+
+        Args:
+            contents (MessageContent | list[MessageContent]): The message contents.
+                If a single content is provided, it will be wrapped in a list.
+            metadata (dict[str, Any], optional): Additional metadata for the message. Defaults to None.
+
+        Returns:
+            Message: A new message with SYSTEM role.
+        """
+    @classmethod
+    def user(cls, contents: MessageContent | list[MessageContent], metadata: dict[str, Any] | None = None) -> Message:
+        """Create a user message.
+
+        Args:
+            contents (MessageContent | list[MessageContent]): The message contents.
+                If a single content is provided, it will be wrapped in a list.
+            metadata (dict[str, Any], optional): Additional metadata for the message. Defaults to None.
+
+        Returns:
+            Message: A new message with USER role.
+        """
+    @classmethod
+    def assistant(cls, contents: MessageContent | list[MessageContent], metadata: dict[str, Any] | None = None) -> Message:
+        """Create an assistant message.
+
+        Args:
+            contents (MessageContent | list[MessageContent]): The message contents.
+                If a single content is provided, it will be wrapped in a list.
+            metadata (dict[str, Any], optional): Additional metadata for the message. Defaults to None.
+
+        Returns:
+            Message: A new message with ASSISTANT role.
+        """

gllm_inference/schema/model_id.pyi

@@ -0,0 +1,138 @@
+from enum import StrEnum
+from gllm_inference.utils import validate_string_enum as validate_string_enum
+from pydantic import BaseModel
+
+PROVIDER_SEPARATOR: str
+PATH_SEPARATOR: str
+URL_NAME_REGEX_PATTERN: str
+
+class ModelProvider(StrEnum):
+    """Defines the supported model providers."""
+    ANTHROPIC = 'anthropic'
+    AZURE_OPENAI = 'azure-openai'
+    BEDROCK = 'bedrock'
+    DATASAUR = 'datasaur'
+    GOOGLE = 'google'
+    LANGCHAIN = 'langchain'
+    LITELLM = 'litellm'
+    OPENAI = 'openai'
+    OPENAI_COMPATIBLE = 'openai-compatible'
+    TWELVELABS = 'twelvelabs'
+    VOYAGE = 'voyage'
+
+class ModelId(BaseModel):
+    '''Defines a representation of a valid model id.
+
+    Attributes:
+        provider (ModelProvider): The provider of the model.
+        name (str | None): The name of the model.
+        path (str | None): The path of the model.
+
+    Provider-specific examples:
+        # Using Anthropic
+        ```python
+        model_id = ModelId.from_string("anthropic/claude-3-5-sonnet-latest")
+        ```
+
+        # Using Bedrock
+        ```python
+        model_id = ModelId.from_string("bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0")
+        ```
+
+        # Using Datasaur
+        ```python
+        model_id = ModelId.from_string("datasaur/https://deployment.datasaur.ai/api/deployment/teamId/deploymentId/")
+        ```
+
+        # Using Google
+        ```python
+        model_id = ModelId.from_string("google/gemini-1.5-flash")
+        ```
+
+        # Using OpenAI
+        ```python
+        model_id = ModelId.from_string("openai/gpt-4o-mini")
+        ```
+
+        # Using Azure OpenAI
+        ```python
+        model_id = ModelId.from_string("azure-openai/https://my-resource.openai.azure.com:my-deployment")
+        ```
+
+        # Using OpenAI compatible endpoints (e.g. Groq)
+        ```python
+        model_id = ModelId.from_string("openai-compatible/https://api.groq.com/openai/v1:llama3-8b-8192")
+        ```
+
+        # Using Voyage
+        ```python
+        model_id = ModelId.from_string("voyage/voyage-3.5-lite")
+        ```
+
+        # Using TwelveLabs
+        ```python
+        model_id = ModelId.from_string("twelvelabs/Marengo-retrieval-2.7")
+        ```
+
+        # Using LangChain
+        ```python
+        model_id = ModelId.from_string("langchain/langchain_openai.ChatOpenAI:gpt-4o-mini")
+        ```
+        For the list of supported providers, please refer to the following table:
+        https://python.langchain.com/docs/integrations/chat/#featured-providers
+
+        # Using LiteLLM
+        ```python
+        model_id = ModelId.from_string("litellm/openai/gpt-4o-mini")
+        ```
+        For the list of supported providers, please refer to the following page:
+        https://docs.litellm.ai/docs/providers/
+
+    Custom model name validation example:
+        ```python
+        validation_map = {
+            ModelProvider.ANTHROPIC: {"claude-3-5-sonnet-latest"},
+            ModelProvider.GOOGLE: {"gemini-1.5-flash", "gemini-1.5-pro"},
+            ModelProvider.OPENAI: {"gpt-4o", "gpt-4o-mini"},
+
+        model_id = ModelId.from_string("...", validation_map)
+        ```
+    '''
+    provider: ModelProvider
+    name: str | None
+    path: str | None
+    @classmethod
+    def from_string(cls, model_id: str, validation_map: dict[str, set[str]] | None = None) -> ModelId:
+        """Parse a model id string into a ModelId object.
+
+        Args:
+            model_id (str): The model id to parse. Must be in the the following format:
+                1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
+                2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
+                3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
+                4. For `litellm` provider: `litellm/provider/model-name`.
+                5. For `datasaur` provider: `datasaur/base-url`.
+                6. For other providers: `provider/model-name`.
+            validation_map (dict[str, set[str]] | None, optional): An optional dictionary that maps provider names to
+                sets of valid model names. For the defined model providers, the model names will be validated against
+                the set of valid model names. For the undefined model providers, the model name will not be validated.
+                Defaults to None.
+
+        Returns:
+            ModelId: The parsed ModelId object.
+
+        Raises:
+            ValueError: If the provided model id is invalid or if the model name is not valid for the provider.
+        """
+    def to_string(self) -> str:
+        """Convert the ModelId object to a string.
+
+        Returns:
+            str: The string representation of the ModelId object. The format is as follows:
+                1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
+                2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
+                3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
+                4. For `litellm` provider: `litellm/provider/model-name`.
+                5. For `datasaur` provider: `datasaur/base-url`.
+                6. For other providers: `provider/model-name`.
+        """

gllm_inference/schema/reasoning.pyi

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+class Reasoning(BaseModel):
+    """Defines a reasoning output when a language model is configured to use reasoning.
+
+    Attributes:
+        id (str): The ID of the reasoning output. Defaults to an empty string.
+        reasoning (str): The reasoning text. Defaults to an empty string.
+        type (str): The type of the reasoning output. Defaults to an empty string.
+        data (str): The additional data of the reasoning output. Defaults to an empty string.
+    """
+    id: str
+    reasoning: str
+    type: str
+    data: str

gllm_inference/schema/token_usage.pyi

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+
+class TokenUsage(BaseModel):
+    """Defines the token usage data structure of a language model.
+
+    Attributes:
+        input_tokens (int): The number of input tokens.
+        output_tokens (int): The number of output tokens.
+    """
+    input_tokens: int
+    output_tokens: int

gllm_inference/schema/tool_call.pyi

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+from typing import Any
+
+class ToolCall(BaseModel):
+    """Defines a tool call request when a language model decides to invoke a tool.
+
+    Attributes:
+        id (str): The ID of the tool call.
+        name (str): The name of the tool.
+        args (dict[str, Any]): The arguments of the tool call.
+    """
+    id: str
+    name: str
+    args: dict[str, Any]

gllm_inference/schema/tool_result.pyi

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+
+class ToolResult(BaseModel):
+    """Defines a tool result to be sent back to the language model.
+
+    Attributes:
+        id (str): The ID of the tool call.
+        output (str): The output of the tool call.
+    """
+    id: str
+    output: str

gllm_inference/schema/type_alias.pyi

@@ -0,0 +1,15 @@
+from aiohttp import ClientResponse
+from gllm_inference.schema.code_exec_result import Attachment as Attachment
+from gllm_inference.schema.reasoning import Reasoning as Reasoning
+from gllm_inference.schema.tool_call import ToolCall as ToolCall
+from gllm_inference.schema.tool_result import ToolResult as ToolResult
+from httpx import Response as HttpxResponse
+from pydantic import BaseModel
+from requests import Response
+from typing import Any
+
+ErrorResponse = Response | HttpxResponse | ClientResponse | str | dict[str, Any]
+ResponseSchema = dict[str, Any] | type[BaseModel]
+MessageContent = str | Attachment | ToolCall | ToolResult | Reasoning
+EMContent = str | Attachment | tuple[str | Attachment, ...]
+Vector = list[float]

gllm_inference/utils/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.utils.langchain import load_langchain_model as load_langchain_model, parse_model_data as parse_model_data
+from gllm_inference.utils.validation import validate_string_enum as validate_string_enum
+
+__all__ = ['load_langchain_model', 'parse_model_data', 'validate_string_enum']

gllm_inference/utils/langchain.pyi

@@ -0,0 +1,30 @@
+from _typeshed import Incomplete
+from langchain_core.embeddings import Embeddings as Embeddings
+from langchain_core.language_models import BaseChatModel as BaseChatModel
+from typing import Any
+
+MODEL_NAME_KEYS: Incomplete
+
+def load_langchain_model(model_class_path: str, model_name: str, model_kwargs: dict[str, Any]) -> BaseChatModel | Embeddings:
+    '''Loads the LangChain\'s model instance.
+
+    Args:
+        model_class_path (str): The path to the LangChain\'s class, e.g. "langchain_openai.ChatOpenAI".
+        model_name (str): The model name.
+        model_kwargs (dict[str, Any]): The additional keyword arguments.
+
+    Returns:
+        BaseChatModel | Embeddings: The LangChain\'s model instance.
+    '''
+def parse_model_data(model: BaseChatModel | Embeddings) -> dict[str, str]:
+    """Parses the model data from LangChain's BaseChatModel or Embeddings instance.
+
+    Args:
+        model (BaseChatModel | Embeddings): The LangChain's BaseChatModel or Embeddings instance.
+
+    Returns:
+        dict[str, str]: The dictionary containing the model name and path.
+
+    Raises:
+        ValueError: If the model name is not found in the model data.
+    """

gllm_inference/utils/validation.pyi

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+def validate_string_enum(enum_type: type[StrEnum], value: str) -> None:
+    """Validates that the provided value is a valid string enum value.
+
+    Args:
+        enum_type (type[StrEnum]): The type of the string enum.
+        value (str): The value to validate.
+
+    Raises:
+        ValueError: If the provided value is not a valid string enum value.
+    """