lionagi 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/core/action/function_calling.py

@@ -1,153 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import asyncio
-
-from lionagi.core.typing import Any, Field, PrivateAttr, override
-from lionagi.libs.func.decorators import CallDecorator as cd
-from lionagi.libs.func.types import tcall
-from lionagi.settings import TimedFuncCallConfig
-
-from .base import EventStatus, ObservableAction
-from .tool import Tool
-
-
-class FunctionCalling(ObservableAction):
-    """Represents an action that calls a function with specified arguments.
-
-    Encapsulates the complete function execution pipeline including:
-    1. Pre-processing of input arguments
-    2. Timed function execution
-    3. Post-processing of results
-    4. Optional result parsing
-    5. Error handling and status tracking
-
-    The execution is performed asynchronously and includes timing information
-    and comprehensive error handling. The execution status, timing, and any
-    errors are tracked and can be accessed after execution.
-
-    Attributes:
-        func_tool (Tool): Tool containing the function to be invoked and its
-            processing pipeline configuration.
-        arguments (dict[str, Any]): Arguments to pass to the function.
-        function (str): Name of the function being called (derived from tool).
-        _content_fields (list): Fields to include in log content section.
-    """
-
-    func_tool: Tool | None = Field(default=None, exclude=True)
-    _content_fields: list = PrivateAttr(
-        default=["execution_response", "arguments", "function"]
-    )
-    arguments: dict[str, Any] | None = None
-    function: str | None = None
-
-    def __init__(
-        self,
-        func_tool: Tool,
-        arguments: dict[str, Any],
-        timed_config: dict | TimedFuncCallConfig = None,
-        **kwargs: Any,
-    ) -> None:
-        """Initialize a FunctionCalling instance.
-
-        Args:
-            func_tool: Tool containing the function to invoke and its
-                processing pipeline configuration.
-            arguments: Arguments to pass to the function.
-            timed_config: Configuration for timing and retries.
-                If None, uses default config.
-            **kwargs: Additional keyword arguments for timed config.
-        """
-        super().__init__(timed_config=timed_config, **kwargs)
-        self.func_tool = func_tool
-        self.arguments = arguments or {}
-        self.function = self.func_tool.function_name
-
-    @override
-    async def invoke(self) -> Any:
-        """Asynchronously invokes the function with stored arguments.
-
-        Executes the complete function pipeline:
-        1. Pre-processes arguments using tool's pre_processor if defined
-        2. Executes function with timing and retry logic
-        3. Post-processes result using tool's post_processor if defined
-        4. Parses result using tool's parser if defined
-        5. Tracks execution status, timing, and any errors
-
-        Returns:
-            The final processed result of the function execution.
-            If execution fails, returns None and sets error information.
-
-        Note:
-            - All processing steps (pre/post/parse) are optional
-            - Timing information is stored in execution_time
-            - Errors are stored in execution_error
-            - Raw response is stored in execution_response
-            - Final status is stored in status
-        """
-        start = asyncio.get_event_loop().time()
-        try:
-            # Create inner function with pre/post processing
-            @cd.pre_post_process(
-                preprocess=self.func_tool.pre_processor,
-                postprocess=self.func_tool.post_processor,
-                preprocess_kwargs=self.func_tool.pre_processor_kwargs or {},
-                postprocess_kwargs=self.func_tool.post_processor_kwargs or {},
-            )
-            async def _inner(**kwargs) -> Any:
-                """Inner function that handles the actual execution.
-
-                Applies timing and retry logic through tcall, and handles
-                special case of timing information in result tuple.
-                """
-                config = self._timed_config.to_dict()
-                result = await tcall(
-                    self.func_tool.function, **kwargs, **config
-                )
-                # Handle tuple result from tcall when retry_timing is True
-                if isinstance(result, tuple) and len(result) == 2:
-                    return result[0]  # Return just the result, not timing info
-                return result
-
-            # Execute function with pre/post processing
-            result = await _inner(**self.arguments)
-            self.execution_response = result
-            self.execution_time = asyncio.get_event_loop().time() - start
-            self.status = EventStatus.COMPLETED
-
-            # Apply parser if defined
-            if self.func_tool.parser is not None:
-                if asyncio.iscoroutinefunction(self.func_tool.parser):
-                    result = await self.func_tool.parser(result)
-                else:
-                    result = self.func_tool.parser(result)
-            return result
-
-        except Exception as e:
-            self.status = EventStatus.FAILED
-            self.execution_error = str(e)
-            self.execution_time = asyncio.get_event_loop().time() - start
-            return None
-
-    def __str__(self) -> str:
-        """Returns a string representation of the function call.
-
-        Returns:
-            A string in the format "function_name(arguments)".
-        """
-        return f"{self.func_tool.function_name}({self.arguments})"
-
-    def __repr__(self) -> str:
-        """Returns a detailed string representation of the function call.
-
-        Returns:
-            A string containing the class name and key attributes.
-        """
-        return (
-            f"FunctionCalling(function={self.func_tool.function_name}, "
-            f"arguments={self.arguments})"
-        )
-
-
-__all__ = ["FunctionCalling"]

