gllm-core-binary 0.3.23b3__py3-none-any.whl → 0.4.2b1__py3-none-any.whl

gllm_core/adapters/__init__.py

@@ -0,0 +1,5 @@
+"""Adapters for external formats."""
+
+from gllm_core.adapters.tool import from_google_function, from_langchain_tool
+
+__all__ = ["from_google_function", "from_langchain_tool"]

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__.py

@@ -0,0 +1,6 @@
+"""Tool adapters for external formats."""
+
+from gllm_core.adapters.tool.google_adk import from_google_function
+from gllm_core.adapters.tool.langchain import from_langchain_tool
+
+__all__ = ["from_langchain_tool", "from_google_function"]

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.py

@@ -0,0 +1,91 @@
+"""Google ADK tool adapter conversions.
+
+Authors:
+    Dimitrij Ray (dimitrij.ray@gdplabs.id)
+
+References:
+    NONE
+"""
+
+import asyncio
+from typing import Any, Callable
+
+from gllm_core.schema.tool import Tool
+
+_DEFAULT_SCHEMA: dict[str, Any] = {"type": "object", "properties": {}}
+
+
+def _validate_and_extract_schema(parameters: Any) -> dict[str, Any]:
+    """Validate and extract the input schema from Google ADK parameters.
+
+    Args:
+        parameters (Any): The parameters from the Google ADK function declaration.
+
+    Returns:
+        dict[str, Any]: The validated input schema.
+
+    Raises:
+        TypeError: If the schema has invalid structure.
+    """
+    if parameters is None:
+        return _DEFAULT_SCHEMA.copy()
+
+    if isinstance(parameters, dict):
+        if "properties" in parameters and not isinstance(parameters.get("properties"), dict):
+            raise TypeError("Google ADK function schema 'properties' must be a dictionary.")
+        return parameters
+
+    return dict(parameters) if hasattr(parameters, "__iter__") else _DEFAULT_SCHEMA.copy()
+
+
+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.
+    """
+    if function_declaration is None:
+        raise ValueError("Google ADK function declaration cannot be None.")
+
+    for attr in ("name", "description"):
+        if not hasattr(function_declaration, attr):
+            raise AttributeError(f"Google ADK function declaration must have a {attr!r} attribute.")
+
+    name = function_declaration.name
+    description = function_declaration.description
+
+    if not isinstance(name, str) or not name:
+        raise ValueError("Google ADK function 'name' must be a non-empty string.")
+
+    if description is not None and not isinstance(description, str):
+        raise TypeError("Google ADK function 'description' must be a string when provided.")
+
+    if func is not None and not callable(func):
+        raise TypeError("Google ADK tool implementation must be callable when provided.")
+
+    parameters = getattr(function_declaration, "parameters", None)
+    input_schema = _validate_and_extract_schema(parameters)
+
+    is_async = asyncio.iscoroutinefunction(func) if func else False
+
+    return Tool(
+        name=name,
+        description=description,
+        input_schema=input_schema,
+        func=func,
+        is_async=is_async,
+    )

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.py

@@ -0,0 +1,130 @@
+"""LangChain tool adapter conversions.
+
+Authors:
+    Dimitrij Ray (dimitrij.ray@gdplabs.id)
+
+References:
+    NONE
+"""
+
+import asyncio
+from typing import Any, Callable
+
+from gllm_core.schema.tool import Tool
+
+
+class LangChainToolKeys:
+    """Constants for LangChain tool attribute keys."""
+
+    FUNC = "func"
+    COROUTINE = "coroutine"
+    RUN = "_run"
+    ARUN = "_arun"
+    NAME = "name"
+    DESCRIPTION = "description"
+    ARGS_SCHEMA = "args_schema"
+
+
+LANGCHAIN_FUNCTION_ATTRS = (
+    LangChainToolKeys.FUNC,
+    LangChainToolKeys.COROUTINE,
+    LangChainToolKeys.RUN,
+    LangChainToolKeys.ARUN,
+)
+
+
+def _extract_attribute(tool: Any, attr_name: str) -> Any:
+    """Extract an attribute from a LangChain tool.
+
+    A LangChain tool can be either a dictionary-like object or an object with attributes.
+    This function handles both cases:
+        1. If the tool has the attribute as an attribute, it returns the attribute value.
+        2. If the tool has the attribute as a key (is a dictionary-like object), it returns the key value.
+        3. Otherwise, it returns None.
+
+    Args:
+        tool (Any): The LangChain tool to extract the attribute from.
+        attr_name (str): The attribute name to extract.
+
+    Returns:
+        Any: The attribute value, or None if not found.
+    """
+    if hasattr(tool, attr_name):
+        return getattr(tool, attr_name)
+
+    if hasattr(tool, "get"):
+        return tool.get(attr_name)
+
+    return None
+
+
+def _get_langchain_tool_func(tool: Any) -> Callable | None:
+    """Gets the function from a LangChain tool.
+
+    This function extracts the appropriate callable from a LangChain tool, with the following priority:
+        1. func
+        2. coroutine
+        3. _run
+        4. _arun
+
+    Args:
+        tool (Any): The LangChain tool to extract the function from.
+
+    Returns:
+        Callable | None: The extracted function, or None if no function is found.
+    """
+    for func_key in LANGCHAIN_FUNCTION_ATTRS:
+        func = _extract_attribute(tool, func_key)
+        if callable(func):
+            return func
+
+    return None
+
+
+def _get_input_schema(tool: Any) -> dict[str, Any]:
+    """Get input schema from a LangChain tool.
+
+    Args:
+        tool (Any): The LangChain tool to get schema from.
+
+    Returns:
+        dict[str, Any]: The input schema, or default empty schema if none found.
+    """
+    input_schema = _extract_attribute(tool, LangChainToolKeys.ARGS_SCHEMA)
+
+    return input_schema if input_schema is not None else {"type": "object", "properties": {}}
+
+
+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.
+    """
+    name = _extract_attribute(langchain_tool, LangChainToolKeys.NAME)
+    if not name:
+        raise ValueError("LangChain tool must have a 'name' attribute or key.")
+
+    description = _extract_attribute(langchain_tool, LangChainToolKeys.DESCRIPTION)
+    if not description:
+        raise ValueError("LangChain tool must have a 'description' attribute or key.")
+
+    func = _get_langchain_tool_func(langchain_tool)
+    input_schema = _get_input_schema(langchain_tool)
+
+    return Tool(
+        name=name,
+        description=description,
+        input_schema=input_schema,
+        func=func,
+        is_async=asyncio.iscoroutinefunction(func) if func is not None else False,
+    )

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.py

