gllm-core-binary 0.3.26__cp311-cp311-win_amd64.whl → 0.4.4b3__cp311-cp311-win_amd64.whl

gllm_core/adapters/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_core.adapters.tool import from_google_function as from_google_function, from_langchain_tool as from_langchain_tool
+
+__all__ = ['from_google_function', 'from_langchain_tool']

gllm_core/adapters/tool/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_core.adapters.tool.google_adk import from_google_function as from_google_function
+from gllm_core.adapters.tool.langchain import from_langchain_tool as from_langchain_tool
+
+__all__ = ['from_langchain_tool', 'from_google_function']

gllm_core/adapters/tool/google_adk.pyi

@@ -0,0 +1,23 @@
+from gllm_core.schema.tool import Tool as Tool
+from typing import Any, Callable
+
+def from_google_function(function_declaration: Any, func: Callable | None = None) -> Tool:
+    """Convert a Google ADK function declaration into the SDK Tool representation.
+
+    The Google ADK `FunctionDeclaration` provides access to:
+    1. `name`: The function name
+    2. `description`: The function description
+    3. `parameters`: A dict in JSON Schema format (OpenAPI 3.0 compatible)
+
+    Args:
+        function_declaration (Any): The Google ADK function declaration to convert.
+        func (Callable | None, optional): The implementation function for the tool. Defaults to None.
+
+    Returns:
+        Tool: The converted SDK tool.
+
+    Raises:
+        ValueError: If the function declaration is None or has invalid fields.
+        AttributeError: If required attributes are missing.
+        TypeError: If field types are incorrect.
+    """

gllm_core/adapters/tool/langchain.pyi

@@ -0,0 +1,31 @@
+from _typeshed import Incomplete
+from gllm_core.schema.tool import Tool as Tool
+from typing import Any
+
+class LangChainToolKeys:
+    """Constants for LangChain tool attribute keys."""
+    FUNC: str
+    COROUTINE: str
+    RUN: str
+    ARUN: str
+    NAME: str
+    DESCRIPTION: str
+    ARGS_SCHEMA: str
+
+LANGCHAIN_FUNCTION_ATTRS: Incomplete
+
+def from_langchain_tool(langchain_tool: Any) -> Tool:
+    """Convert a LangChain tool into the SDK Tool representation.
+
+    This function handles both traditional LangChain tools created with the @tool decorator
+    and tools created by subclassing the LangChain Tool class.
+
+    Args:
+        langchain_tool (Any): The LangChain tool to convert.
+
+    Returns:
+        Tool: The converted SDK tool.
+
+    Raises:
+        ValueError: If the input is not a valid LangChain tool.
+    """

gllm_core/constants.pyi

@@ -13,7 +13,6 @@ class EventType(StrEnum):
     """Defines event types for the event emitter module."""
     ACTIVITY = 'activity'
     CODE = 'code'
-    DATA = 'data'
     REFERENCE = 'reference'
     RESPONSE = 'response'
     STATUS = 'status'

gllm_core/event/event_emitter.pyi

@@ -1,11 +1,11 @@
 from _typeshed import Incomplete
-from gllm_core.constants import EventLevel as EventLevel, EventType as EventType
+from gllm_core.constants import EventLevel as EventLevel
 from gllm_core.event.handler import ConsoleEventHandler as ConsoleEventHandler, PrintEventHandler as PrintEventHandler, StreamEventHandler as StreamEventHandler
 from gllm_core.event.handler.event_handler import BaseEventHandler as BaseEventHandler
 from gllm_core.event.hook.event_hook import BaseEventHook as BaseEventHook
 from gllm_core.schema import Event as Event
 from gllm_core.utils import validate_string_enum as validate_string_enum
-from typing import Any, AsyncGenerator
+from typing import AsyncGenerator
 
 class EventEmitter:
     '''Handles events emitting using event handlers with various levels and types.
@@ -123,31 +123,19 @@ class EventEmitter:
         Returns:
             EventEmitter: A new instance of the EventEmitter class with a single StreamEventHandler.
         """
-    async def emit(self, value: str | dict[str, Any] | Event, event_level: EventLevel = ..., event_type: str = ..., metadata: dict[str, Any] | None = None, event_id: str | None = None, disabled_handlers: list[str] | None = None) -> None:
-        '''Emits an event using the configured event handlers.
+    async def emit(self, event: Event, disabled_handlers: list[str] | None = None) -> None:
+        """Emits an event using the configured event handlers.
 
-        If the value is an Event object, it is used directly and other parameters are ignored.
-        Otherwise, a new Event object is created with the provided parameters. The event is
-        then passed to all handlers except those listed in disabled_handlers. Events are only
-        processed if their severity level meets or exceeds the EventEmitter\'s configured level.
+        Events are emitted by passing them to all handlers except those listed in disabled_handlers.
+        Events are only processed if their severity level meets or exceeds the EventEmitter's configured level.
 
         Args:
-            value (str | dict[str, Any] | Event): The event value or Event object to emit. If an Event object
-                is provided, other parameters are ignored and the Event is used as-is.
-            event_level (EventLevel, optional): The severity level of the event.
-                Defaults to EventLevel.DEBUG.
-            event_type (str, optional): The type of event (e.g., "status", "response").
-                Defaults to EventType.STATUS.value.
-            metadata (dict[str, Any] | None, optional): Additional metadata for the event.
-                Defaults to None, which creates an empty dictionary.
-            event_id (str | None, optional): Unique identifier for the event.
-                Defaults to None, which creates an empty string.
-            disabled_handlers (list[str] | None, optional): Names of handlers to skip for
-                this event. Defaults to None.
+            event (Event): The event to emit.
+            disabled_handlers (list[str] | None, optional): Names of handlers to skip for this event. Defaults to None.
 
         Raises:
             ValueError: If the provided event_level is not a valid EventLevel.
-        '''
+        """
     async def close(self) -> None:
         """Closes all handlers in the handler list.
 

gllm_core/event/handler/console_event_handler.pyi

@@ -1,5 +1,4 @@
 from _typeshed import Incomplete
-from gllm_core.constants import EventType as EventType
 from gllm_core.event.handler.event_handler import BaseEventHandler as BaseEventHandler
 from gllm_core.schema import Event as Event
 

gllm_core/event/handler/print_event_handler.pyi

@@ -15,7 +15,7 @@ class PrintEventHandler(BaseEventHandler):
     """
     padding_char: Incomplete
     console: Incomplete