lionagi/core/action/tool.py

@@ -1,202 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-from datetime import datetime
-
-from pydantic import field_serializer, field_validator
-
-from lionagi.core.generic.types import Element
-from lionagi.core.typing import Any, Callable, Field, Literal, override
-from lionagi.libs.parse import function_to_schema, to_list
-
-
-class Tool(Element):
-    """Represents a callable tool with pre/post-processing capabilities.
-
-    A Tool wraps a function with optional pre-processing, post-processing,
-    and result parsing capabilities. It also maintains a schema describing
-    the function's interface in OpenAI function calling format.
-
-    The processing pipeline consists of:
-    1. Pre-processor: Transforms input arguments before function call
-    2. Function: The actual function being called
-    3. Post-processor: Transforms function result
-    4. Parser: Converts result to JSON serializable format
-
-    Each processing step is optional and can be configured independently.
-    The schema is automatically generated from the function's signature
-    and docstring unless explicitly provided.
-
-    Attributes:
-        function: The callable function of the tool.
-        schema_: Schema of the function in OpenAI format.
-        pre_processor: Optional function to preprocess input arguments.
-        pre_processor_kwargs: Optional kwargs for the pre-processor.
-        post_processor: Optional function to post-process the result.
-        post_processor_kwargs: Optional kwargs for the post-processor.
-        parser: Optional function to parse result to JSON format.
-    """
-
-    function: Callable[..., Any] = Field(
-        ...,
-        description="The callable function of the tool.",
-    )
-    schema_: dict[str, Any] | None = Field(
-        default=None,
-        description="Schema of the function in OpenAI format.",
-    )
-    pre_processor: Callable[[Any], Any] | None = Field(
-        default=None,
-        description="Function to preprocess input arguments.",
-    )
-    pre_processor_kwargs: dict[str, Any] | None = Field(
-        default=None,
-        description="Keyword arguments for the pre-processor.",
-    )
-    post_processor: Callable[[Any], Any] | None = Field(
-        default=None,
-        description="Function to post-process the result.",
-    )
-    post_processor_kwargs: dict[str, Any] | None = Field(
-        default=None,
-        description="Keyword arguments for the post-processor.",
-    )
-    parser: Callable[[Any], Any] | None = Field(
-        default=None,
-        description="Function to parse result to JSON serializable format.",
-    )
-
-    @override
-    def __init__(self, **data: Any) -> None:
-        """Initialize a Tool instance.
-
-        If schema_ is not provided, automatically generates it from the
-        function's signature and docstring.
-
-        Args:
-            **data: Keyword arguments to initialize the Tool instance.
-        """
-        super().__init__(**data)
-        if self.schema_ is None:
-            self.schema_ = function_to_schema(self.function)
-
-    @field_validator("function")
-    def _validate_function(cls, v: Any) -> Callable[..., Any]:
-        if not callable(v):
-            raise ValueError("Function must be callable.")
-        if not hasattr(v, "__name__"):
-            raise ValueError("Function must have a name.")
-        return v
-
-    @field_serializer(
-        "function",
-        "pre_processor",
-        "post_processor",
-        "parser",
-        "pre_processor_kwargs",
-        "post_processor_kwargs",
-    )
-    def serialize_field(self, v: Any) -> str | None:
-        """Serialize various fields of the Tool class.
-
-        Handles serialization of callable functions and dictionaries:
-        - Functions are serialized to their names
-        - Dictionaries are serialized to JSON strings
-        - Other values are returned as None
-
-        Args:
-            v: The value to serialize.
-
-        Returns:
-            str: Serialized representation of the value.
-            None: If value cannot be serialized.
-        """
-        if callable(v):
-            return v.__name__
-        elif isinstance(v, dict):
-            return json.dumps(v)
-        return None
-
-    @property
-    def function_name(self) -> str:
-        """Get the name of the function from the schema.
-
-        Returns:
-            str: The name of the function as defined in the schema.
-        """
-        return self.schema_["function"]["name"]
-
-    @override
-    def __str__(self) -> str:
-        """Return a string representation of the Tool.
-
-        Includes class name, ID, timestamp, and schema for debugging
-        and logging purposes.
-
-        Returns:
-            str: A detailed string representation of the Tool.
-        """
-        timestamp_str = self.created_datetime.strftime("%Y-%m-%d %H:%M:%S")
-        return (
-            f"{self.class_name()}(ln_id={str(self.ln_id)[:6]}.., "
-            f"created_timestamp={timestamp_str}), "
-            f"schema_={json.dumps(self.schema_, indent=4)}"
-        )
-
-
-def func_to_tool(
-    func_: Callable[..., Any] | list[Callable[..., Any]],
-    parser: Callable[[Any], Any] | list[Callable[[Any], Any]] | None = None,
-    docstring_style: Literal["google", "rest"] = "google",
-    **kwargs,
-) -> list[Tool]:
-    """Convert functions to Tool objects.
-
-    Helper function to create Tool instances from callable functions.
-    Supports both single functions and lists of functions, with optional
-    result parsers for each function.
-
-    Args:
-        func_: Single function or list of functions to convert.
-        parser: Optional parser(s) for function results. If provided for
-            multiple functions, must match length of func_ list.
-        docstring_style: Style of docstring parsing for schema generation.
-            Supports 'google' or 'rest' format.
-        **kwargs: Additional keyword arguments for Tool constructor.
-
-    Returns:
-        list[Tool]: List of Tool objects created from the functions.
-
-    Raises:
-        ValueError: If number of parsers doesn't match number of functions.
-
-    Example:
-        >>> def my_func(x: int) -> str:
-        ...     '''Convert int to string.'''
-        ...     return str(x)
-        >>> tools = func_to_tool(my_func)
-        >>> assert len(tools) == 1
-        >>> assert isinstance(tools[0], Tool)
-    """
-    funcs = to_list(func_)
-    parsers = to_list(parser)
-
-    if parser and len(funcs) != len(parsers):
-        raise ValueError("Length of parser must match length of func, ")
-
-    tools = []
-    for idx, func in enumerate(funcs):
-        tool = Tool(
-            function=func,
-            schema_=function_to_schema(func, style=docstring_style),
-            parser=parsers[idx] if parser else None,
-            **kwargs,
-        )
-        tools.append(tool)
-
-    return tools
-
-
-__all__ = ["Tool", "func_to_tool"]