@@ -26,7 +26,6 @@ class EventType(StrEnum):
 
     ACTIVITY = "activity"
     CODE = "code"
-    DATA = "data"  # TODO: Remove in v0.4
     REFERENCE = "reference"
     RESPONSE = "response"
     STATUS = "status"

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.py

@@ -7,10 +7,9 @@ References:
     NONE
 """
 
-from datetime import datetime
-from typing import Any, AsyncGenerator
+from typing import AsyncGenerator
 
-from gllm_core.constants import EventLevel, EventType
+from gllm_core.constants import EventLevel
 from gllm_core.event.handler import ConsoleEventHandler, PrintEventHandler, StreamEventHandler
 from gllm_core.event.handler.event_handler import BaseEventHandler
 from gllm_core.event.hook.event_hook import BaseEventHook
@@ -158,55 +157,20 @@ class EventEmitter:
         """
         return cls(handlers=[StreamEventHandler()], event_level=event_level, hooks=hooks)
 
-    # TODO: Reorder parameters in v0.4, some can even be made keyword-only
-    async def emit(  # noqa: PLR0913
-        self,
-        value: str | dict[str, Any] | Event,
-        event_level: EventLevel = EventLevel.DEBUG,  # TODO: Change default to EventLevel.INFO in v0.4
-        event_type: str = EventType.STATUS.value,  # TODO: Change default to EventType.RESPONSE.value in v0.4
-        metadata: dict[str, Any] | None = None,
-        event_id: str | None = None,
-        disabled_handlers: list[str] | None = None,
-    ) -> None:
+    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.
         """
-        if isinstance(value, Event):
-            event = value
-            event_level = value.level
-        else:
-            validate_string_enum(EventLevel, event_level)
-            event = Event(
-                id=event_id,
-                value=value,
-                level=event_level,
-                type=event_type,
-                metadata=metadata or {},
-                timestamp=datetime.now(),
-            )
-
-        if event_level < self.severity:
+        if event.level < self.severity:
             return
 
         for hook in self.hooks:

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.py

@@ -7,11 +7,8 @@ References:
     NONE
 """
 
-import json
-
 from rich.console import Console
 
-from gllm_core.constants import EventType
 from gllm_core.event.handler.event_handler import BaseEventHandler
 from gllm_core.schema import Event
 
@@ -47,13 +44,5 @@ class ConsoleEventHandler(BaseEventHandler):
         Raises:
             ValueError: If the event type is invalid.
         """
-        # TODO: Refactor in v0.4
-        if event.type == EventType.DATA:
-            try:
-                color = self._get_rich_color(json.loads(event.value)["data_type"])
-            except (KeyError, json.JSONDecodeError):
-                color = self._get_rich_color(event.type)
-        else:
-            color = self._get_rich_color(event.type)
-
+        color = self._get_rich_color(event.type)
         self.console.print(f"[{color}]{event.model_dump_json()}[/]")

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.py

@@ -7,7 +7,7 @@ References:
     NONE
 """
 
-import json
+from typing import Any
 
 from rich.console import Console
 from rich.panel import Panel