-    def __init__(self, name: str | None = None, color_map: dict[str, str] | None = None, padding_char: str = '=', separator_length: int | None = None) -> None:
+    def __init__(self, name: str | None = None, color_map: dict[str, str] | None = None, padding_char: str = '=') -> None:
         '''Initializes a new instance of the PrintEventHandler class.
 
         Args:
@@ -24,7 +24,6 @@ class PrintEventHandler(BaseEventHandler):
             color_map (dict[str, str], optional): The dictionary that maps certain event types to their corresponding
                 colors in Rich format. Defaults to None, in which case the default color map will be used.
             padding_char (str, optional): The character to use for padding. Defaults to "=".
-            separator_length (int | None, optional): Deprecated parameter. Defaults to None.
         '''
     async def emit(self, event: Event) -> None:
         """Emits the given event.

gllm_core/schema/__init__.pyi

@@ -1,6 +1,6 @@
 from gllm_core.schema.chunk import Chunk as Chunk
-from gllm_core.schema.component import Component as Component
+from gllm_core.schema.component import Component as Component, main as main
 from gllm_core.schema.event import Event as Event
 from gllm_core.schema.tool import Tool as Tool, tool as tool
 
-__all__ = ['Chunk', 'Component', 'Event', 'Tool', 'tool']
+__all__ = ['Chunk', 'Component', 'Event', 'Tool', 'main', 'tool']

gllm_core/schema/component.pyi

@@ -1,26 +1,71 @@
-import abc
-from abc import ABC
 from gllm_core.event.event_emitter import EventEmitter as EventEmitter
+from gllm_core.schema.schema_generator import generate_params_model as generate_params_model
+from gllm_core.schema.tool import Tool as Tool, tool as tool
 from gllm_core.utils import BinaryHandlingStrategy as BinaryHandlingStrategy, binary_handler_factory as binary_handler_factory
-from gllm_core.utils.analyzer import MethodSignature as MethodSignature, ParameterInfo as ParameterInfo, ParameterKind as ParameterKind, RunAnalyzer as RunAnalyzer, RunProfile as RunProfile
+from gllm_core.utils.analyzer import MethodSignature as MethodSignature, ParameterInfo as ParameterInfo, ParameterKind as ParameterKind, RunProfile as RunProfile, analyze_method as analyze_method
 from gllm_core.utils.logger_manager import LoggerManager as LoggerManager
-from typing import Any
+from gllm_core.utils.main_method_resolver import MainMethodResolver as MainMethodResolver
+from pydantic import BaseModel as BaseModel
+from typing import Any, Callable
 
-class Component(ABC, metaclass=abc.ABCMeta):
+def main(method: Callable) -> Callable:
+    """Decorate a Component method as the async main entrypoint.
+
+    Usage:
+        Declare the coroutine that should act as the primary execution path
+        for a `Component` subclass. The decorated coroutine will be resolved by
+        `Component.run()` unless another subclass overrides the decoration.
+
+    Args:
+        method (Callable): Coroutine to mark as the main entrypoint.
+
+    Returns:
+        Callable: The same coroutine that is passed to the decorator. The decorator only marks the method as the main
+            entrypoint. It does not wrap or change its behavior or signature.
+
+    Raises:
+        TypeError: If the decorated callable is not asynchronous.
+    """
+
+class Component:
     '''An abstract base class for all components used throughout the Gen AI applications.
 
     Every instance of Component has access to class-level `_default_log_level` and `_logger`, as detailed below.
     For components that require high observability, it is recommended to set `_default_log_level` to `logging.INFO`
     or higher.
 
-    Example:
-    ```python
-    class MyComponent(Component):
-        _default_log_level = logging.INFO
+    Defining Custom Components:
+        There are two ways to define the main execution logic for a component:
+
+        1. **Using the @main decorator (Recommended)**:
+           Decorate an async method with `@main` to mark it as the primary entrypoint.
+           This is the preferred approach as it provides explicit control over the main method.
+
+           ```python
+           class MyComponent(Component):
+               _default_log_level = logging.INFO
+
+               @main
+               async def execute(self, **kwargs: Any) -> Any:
+                   return "Hello from @main!"
+           ```
+
+        2. **Implementing _run method (Deprecated)**:
+           Override the abstract `_run` method. This is the traditional approach and still supported.
+
+           ```python
+           class MyComponent(Component):
+               _default_log_level = logging.INFO
 
-        def _run(self, **kwargs: Any) -> Any:
-            return "Hello, World!"
-    ```
+               async def _run(self, **kwargs: Any) -> Any:
+                   return "Hello, World!"
+           ```
+
+        The `run()` method resolves the main entrypoint using the following precedence:
+        1. Method decorated with @main in the current class.
+        2. Method decorated with @main in the nearest ancestor class.
+        3. Method named in __main_method__ property.
+        4. The _run method (with deprecation warning).
 
     Attributes:
         run_profile (RunProfile): The profile of the `_run` method.
@@ -31,21 +76,122 @@ class Component(ABC, metaclass=abc.ABCMeta):
             **Do not override this property in your subclass.**
 
             You also do not need to write this attribute in your component\'s docstring.
-        _default_log_level (int): The default log level for the component. Defaults to DEBUG.
-        _logger (logging.Logger): The logger instance for the component.
     '''
+    def __init_subclass__(cls, **kwargs) -> None:
+        """Hook called when a subclass is created.
+
+        This validates the __main_method__ property and checks for multiple @main decorators
+        within the current class definition. Uses MainMethodResolver for consistent validation logic.
+
+        Note: Multiple inheritance conflicts are intentionally deferred to runtime (get_main())
+        to allow class definition to succeed.
+
+        Raises:
+            AttributeError: If __main_method__ refers to a non-existent method.
+            TypeError: If multiple methods are decorated with @main in the same class.
+        """
+    @classmethod
+    def get_main(cls) -> Callable | None:
+        """Return the resolved main coroutine for this Component class.
+
+        This method resolves the main method for the Component class following
+        the precedence rules:
+        1. Most derived coroutine decorated with `@main`.
+        2. Method named by `__main_method__`.
+        3. `_run` coroutine as a deprecated fallback.
+
+        Results are cached for performance.
+
+        Returns:
+            Callable | None: The coroutine that will be executed by `run()` or
+                `None` when no entrypoint can be determined.
+
+        Raises:
+            TypeError: If conflicting main methods are inherited from multiple ancestors.
+        """
+    @property
+    def input_params(self) -> type[BaseModel] | None:
+        '''Return the Pydantic model describing this component\'s main method input parameters.
+
+        Returns:
+            type[BaseModel] | None: The cached model that mirrors the signature of
+                the resolved main method, or `None` if no main method can be
+                determined.
+
+        Examples:
+            ```python
+            from pydantic import ValidationError
+
+            component = SomeComponent()
+            ParamsModel = component.input_params
+            assert ParamsModel.__name__ == "SomeComponentParams"
+            fields = list(ParamsModel.model_fields)
+
+            # Validation with valid params
+            params = ParamsModel(text="hello")
+
+            # Validation catches missing required fields
+            try:
+                invalid_params = ParamsModel()  # Missing required \'text\' field
+            except ValidationError as e:
+                print(f"Validation failed: {e.error_count()} errors")
+
+            # Argument construction
+            payload = params.model_dump()
+            result = await component.run(**payload)
+            ```
+        '''
     async def run(self, **kwargs: Any) -> Any:
         """Runs the operations defined for the component.
 