lionagi/core/action/types.py

@@ -1,16 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from .action_manager import ActionManager
-from .base import ObservableAction
-from .function_calling import FunctionCalling
-from .tool import Tool, func_to_tool
-
-__all__ = (
-    "ObservableAction",
-    "FunctionCalling",
-    "Tool",
-    "func_to_tool",
-    "ActionManager",
-)

lionagi/core/communication/action_request.py

@@ -1,163 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing_extensions import override
-
-from lionagi.core.typing import ID, Any, Callable, IDType, Note
-from lionagi.libs.parse import to_dict
-from lionagi.libs.utils import copy
-
-from .message import MessageFlag, MessageRole, RoledMessage
-
-
-def prepare_action_request(
-    function: str | Callable,
-    arguments: dict,
-) -> Note:
-    """
-    Prepare an action request with function and arguments.
-
-    This function validates and formats the action request parameters,
-    ensuring arguments are properly structured as a dictionary.
-
-    Args:
-        function: Function to execute, either as name or callable
-        arguments: Arguments to pass to the function
-
-    Returns:
-        Note: Formatted action request
-
-    Raises:
-        ValueError: If arguments cannot be converted to a dictionary
-    """
-    args = copy(arguments)
-    if not isinstance(arguments, dict):
-        try:
-            arguments = to_dict(
-                args, fuzzy_parse=True, str_type="json", suppress=True
-            )
-            if not arguments:
-                arguments = to_dict(args, str_type="xml", suppress=True)
-            if not arguments or not isinstance(arguments, dict):
-                raise ValueError
-        except Exception:
-            raise ValueError("Arguments must be a dictionary.")
-    return Note(action_request={"function": function, "arguments": arguments})
-
-
-class ActionRequest(RoledMessage):
-    """
-    Represents a request for an action in the system.
-
-    This class encapsulates the details needed to execute a function call,
-    including the function name/reference and its arguments. It also tracks
-    whether the request has been responded to.
-
-    Example:
-        >>> request = ActionRequest(
-        ...     function="calculate_sum",
-        ...     arguments={"numbers": [1, 2, 3]},
-        ...     sender="user",
-        ...     recipient="system"
-        ... )
-        >>> print(request.function)
-        'calculate_sum'
-    """
-
-    @override
-    def __init__(
-        self,
-        function: str | Callable | MessageFlag,
-        arguments: dict | MessageFlag,
-        sender: ID.Ref | MessageFlag = None,
-        recipient: ID.Ref | MessageFlag = None,
-        protected_init_params: dict | None = None,
-    ) -> None:
-        """
-        Initialize an ActionRequest instance.
-
-        Args:
-            function: The function to be invoked
-            arguments: The arguments for the function
-            sender: The sender of the request
-            recipient: The recipient of the request
-            protected_init_params: Protected initialization parameters
-        """
-        message_flags = [function, arguments, sender, recipient]
-
-        if all(x == MessageFlag.MESSAGE_LOAD for x in message_flags):
-            protected_init_params = protected_init_params or {}
-            super().__init__(**protected_init_params)
-            return
-
-        if all(x == MessageFlag.MESSAGE_CLONE for x in message_flags):
-            super().__init__(role=MessageRole.ASSISTANT)
-            return
-
-        function = function.__name__ if callable(function) else function
-
-        super().__init__(
-            role=MessageRole.ASSISTANT,
-            content=prepare_action_request(
-                function=function, arguments=arguments
-            ),
-            sender=sender,
-            recipient=recipient,
-        )
-
-    @property
-    def action_response_id(self) -> IDType | None:
-        """
-        Get the ID of the corresponding action response.
-
-        Returns:
-            IDType | None: The ID of the action response, or None if not responded
-        """
-        return self.content.get("action_response_id", None)
-
-    @property
-    def is_responded(self) -> bool:
-        """
-        Check if the action request has been responded to.
-
-        Returns:
-            bool: True if the request has a response, False otherwise
-        """
-        return self.action_response_id is not None
-
-    @property
-    def request(self) -> dict[str, Any]:
-        """
-        Get the action request content as a dictionary.
-
-        Returns:
-            dict[str, Any]: The request content excluding output
-        """
-        a = copy(self.content.get("action_request", {}))
-        a.pop("output", None)
-        return a
-
-    @property
-    def arguments(self) -> dict[str, Any]:
-        """
-        Get the arguments for the action request.
-
-        Returns:
-            dict[str, Any]: The arguments dictionary
-        """
-        return self.request.get("arguments", {})
-
-    @property
-    def function(self) -> str:
-        """
-        Get the function name for the action request.
-
-        Returns:
-            str: The name of the function to be invoked
-        """
-        return self.request.get("function", "")
-
-    @override
-    def _format_content(self) -> dict[str, Any]:
-        return {"role": self.role.value, "content": self.request}

