gllm-inference-binary 0.5.51b3__cp313-cp313-macosx_11_0_x86_64.whl

gllm_inference/schema/config.pyi

@@ -0,0 +1,15 @@
+from gllm_inference.schema.enums import TruncateSide as TruncateSide
+from pydantic import BaseModel
+
+class TruncationConfig(BaseModel):
+    """Configuration for text truncation behavior.
+
+    Attributes:
+        max_length (int): Maximum length of text content. Required.
+        truncate_side (TruncateSide | None): Side to truncate from when max_length is exceeded.
+            1. TruncateSide.RIGHT: Keep the beginning of the text, truncate from the end (default)
+            2. TruncateSide.LEFT: Keep the end of the text, truncate from the beginning
+            If None, defaults to TruncateSide.RIGHT
+    """
+    max_length: int
+    truncate_side: TruncateSide | None

gllm_inference/schema/enums.pyi

@@ -0,0 +1,69 @@
+from enum import StrEnum
+
+class AttachmentType(StrEnum):
+    """Defines valid attachment types."""
+    AUDIO = 'audio'
+    DOCUMENT = 'document'
+    IMAGE = 'image'
+    VIDEO = 'video'
+
+class BatchStatus(StrEnum):
+    """Defines the status of a batch job."""
+    CANCELING = 'canceling'
+    IN_PROGRESS = 'in_progress'
+    FINISHED = 'finished'
+    UNKNOWN = 'unknown'
+
+class LMEventType(StrEnum):
+    """Defines event types to be emitted by the LM invoker."""
+    ACTIVITY = 'activity'
+    CODE = 'code'
+    THINKING = 'thinking'
+
+class LMEventTypeSuffix(StrEnum):
+    """Defines suffixes for LM event types."""
+    START = '_start'
+    END = '_end'
+
+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 ActivityType(StrEnum):
+    """Defines valid activity types."""
+    FIND_IN_PAGE = 'find_in_page'
+    MCP_CALL = 'mcp_call'
+    MCP_LIST_TOOLS = 'mcp_list_tools'
+    OPEN_PAGE = 'open_page'
+    SEARCH = 'search'
+    WEB_SEARCH = 'web_search'
+
+class MessageRole(StrEnum):
+    """Defines valid message roles."""
+    SYSTEM = 'system'
+    USER = 'user'
+    ASSISTANT = 'assistant'
+
+class TruncateSide(StrEnum):
+    """Enumeration for truncation sides."""
+    RIGHT = 'RIGHT'
+    LEFT = 'LEFT'
+
+class JinjaEnvType(StrEnum):
+    """Enumeration for Jinja environment types."""
+    JINJA_DEFAULT = 'jinja_default'
+    RESTRICTED = 'restricted'
+
+class WebSearchKey(StrEnum):
+    """Defines valid web search keys."""
+    PATTERN = 'pattern'
+    QUERY = 'query'
+    SOURCES = 'sources'
+    TYPE = 'type'
+    URL = 'url'

gllm_inference/schema/events.pyi

