lionagi 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

lionagi/__init__.py

@@ -1,59 +1,27 @@
+"""The LION framework."""
+
 import logging
 
 from dotenv import load_dotenv
 
-import lionagi.core.director.direct as direct
-from lionagi.core.action import func_to_tool
-from lionagi.core.collections import flow, iModel, pile, progression
-from lionagi.core.collections.abc import Field
-from lionagi.core.generic import Edge, Graph, Node, Tree
-from lionagi.core.report import Form, Report
-from lionagi.core.session.branch import Branch
-from lionagi.core.session.session import Session
-from lionagi.core.work.worker import Worker, work, worklink
-from lionagi.integrations.chunker.chunk import chunk
-from lionagi.integrations.loader.load import load
-from lionagi.integrations.provider.services import Services
-from lionagi.libs.ln_convert import to_df, to_dict, to_list, to_readable_dict
-from lionagi.libs.ln_func_call import CallDecorator as cd
-from lionagi.libs.ln_func_call import alcall, bcall, lcall, tcall
-
+from .core.session.types import Branch
+from .integrations.litellm_.imodel import LiteiModel
+from .protocols.operatives.step import Step
+from .service import iModel
+from .settings import Settings
 from .version import __version__
 
+load_dotenv()
+
+
 __all__ = [
-    "Field",
-    "progression",
-    "flow",
-    "pile",
+    "Settings",
+    "__version__",
     "iModel",
-    "work",
-    "worklink",
-    "Worker",
+    "LiteiModel",
     "Branch",
-    "Session",
-    "Form",
-    "Report",
-    "Services",
-    "direct",
-    "Node",
-    "Graph",
-    "Tree",
-    "Edge",
-    "chunk",
-    "load",
-    "func_to_tool",
-    "cd",
-    "alcall",
-    "bcall",
-    "to_list",
-    "to_dict",
-    "lcall",
-    "to_df",
-    "tcall",
-    "to_readable_dict",
+    "Step",
 ]
 
-
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
-load_dotenv()

lionagi/core/__init__.py

@@ -1 +1,3 @@
-from . import *
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/core/_class_registry.py

@@ -0,0 +1,69 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+from typing import TypeVar
+
+from lionagi.libs.utils import get_class_file_registry, get_class_objects
+
+T = TypeVar("T")
+LION_CLASS_REGISTRY: dict[str, type[T]] = {}
+LION_CLASS_FILE_REGISTRY: dict[str, str] = {}
+
+pattern_list = [
+    "lionagi/core/generic",
+    "lionagi/core/communication",
+    "lionagi/core/action",
+    "lionagi/core/session",
+    "lionagi/core/forms",
+]
+
+
+if not LION_CLASS_FILE_REGISTRY:
+    script_path = os.path.abspath(__file__)
+    script_dir = os.path.dirname(script_path)
+
+    LION_CLASS_FILE_REGISTRY = get_class_file_registry(
+        script_dir, pattern_list
+    )
+
+
+def get_class(class_name: str) -> type:
+    """
+    Retrieve a class by name from the registry or dynamically import it.
+
+    This function first checks the LION_CLASS_REGISTRY for the requested class.
+    If not found, it uses mor to dynamically import the class. The
+    function ensures that the retrieved class is a subclass of the specified
+    base_class.
+
+    Args:
+        class_name: The name of the class to retrieve.
+
+    Returns:
+        The requested class, which is a subclass of base_class.
+
+    Raises:
+        ValueError: If the class is not found or not a subclass of base_class.
+
+    Usage:
+        MyClass = get_class("MyClassName", BaseClass)
+        instance = MyClass()
+
+    Note:
+        This function automatically registers newly found classes in the
+        LION_CLASS_REGISTRY for future quick access.
+    """
+    if class_name in LION_CLASS_REGISTRY:
+        return LION_CLASS_REGISTRY[class_name]
+
+    try:
+        found_class_filepath = LION_CLASS_FILE_REGISTRY[class_name]
+        found_class_dict = get_class_objects(found_class_filepath)
+        return found_class_dict[class_name]
+    except Exception as e:
+        raise ValueError(f"Unable to find class {class_name}: {e}")
+
+
+# File: lionagi/core/util/class_registry_util.py

lionagi/core/action/__init__.py

