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

lionagi/core/action/tool_manager.py

@@ -1,342 +0,0 @@
-import inspect
-from collections.abc import Callable
-from functools import singledispatchmethod
-from typing import Any, List, Tuple, Union
-
-from lionfuncs import function_to_schema, lcall, to_dict, to_list
-
-from lionagi.core.action.function_calling import FunctionCalling
-from lionagi.core.action.tool import TOOL_TYPE, Tool
-from lionagi.core.collections.abc import Actionable
-
-
-class ToolManager(Actionable):
-    """
-    Manages tools in the system. Provides functionality to register tools,
-    invoke them based on various input formats, and retrieve tool schemas.
-    """
-
-    def __init__(self, registry: dict[str, Tool] = None) -> None:
-        """
-        Initializes a new instance of ToolManager.
-
-        Args:
-            registry (dict[str, Tool], optional): A dictionary to store registered tools.
-                Defaults to an empty dictionary.
-        """
-        self.registry = registry or {}
-
-    def __contains__(self, tool) -> bool:
-        if isinstance(tool, Tool):
-            return tool.name in self.registry
-
-        elif isinstance(tool, str):
-            return tool in self.registry
-
-        elif inspect.isfunction(tool):
-            return tool.__name__ in self.registry
-
-        return False
-
-    def _register_tool(
-        self, tool: Tool | Callable, update: bool = False
-    ) -> bool:
-        """
-        Registers a single tool or multiple tools based on the input type.
-
-        Args:
-            tool (Any): Can be a single Tool, a list of Tools, a callable, or other forms.
-
-        Raises:
-            TypeError: If the tools argument type is unsupported.
-        """
-        if not update and tool in self:
-            raise ValueError(f"Function {tool.name} is already registered.")
-        if isinstance(tool, Callable):
-            tool = func_to_tool(tool)
-            tool = (
-                tool[0] if isinstance(tool, list) and len(tool) == 1 else tool
-            )
-        if not isinstance(tool, Tool):
-            raise TypeError("Please register a Tool object.")
-        self.registry[tool.name] = tool
-        return True
-
-    def update_tools(self, tools: list | Tool | Callable):
-        if isinstance(tools, Tool) or isinstance(tools, Callable):
-            return self._register_tool(tools, update=True)
-        else:
-            return all(lcall(tools, self._register_tool, update=True))
-
-    def register_tools(self, tools: list | Tool | Callable):
-        """
-        Registers multiple Tools.
-
-        Args:
-            tools (list): The list of Tools to register.
-
-        Returns:
-            bool: True if all tools are successfully registered.
-        """
-        if isinstance(tools, Tool) or isinstance(tools, Callable):
-            return self._register_tool(tools)
-        else:
-            return all(lcall(tools, self._register_tool))
-
-    async def invoke(self, func_calling=None):
-        """
-        Invokes a function based on the provided function calling description.
-
-        Args:
-            func_calling (Any, optional): The function calling description, which can be:
-                - tuple: (name, kwargs)
-                - dict: {"function": name, "arguments": kwargs}
-                - str: JSON string of dict format
-                - ActionRequest object
-                - FunctionCalling object
-
-        Returns:
-            Any: The result of the function call.
-
-        Raises:
-            ValueError: If func_calling is None or the function is not registered.
-        """
-        if not func_calling:
-            raise ValueError("func_calling is required.")
-
-        if not isinstance(func_calling, FunctionCalling):
-            func_calling = FunctionCalling.create(func_calling)
-
-        if func_calling.func_name in self.registry:
-            return await self.registry[func_calling.func_name].invoke(
-                func_calling=func_calling
-            )
-
-        raise ValueError(
-            f"Function {func_calling.func_name} is not registered."
-        )
-
-    @property
-    def _schema_list(self) -> list[dict[str, Any]]:
-        """
-        Lists all tool schemas currently registered in the ToolManager.
-
-        Returns:
-            list[dict[str, Any]]: A list of tool schemas.
-        """
-        return [tool.schema_ for tool in self.registry.values()]
-
-    def get_tool_schema(self, tools: TOOL_TYPE, **kwargs) -> dict:
-        """
-        Retrieves the schema for a specific tool or all tools based on the input.
-
-        Args:
-            tools (TOOL_TYPE): Can be a boolean, specific tool name, Tool, or list of tools.
-            **kwargs: Additional keyword arguments to be merged with tool schema.
-
-        Returns:
-            dict: Combined tool schema and kwargs.
-        """
-        if isinstance(tools, bool):
-            tool_kwarg = {"tools": self._schema_list}
-            return tool_kwarg | kwargs
-
-        else:
-            tool_kwarg = {"tools": self._get_tool_schema(tools)}
-            return tool_kwarg | kwargs
-
-    @singledispatchmethod
-    def _get_tool_schema(self, tool: Any) -> dict:
-        """
-        Retrieves the schema for a specific tool based on its type.
-
-        Args:
-            tool (Any): The tool descriptor, can be a dict, Tool, str, or list.
-
-        Raises:
-            TypeError: If the tool type is unsupported.
-        """
-        raise TypeError(f"Unsupported type {type(tool)}")
-
-    @_get_tool_schema.register(dict)
-    def _(self, tool):
-        """
-        Assumes that the tool is a schema and returns it.
-
-        Args:
-            tool (dict): The tool schema.
-
-        Returns:
-            dict: The tool schema.
-        """
-        return tool
-
-    @_get_tool_schema.register(Tool)
-    def _(self, tool):
-        """
-        Retrieves the schema for a Tool object.
-
-        Args:
-            tool (Tool): The Tool object.
-
-        Returns:
-            dict: The tool schema.
-
-        Raises:
-            ValueError: If the Tool is not registered.
-        """
-        if tool.name in self.registry:
-            return self.registry[tool.name].schema_
-        else:
-            err_msg = f"Function {tool.name} is not registered."
-            raise ValueError(err_msg)
-
-    @_get_tool_schema.register(str)
-    def _(self, tool):
-        """
-        Assumes that the tool is a name and retrieves its schema.
-
-        Args:
-            tool (str): The tool name.
-
-        Returns:
-            dict: The tool schema.
-
-        Raises:
-            ValueError: If the tool name is not registered.
-        """
-        if tool in self.registry:
-            return self.registry[tool].schema_
-        else:
-            err_msg = f"Function {tool} is not registered."
-            raise ValueError(err_msg)
-
-    @_get_tool_schema.register(list)
-    def _(self, tools):
-        """
-        Retrieves the schema for a list of tools.
-
-        Args:
-            tools (list): The list of tools.
-
-        Returns:
-            list: A list of tool schemas.
-        """
-        return lcall(tools, self._get_tool_schema)
-
-    def parse_tool(self, tools: TOOL_TYPE, **kwargs) -> dict:
-        """
-        Parses and merges tool schemas based on the provided tool descriptors.
-
-        Args:
-            tools (TOOL_TYPE): The tools to parse, can be a single tool or list.
-            **kwargs: Additional keyword arguments to be merged with the tool schema.
-
-        Returns:
-            dict: The merged tool schema and additional arguments.
-        """
-        if tools:
-            if isinstance(tools, bool):
-                tool_kwarg = {"tools": self._schema_list}
-                kwargs = tool_kwarg | kwargs
-            else:
-                tools = (
-                    to_list(tools) if not isinstance(tools, list) else [tools]
-                )
-                tool_kwarg = {"tools": lcall(tools, self._get_tool_schema)}
-                kwargs = tool_kwarg | kwargs
-
-        return kwargs
-
-    @staticmethod
-    def parse_tool_request(response: dict) -> tuple[str, dict]:
-        """
-        Parses a tool request from a given response dictionary.
-
-        Args:
-            response (dict): The response data containing the tool request.
-
-        Returns:
-            Tuple[str, dict]: The function name and its arguments.
-
-        Raises:
-            ValueError: If the response is not a valid function call.
-        """
-        try:
-            func = response["action"][7:]
-            args = 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 func_to_tool(
-    func_: Callable | list[Callable],
-    parser: Callable | list[Callable] = None,
-    docstring_style: str = "google",
-    **kwargs,
-) -> list[Tool]:
-    """
-    Converts functions to Tool objects, optionally associating parsers with each function
-    and applying a specified docstring parsing style to generate tool schemas.
-
-    Args:
-        func_ (Callable | list[Callable]): The function(s) to convert into tool(s).
-        parser (Callable | list[Callable], optional): Parser(s) to associate with
-            the function(s). If a list is provided, it should match the length of func_.
-        docstring_style (str, optional): The style of the docstring parser to use when
-            generating tool schemas. Defaults to "google".
-
-    Returns:
-        list[Tool]: A list of Tool objects created from the provided function(s).
-
-    Raises:
-        ValueError: If the length of the parsers does not match the length of the
-            functions when both are provided as lists.
-
-    Examples:
-        # Convert a single function with a custom parser
-        tools = func_to_tool(my_function, my_parser)
-
-        # Convert multiple functions without parsers
-        tools = func_to_tool([func_one, func_two])
-
-        # Convert multiple functions with multiple parsers
-        tools = func_to_tool([func_one, func_two], [parser_one, parser_two])
-    """
-    fs = []
-    funcs = to_list(func_, flatten=True, dropna=True)
-    parsers = 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(
-                function=_f,
-                schema_=function_to_schema(_f, style=docstring_style),
-                parser=parsers[idx] if len(parsers) > 1 else parsers[0],
-                **kwargs,
-            )
-
-            fs.append(f_)
-
-    else:
-        fs = lcall(
-            funcs,
-            lambda _f: Tool(
-                function=_f,
-                schema_=function_to_schema(_f, style=docstring_style),
-                **kwargs,
-            ),
-        )
-
-    return fs

