lionagi 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

lionagi/core/tool/tool_manager.py

@@ -1,282 +0,0 @@
-import asyncio
-
-from typing import Tuple, Any, TypeVar, Callable
-from lionagi.libs import func_call, convert, ParseUtil
-
-from lionagi.core.tool.tool import Tool, TOOL_TYPE
-
-T = TypeVar("T", bound=Tool)
-
-
-class ToolManager:
-    """
-    A manager class for handling the registration and invocation of tools that are subclasses of Tool.
-
-    This class maintains a registry of tool instances, allowing for dynamic invocation based on
-    tool name and provided arguments. It supports both synchronous and asynchronous tool function
-    calls.
-
-    Attributes:
-        registry (dict[str, Tool]): A dictionary to hold registered tools, keyed by their names.
-    """
-
-    registry: dict = {}
-
-    def name_existed(self, name: str) -> bool:
-        """
-        Checks if a tool name already exists in the registry.
-
-        Args:
-            name (str): The name of the tool to check.
-
-        Returns:
-            bool: True if the name exists, False otherwise.
-        """
-        return name in self.registry
-
-    @property
-    def has_tools(self):
-        return self.registry != {}
-
-    def _register_tool(self, tool: Tool | Callable) -> None:
-        """
-        Registers a tool in the registry. Raises a TypeError if the object is not an instance of Tool.
-
-        Args:
-            tool (Tool): The tool instance to register.
-
-        Raises:
-            TypeError: If the provided object is not an instance of Tool.
-        """
-        if isinstance(tool, Callable):
-            tool = func_to_tool(tool)[0]
-        if not isinstance(tool, Tool):
-            raise TypeError("Please register a Tool object.")
-        name = tool.schema_["function"]["name"]
-        self.registry.update({name: tool})
-
-    async def invoke(self, func_calls: Tuple[str, dict[str, Any]]) -> Any:
-        """
-        Invokes a registered tool's function with the given arguments. Supports both coroutine and regular functions.
-
-        Args:
-            func_call (Tuple[str, Dict[str, Any]]): A tuple containing the function name and a dictionary of keyword arguments.
-
-        Returns:
-            Any: The result of the function call.
-
-        Raises:
-            ValueError: If the function name is not registered or if there's an error during function invocation.
-        """
-        name, kwargs = func_calls
-        if not self.name_existed(name):
-            raise ValueError(f"Function {name} is not registered.")
-        tool = self.registry[name]
-        func = tool.func
-        parser = tool.parser
-        try:
-            if func_call.is_coroutine_func(func):
-                tasks = [func_call.call_handler(func, **kwargs)]
-                out = await asyncio.gather(*tasks)
-                return parser(out[0]) if parser else out[0]
-            else:
-                out = func(**kwargs)
-                return parser(out) if parser else out
-        except Exception as e:
-            raise ValueError(
-                f"Error when invoking function {name} with arguments {kwargs} with error message {e}"
-            ) from e
-
-    @staticmethod
-    def get_function_call(response: dict) -> Tuple[str, dict]:
-        """
-        Extracts a function call and arguments from a response dictionary.
-
-        Args:
-            response (dict): The response dictionary containing the function call information.
-
-        Returns:
-            Tuple[str, dict]: A tuple containing the function name and a dictionary of arguments.
-
-        Raises:
-            ValueError: If the response does not contain valid function call information.
-        """
-        try:
-            func = response["action"][7:]
-            args = convert.to_dict(response["arguments"])
-            return func, args
-        except Exception:
-            try:
-                func = response["recipient_name"].split(".")[-1]
-                args = response["parameters"]
-                return func, args
-            except:
-                raise ValueError("response is not a valid function call")
-
-    def register_tools(self, tools: list[Tool]) -> None:
-        """
-        Registers multiple tools in the registry.
-
-        Args:
-            tools (list[Tool]): A list of tool instances to register.
-        """
-        func_call.lcall(tools, self._register_tool)
-
-    def to_tool_schema_list(self) -> list[dict[str, Any]]:
-        """
-        Generates a list of schemas for all registered tools.
-
-        Returns:
-            list[dict[str, Any]]: A list of tool schemas.
-
-        """
-        return [tool.schema_ for tool in self.registry.values()]
-
-    def parse_tool(self, tools: TOOL_TYPE, **kwargs) -> dict:
-        """
-        Parses tool information and generates a dictionary for tool invocation.
-
-        Args:
-            tools: Tool information which can be a single Tool instance, a list of Tool instances, a tool name, or a list of tool names.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            dict: A dictionary containing tool schema information and any additional keyword arguments.
-
-        Raises:
-            ValueError: If a tool name is provided that is not registered.
-        """
-
-        def tool_check(tool):
-            if isinstance(tool, dict):
-                return tool
-            elif isinstance(tool, Tool):
-                return tool.schema_
-            elif isinstance(tool, str):
-                if self.name_existed(tool):
-                    tool: Tool = self.registry[tool]
-                    return tool.schema_
-                else:
-                    raise ValueError(f"Function {tool} is not registered.")
-
-        if isinstance(tools, bool):
-            tool_kwarg = {"tools": self.to_tool_schema_list()}
-            kwargs = tool_kwarg | kwargs
-
-        else:
-            if not isinstance(tools, list):
-                tools = [tools]
-            tool_kwarg = {"tools": func_call.lcall(tools, tool_check)}
-            kwargs = tool_kwarg | kwargs
-
-        return kwargs
-
-
-def func_to_tool(
-    func_: Callable | list[Callable], parser=None, docstring_style="google"
-):
-    """
-    Transforms a given function into a Tool object, equipped with a schema derived
-    from its docstring. This process involves parsing the function's docstring based
-    on a specified style ('google' or 'reST') to extract relevant metadata and
-    parameters, which are then used to construct a comprehensive schema for the Tool.
-    This schema facilitates the integration of the function with systems or
-    frameworks that rely on structured metadata for automation, documentation, or
-    interface generation purposes.
-
-    The function to be transformed can be any Callable that adheres to the
-    specified docstring conventions. The resulting Tool object encapsulates the
-    original function, allowing it to be utilized within environments that require
-    objects with structured metadata.
-
-    Args:
-        func_ (Callable): The function to be transformed into a Tool object. This
-            function should have a docstring that follows the
-            specified docstring style for accurate schema generation.
-        parser (Optional[Any]): An optional parser object associated with the Tool.
-                  This parameter is currently not utilized in the
-                  transformation process but is included for future
-                  compatibility and extension purposes.
-        docstring_style (str): The format of the docstring to be parsed, indicating
-                 the convention used in the function's docstring.
-                 Supports 'google' for Google-style docstrings and
-                 'reST' for reStructuredText-style docstrings. The
-                 chosen style affects how the docstring is parsed and
-                 how the schema is generated.
-
-    Returns:
-        Tool: An object representing the original function wrapped as a Tool, along
-            with its generated schema. This Tool object can be used in systems that
-            require detailed metadata about functions, facilitating tasks such as
-            automatic documentation generation, user interface creation, or
-            integration with other software tools.
-
-    Examples:
-        >>> def example_function_google(param1: int, param2: str) -> bool:
-        ...     '''
-        ...     An example function using Google style docstrings.
-        ...
-        ...     Args:
-        ...         param1 (int): The first parameter, demonstrating an integer input_.
-        ...         param2 (str): The second parameter, demonstrating a string input_.
-        ...
-        ...     Returns:
-        ...         bool: A boolean value, illustrating the return type.
-        ...     '''
-        ...     return True
-        ...
-        >>> tool_google = func_to_tool(example_function_google, docstring_style='google')
-        >>> print(isinstance(tool_google, Tool))
-        True
-
-        >>> def example_function_reST(param1: int, param2: str) -> bool:
-        ...     '''
-        ...     An example function using reStructuredText (reST) style docstrings.
-        ...
-        ...     :param param1: The first parameter, demonstrating an integer input_.
-        ...     :type param1: int
-        ...     :param param2: The second parameter, demonstrating a string input_.
-        ...     :type param2: str
-        ...     :returns: A boolean value, illustrating the return type.
-        ...     :rtype: bool
-        ...     '''
-        ...     return True
-        ...
-        >>> tool_reST = func_to_tool(example_function_reST, docstring_style='reST')
-        >>> print(isinstance(tool_reST, Tool))
-        True
-
-    Note:
-        The transformation process relies heavily on the accuracy and completeness of
-        the function's docstring. Functions with incomplete or incorrectly formatted
-        docstrings may result in incomplete or inaccurate Tool schemas.
-    """
-
-    fs = []
-    funcs = convert.to_list(func_, flatten=True, dropna=True)
-    parsers = convert.to_list(parser, flatten=True, dropna=True)
-
-    if parser:
-        if len(funcs) != len(parsers) != 1:
-            raise ValueError(
-                "Length of parser must match length of func. Except if you only pass one"
-            )
-
-        for idx in range(len(funcs)):
-            f_ = lambda _f: Tool(
-                func=_f,
-                schema_=ParseUtil._func_to_schema(_f, style=docstring_style),
-                parser=parsers[idx] if len(parsers) > 1 else parsers[0],
-            )
-
-            fs.append(f_)
-
-    else:
-        fs = func_call.lcall(
-            funcs,
-            lambda _f: Tool(
-                func=_f, schema_=ParseUtil._func_to_schema(_f, style=docstring_style)
-            ),
-        )
-
-    return fs