@@ -0,0 +1,105 @@
+from _typeshed import Incomplete
+from gllm_core.schema import Event
+from gllm_inference.schema.activity import Activity as Activity
+from gllm_inference.schema.enums import LMEventType as LMEventType, LMEventTypeSuffix as LMEventTypeSuffix
+from typing import Any, Literal, Self
+
+CodeEventType: Incomplete
+ThinkingEventType: Incomplete
+
+class ActivityEvent(Event):
+    """Event schema for model-triggered activities (e.g. web search, MCP call, etc.).
+
+    Attributes:
+        id (str): The ID of the activity event. Defaults to None.
+        value (dict[str, Any]): The value of the activity event.
+        level (EventLevel): The severity level of the activity event. Defaults to EventLevel.INFO.
+        type (Literal[EventType.ACTIVITY]): The type of the activity event. Defaults to EventType.ACTIVITY.
+        timestamp (datetime): The timestamp of the activity event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the activity event. Defaults to an empty dictionary.
+    """
+    value: dict[str, Any]
+    type: Literal[LMEventType.ACTIVITY]
+    @classmethod
+    def from_activity(cls, id_: str | None = None, activity: Activity | None = None) -> ActivityEvent:
+        """Create an activity event from an Activity object.
+
+        Args:
+            id_ (str | None, optional): The ID of the activity event. Defaults to None.
+            activity (Activity | None, optional): The activity object to create the event from.
+                Defaults to None, in which case the value will be an empty dictionary.
+
+        Returns:
+            ActivityEvent: The activity event.
+        """
+
+class BlockBasedEvent(Event):
+    """Event schema block-based events, which are limited by start and end events.
+
+    Attributes:
+        id (str): The ID of the block-based event. Defaults to None.
+        value (str): The value of the block-based event. Defaults to an empty string.
+        level (EventLevel): The severity level of the block-based event. Defaults to EventLevel.INFO.
+        type (str): The type of the block-based event. Defaults to an empty string.
+        timestamp (datetime): The timestamp of the block-based event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the block-based event. Defaults to an empty dictionary.
+    """
+    value: str
+    type: str
+    @classmethod
+    def start(cls, id_: str | None = None) -> Self:
+        """Create a block-based start event.
+
+        Args:
+            id_ (str | None, optional): The ID of the block-based event. Defaults to None.
+
+        Returns:
+            Self: The block-based start event.
+        """
+    @classmethod
+    def content(cls, id_: str | None = None, value: str = '') -> Self:
+        """Create a block-based content event.
+
+        Args:
+            id_ (str | None, optional): The ID of the block-based event. Defaults to None.
+            value (str, optional): The block-based content. Defaults to an empty string.
+
+        Returns:
+            Self: The block-based content event.
+        """
+    @classmethod
+    def end(cls, id_: str | None = None) -> Self:
+        """Create a block-based end event.
+
+        Args:
+            id_ (str | None, optional): The ID of the block-based event. Defaults to None.
+
+        Returns:
+            Self: The block-based end event.
+        """
+
+class CodeEvent(BlockBasedEvent):
+    """Event schema for model-generated code to be executed.
+
+    Attributes:
+        id (str): The ID of the code event. Defaults to None.
+        value (str): The value of the code event. Defaults to an empty string.
+        level (EventLevel): The severity level of the code event. Defaults to EventLevel.INFO.
+        type (CodeEventType): The type of the code event. Defaults to EventType.CODE.
+        timestamp (datetime): The timestamp of the code event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the code event. Defaults to an empty dictionary.
+    """
+    type: CodeEventType
+
+class ThinkingEvent(BlockBasedEvent):
+    """Event schema for model-generated thinking.
+
+    Attributes:
+        id (str): The ID of the thinking event. Defaults to None.
+        value (str): The value of the thinking event. Defaults to an empty string.
+        level (EventLevel): The severity level of the thinking event. Defaults to EventLevel.INFO.
+        type (ThinkingEventType): The type of the thinking event. Defaults to EventType.THINKING.
+        timestamp (datetime): The timestamp of the thinking event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the thinking event. Defaults to an empty dictionary.
+    """
+    type: ThinkingEventType

gllm_inference/schema/lm_input.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.schema.message import Message as Message
+from gllm_inference.schema.type_alias import MessageContent as MessageContent
+
+LMInput = list[Message] | list[MessageContent] | str

gllm_inference/schema/lm_output.pyi

