lionagi 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

lionagi/core/tool/tool_manager.py

@@ -1,283 +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 tools:
-            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/report/form.py

@@ -1,64 +0,0 @@
-from pydantic import Field
-
-# from lionagi import logging as _logging
-from lionagi.core.generic import BaseComponent
-from lionagi.experimental.report.util import get_input_output_fields, system_fields
-
-
-class Form(BaseComponent):
-
-    assignment: str = Field(..., examples=["input1, input2 -> output"])
-
-    input_fields: list[str] = Field(default_factory=list)
-    output_fields: list[str] = Field(default_factory=list)
-
-    def __init__(self, **kwargs):
-        """
-        at initialization, all relevant fields if not already provided, are set to None,
-        not every field is required to be filled, nor required to be declared at initialization
-        """
-        super().__init__(**kwargs)
-        self.input_fields, self.output_fields = get_input_output_fields(self.assignment)
-        for i in self.input_fields + self.output_fields:
-            if i not in self.model_fields:
-                self._add_field(i, value=None)
-
-    @property
-    def workable(self):
-        if self.filled:
-            return False
-
-        for i in self.input_fields:
-            if not getattr(self, i, None):
-                return False
-
-        return True
-
-    @property
-    def work_fields(self):
-        dict_ = self.to_dict()
-        return {
-            k: v
-            for k, v in dict_.items()
-            if k not in system_fields and k in self.input_fields + self.output_fields
-        }
-
-    @property
-    def filled(self):
-        return all([value is not None for _, value in self.work_fields.items()])
-
-    def fill(self, form: "Form" = None, **kwargs):
-        """
-        only work fields for this form can be filled
-        a field can only be filled once
-        """
-        if self.filled:
-            raise ValueError("Form is already filled")
-
-        fields = form.work_fields if form else {}
-        kwargs = {**fields, **kwargs}
-
-        for k, v in kwargs.items():
-            if k not in self.work_fields:
-                raise ValueError(f"Field {k} is not a valid work field")
-            setattr(self, k, v)

lionagi/experimental/report/report.py

@@ -1,138 +0,0 @@
-from typing import Any, Type
-from pydantic import Field
-
-# from lionagi import logging as _logging
-from lionagi.core.generic import BaseComponent
-from lionagi.experimental.report.form import Form
-from lionagi.experimental.report.util import get_input_output_fields
-
-
-class Report(BaseComponent):
-
-    assignment: str = Field(..., examples=["input1, input2 -> output"])
-
-    forms: dict[str, Form] = Field(
-        default_factory=dict,
-        description="A dictionary of forms related to the report, in {assignment: Form} format.",
-    )
-
-    form_assignments: list = Field(
-        [],
-        description="assignment for the report",
-        examples=[["a, b -> c", "a -> e", "b -> f", "c -> g", "e, f, g -> h"]],
-    )
-
-    form_template: Type[Form] = Field(
-        Form, description="The template for the forms in the report."
-    )
-
-    input_fields: list[str] = Field(default_factory=list)
-    output_fields: list[str] = Field(default_factory=list)
-
-    def __init__(self, **kwargs):
-        """
-        at initialization, all relevant fields if not already provided, are set to None
-        """
-        super().__init__(**kwargs)
-        self.input_fields, self.output_fields = get_input_output_fields(self.assignment)
-
-        # if assignments is not provided, set it to assignment
-        if self.form_assignments == []:
-            self.form_assignments.append(self.assignment)
-
-        # create forms
-        new_forms = {i: self.form_template(assignment=i) for i in self.form_assignments}
-
-        # add new forms into the report (will ignore new forms already in the
-        # report with same assignment)
-        for k, v in new_forms.items():
-            if k not in self.forms:
-                self.forms[k] = v
-
-        # if the fields are not declared in the report, add them to report
-        # with value set to None
-        for k, v in self.forms.items():
-            for f in list(v.work_fields.keys()):
-                if f not in self.model_fields:
-                    field = v.model_fields[f]
-                    self._add_field(f, value=None, field=field)
-
-        # if there are fields in the report that are not in the forms, add them to
-        # the forms with values
-        for k, v in self.model_fields.items():
-            if getattr(self, k, None) is not None:
-                for f in self.forms.values():
-                    if k in f.work_fields:
-                        f.fill(**{k: getattr(self, k)})
-
-    @property
-    def work_fields(self) -> dict[str, Any]:
-        """
-        all work fields across all forms, including intermediate output fields,
-        this information is extracted from the forms
-        """
-
-        all_fields = {}
-        for form in self.forms.values():
-            for k, v in form.work_fields.items():
-                if k not in all_fields:
-                    all_fields[k] = v
-        return all_fields
-
-    def fill(self, **kwargs):
-        """
-        fill the information to both the report and forms
-        """
-        kwargs = {**self.work_fields, **kwargs}
-        for k, v in kwargs.items():
-            if k in self.work_fields and getattr(self, k, None) is None:
-                setattr(self, k, v)
-
-        for form in self.forms.values():
-            if not form.filled:
-                _kwargs = {k: v for k, v in kwargs.items() if k in form.work_fields}
-                form.fill(**_kwargs)
-
-    @property
-    def filled(self):
-        return all([value is not None for _, value in self.work_fields.items()])
-
-    @property
-    def workable(self) -> bool:
-
-        if self.filled:
-            # _logging.info("The report is already filled, no need to work on it.")
-            return False
-
-        for i in self.input_fields:
-            if not getattr(self, i, None):
-                # _logging.error(f"Field '{i}' is required to work on the report.")
-                return False
-
-        # this is the required fields from report's own assignment
-        fields = self.input_fields
-        fields.extend(self.output_fields)
-
-        # if the report's own assignment is not in the forms, return False
-        for f in fields:
-            if f not in self.work_fields:
-                # _logging.error(f"Field {f} is a required deliverable, not found in work field.")
-                return False
-
-        # get all the output fields from all the forms
-        outs = []
-        for form in self.forms.values():
-            outs.extend(form.output_fields)
-
-        # all output fields should be unique, not a single output field should be
-        # calculated by more than one form
-        if len(outs) != len(set(outs)):
-            # _logging.error("There are duplicate output fields in the forms.")
-            return False
-
-        return True
-
-    @property
-    def next_forms(self) -> list[Form] | None:
-        a = [i for i in self.forms.values() if i.workable]
-        return a if len(a) > 0 else None

lionagi/experimental/report/util.py

@@ -1,47 +0,0 @@
-from lionagi.libs import convert
-
-system_fields = [
-    "id_",
-    "node_id",
-    "meta",
-    "metadata",
-    "timestamp",
-    "content",
-    "assignment",
-    "assignments",
-    "task",
-    "template_name",
-    "version",
-    "description",
-    "in_validation_kwargs",
-    "out_validation_kwargs",
-    "fix_input",
-    "fix_output",
-    "input_fields",
-    "output_fields",
-    "choices",
-    "prompt_fields",
-    "prompt_fields_annotation",
-    "instruction_context",
-    "instruction",
-    "instruction_output_fields",
-    "inputs",
-    "outputs",
-    "process",
-    "_validate_field",
-    "_process_input",
-    "_process_response",
-    "_validate_field_choices",
-    "_validate_input_choices",
-    "_validate_output_choices",
-]
-
-
-def get_input_output_fields(str_: str) -> list[list[str]]:
-
-    inputs, outputs = str_.split("->")
-
-    input_fields = [convert.strip_lower(i) for i in inputs.split(",")]
-    output_fields = [convert.strip_lower(o) for o in outputs.split(",")]
-
-    return input_fields, output_fields

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.")