lionagi/experimental/tool/function_calling.py

@@ -1,43 +0,0 @@
-from typing import Any, Callable
-from pydantic import BaseModel, Field, field_serializer
-from functools import singledispatchmethod
-from lionagi.libs import convert
-
-
-class FunctionCalling(BaseModel):
-    func: Any = Field(..., alias="function")
-    kwargs: Any = Field({}, alias="arguments")
-
-    @field_serializer("func")
-    def serialize_func(self, func: Callable):
-        return func.__name__
-
-    @property
-    def func_name(self):
-        return self.func.__name__
-
-    @classmethod
-    @singledispatchmethod
-    def create(cls, func_call: Any):
-        raise TypeError(f"Unsupported type {type(func_call)}")
-
-    @create.register
-    def _(cls, func_call: tuple):
-        if len(func_call) == 2:
-            return cls(func=func_call[0], kwargs=func_call[1])
-        else:
-            raise ValueError(f"Invalid tuple length {len(func_call)}")
-
-    @create.register
-    def _(cls, func_call: dict):
-        return cls(**func_call)
-
-    @create.register
-    def _(cls, func_call: str):
-        try:
-            return cls(**convert.to_dict(func_call))
-        except Exception as e:
-            raise ValueError(f"Invalid string {func_call}") from e
-
-    def __str__(self):
-        return f"{self.func_name}({self.kwargs})"