-        This method emits the provided input arguments using an EventEmitter instance if available, executes a process
-        defined in the `_run` method, and emits the resulting output if the EventEmitter is provided.
+        This method emits the provided input arguments using an EventEmitter instance if available, executes the
+        resolved main method, and emits the resulting output if the EventEmitter is provided.
+
+        The main method is resolved using the following precedence:
+        1. Method decorated with @main in the current class.
+        2. Method decorated with @main in the nearest ancestor class.
+        3. Method named in __main_method__ property.
+        4. The _run method (with deprecation warning).
 
         Args:
             **kwargs (Any): A dictionary of arguments to be processed. May include an `event_emitter`
                 key with an EventEmitter instance.
 
         Returns:
-            Any: The result of the `_run` method.
+            Any: The result of the resolved main method.
+
+        Raises:
+            TypeError: If conflicting main methods are inherited from multiple ancestors.
+            AttributeError: If __main_method__ refers to a non-existent method.
+        """
+    def as_tool(self, name: str | None = None, description: str | None = None, title: str | None = None) -> Tool:
+        """Convert the component's main method into a `Tool` instance.
+
+        Example:
+            ```python
+            from gllm_core.schema import Component, main
+
+            class MyComponent(Component):
+                @main
+                async def my_method(self, param: str) -> str:
+                    return param
+
+            component = MyComponent()
+            tool = component.as_tool()
+            ```
+
+        Args:
+            name (str | None, optional): Identifier for the resulting tool. Defaults to the component class name.
+            description (str | None, optional): Summary of the tool's behavior. Defaults to None, in which case the
+                main method's docstring is used.
+            title (str | None, optional): Optional display title for the tool. Defaults to None, in which case the
+                component's class name is used.
+
+        Returns:
+            Tool: The tool wrapping the component's main method.
+
+        Raises:
+            RuntimeError: If the component does not declare a main method using @main or __main_method__.
         """
     @property
     def run_profile(self) -> RunProfile:

gllm_core/schema/schema_generator.pyi

@@ -0,0 +1,35 @@
+from gllm_core.utils.analyzer import analyze_method as analyze_method
+from pydantic import BaseModel as BaseModel
+from typing import Callable
+
+def generate_params_model(method: Callable, class_name: str) -> type[BaseModel]:
+    '''Generate a Pydantic model representing a component method signature.
+
+    The generated class is named `{class_name}Params` and contains one field for
+    every parameter in `method`. The first `self` parameter is ignored, `*args` are
+    skipped entirely, and `**kwargs` trigger `extra="allow"` to permit arbitrary
+    keyword arguments at runtime.
+
+    For legacy `_run` methods with only `**kwargs`, this function will use
+    RunAnalyzer to infer parameters from the method body usage patterns.
+
+    Args:
+        method (Callable): Method whose signature should be represented.
+        class_name (str): Component class name used to derive the generated model name.
+
+    Returns:
+        type[BaseModel]: A Pydantic `BaseModel` subclass describing the method\'s
+            parameters.
+
+    Example:
+        ```python
+        class_name = "TextProcessor"
+
+        def process(self, text: str, count: int = 5) -> str:
+            return text * count
+
+        Model = generate_params_model(process, class_name)
+        assert Model.__name__ == "TextProcessorParams"
+        assert Model(text="hello", count=2).model_dump() == {"text": "hello", "count": 2}
+        ```
+    '''

gllm_core/schema/tool.pyi

@@ -110,6 +110,27 @@ class Tool(BaseModel):
     is_async: bool
     model_config: Incomplete
     @classmethod
+    def from_langchain(cls, langchain_tool: Any) -> Tool:
+        """Create a Tool from a LangChain tool instance.
+
+        Args:
+            langchain_tool (Any): LangChain tool implementation to convert.
+
+        Returns:
+            Tool: Tool instance derived from the LangChain representation.
+        """
+    @classmethod
+    def from_google_adk(cls, function_declaration: Any, func: Callable | None = None) -> Tool:
+        """Create a Tool from a Google ADK function declaration.
+
+        Args:
+            function_declaration (Any): Google ADK function declaration to convert.
+            func (Callable | None): Optional implementation callable for the tool.
+
+        Returns:
+            Tool: Tool instance derived from the Google ADK definition.
+        """
+    @classmethod
     def validate_input_schema(cls, v: Any):
         """Validate and convert input_schema to JSON Schema dict if it's a Pydantic model.
 