@@ -1,13 +1,3 @@
-from .function_calling import FunctionCalling
-from .node import ActionNode, DirectiveSelection
-from .tool import Tool
-from .tool_manager import ToolManager, func_to_tool
-
-__all__ = [
-    "FunctionCalling",
-    "Tool",
-    "ToolManager",
-    "func_to_tool",
-    "ActionNode",
-    "DirectiveSelection",
-]
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/core/action/action_manager.py

@@ -0,0 +1,287 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from functools import singledispatchmethod
+
+from lionagi.core.communication.action_request import ActionRequest
+from lionagi.core.generic.log_manager import LogManager
+from lionagi.core.typing import Any, Callable
+from lionagi.libs.parse.types import to_dict, to_list
+from lionagi.protocols.operatives.action import ActionRequestModel
+
+from .function_calling import FunctionCalling
+from .tool import Tool, func_to_tool
+
+# Type definitions for tool registration and lookup
+FUNCTOOL = Tool | Callable[..., Any]
+FINDABLE_TOOL = FUNCTOOL | str
+INPUTTABLE_TOOL = dict[str, Any] | bool | FINDABLE_TOOL
+TOOL_TYPE = FINDABLE_TOOL | list[FINDABLE_TOOL] | INPUTTABLE_TOOL
+
+
+class ActionManager:
+    """Manages registration and execution of tools.
+
+    The ActionManager serves as a central registry for tools, providing:
+    1. Tool registration and management
+    2. Function call matching to registered tools
+    3. Tool invocation with argument handling
+    4. Logging of tool execution
+
+    Tools can be registered either as Tool objects or as callable functions
+    (which are automatically converted to Tool objects). The manager supports
+    various formats for function calls and provides comprehensive logging
+    of tool execution.
+
+    Attributes:
+        registry (dict[str, Tool]): Dictionary mapping tool names to Tool objects.
+        logger (LogManager): Logger for tracking tool execution.
+    """
+
+    def __init__(
+        self, registry: dict[str, Tool] | None = None, logger=None
+    ) -> None:
+        """Initialize the ActionManager instance.
+
+        Args:
+            registry: Optional dictionary of pre-registered tools.
+                Keys are tool names, values are Tool objects.
+            logger: Optional logger for tracking tool execution.
+                If None, creates a new LogManager instance.
+        """
+        self.registry: dict[str, Tool] = registry or {}
+        self.logger = logger or LogManager()
+
+    def __contains__(self, tool: FINDABLE_TOOL) -> bool:
+        """Check if a tool is registered in the registry.
+
+        Supports checking by:
+        - Tool object
+        - Tool name (string)
+        - Callable function
+
+        Args:
+            tool: The tool to check for registration.
+
+        Returns:
+            bool: True if tool is registered, False otherwise.
+        """
+        if isinstance(tool, Tool):
+            return tool.function_name in self.registry
+        elif isinstance(tool, str):
+            return tool in self.registry
+        elif callable(tool):
+            return tool.__name__ in self.registry
+        return False
+
+    def register_tool(
+        self,
+        tool: FUNCTOOL,
+        update: bool = False,
+    ) -> None:
+        """Register a single tool in the registry.
+
+        If the tool is a callable function, it is automatically converted
+        to a Tool object. Existing tools can be updated if update=True.
+
+        Args:
+            tool: The tool to register (Tool object or callable).
+            update: If True, update existing tool; if False, raise error.
+
+        Raises:
+            ValueError: If tool already registered and update=False.
+            TypeError: If tool is not a Tool object or callable.
+        """
+        if not update and tool in self:
+            name = None
+            if isinstance(tool, Tool):
+                name = tool.function_name
+            elif callable(tool):
+                name = tool.__name__
+            raise ValueError(f"Tool {name} is already registered.")
+
+        if callable(tool):
+            tool = func_to_tool(tool)[0]
+        if not isinstance(tool, Tool):
+            raise TypeError("Please register a Tool object or callable.")
+
+        self.registry[tool.function_name] = tool
+
+    def register_tools(
+        self,
+        tools: list[FUNCTOOL] | FUNCTOOL,
+        update: bool = False,
+    ) -> None:
+        """Register multiple tools in the registry.
+
+        Handles both single tools and lists of tools. Each tool can be
+        either a Tool object or a callable function.
+
+        Args:
+            tools: Single tool or list of tools to register.
+            update: If True, update existing tools; if False, raise error.
+
+        Raises:
+            ValueError: If any tool is already registered.
+            TypeError: If any tool is not a Tool object or callable.
+        """
+        tools_list = tools if isinstance(tools, list) else [tools]
+        [
+            self.register_tool(tool, update=update)
+            for tool in to_list(tools_list, dropna=True, flatten=True)
+        ]
+
+    @singledispatchmethod
+    def match_tool(self, func_call: Any) -> FunctionCalling:
+        """Match a function call to a registered tool.
+
+        This is a single dispatch method that handles different function
+        call formats. The base method handles unsupported types.
+
+        Args:
+            func_call: The function call specification.
+
+        Raises:
+            TypeError: If input type is not supported.
+        """
+        raise TypeError(f"Unsupported type {type(func_call)}")
+
+    @match_tool.register
+    def _(self, func_call: tuple) -> FunctionCalling:
+        if len(func_call) == 2:
+            function_name = func_call[0]
+            arguments = func_call[1]
+            tool = self.registry.get(function_name)
+            if not tool:
+                raise ValueError(f"Function {function_name} is not registered")
+            return FunctionCalling(func_tool=tool, arguments=arguments)
+        else:
+            raise ValueError(f"Invalid function call {func_call}")
+
+    @match_tool.register
+    def _(self, func_call: dict) -> FunctionCalling:
+        if len(func_call) == 2 and (
+            {
+                "function",
+                "arguments",
+            }
+            <= func_call.keys()
+        ):
+            function_name = func_call["function"]
+            tool = self.registry.get(function_name)
+            if not tool:
+                raise ValueError(f"Function {function_name} is not registered")
+            return FunctionCalling(
+                func_tool=tool,
+                arguments=func_call["arguments"],
+            )
+        raise ValueError(f"Invalid function call {func_call}")
+
+    @match_tool.register
+    def _(
+        self, func_call: ActionRequest | ActionRequestModel
+    ) -> FunctionCalling:
+        tool = self.registry.get(func_call.function)
+        if not tool:
+            func_ = func_call.function
+            raise ValueError(f"Function {func_} is not registered.")
+        return FunctionCalling(func_tool=tool, arguments=func_call.arguments)
+
+    @match_tool.register
+    def _(self, func_call: str) -> FunctionCalling:
+        _call = None
+        try:
+            _call = to_dict(func_call, str_type="json", fuzzy_parse=True)
+        except Exception as e:
+            raise ValueError(f"Invalid function call {func_call}") from e
+
+        if isinstance(_call, dict):
+            return self.match_tool(_call)
+        raise ValueError(f"Invalid function call {func_call}")
+
+    async def invoke(self, func_call: dict | str | ActionRequest) -> Any:
+        """Invoke a tool based on the provided function call.
+
+        1. Matches function call to registered tool
+        2. Creates FunctionCalling instance
+        3. Invokes function with arguments
+        4. Logs execution details
+        5. Returns result
+
+        Args:
+            func_call: Function call specification in supported format.
+            log_manager: Optional logger for execution tracking.
+
+        Returns:
+            Result of tool invocation after processing pipeline.
+
+        Raises:
+            ValueError: If function not registered or call format invalid.
+        """
+        function_calling = self.match_tool(func_call)
+        result = await function_calling.invoke()
+        await self.logger.alog(function_calling.to_log())
+        return result
+
+    @property
+    def schema_list(self) -> list[dict[str, Any]]:
+        """List all tool schemas currently registered.
+
+        Returns:
+            List of OpenAI function schemas for all registered tools.
+        """
+        return [tool.schema_ for tool in self.registry.values()]
+
+    def get_tool_schema(
+        self,
+        tools: TOOL_TYPE = False,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Retrieve the schema for specific tools or all tools.
+
+        Args:
+            tools: Specification of which tools to retrieve schemas for.
+                If True, return all tools. If False, return empty dict.
+                Can also be a specific tool or list of tools.
+            **kwargs: Additional keyword arguments to include in output.
+
+        Returns:
+            Dictionary containing tool schemas and additional kwargs.
+
+        Raises:
+            ValueError: If a specified tool is not registered.
+            TypeError: If an unsupported tool type is provided.
+        """
+        if isinstance(tools, bool):
+            if tools:
+                tool_kwarg = {"tools": self.schema_list}
+            else:
+                tool_kwarg = {}
+        else:
+            tool_kwarg = {"tools": self._get_tool_schema(tools)}
+        return tool_kwarg | kwargs
+
+    def _get_tool_schema(
+        self,
+        tool: Any,
+    ) -> dict[str, Any] | list[dict[str, Any]]:
+        if isinstance(tool, dict):
+            return tool
+        if isinstance(tool, Callable):
+            name = tool.__name__
+            if name in self.registry:
+                return self.registry[name].schema_
+            raise ValueError(f"Tool {name} is not registered.")
+
+        elif isinstance(tool, Tool) or isinstance(tool, str):
+            name = tool.function_name if isinstance(tool, Tool) else tool
+            if name in self.registry:
+                return self.registry[name].schema_
+            raise ValueError(f"Tool {name} is not registered.")
+        elif isinstance(tool, list):
+            return [self._get_tool_schema(t) for t in tool]
+        raise TypeError(f"Unsupported type {type(tool)}")
+
+
+__all__ = ["ActionManager"]

lionagi/core/action/base.py

@@ -0,0 +1,109 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.core.generic.types import Element, Log
+from lionagi.core.typing import Any, Enum, NoReturn, PrivateAttr, override
+from lionagi.settings import Settings, TimedFuncCallConfig
+
+
+class EventStatus(str, Enum):
+    """Status states for tracking action execution progress.
+
+    Attributes:
+        PENDING: Initial state before execution starts
+        PROCESSING: Action is currently being executed
+        COMPLETED: Action completed successfully
+        FAILED: Action failed during execution
+    """
+
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class ObservableAction(Element):
+    """Base class for actions that can be monitored and tracked.
+
+    Provides functionality for tracking execution status, timing, and results
+    of action invocations. Inherits from Element for serialization capabilities.
+
+    Attributes:
+        status (EventStatus): Current execution status of the action
+        execution_time (float | None): Time taken to execute the action in seconds
+        execution_response (Any): Result returned from the action execution
+        execution_error (str | None): Error message if execution failed
+        _timed_config (TimedFuncCallConfig): Configuration for timed execution
+        _content_fields (list): Fields to include in content section of logs
+    """
+
+    status: EventStatus = EventStatus.PENDING
+    execution_time: float | None = None
+    execution_response: Any = None
+    execution_error: str | None = None
+    _timed_config: TimedFuncCallConfig | None = PrivateAttr(None)
+    _content_fields: list = PrivateAttr(["execution_response"])
+
+    @override
+    def __init__(
+        self, timed_config: dict | TimedFuncCallConfig | None, **kwargs: Any
+    ) -> None:
+        """Initialize an ObservableAction instance.
+
+        Args:
+            timed_config: Configuration for timed function execution.
+                If None, uses default config from Settings.
+                If dict, converts to TimedFuncCallConfig.
+            **kwargs: Additional keyword arguments passed to TimedFuncCallConfig
+                if timed_config is a dict.
+        """
+        super().__init__()
+        if timed_config is None:
+            self._timed_config = Settings.Config.TIMED_CALL
+
+        else:
+            if isinstance(timed_config, TimedFuncCallConfig):
+                timed_config = timed_config.to_dict()
+            if isinstance(timed_config, dict):
+                timed_config = {**timed_config, **kwargs}
+            timed_config = TimedFuncCallConfig(**timed_config)
+            self._timed_config = timed_config
+
+    def to_log(self) -> Log:
+        """Convert the action to a log entry.
+
+        Creates a structured log entry with execution details split into
+        content and loginfo sections. Content includes execution results,
+        while loginfo includes metadata and status information.
+
+        Returns:
+            Log: A log entry representing the action's execution state
+                and results.
+        """
+        dict_ = self.to_dict()
+        dict_["status"] = self.status.value
+        content = {k: dict_[k] for k in self._content_fields if k in dict_}
+        loginfo = {k: dict_[k] for k in dict_ if k not in self._content_fields}
+        return Log(content=content, loginfo=loginfo)
+
+    @classmethod
+    def from_dict(cls, data: dict, /, **kwargs: Any) -> NoReturn:
+        """Event cannot be re-created from dictionary.
+
+        This method is intentionally not implemented as actions represent
+        one-time events that should not be recreated from serialized state.
+
+        Args:
+            data: Dictionary of serialized action data
+            **kwargs: Additional keyword arguments
+
+        Raises:
+            NotImplementedError: Always raised as actions cannot be recreated
+        """
+        raise NotImplementedError(
+            "An event cannot be recreated. Once it's done, it's done."
+        )
+
+
+__all__ = ["ObservableAction"]