lionagi/experimental/tool/manual.py

@@ -1,66 +0,0 @@
-import re
-from typing import Dict, Union, Callable, Any
-
-
-class BaseManual:
-    def __init__(self, template_str: str):
-        self.template_str = template_str
-
-    def _evaluate_condition(self, match, context):
-        condition, text = match.groups()
-        # Future implementations might parse and evaluate the condition more thoroughly
-        return text if condition in context and context[condition] else ""
-
-    def _render_conditionals(self, context: Dict[str, Union[str, int, float]]) -> str:
-        conditional_pattern = re.compile(r"\{if (.*?)\}(.*?)\{endif\}", re.DOTALL)
-        return conditional_pattern.sub(
-            lambda match: self._evaluate_condition(match, context), self.template_str
-        )
-
-    def _replace_callable(self, match, context):
-        key = match.group(1)
-        if key in context:
-            value = context[key]
-            return str(value() if callable(value) else value)
-        return match.group(0)  # Unmatched placeholders remain unchanged.
-
-    def _render_placeholders(
-        self,
-        rendered_template: str,
-        context: Dict[str, Union[str, int, float, Callable]],
-    ) -> str:
-        return re.sub(
-            r"\{(\w+)\}",
-            lambda match: self._replace_callable(match, context),
-            rendered_template,
-        )
-
-    def generate(self, context: Dict[str, Union[str, int, float, Callable]]) -> str:
-        """
-        Generates output by first processing conditionals, then rendering placeholders,
-        including executing callable objects for dynamic data generation.
-        """
-        template_with_conditionals = self._render_conditionals(context)
-        final_output = self._render_placeholders(template_with_conditionals, context)
-        return final_output
-
-
-# from experiments.executor.executor import SafeEvaluator
-
-# class DecisionTreeManual:
-#     def __init__(self, root):
-#         self.root = root
-#         self.evaluator = SafeEvaluator()
-
-#     def evaluate(self, context):
-#         return self._traverse_tree(self.root, context)
-
-#     def _traverse_tree(self, node, context):
-#         if isinstance(node, CompositeActionNode) or isinstance(node, ActionNode):
-#             return node.execute(context)
-#         elif isinstance(node, DecisionNode):
-#             condition_result = self.evaluator.evaluate(node.condition, context)
-#             next_node = node.true_branch if condition_result else node.false_branch
-#             return self._traverse_tree(next_node, context)
-#         else:
-#             raise ValueError("Invalid node type.")

lionagi/experimental/tool/schema.py