gllm_core/utils/__init__.pyi

@@ -5,8 +5,9 @@ from gllm_core.utils.concurrency import asyncify as asyncify, get_default_portal
 from gllm_core.utils.event_formatter import format_chunk_message as format_chunk_message, get_placeholder_keys as get_placeholder_keys
 from gllm_core.utils.google_sheets import load_gsheets as load_gsheets
 from gllm_core.utils.logger_manager import LoggerManager as LoggerManager
+from gllm_core.utils.main_method_resolver import MainMethodResolver as MainMethodResolver
 from gllm_core.utils.merger_method import MergerMethod as MergerMethod
 from gllm_core.utils.retry import RetryConfig as RetryConfig, retry as retry
 from gllm_core.utils.validation import validate_string_enum as validate_string_enum
 
-__all__ = ['BinaryHandlingStrategy', 'ChunkMetadataMerger', 'LoggerManager', 'MergerMethod', 'RunAnalyzer', 'RetryConfig', 'asyncify', 'get_default_portal', 'binary_handler_factory', 'format_chunk_message', 'get_placeholder_keys', 'load_gsheets', 'syncify', 'retry', 'validate_string_enum']
+__all__ = ['BinaryHandlingStrategy', 'ChunkMetadataMerger', 'LoggerManager', 'MainMethodResolver', 'MergerMethod', 'RunAnalyzer', 'RetryConfig', 'asyncify', 'get_default_portal', 'binary_handler_factory', 'format_chunk_message', 'get_placeholder_keys', 'load_gsheets', 'syncify', 'retry', 'validate_string_enum']

gllm_core/utils/analyzer.pyi

@@ -2,7 +2,7 @@ import ast
 from _typeshed import Incomplete
 from enum import StrEnum
 from pydantic import BaseModel
-from typing import Any
+from typing import Any, Callable
 
 class ParameterKind(StrEnum):
     """Enum representing the different kinds of parameters a method can have."""