lionagi/core/communication/action_response.py

@@ -1,149 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from lionagi.core.typing import ID, Any, Note, override
-from lionagi.libs.utils import copy
-
-from .action_request import ActionRequest
-from .message import MessageFlag, MessageRole, RoledMessage
-
-
-def prepare_action_response_content(
-    action_request: ActionRequest,
-    output: Any,
-) -> Note:
-    """
-    Prepare the content for an action response.
-
-    Creates a standardized Note object containing the response details and
-    maintaining reference to the original request.
-
-    Args:
-        action_request: The original action request being responded to
-        output: The result from executing the requested function
-
-    Returns:
-        Note: Formatted action response content
-    """
-    return Note(
-        action_request_id=action_request.ln_id,
-        action_response={
-            "function": action_request.function,
-            "arguments": action_request.arguments,
-            "output": output,
-        },
-    )
-
-
-class ActionResponse(RoledMessage):
-    """
-    Represents a response to an action request in the system.
-
-    This class encapsulates the result of executing an action request,
-    maintaining references to the original request and providing access
-    to the execution results.
-
-    Example:
-        >>> request = ActionRequest(function="sum", arguments={"nums": [1,2,3]})
-        >>> response = ActionResponse(action_request=request, output=6)
-        >>> print(response.output)
-        6
-    """
-
-    @override
-    def __init__(
-        self,
-        action_request: ID[ActionRequest].Item,
-        output: Any = None,
-        protected_init_params: dict | None = None,
-    ) -> None:
-        """
-        Initialize an ActionResponse instance.
-
-        Args:
-            action_request: The original action request to respond to
-            output: The result from the function execution
-            protected_init_params: Protected initialization parameters
-
-        Raises:
-            ValueError: If action_request is invalid or already responded to
-        """
-        message_flags = [
-            action_request,
-            output,
-        ]
-
-        if all(x == MessageFlag.MESSAGE_LOAD for x in message_flags):
-            protected_init_params = protected_init_params or {}
-            super().__init__(**protected_init_params)
-            return
-
-        if all(x == MessageFlag.MESSAGE_CLONE for x in message_flags):
-            super().__init__(role=MessageRole.ASSISTANT)
-            return
-
-        super().__init__(
-            role=MessageRole.ASSISTANT,
-            recipient=action_request.sender,
-            sender=action_request.recipient,
-            content=prepare_action_response_content(
-                action_request=action_request,
-                output=output,
-            ),
-        )
-        action_request.content["action_response_id"] = self.ln_id
-
-    @property
-    def function(self) -> str:
-        """
-        Get the function name from the action response.
-
-        Returns:
-            str: The name of the function that was executed
-        """
-        return copy(self.content.get(["action_response", "function"]))
-
-    @property
-    def arguments(self) -> dict[str, Any]:
-        """
-        Get the function arguments from the action response.
-
-        Returns:
-            dict[str, Any]: The arguments that were used
-        """
-        return copy(self.content.get(["action_response", "arguments"]))
-
-    @property
-    def output(self) -> Any:
-        """
-        Get the function output from the action response.
-
-        Returns:
-            Any: The result returned by the function
-        """
-        return self.content.get(["action_response", "output"])
-
-    @property
-    def response(self) -> dict[str, Any]:
-        """
-        Get the complete action response as a dictionary.
-
-        Returns:
-            dict[str, Any]: The response including function details and output
-        """
-        return copy(self.content.get("action_response", {}))
-
-    @property
-    def action_request_id(self) -> ID[ActionRequest].ID | None:
-        """
-        Get the ID of the corresponding action request.
-
-        Returns:
-            ID[ActionRequest].ID | None: The ID of the original request
-        """
-        return copy(self.content.get("action_request_id", None))
-
-    @override
-    def _format_content(self) -> dict[str, Any]:
-        return {"role": self.role.value, "content": self.response}