@@ -1,59 +0,0 @@
-from typing import Any
-from pydantic import field_serializer
-from functools import singledispatchmethod
-from lionagi import logging as _logging
-from lionagi.libs import func_call, AsyncUtil
-from lionagi.core.generic.node import Node
-from .function_calling import FunctionCalling
-
-
-class Tool(Node):
-
-    func: Any
-    schema_: dict | None = None
-    manual: Any | None = None
-    parser: Any | None = None
-    pre_processor: Any | None = None
-    post_processor: Any | None = None
-
-    @property
-    def name(self):
-        return self.schema_["function"]["name"]
-
-    @field_serializer("func")
-    def serialize_func(self, func):
-        return func.__name__
-
-    @singledispatchmethod
-    async def invoke(self, values: Any) -> Any:
-        raise TypeError(f"Unsupported type {type(values)}")
-
-    @invoke.register
-    async def _(self, kwargs: dict):
-
-        out = None
-
-        if self.pre_processor:
-            kwargs = await func_call.unified_call(self.pre_processor, kwargs)
-        try:
-            out = await func_call.unified_call(self.func, **kwargs)
-
-        except Exception as e:
-            _logging.error(f"Error invoking function {self.func_name}: {e}")
-            return None
-
-        if self.post_processor:
-            return await func_call.unified_call(self.post_processor, out)
-
-        return out
-
-    @invoke.register
-    async def _(self, function_calls: FunctionCalling):
-        return await self.invoke(function_calls.kwargs)
-
-    @invoke.register
-    async def _(self, values: list):
-        return await func_call.alcall(self.invoke, values)
-
-
-TOOL_TYPE = bool | Tool | str | list[Tool | str | dict] | dict

lionagi/experimental/tool/tool_manager.py

@@ -1,138 +0,0 @@
-import asyncio
-from functools import singledispatchmethod
-from collections import deque
-from typing import Tuple, Any, TypeVar, Callable
-from lionagi.libs import func_call, convert, ParseUtil
-from lionagi import logging as _logging
-from .schema import Tool, TOOL_TYPE
-from .util import func_to_tool, parse_tool_response
-from .function_calling import FunctionCalling
-
-T = TypeVar("T", bound=Tool)
-
-
-class ToolManager:
-
-    def __init__(
-        self,
-        tool_registry: dict = {},
-        function_calling_tasks: dict[str : deque[FunctionCalling]] = {},
-    ):
-        self.registry = tool_registry
-        self.function_calling_tasks = function_calling_tasks
-
-    @singledispatchmethod
-    def register_tools(self, tools: Any):
-        raise TypeError(f"Unsupported type {type(tools)}")
-
-    @register_tools.register(Tool)
-    def _(self, tools):
-        name = tools.schema_["function"]["name"]
-        if self._has_name(name):
-            err_msg = f"Function {name} is already registered."
-            _logging.error(err_msg)
-            raise ValueError(err_msg)
-        else:
-            self.registry[name] = tools
-            self.function_calling_tasks[name] = deque()
-            return True
-
-    @register_tools.register(Callable)
-    def _(self, tools):
-        tool = func_to_tool(tools)[0]
-        return self.register_tools(tool)
-
-    @register_tools.register(list)
-    def _(self, tools):
-        return func_call.lcall(tools, self.register_tools)
-
-    @singledispatchmethod
-    def register_function_calling(self, func_params: Any):
-        raise TypeError(f"Unsupported type {type(func_params)}")
-
-    @register_function_calling.register(tuple)
-    def _(self, func_params):
-        func = self.registry[func_params[0]].func
-        kwargs = func_params[1]
-        _function_calling = FunctionCalling(func=func, kwargs=kwargs)
-        self.function_calling_tasks[func.__name__].append(_function_calling)
-        return True
-
-    @register_function_calling.register(dict)
-    def _(self, response):
-        tuple_ = parse_tool_response(response)
-        return self.register_function_calling(tuple_)
-
-    @register_function_calling.register(list)
-    def _(self, func_params):
-        return func_call.lcall(func_params, self.register_function_calling)
-
-    async def invoke(self, func_params: Tuple[str, dict[str, Any]]) -> Any:
-        name, kwargs = func_params
-        if not self._has_name(name):
-            raise ValueError(f"Function {name} is not registered.")
-        tool = self.registry[name]
-        func = tool.func
-        parser = tool.parser
-        try:
-            out = await func_call.unified_call(func, **kwargs)
-            return parser(out) if parser else out
-
-        except Exception as e:
-            raise ValueError(
-                f"Error when invoking function {name} with arguments {kwargs} with error message {e}"
-            ) from e
-
-    @property
-    def _schema_list(self) -> list[dict[str, Any]]:
-        return [tool.schema_ for tool in self.registry.values()]
-
-    def get_tool_schema(self, tools: TOOL_TYPE, **kwargs):
-        if isinstance(tools, bool):
-            tool_kwarg = {"tools": self._schema_list}
-            return tool_kwarg | kwargs
-
-        else:
-            if not isinstance(tools, list):
-                tools = [tools]
-            tool_kwarg = {"tools": self._get_tool_schema(tools)}
-            return tool_kwarg | kwargs
-
-    def _has_name(self, name: str) -> bool:
-        return name in self.registry
-
-    @singledispatchmethod
-    def _get_tool_schema(self, tool: Any) -> dict:
-        raise TypeError(f"Unsupported type {type(tool)}")
-
-    @_get_tool_schema.register(dict)
-    def _(self, tool):
-        """
-        assuming that the tool is a schema
-        """
-        return tool
-
-    @_get_tool_schema.register(Tool)
-    def _(self, tool):
-        if self._has_name(tool.name):
-            return self.registry[tool.name].schema_
-        else:
-            err_msg = f"Function {tool.name} is not registered."
-            _logging.error(err_msg)
-            raise ValueError(err_msg)
-
-    @_get_tool_schema.register(str)
-    def _(self, tool):
-        """
-        assuming that the tool is a name
-        """
-        if self._has_name(tool):
-            return self.registry[tool].schema_
-        else:
-            err_msg = f"Function {tool} is not registered."
-            _logging.error(err_msg)
-            raise ValueError(err_msg)
-
-    @_get_tool_schema.register(list)
-    def _(self, tools):
-        return func_call.lcall(tools, self._get_tool_schema)