@@ -107,3 +107,17 @@ class RunAnalyzer(ast.NodeVisitor):
         Args:
             node (ast.Subscript): The Subscript node to visit.
         '''
+
+def analyze_method(cls, method: Callable) -> RunProfile:
+    """Analyze a method using RunAnalyzer.
+
+    This function encapsulates the common analysis logic used by both
+    Component._analyze_run_method() and schema_generator._generate_from_analyzer().
+
+    Args:
+        cls (type): The class containing the method (for analyzer context).
+        method (Callable): The method to analyze.
+
+    Returns:
+        RunProfile: The analysis results.
+    """

gllm_core/utils/logger_manager.pyi

@@ -9,6 +9,8 @@ DEFAULT_DATE_FORMAT: str
 TEXT_COLOR_MAP: Incomplete
 LOG_FORMAT_KEY: str
 RICH_CLOSE_TAG: str
+JSON_LOG_FIELDS: Incomplete
+JSON_ERROR_FIELDS_MAP: Incomplete
 
 class TextRichHandler(RichHandler):
     """Custom RichHandler that applies specific colors and log format."""

gllm_core/utils/main_method_resolver.pyi

@@ -0,0 +1,54 @@
+from _typeshed import Incomplete
+from gllm_core.utils.logger_manager import LoggerManager as LoggerManager
+from typing import Callable
+
+class MainMethodResolver:
+    """Resolves the main entrypoint method for Component classes.
+
+    This resolver implements the precedence rules for determining which method
+    should be used as the main entrypoint:
+    1. Method decorated with @main in the most derived class.
+    2. Method named by __main_method__ property.
+    3. _run method (with deprecation warning).
+
+    Attributes:
+        cls (type): The Component class to resolve the main method for.
+    """
+    cls: Incomplete
+    def __init__(self, component_class: type) -> None:
+        """Initialize the resolver with a Component class.
+
+        Args:
+            component_class (type): The Component class to resolve the main method for.
+        """
+    @staticmethod
+    def validate_class(component_class: type) -> None:
+        """Validate main method configuration at class definition time.
+
+        This performs early validation that can be done when a Component subclass
+        is defined, before any instances are created or methods are called.
+
+        Validations performed:
+        1. Check that __main_method__ property points to an existing method
+        2. Check that only one @main decorator is used within the same class
+
+        Note: Multiple inheritance conflicts are intentionally NOT checked here,
+        as they are deferred to runtime (get_main()) to allow class definition
+        to succeed.
+
+        Args:
+            component_class (type): The Component class to validate.
+
+        Raises:
+            AttributeError: If __main_method__ refers to a non-existent method.
+            TypeError: If multiple methods are decorated with @main in the same class.
+        """
+    def resolve(self) -> Callable | None:
+        """Resolve the main method following precedence rules.
+
+        Returns:
+            Callable | None: The resolved main method, or None if not found.
+
+        Raises:
+            TypeError: If conflicting main methods are inherited from multiple ancestors.
+        """

gllm_core/utils/retry.pyi

@@ -1,7 +1,8 @@
 from _typeshed import Incomplete
 from gllm_core.utils import LoggerManager as LoggerManager
+from gllm_core.utils.concurrency import syncify as syncify
 from pydantic import BaseModel
-from typing import Any, Callable, TypeVar
+from typing import Any, Callable, TypeVar, overload
 
 logger: Incomplete
 T = TypeVar('T')
@@ -14,7 +15,6 @@ class RetryConfig(BaseModel):
         max_retries (int): Maximum number of retry attempts.
         base_delay (float): Base delay in seconds between retries.
         max_delay (float): Maximum delay in seconds between retries.
-        exponential_base (float): Base for exponential backoff. Deprecated and will be removed in v0.4.
         jitter (bool): Whether to add random jitter to delays.
         timeout (float | None): Overall timeout in seconds for the entire operation. If None, timeout is disabled.
         retry_on_exceptions (tuple[type[Exception], ...]): Tuple of exception types to retry on.
@@ -22,7 +22,6 @@ class RetryConfig(BaseModel):
     max_retries: int
     base_delay: float
     max_delay: float
-    exponential_base: float
     jitter: bool
     timeout: float | None
     retry_on_exceptions: tuple[type[Exception], ...]
@@ -36,29 +35,7 @@ class RetryConfig(BaseModel):
             ValueError: If max_delay is less than base_delay.
         """
 
-async def retry(func: Callable[..., Any], *args: Any, retry_config: RetryConfig | None = None, **kwargs: Any) -> T:
-    """Executes a function with retry logic and exponential backoff.
-
-    This function executes the provided function with retry logic. It will first try to execute the function once.
-    If the function raises an exception that matches the retry_on_exceptions, it will retry up to max_retries times
-    with exponential backoff. Therefore, the max number of attempts is max_retries + 1. If provided, the timeout
-    applies to the entire retry operation, including all attempts and delays.
-
-    Example:
-        If you set timeout=10.0 and max_retries=3, the entire retry operation (including all attempts
-        and delays) will timeout after 10 seconds, not 10 seconds per attempt.
-
-    Args:
-        func (Callable[..., Any]): The function to execute.
-        *args (Any): Positional arguments to pass to the function.
-        retry_config (RetryConfig | None, optional): Retry configuration. If None, uses default config.
-            Defaults to None.
-        **kwargs (Any): Keyword arguments to pass to the function.
-
-    Returns:
-        T: The result of the function execution.
-
-    Raises:
-        Exception: The last exception raised by the function if all retries are exhausted.
-        asyncio.TimeoutError: If the overall timeout is exceeded.
-    """
+@overload
+async def retry(func: Callable[..., Any], *args: Any, retry_config: RetryConfig | None = None, **kwargs: Any) -> T: ...
+@overload
+def retry(config: RetryConfig | None = None) -> Callable[[Callable[..., Any]], Callable[..., Any]]: ...

gllm_core.pyi

@@ -9,36 +9,38 @@ __name__ = ...
 
 # Modules used internally, to allow implicit dependencies to be seen:
 import os
-import enum
-import datetime
+import gllm_core.adapters.tool.from_google_function
+import gllm_core.adapters.tool.from_langchain_tool
+import asyncio
 import typing
+import enum
 import gllm_core.event.handler.ConsoleEventHandler
 import gllm_core.event.handler.PrintEventHandler
 import gllm_core.event.handler.StreamEventHandler
 import gllm_core.schema.Event
 import gllm_core.utils.validate_string_enum
-import json
 import rich
 import rich.console
 import abc
 import gllm_core.utils.LoggerManager
 import rich.panel
 import rich.style
-import asyncio
+import json
 import gllm_core.event.EventEmitter
 import gllm_core.schema.Component
 import gllm_core.utils.get_placeholder_keys
 import uuid
 import pydantic
 import __future__
-import ast
 import inspect
 import logging
-import textwrap
 import warnings
 import functools
 import traceback
 import gllm_core.utils.BinaryHandlingStrategy
+import datetime
+import ast
+import textwrap
 import base64
 import atexit
 import threading

{gllm_core_binary-0.3.26.dist-info → gllm_core_binary-0.4.4b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gllm-core-binary
-Version: 0.3.26
+Version: 0.4.4b3
 Summary: A library containing core components for Gen AI applications.
 Author-email: Dimitrij Ray <dimitrij.ray@gdplabs.id>, Henry Wicaksono <henry.wicaksono@gdplabs.id>, Resti Febriana <resti.febriana@gdplabs.id>
 Requires-Python: <3.14,>=3.11
@@ -27,6 +27,11 @@ Requires-Dist: pytest<9.0.0,>=8.1.1; extra == "dev"
 Requires-Dist: pytest-asyncio<1.0.0,>=0.23.6; extra == "dev"
 Requires-Dist: pytest-cov<6.0.0,>=5.0.0; extra == "dev"
 Requires-Dist: ruff<1.0.0,>=0.6.7; extra == "dev"
+Provides-Extra: langchain
+Requires-Dist: langchain-core<1.0.0,>=0.3.0; extra == "langchain"
+Provides-Extra: google-adk
+Requires-Dist: google-adk<2.0.0,>=1.0.0; extra == "google-adk"
+Requires-Dist: starlette<1.0.0,>=0.49.0; extra == "google-adk"
 
 # GLLM Core
 

gllm_core_binary-0.4.4b3.dist-info/RECORD

@@ -0,0 +1,44 @@
+gllm_core.cp311-win_amd64.pyd,sha256=4mjl0j8qNOrS45QQgXqBpIhQwiReUSdt4dKp3ujhBdQ,1234944
+gllm_core.pyi,sha256=n1D4ZCjhQUKv7qxTYLWh-afK6ECPZCddwckzt6afO2w,1446
+gllm_core/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gllm_core/constants.pyi,sha256=9M5UxEkdttu4fSJTLxhjt7q1xTRYbjTFheM5EjQ5Bs4,904
+gllm_core/adapters/__init__.pyi,sha256=N8JBGr2mPUMAGaMd__7XxGr2NAzfaFMuNH15QkSfbrA,187
+gllm_core/adapters/tool/__init__.pyi,sha256=zRmMo1ilDaYF-cErfkQqy8zGnArHebdWmox-P34_7fI,244
+gllm_core/adapters/tool/google_adk.pyi,sha256=0awaKRXmmK5NiAP9vNNYjMARDPWfWyQqy29k3WHoX2s,953
+gllm_core/adapters/tool/langchain.pyi,sha256=LBqox8xFm6jSxPfBEftJr_zUmXwPk_qHNwU3bZaphhE,855
+gllm_core/event/__init__.pyi,sha256=HVs5C80lFzVEH7mO8KJTUqEPi_7KyPvNeMLuoG-hDeE,177
+gllm_core/event/event_emitter.pyi,sha256=dzhlOGnA2h5-OSRZHt-AJ-THul-rDUatfwr6dyYzYu8,7297
+gllm_core/event/messenger.pyi,sha256=8Nvra-a7RqnfX0PAtm-Of5M8CvsYr0L_1k3HgdNCR5I,3190
+gllm_core/event/handler/__init__.pyi,sha256=gZ21Fjjog3-e3-_Xv5sTpX9_Mx8X2LUzTrqp_tPisCg,377
+gllm_core/event/handler/console_event_handler.pyi,sha256=eCv0SaZEpbu8W2jQPLnWwXNzhGOSM5KAtDVUYfvlvMs,1494
+gllm_core/event/handler/event_handler.pyi,sha256=chEYnw3Rp9Lk3Cz4dSn6EVlzje4BG-SlM82J-4UE5Hw,2153
+gllm_core/event/handler/print_event_handler.pyi,sha256=D_xNtpcBsGl7NVSCvFKEGvaUqfMTxPaQV8zXECwmZ2Q,1674
+gllm_core/event/handler/stream_event_handler.pyi,sha256=5faGSFQLBN7XMqd4nIfGkdTBI_ALVaE-fmxVAjzca9w,2908
+gllm_core/event/hook/__init__.pyi,sha256=gSDHYl0yi00zHHMRvU_Eg8qLqsGHESTvoNE3MXig-g0,149
+gllm_core/event/hook/event_hook.pyi,sha256=rMatofdNAwHI65ya_7-q3NAfmTuKhc2WkXeiGPAvcKI,600
+gllm_core/event/hook/json_stringify_event_hook.pyi,sha256=I-QxbaLc4rEyqhW_f4INN5UxBg_ZofHHN1HQKfPJ7rs,585
+gllm_core/schema/__init__.pyi,sha256=X7Gv3xgtl4Ylzsg9iuGgjJPkQey7OdvvIC_X1e5_LAI,310
+gllm_core/schema/chunk.pyi,sha256=ZVYQitMtvMStiFssnTCgtSIcj30VSsK2dKscSysl3R4,2378
+gllm_core/schema/component.pyi,sha256=fghUD8QJRXjjUT2jn64dkM_KjMv6MV9OAQUXjc7xsD0,9164
+gllm_core/schema/event.pyi,sha256=Yd74uSWhIO1lx0_p70rYt-LMz4FZHbbbqJP7xhVh_pY,1335
+gllm_core/schema/schema_generator.pyi,sha256=ToadC6UKEq35k32wUK1VaMKiICRtENXUYdAQOMlTg3U,1445
+gllm_core/schema/tool.pyi,sha256=T5TufJZPYUzYoSPZBX0FkqgZ9u03VAIsZdwvY1PS7nw,8848
+gllm_core/utils/__init__.pyi,sha256=ZFilGPXXqc2JGwy8AV8N7pf6zmtd9clzuk310PIGkBs,1359
+gllm_core/utils/analyzer.pyi,sha256=M48PRor76L5eAQBpSqpv3EkZ4kU1t5Zm3CPFd34dxWM,4470
+gllm_core/utils/binary_handler_factory.pyi,sha256=imcuCL2oa-7uwTnC_vI-_KvE1hGu1-5U4ZiF5fShDmQ,1739
+gllm_core/utils/chunk_metadata_merger.pyi,sha256=J1lHTFV-0IiC6xKzzC7x1D1wBoki249muEU2HrF6C58,2317
+gllm_core/utils/concurrency.pyi,sha256=n_Mb9D_2hJAQ7VSwDBxhgmDv7hyFRKevDlhcHoAjvyA,3959
+gllm_core/utils/event_formatter.pyi,sha256=ocQ_Ev_XorRhLzj0c2szlclz8V3_Ysbg6qHmjhmur3k,1375
+gllm_core/utils/google_sheets.pyi,sha256=IjKdc7H3hBLAp8I8jxnwDfKP79D1EIBIRQKKFTUNqjM,939
+gllm_core/utils/imports.pyi,sha256=-KM0pyw7yFVCUZjHjoNBRFgEnI8hlr0pquKuhcA2X9M,2196
+gllm_core/utils/logger_manager.pyi,sha256=IDRgA-5jRDu4miO5Ru_tFJHql2JlHdr1GvZdmdS9Sg8,7159
+gllm_core/utils/main_method_resolver.pyi,sha256=dHozSqFMwCyVorQ0ZE9N-c2V4PkpF8FdU1VGGPvTjK4,2178
+gllm_core/utils/merger_method.pyi,sha256=JsgHnO47cqenqNxCrHqhAR-nnR_dEqE-7wprVrd8ZFg,1868
+gllm_core/utils/retry.pyi,sha256=KxlPzURzZfCSgKC44v98nR2bqamzHqtbRuXLDEuX29c,1614
+gllm_core/utils/similarity.pyi,sha256=HmSxE5VfPwYZYih_bSIz8QRDbkouO_jij-FX6TSCEdM,439
+gllm_core/utils/validation.pyi,sha256=-RdMmb8afH7F7q4Ao7x6FbwaDfxUHn3hA3WiOgzB-3s,397
+gllm_core.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
+gllm_core_binary-0.4.4b3.dist-info/METADATA,sha256=twBMLynLeu3Z9RMIH4bBPynGtO4JBYoKxFvBo9H3s0Y,4681
+gllm_core_binary-0.4.4b3.dist-info/WHEEL,sha256=l2aKBREYfqJ7T2ljmr6hUiXPoNvvXF47bG4IHjuSyS4,96
+gllm_core_binary-0.4.4b3.dist-info/top_level.txt,sha256=UYoTGvK_Yec95-_QUuVCKEr6PUXb5Lc7Dr-x8SeX9uM,10
+gllm_core_binary-0.4.4b3.dist-info/RECORD,,

gllm_core_binary-0.3.26.dist-info/RECORD

@@ -1,38 +0,0 @@
-gllm_core.cp311-win_amd64.pyd,sha256=Yk3AMBvaZT6sWLfpD9w4-GnGV2RNGZv-azacDll2nhQ,1100288
-gllm_core.pyi,sha256=uFfH-UIH_BzQ6ZGcsg0-Yf6HN-hjUpbCzOjXoURo8Is,1343
-gllm_core/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gllm_core/constants.pyi,sha256=p7-Sr-sNmjv6mboGJmALDd3UtTZ4y0m_gmUXIBbAzBk,923
-gllm_core/event/__init__.pyi,sha256=HVs5C80lFzVEH7mO8KJTUqEPi_7KyPvNeMLuoG-hDeE,177
-gllm_core/event/event_emitter.pyi,sha256=7WcK-SV4xVwh48rsc-gt_41J8qksBTxbWSWfnr85dYk,8386
-gllm_core/event/messenger.pyi,sha256=8Nvra-a7RqnfX0PAtm-Of5M8CvsYr0L_1k3HgdNCR5I,3190
-gllm_core/event/handler/__init__.pyi,sha256=gZ21Fjjog3-e3-_Xv5sTpX9_Mx8X2LUzTrqp_tPisCg,377
-gllm_core/event/handler/console_event_handler.pyi,sha256=h3Dpj6-UeZnKUm7iFFOmRWk8k2Hw6YsvP28FUWYjU4U,1550
-gllm_core/event/handler/event_handler.pyi,sha256=chEYnw3Rp9Lk3Cz4dSn6EVlzje4BG-SlM82J-4UE5Hw,2153
-gllm_core/event/handler/print_event_handler.pyi,sha256=Z34M73brc4eaDLDt_nmdo638qsyUVuuMLyIJ0PdBt6c,1805
-gllm_core/event/handler/stream_event_handler.pyi,sha256=5faGSFQLBN7XMqd4nIfGkdTBI_ALVaE-fmxVAjzca9w,2908
-gllm_core/event/hook/__init__.pyi,sha256=gSDHYl0yi00zHHMRvU_Eg8qLqsGHESTvoNE3MXig-g0,149
-gllm_core/event/hook/event_hook.pyi,sha256=rMatofdNAwHI65ya_7-q3NAfmTuKhc2WkXeiGPAvcKI,600
-gllm_core/event/hook/json_stringify_event_hook.pyi,sha256=I-QxbaLc4rEyqhW_f4INN5UxBg_ZofHHN1HQKfPJ7rs,585
-gllm_core/schema/__init__.pyi,sha256=oqfGtlLWbWJmHiKXA9Yfz1HoEpMRqStnxwNaRRIb2Vw,288
-gllm_core/schema/chunk.pyi,sha256=ZVYQitMtvMStiFssnTCgtSIcj30VSsK2dKscSysl3R4,2378
-gllm_core/schema/component.pyi,sha256=3eJs3KlLdsJ5vMebwvBRGappUZ43tmdMtl2mQpSob7k,2843
-gllm_core/schema/event.pyi,sha256=Yd74uSWhIO1lx0_p70rYt-LMz4FZHbbbqJP7xhVh_pY,1335
-gllm_core/schema/tool.pyi,sha256=miqqYG0XtNY4p7UCYRS1-A23FY9wq_LZ6RvbcgGIyNQ,8038
-gllm_core/utils/__init__.pyi,sha256=U13s25K_edFp2WoCHfB0NyTROXvnP62P5A2YRukSIhs,1246
-gllm_core/utils/analyzer.pyi,sha256=M7_KYdBqz5S5fEPvnd49e6ij01dOvJD-k7amAlvRwNQ,3989
-gllm_core/utils/binary_handler_factory.pyi,sha256=imcuCL2oa-7uwTnC_vI-_KvE1hGu1-5U4ZiF5fShDmQ,1739
-gllm_core/utils/chunk_metadata_merger.pyi,sha256=J1lHTFV-0IiC6xKzzC7x1D1wBoki249muEU2HrF6C58,2317
-gllm_core/utils/concurrency.pyi,sha256=n_Mb9D_2hJAQ7VSwDBxhgmDv7hyFRKevDlhcHoAjvyA,3959
-gllm_core/utils/event_formatter.pyi,sha256=ocQ_Ev_XorRhLzj0c2szlclz8V3_Ysbg6qHmjhmur3k,1375
-gllm_core/utils/google_sheets.pyi,sha256=IjKdc7H3hBLAp8I8jxnwDfKP79D1EIBIRQKKFTUNqjM,939
-gllm_core/utils/imports.pyi,sha256=-KM0pyw7yFVCUZjHjoNBRFgEnI8hlr0pquKuhcA2X9M,2196
-gllm_core/utils/logger_manager.pyi,sha256=pOXREtzMuLpWRl2-IwmPc6Kk3RCmB8Se5laX3MQhqls,7095
-gllm_core/utils/merger_method.pyi,sha256=JsgHnO47cqenqNxCrHqhAR-nnR_dEqE-7wprVrd8ZFg,1868
-gllm_core/utils/retry.pyi,sha256=2RcG5C9xQS2nCSWBmtsOfKgIk5mVXHmYBrXrqStvsrI,2839
-gllm_core/utils/similarity.pyi,sha256=HmSxE5VfPwYZYih_bSIz8QRDbkouO_jij-FX6TSCEdM,439
-gllm_core/utils/validation.pyi,sha256=-RdMmb8afH7F7q4Ao7x6FbwaDfxUHn3hA3WiOgzB-3s,397
-gllm_core.build/.gitignore,sha256=aEiIwOuxfzdCmLZe4oB1JsBmCUxwG8x-u-HBCV9JT8E,1
-gllm_core_binary-0.3.26.dist-info/METADATA,sha256=d90BKKtLhS4qjcIPXtqAcDTt_RcFuGgCz0aHH_q1LOQ,4430
-gllm_core_binary-0.3.26.dist-info/WHEEL,sha256=l2aKBREYfqJ7T2ljmr6hUiXPoNvvXF47bG4IHjuSyS4,96
-gllm_core_binary-0.3.26.dist-info/top_level.txt,sha256=UYoTGvK_Yec95-_QUuVCKEr6PUXb5Lc7Dr-x8SeX9uM,10
-gllm_core_binary-0.3.26.dist-info/RECORD,,