lionagi/core/agent/README.md

@@ -1 +0,0 @@
-agent as worker with structured executor

lionagi/core/agent/base_agent.py

@@ -1,82 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-
-from lionagi.core.executor.base_executor import BaseExecutor
-from lionagi.core.generic.node import Node
-from lionagi.core.mail.mail_manager import MailManager
-from lionagi.core.mail.start_mail import StartMail
-from lionagi.libs import AsyncUtil, func_call
-
-
-class BaseAgent(Node):
-
-    def __init__(
-        self,
-        structure: BaseExecutor,
-        executable: BaseExecutor,
-        output_parser=None,
-        **kwargs,
-    ) -> None:
-        """
-        Initializes the BaseAgent instance.
-
-        Args:
-            structure: The structure of the agent.
-            executable_obj: The executable object of the agent.
-            output_parser: A function for parsing the agent's output (optional).
-        """
-        super().__init__(**kwargs)
-        self.structure: BaseExecutor = structure
-        self.executable: BaseExecutor = executable
-        self.start: StartMail = StartMail()
-        self.mail_manager: MailManager = MailManager(
-            [self.structure, self.executable, self.start]
-        )
-        self.output_parser: Callable | None = output_parser
-        self.start_context: Any | None = None
-
-    async def mail_manager_control(self, refresh_time=1):
-        """
-        Controls the mail manager execution based on the structure and executable states.
-
-        Args:
-            refresh_time: The time interval (in seconds) for checking the execution states (default: 1).
-        """
-        while (
-            not self.structure.execute_stop or not self.executable.execute_stop
-        ):
-            await AsyncUtil.sleep(refresh_time)
-        self.mail_manager.execute_stop = True
-
-    async def execute(self, context=None):
-        """
-        Executes the agent with the given context and returns the parsed output (if available).
-
-        Args:
-            context: The initial context for the agent (optional).
-
-        Returns:
-            The parsed output of the agent (if available).
-        """
-        self.start_context = context
-        self.start.trigger(
-            context=context,
-            structure_id=self.structure.ln_id,
-            executable_id=self.executable.ln_id,
-        )
-        await func_call.mcall(
-            [0.1, 0.1, 0.1, 0.1],
-            [
-                self.structure.execute,
-                self.executable.execute,
-                self.mail_manager.execute,
-                self.mail_manager_control,
-            ],
-        )
-
-        self.structure.execute_stop = False
-        self.executable.execute_stop = False
-        self.mail_manager.execute_stop = False
-
-        if self.output_parser:
-            return self.output_parser(self)