lionagi/experimental/tool/util.py

@@ -1,16 +0,0 @@
-from typing import Tuple
-from lionagi.libs import convert
-
-
-def parse_tool_response(response: dict) -> Tuple[str, dict]:
-    try:
-        func = response["action"][7:]
-        args = convert.to_dict(response["arguments"])
-        return func, args
-    except Exception:
-        try:
-            func = response["recipient_name"].split(".")[-1]
-            args = response["parameters"]
-            return func, args
-        except:
-            raise ValueError("response is not a valid function call")

lionagi/experimental/work/_logger.py

@@ -1,25 +0,0 @@
-from collections import deque
-from typing import Dict
-from pydantic import BaseModel, Field
-from .schema import Work, WorkStatus
-
-
-class WorkLog(BaseModel):
-    """Model to store and manage work logs."""
-
-    logs: Dict[str, Work] = Field(default={}, description="Logs of work items")
-    pending: deque = Field(
-        default_factory=deque, description="Priority queue of pending work items"
-    )
-    errored: deque = Field(
-        default_factory=deque, description="Queue of errored work items"
-    )
-
-    def append(self, work: Work):
-        """Append a work item to the logs and pending queue."""
-        self.logs[str(work.form_id)] = work
-        self.pending.append(str(work.form_id))
-
-    def get_by_status(self, status: WorkStatus) -> Dict[str, Work]:
-        """Get work items by their status."""
-        return {wid: work for wid, work in self.logs.items() if work.status == status}

lionagi/experimental/work/schema.py

@@ -1,30 +0,0 @@
-from enum import Enum
-from typing import Any, Dict, List
-from pydantic import Field
-from lionagi.core.generic import BaseComponent
-
-
-class WorkStatus(str, Enum):
-    """Enum to represent different statuses of work."""
-
-    PENDING = "PENDING"
-    IN_PROGRESS = "IN_PROGRESS"
-    COMPLETED = "COMPLETED"
-    FAILED = "FAILED"
-    CANCELLED = "CANCELLED"
-
-
-class Work(BaseComponent):
-    """Base component for handling individual units of work."""
-
-    form_id: str = Field(..., description="ID of the form for this work")
-    priority: int = Field(default=0, description="Priority of the work")
-    status: WorkStatus = Field(
-        default=WorkStatus.PENDING, description="Current status of the work"
-    )
-    deliverables: Dict[str, Any] | list = Field(
-        default={}, description="Deliverables produced by the work"
-    )
-    dependencies: List["Work"] = Field(
-        default_factory=list, description="List of work items this work depends on"
-    )