@@ -0,0 +1,44 @@
+from gllm_core.schema import Chunk as Chunk
+from gllm_inference.schema.attachment import Attachment as Attachment
+from gllm_inference.schema.code_exec_result import CodeExecResult as CodeExecResult
+from gllm_inference.schema.mcp import MCPCall as MCPCall
+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.
+        attachments (list[Attachment]): The attachments, if the language model decides to output attachments.
+            Defaults to an empty list.
+        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.
+        mcp_calls (list[MCPCall]): The MCP calls, if the language model decides to invoke MCP tools.
+            Defaults to an empty list.
+    """
+    response: str
+    attachments: list[Attachment]
+    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]
+    mcp_calls: list[MCPCall]

gllm_inference/schema/mcp.pyi

@@ -0,0 +1,31 @@
+from pydantic import BaseModel
+from typing import Any
+
+class MCPServer(BaseModel):
+    """Defines an MCP server.
+
+    Attributes:
+        url (str): The URL of the MCP server.
+        name (str): The name of the MCP server.
+        allowed_tools (list[str] | None): The allowed tools of the MCP server.
+            Defaults to None, in which case all tools are allowed.
+    """
+    url: str
+    name: str
+    allowed_tools: list[str] | None
+
+class MCPCall(BaseModel):
+    """Defines an MCP call.
+
+    Attributes:
+        id (str): The ID of the MCP call. Defaults to an empty string.
+        server_name (str): The name of the MCP server. Defaults to an empty string.
+        tool_name (str): The name of the tool. Defaults to an empty string.
+        args (dict[str, Any]): The arguments of the tool. Defaults to an empty dictionary.
+        output (str | None): The output of the tool. Defaults to None.
+    """
+    id: str
+    server_name: str
+    tool_name: str
+    args: dict[str, Any]
+    output: str | None

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,176 @@
+from _typeshed import Incomplete
+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'
+    COHERE = 'cohere'
+    DATASAUR = 'datasaur'
+    GOOGLE = 'google'
+    JINA = 'jina'
+    LANGCHAIN = 'langchain'
+    LITELLM = 'litellm'
+    OPENAI = 'openai'
+    PORTKEY = 'portkey'
+    OPENAI_CHAT_COMPLETIONS = 'openai-chat-completions'
+    OPENAI_COMPATIBLE = 'openai-compatible'
+    TWELVELABS = 'twelvelabs'
+    VOYAGE = 'voyage'
+    XAI = 'xai'
+
+PROVIDERS_OPTIONAL_PATH: Incomplete
+PROVIDERS_SUPPORT_PATH: Incomplete
+
+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-sonnet-4-20250514")
+        ```
+
+        # Using Bedrock
+        ```python
+        model_id = ModelId.from_string("bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0")
+        ```
+
+        # Using Cohere
+        ```python
+        model_id = ModelId.from_string("cohere/embed-english-v3.0")
+        ```
+
+        # Using Cohere with custom endpoint
+        ```python
+        model_id = ModelId.from_string("cohere/https://my-cohere-url:8000/v1:my-model-name")
+        ```
+
+        # 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-2.5-flash-lite")
+        ```
+
+        # Using Jina
+        ```python
+        model_id = ModelId.from_string("jina/jina-embeddings-v2-large")
+        ```
+
+        # Using Jina with custom endpoint
+        ```python
+        model_id = ModelId.from_string("jina/https://my-jina-url:8000/v1:my-model-name")
+        ```
+
+        # Using OpenAI
+        ```python
+        model_id = ModelId.from_string("openai/gpt-5-nano")
+        ```
+
+        # Using OpenAI with Chat Completions API
+        ```python
+        model_id = ModelId.from_string("openai-chat-completions/gpt-5-nano")
+        ```
+
+        # Using OpenAI Responses API-compatible endpoints (e.g. SGLang)
+        ```python
+        model_id = ModelId.from_string("openai/https://my-sglang-url:8000/v1:my-model-name")
+        ```
+
+        # Using OpenAI Chat Completions API-compatible endpoints (e.g. Groq)
+        ```python
+        model_id = ModelId.from_string("openai-chat-completions/https://api.groq.com/openai/v1:llama3-8b-8192")
+        ```
+
+        # Using Azure OpenAI
+        ```python
+        model_id = ModelId.from_string("azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment")
+        ```
+
+        # 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/
+
+        # Using xAI
+        ```python
+        model_id = ModelId.from_string("xai/grok-4-0709")
+        ```
+        For the list of supported models, please refer to the following page:
+        https://docs.x.ai/docs/models
+
+    Custom model name validation example:
+        ```python
+        validation_map = {
+            ModelProvider.ANTHROPIC: {"claude-sonnet-4-20250514"},
+            ModelProvider.GOOGLE: {"gemini-2.5-flash-lite"},
+            ModelProvider.OPENAI: {"gpt-4.1-nano", "gpt-5-nano"},
+        }
+
+        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 format defined in the following page:
+                https://gdplabs.gitbook.io/sdk/resources/supported-models
+            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 defined in the following page:
+                https://gdplabs.gitbook.io/sdk/resources/supported-models
+        """

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,75 @@
+from pydantic import BaseModel
+
+class InputTokenDetails(BaseModel):
+    """Defines the input token details schema.
+
+    Attributes:
+        cached_tokens (int): The number of cached tokens. Defaults to 0.
+        uncached_tokens (int): The number of uncached tokens. Defaults to 0.
+    """
+    cached_tokens: int
+    uncached_tokens: int
+    def __add__(self, other: InputTokenDetails) -> InputTokenDetails:
+        """Add two InputTokenDetails objects together.
+
+        Args:
+            other (InputTokenDetails): The other InputTokenDetails object to add.
+
+        Returns:
+            InputTokenDetails: A new InputTokenDetails object with summed values.
+        """
+
+class OutputTokenDetails(BaseModel):
+    """Defines the output token details schema.
+
+    Attributes:
+        reasoning_tokens (int): The number of reasoning tokens. Defaults to 0.
+        response_tokens (int): The number of response tokens. Defaults to 0.
+    """
+    reasoning_tokens: int
+    response_tokens: int
+    def __add__(self, other: OutputTokenDetails) -> OutputTokenDetails:
+        """Add two OutputTokenDetails objects together.
+
+        Args:
+            other (OutputTokenDetails): The other OutputTokenDetails object to add.
+
+        Returns:
+            OutputTokenDetails: A new OutputTokenDetails object with summed values.
+        """
+
+class TokenUsage(BaseModel):
+    """Defines the token usage data structure of a language model.
+
+    Attributes:
+        input_tokens (int): The number of input tokens. Defaults to 0.
+        output_tokens (int): The number of output tokens. Defaults to 0.
+        input_token_details (InputTokenDetails | None): The details of the input tokens. Defaults to None.
+        output_token_details (OutputTokenDetails | None): The details of the output tokens. Defaults to None.
+    """
+    input_tokens: int
+    output_tokens: int
+    input_token_details: InputTokenDetails | None
+    output_token_details: OutputTokenDetails | None
+    @classmethod
+    def from_token_details(cls, input_tokens: int | None = None, output_tokens: int | None = None, cached_tokens: int | None = None, reasoning_tokens: int | None = None) -> TokenUsage:
+        """Creates a TokenUsage from token details.
+
+        Args:
+            input_tokens (int | None): The number of input tokens. Defaults to None.
+            output_tokens (int | None): The number of output tokens. Defaults to None.
+            cached_tokens (int | None): The number of cached tokens. Defaults to None.
+            reasoning_tokens (int | None): The number of reasoning tokens. Defaults to None.
+
+        Returns:
+            TokenUsage: The instantiated TokenUsage.
+        """
+    def __add__(self, other: TokenUsage) -> TokenUsage:
+        """Add two TokenUsage objects together.
+
+        Args:
+            other (TokenUsage): The other TokenUsage object to add.
+
+        Returns:
+            TokenUsage: A new TokenUsage object with summed values.
+        """

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,11 @@
+from gllm_inference.schema.attachment 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 pydantic import BaseModel
+from typing import 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,5 @@
+from gllm_inference.utils.io_utils import base64_to_bytes as base64_to_bytes
+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__ = ['base64_to_bytes', 'load_langchain_model', 'parse_model_data', 'validate_string_enum']

gllm_inference/utils/io_utils.pyi

@@ -0,0 +1,26 @@
+from _typeshed import Incomplete
+
+logger: Incomplete
+DEFAULT_BASE64_ALLOWED_MIMETYPES: Incomplete
+
+def base64_to_bytes(value: str, *, allowed_mimetypes: tuple[str, ...] | None = ...) -> str | bytes:
+    '''Decode a base64 string to bytes based on allowed MIME type.
+
+    The conversion steps are as follows:
+        1. The function first attempts to decode the given string from base64.
+        2. If decoding succeeds, it checks the MIME type of the decoded content.
+        3. When the MIME type matches one of the allowed patterns (e.g., ``"image/*"``),
+            the raw bytes are returned. Otherwise, the original string is returned unchanged.
+
+    Args:
+        value (str): Input data to decode.
+        allowed_mimetypes (tuple[str, ...], optional): MIME type prefixes that are allowed
+            to be decoded into bytes. Defaults to ("image/*", "audio/*", "video/*").
+
+    Returns:
+        str | bytes: Base64-encoded string or raw bytes if MIME type is allowed;
+            otherwise returns original string.
+
+    Raises:
+        ValueError: If the input is not a string.
+    '''