lionagi/core/agent/eval/README.md

@@ -1 +0,0 @@
-TODO

lionagi/core/agent/eval/evaluator.py

@@ -1 +0,0 @@
-# TODO

lionagi/core/agent/eval/vote.py

@@ -1,40 +0,0 @@
-# TODO
-
-# from lionagi.libs import func_call
-# import numpy as np
-# from lionagi.core.form.predict import predict
-# from lionagi.core.form.score import score
-
-
-# async def vote(
-#     sentence,
-#     directive=predict,
-#     num_generations=5,
-#     num_output=1,
-#     num_scorer=5,
-#     score_range=(0, 100),
-#     num_digit=2,
-#     scorer_instruction=None,
-#     **kwargs,
-# ):
-#     async def _inner(i):
-#         out_ = await directive(sentence, **kwargs)
-#         score_ = await score(
-#             out_.answer,
-#             context=sentence,
-#             instruction=scorer_instruction,
-#             score_range=score_range,
-#             num_digit=num_digit,
-#             num_instances=num_scorer,
-#             return_template=False,
-#         )
-
-#         out_.__setattr__("score", score_)
-#         return out_
-
-#     _outs = await func_call.alcall(list(range(num_generations)), _inner)
-
-#     top_index = np.argsort([i.score for i in _outs])[-num_output:]
-#     final_output = list(np.array(_outs)[top_index])
-
-#     return final_output[0] if len(final_output) == 1 else final_output

lionagi/core/agent/learn/learner.py