@@ -34,7 +34,6 @@ class PrintEventHandler(BaseEventHandler):
         name: str | None = None,
         color_map: dict[str, str] | None = None,
         padding_char: str = "=",
-        separator_length: int | None = None,  # TODO: Remove in v0.4
     ):
         """Initializes a new instance of the PrintEventHandler class.
 
@@ -44,15 +43,11 @@ 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.
         """
         super().__init__(name, color_map)
         self.padding_char = padding_char
         self.console = Console(highlight=False)
 
-        if separator_length is not None:
-            self._logger.warning("The 'separator_length' parameter is deprecated and will be removed in v0.4.")
-
     async def emit(self, event: Event) -> None:
         """Emits the given event.
 
@@ -63,47 +58,15 @@ class PrintEventHandler(BaseEventHandler):
             self.console.print(f"[{event.level.name}][{event.timestamp}] {event.value}")
             return
 
-        token_type, token_value = self._extract_token_data(event)  # TODO: Remove in v0.4
-
-        if token_type == EventType.ACTIVITY:
-            self._print_activity(token_type, token_value)
-        elif token_type.endswith(EventTypeSuffix.START) or token_type.endswith(EventTypeSuffix.END):
-            self._print_start_end(token_type)
+        if event.type == EventType.ACTIVITY:
+            self._print_activity(event.value)
+        elif event.type.endswith(EventTypeSuffix.START) or event.type.endswith(EventTypeSuffix.END):
+            self._print_start_end(event.type)
         else:
-            style = Style(color=self._get_rich_color(token_type))
-            self.console.print(token_value, end="", style=style)
-
-    # TODO: Remove in v0.4
-    def _extract_token_data(self, event: Event) -> tuple[str, str]:
-        """Extracts the token data from the event.
-
-        This method extracts the token data from the event. If the event type is `EventType.DATA`, the token data
-        are extracted further from the event value.
-
-        Example:
-        If the event value is `{"data_type": "data", "data_value": "test"}`:
-        1. The token type will be "data".
-        2. The token value will be "test".
-
-        Args:
-            event (Event): The event to be extracted.
-
-        Returns:
-            tuple[str, str]: The token type and value.
-        """
-        token_type, token_value = event.type, event.value
-
-        if token_type == EventType.DATA:
-            try:
-                parsed_value = json.loads(token_value)
-                token_type = parsed_value["data_type"]
-                token_value = parsed_value["data_value"]
-            except (json.JSONDecodeError, KeyError):
-                token_type, token_value = event.type, event.value
-
-        return token_type, token_value
+            style = Style(color=self._get_rich_color(event.type))
+            self.console.print(event.value, end="", style=style)
 
-    def _print_activity(self, token_type: str, token_value: str) -> None:
+    def _print_activity(self, activity: dict[str, Any]) -> None:
         """Prints the activity.
 
         This method prints the activity with the following format:
@@ -115,24 +78,17 @@ class PrintEventHandler(BaseEventHandler):
         >>> key2: value2
 
         Args:
-            token_type (str): The type of the token.
-            token_value (str): The value of the token.
+            activity (dict[str, Any]): The activity to print.
         """
-        # TODO: Refactor in v0.4
-        try:
-            activity = json.loads(token_value)
-        except (TypeError, json.JSONDecodeError):
-            activity = token_value
-
-        color = self._get_rich_color(token_type)
-        panel = self._create_separator_panel(token_type, color)
+        color = self._get_rich_color(EventType.ACTIVITY)
+        panel = self._create_separator_panel(EventType.ACTIVITY, color)
         self.console.print()
         self.console.print(panel)
 
         for key, value in activity.items():
             self.console.print(f">>> {key}: {value}", style=Style(color=color))
 
-    def _print_start_end(self, token_type: str) -> None:
+    def _print_start_end(self, event_type: str) -> None:
         """Prints the start or end of block based events.
 
         This method prints the start or end of block based events with the following format:
@@ -146,10 +102,10 @@ class PrintEventHandler(BaseEventHandler):
         ╰───────────────────╯
 
         Args:
-            token_type (str): The type of the token.
+            event_type (str): The type of the event.
         """
-        color = self._get_rich_color(token_type)
-        panel = self._create_separator_panel(token_type, color)
+        color = self._get_rich_color(event_type)
+        panel = self._create_separator_panel(event_type, color)
         self.console.print()
         self.console.print(panel)
 

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__.py

@@ -1,8 +1,8 @@
 """Modules concerning the schemas used throughout the Gen AI applications."""
 
 from gllm_core.schema.chunk import Chunk
-from gllm_core.schema.component import Component
+from gllm_core.schema.component import Component, main
 from gllm_core.schema.event import Event
 from gllm_core.schema.tool import Tool, tool
 
-__all__ = ["Chunk", "Component", "Event", "Tool", "tool"]
+__all__ = ["Chunk", "Component", "Event", "Tool", "main", "tool"]

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']