@@ -1,59 +0,0 @@
-# class LearningFramework:
-#     def __init__(self, learning_model: Any, learning_service: Any):
-#         self.learning_model = learning_model
-#         self.learning_service = learning_service
-
-#     async def learn_from_interaction(self, interaction_data: Dict[str, Any]) -> None:
-#         """
-#         Update the learning model based on interaction data.
-#         """
-#         # Update the embedded model
-#         self.learning_model.update(interaction_data)
-
-#         # Optionally send data to an external learning provider
-#         await self.learning_service.send_data_for_learning(interaction_data)
-
-#     async def adapt_response_strategy(self, context: Dict[str, Any]) -> Dict[str, Any]:
-#         """
-#         Adapt the assistant_response strategy based on learned patterns and context.
-#         """
-#         # Use the learning model to determine the adaptation strategy
-#         adaptation_strategy = self.learning_model.determine_strategy(context)
-#         return adaptation_strategy
-
-
-# class LearningAgent(TaskAgent):
-#     def __init__(
-#         self, name: Optional[str] = None, learning_model: Optional[Any] = None
-#     ):
-#         super().__init__(name)
-#         self.learning_model = learning_model
-
-#     async def learn_from_interaction(self, interaction_data: Any):
-#         """
-#         Update the learning model based on interaction data.
-#         This method should be implemented to integrate specific learning algorithms.
-#         """
-#         if self.learning_model:
-#             # Placeholder for learning logic. Implement learning model updates based on interaction data.
-#             print("Learning from interaction...")
-
-#     async def adapt_response_strategy(self, instruction: Any) -> Any:
-#         """
-#         Adapt the assistant_response strategy based on what has been learned.
-#         Override this method to implement adaptive assistant_response strategies.
-#         """
-#         # Example implementation. Use the learning model to adapt the assistant_response strategy.
-#         print("Adapting assistant_response strategy based on learned patterns...")
-#         # Placeholder for demonstration. Implement adaptive assistant_response generation based on the learning model.
-#         return "Adapted assistant_response based on learning."
-
-#     async def process_instruction(self, instruction: Any) -> Any:
-#         """
-#         Process instruction with learning and adaptation.
-#         """
-#         # Incorporate learning into the instruction processing.
-#         response = await super().process_instruction(instruction)
-#         await self.learn_from_interaction(instruction)
-#         adapted_response = await self.adapt_response_strategy(instruction)
-#         return adapted_response

lionagi/core/agent/plan/unit_template.py

@@ -1 +0,0 @@
-# TODO

lionagi/core/collections/README.md

@@ -1,23 +0,0 @@
-# LionAGI Core Collections
-
-The `lionagi.core.collections` module provides essential data structures and abstractions for managing collections, sequences, and flows of items within the LionAGI system. These components form the foundation for efficient storage, access, and manipulation of data in AI-driven applications.
-
-## Pile
-
-`Pile` is a versatile container for managing collections of `Element` objects. It offers ordered and type-validated storage, flexible key access, item retrieval and assignment, inclusion and exclusion operations, homogeneity checks, iteration, and arithmetic operations. `Pile` also supports insertion, appending, and conversion to DataFrame for easy data analysis.
-
-## Progression
-
-`Progression` represents a sequence of items with a specific order. It provides methods for managing and manipulating the order of items, including inclusion and exclusion, item retrieval and removal, appending, extending, copying, and clearing. `Progression` supports arithmetic operations for adding and subtracting items or progressions, and offers length and iteration capabilities.
-
-## Flow
-
-`Flow` represents a flow of categorical sequences, allowing for the organization and management of multiple `Progression` sequences within a single structure. It provides sequence storage, a registry for sequence lookup by name, a default sequence concept, sequence retrieval and appending, registration, item removal, and iteration over sequences. `Flow` makes it convenient to work with related sequences and perform operations across multiple sequences.
-
-## Exchange
-
-`Exchange` is designed to handle incoming and outgoing flows of items. It uses a `Pile` to store pending items and maintains separate collections for pending incoming and outgoing items. `Exchange` provides methods for including and excluding items based on their direction (incoming or outgoing), facilitating efficient item exchange processing.
-
-These core collections work together to provide a robust and flexible framework for managing data within the LionAGI system. They offer powerful capabilities for storing, accessing, and manipulating collections, sequences, and flows of items, enabling developers to build efficient and organized AI-driven applications.
-
-For detailed usage examples and advanced features, please refer to the individual component documentation and upcoming tutorials.

lionagi/core/collections/__init__.py

@@ -1,16 +0,0 @@
-from .exchange import Exchange
-from .flow import Flow, flow
-from .model import iModel
-from .pile import Pile, pile
-from .progression import Progression, progression
-
-__all__ = [
-    "iModel",
-    "Pile",
-    "pile",
-    "Progression",
-    "progression",
-    "Flow",
-    "flow",
-    "Exchange",
-]