lionagi 0.3.8__py3-none-any.whl → 0.5.0__py3-none-any.whl

lionagi/experimental/evaluator/ast_evaluator.py

@@ -1,119 +0,0 @@
-import ast
-import operator
-
-
-class ASTEvaluator:
-    """
-    Safely evaluates expressions using AST parsing to prevent unsafe operations.
-    """
-
-    def __init__(self):
-        self.allowed_operators = {
-            ast.Eq: operator.eq,
-            ast.NotEq: operator.ne,
-            ast.Lt: operator.lt,
-            ast.LtE: operator.le,
-            ast.Gt: operator.gt,
-            ast.GtE: operator.ge,
-            # Additional operators can be added here as needed
-        }
-
-    def evaluate(self, expression, context):
-        """
-        Evaluate a condition expression within a given context using AST parsing.
-        """
-        try:
-            tree = ast.parse(expression, mode="eval")
-            return self._evaluate_node(tree.body, context)
-        except Exception as e:
-            raise ValueError(
-                f"Failed to evaluate expression: {expression}. Error: {e}"
-            )
-
-    def _evaluate_node(self, node, context):
-        if isinstance(node, ast.Compare):
-            left = self._evaluate_node(node.left, context)
-            for operation, comparator in zip(node.ops, node.comparators):
-                op_func = self.allowed_operators.get(type(operation))
-                if not op_func:
-                    raise ValueError(
-                        f"Operation {type(operation).__name__} is not allowed."
-                    )
-                right = self._evaluate_node(comparator, context)
-                if not op_func(left, right):
-                    return False
-            return True
-        elif isinstance(node, ast.Name):
-            return context.get(node.id)
-        elif isinstance(node, ast.Constant):
-            return node.n
-        else:
-            raise ValueError(
-                "Unsupported AST node type encountered in condition evaluation."
-            )
-
-
-class ASTEvaluationEngine:
-    """
-    Executes scripts safely using the SafeEvaluator for expression evaluation.
-    """
-
-    def __init__(self):
-        self.variables = {}
-        self.safe_evaluator = ASTEvaluator()
-        self.functions = {
-            "processData": self.process_data,
-        }
-
-    def process_data(self, data):
-        # Example placeholder function for data processing
-        return data * 2
-
-    def _evaluate_expression(self, expression):
-        """
-        Evaluates expressions within scripts using SafeEvaluator.
-        """
-        # Here, 'self.variables' serves as the context for the evaluation
-        return self.safe_evaluator.evaluate(expression, self.variables)
-
-    def _assign_variable(self, var_name, value):
-        """
-        Assigns a value to a variable within the script's context.
-        """
-        self.variables[var_name] = value
-
-    def _execute_function(self, func_name, arg):
-        """
-        Executes a predefined function with the given argument.
-        """
-        if func_name in self.functions:
-            function = self.functions[func_name]
-            return function(arg)
-        else:
-            raise ValueError(f"Function '{func_name}' is not defined.")
-
-    def execute(self, script):
-        """
-        Parses and executes a script, handling variable assignments and function calls.
-        """
-        tree = ast.parse(script, mode="exec")
-        for stmt in tree.body:
-            if isinstance(stmt, ast.Assign):
-                var_name = stmt.targets[
-                    0
-                ].id  # Assumes single target assignment for simplicity
-                # Convert the AST node back to a string for evaluation
-                value_expr = ast.unparse(stmt.value)
-                value = self._evaluate_expression(value_expr)
-                self._assign_variable(var_name, value)
-            elif isinstance(stmt, ast.Expr) and isinstance(
-                stmt.value, ast.Call
-            ):
-                func_name = stmt.value.func.id
-                arg_expr = ast.unparse(stmt.value.args[0])
-                arg = self._evaluate_expression(arg_expr)
-                self._execute_function(func_name, arg)
-            else:
-                raise ValueError(
-                    "Unsupported statement type encountered in script execution."
-                )

lionagi/experimental/evaluator/base_evaluator.py

@@ -1,213 +0,0 @@
-import ast
-import operator
-from collections.abc import Callable
-from typing import Any, Dict, Tuple
-
-from lionagi.libs.ln_convert import to_dict
-
-
-class BaseEvaluator:
-    """
-    A class to evaluate mathematical and boolean expressions from strings using Python's AST.
-
-    Attributes:
-        allowed_operators (Dict[type, Any]): A dictionary mapping AST node types to their corresponding Python operator functions.
-        cache (Dict[Tuple[str, Tuple], Any]): A dictionary used to cache the results of evaluated expressions and sub-expressions.
-    """
-
-    def __init__(self) -> None:
-        """Initializes the evaluator with supported operators and an empty cache."""
-        self.allowed_operators: dict[type, Any] = {
-            ast.Add: operator.add,
-            ast.Sub: operator.sub,
-            ast.Mult: operator.mul,
-            ast.Div: operator.truediv,
-            ast.Pow: operator.pow,
-            ast.Mod: operator.mod,
-            ast.Eq: operator.eq,
-            ast.NotEq: operator.ne,
-            ast.Lt: operator.lt,
-            ast.LtE: operator.le,
-            ast.Gt: operator.gt,
-            ast.GtE: operator.ge,
-            ast.And: lambda x, y: x and y,
-            ast.Or: lambda x, y: x or y,
-            ast.Not: operator.not_,
-            ast.USub: operator.neg,
-        }
-        self.cache: dict[tuple[str, tuple], Any] = {}
-
-    def evaluate(self, expression: str, context: dict[str, Any]) -> Any:
-        """
-        Evaluates a given expression string using the provided context.
-
-        Args:
-            expression (str): The expression to evaluate.
-            context (Dict[str, Any]): A dictionary mapping variable names to their values.
-
-        Returns:
-            Any: The result of the evaluated expression.
-
-        Raises:
-            ValueError: If the expression cannot be evaluated.
-        """
-        cache_key = (expression, tuple(sorted(context.items())))
-        if cache_key in self.cache:
-            return self.cache[cache_key]
-
-        try:
-            tree = ast.parse(expression, mode="eval")
-            result = self._evaluate_node(tree.body, context)
-            self.cache[cache_key] = result
-            return result
-        except Exception as e:
-            raise ValueError(
-                f"Failed to evaluate expression: {expression}. Error: {e}"
-            )
-
-    def _evaluate_node(self, node: ast.AST, context: dict[str, Any]) -> Any:
-        """Recursively evaluates an AST node."""
-        if isinstance(node, ast.BinOp):
-            left = self._evaluate_node(node.left, context)
-            op_func = self.allowed_operators[type(node.op)]
-            right = self._evaluate_node(node.right, context)
-            result = op_func(left, right)
-        elif isinstance(node, ast.UnaryOp):
-            operand = self._evaluate_node(node.operand, context)
-            result = self.allowed_operators[type(node.op)](operand)
-        elif isinstance(node, ast.Name):
-            result = context.get(node.id, None)
-        elif isinstance(node, ast.Constant):
-            result = node.value
-        elif isinstance(node, ast.Compare):
-            left = self._evaluate_node(node.left, context)
-            result = True
-            for operation, comparator in zip(node.ops, node.comparators):
-                op_func = self.allowed_operators[type(operation)]
-                right = self._evaluate_node(comparator, context)
-                result = result and op_func(left, right)
-                if not result:
-                    break
-                left = right
-        elif isinstance(node, ast.BoolOp):
-            values = [
-                self._evaluate_node(value, context) for value in node.values
-            ]
-            if isinstance(node.op, ast.And):
-                result = all(values)
-            elif isinstance(node.op, ast.Or):
-                result = any(values)
-            else:
-                raise ValueError("Unsupported boolean operation.")
-        else:
-            raise ValueError("Unsupported operation in condition.")
-        return result
-
-    def add_custom_operator(self, operator_name, operation_func):
-        """Adds a custom operator to the evaluator."""
-        custom_node_class = type(operator_name, (ast.AST,), {})
-        if custom_node_class not in self.allowed_operators:
-            self.allowed_operators[custom_node_class] = operation_func
-        else:
-            raise ValueError(
-                f"Custom operator '{operator_name}' is already defined."
-            )
-
-    def evaluate_file(self, file_path, context, format="line"):
-        """Evaluates expressions from a file."""
-        if format == "line":
-            with open(file_path) as file:
-                last_result = None
-                for line in file:
-                    line = line.strip()
-                    if line:
-                        last_result = self.evaluate(line, context)
-                return last_result
-        elif format == "json":
-            with open(file_path) as file:
-                data = to_dict(file)
-                last_result = None
-                for expression in data:
-                    last_result = self.evaluate(expression, context)
-                return last_result
-        else:
-            raise ValueError(f"Unsupported file format: {format}")
-
-    def validate_expression(self, expression):
-        """Validates the given expression."""
-        try:
-            tree = ast.parse(expression, mode="eval")
-            self._validate_node(tree.body)
-            return True, "Expression is valid."
-        except Exception as e:
-            return False, f"Invalid expression: {str(e)}"
-
-    def _validate_node(self, node):
-        """Validates an AST node."""
-        if isinstance(
-            node, (ast.BinOp, ast.Compare, ast.BoolOp, ast.Name, ast.Constant)
-        ):
-            if (
-                isinstance(node, ast.BinOp)
-                and type(node.op) not in self.allowed_operators
-            ):
-                raise ValueError(
-                    f"Operation {type(node.op).__name__} is not supported."
-                )
-        else:
-            raise ValueError("Unsupported node type in expression.")
-
-
-class BaseEvaluationEngine:
-    def __init__(self) -> None:
-        self.variables: dict[str, Any] = {}
-        self.functions: dict[str, Callable] = {
-            "print": print,
-        }
-
-    def _evaluate_expression(self, expression: str) -> Any:
-        try:
-            return eval(expression, {}, self.variables)
-        except NameError as e:
-            raise ValueError(f"Undefined variable. {e}")
-
-    def _assign_variable(self, var_name: str, value: Any) -> None:
-        self.variables[var_name] = value
-
-    def _execute_function(self, func_name: str, *args: Any) -> None:
-        if func_name in self.functions:
-            self.functions[func_name](*args)
-        else:
-            raise ValueError(f"Function {func_name} not defined.")
-
-    def _execute_statement(self, stmt: ast.AST) -> None:
-        if isinstance(stmt, ast.Assign):
-            var_name = stmt.targets[0].id
-            value = self._evaluate_expression(ast.unparse(stmt.value))
-            self._assign_variable(var_name, value)
-        elif isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call):
-            func_name = stmt.value.func.id
-            args = [
-                self._evaluate_expression(ast.unparse(arg))
-                for arg in stmt.value.args
-            ]
-            self._execute_function(func_name, *args)
-        elif isinstance(stmt, ast.For):
-            iter_var = stmt.target.id
-            if (
-                isinstance(stmt.iter, ast.Call)
-                and stmt.iter.func.id == "range"
-            ):
-                start, end = (
-                    self._evaluate_expression(ast.unparse(arg))
-                    for arg in stmt.iter.args
-                )
-                for i in range(start, end):
-                    self.variables[iter_var] = i
-                    for body_stmt in stmt.body:
-                        self._execute_statement(body_stmt)
-
-    def execute(self, script: str) -> None:
-        tree = ast.parse(script)
-        for stmt in tree.body:
-            self._execute_statement(stmt)

lionagi/experimental/knowledge/base.py

@@ -1,10 +0,0 @@
-from ..collections import Pile, pile
-from ..collections.abc import Component, Field
-from ..generic import Node
-
-
-class Knowledge(Component):
-
-    knowledge_base: Pile[Node] = Field(
-        default_factory=pile,
-    )

lionagi/experimental/strategies/base.py

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

lionagi/integrations/bridge/__init__.py

@@ -1,4 +0,0 @@
-from .langchain_.langchain_bridge import LangchainBridge
-from .llamaindex_.llama_index_bridge import LlamaIndexBridge
-
-__all__ = ["LlamaIndexBridge", "LangchainBridge"]

lionagi/integrations/bridge/autogen_/autogen_.py

@@ -1,127 +0,0 @@
-from typing import Dict, Union
-
-from lionfuncs import check_import
-
-
-def get_ipython_user_proxy():
-
-    try:
-        autogen = check_import("autogen", pip_name="pyautogen")
-        from IPython import get_ipython
-
-    except Exception as e:
-        raise ImportError(f"Please install autogen and IPython. {e}")
-
-    class IPythonUserProxyAgent(autogen.UserProxyAgent):
-
-        def __init__(self, name: str, **kwargs):
-            super().__init__(name, **kwargs)
-            self._ipython = get_ipython()
-
-        def generate_init_message(self, *args, **kwargs) -> str | dict:
-            return (
-                super().generate_init_message(*args, **kwargs)
-                + """If you suggest code, the code will be executed in IPython."""
-            )
-
-        def run_code(self, code, **kwargs):
-            result = self._ipython.run_cell(
-                "%%capture --no-display cap\n" + code
-            )
-            log = self._ipython.ev("cap.stdout")
-            log += self._ipython.ev("cap.stderr")
-            if result.result is not None:
-                log += str(result.result)
-            exitcode = 0 if result.success else 1
-            if result.error_before_exec is not None:
-                log += f"\n{result.error_before_exec}"
-                exitcode = 1
-            if result.error_in_exec is not None:
-                log += f"\n{result.error_in_exec}"
-                exitcode = 1
-            return exitcode, log, None
-
-    return IPythonUserProxyAgent
-
-
-def get_autogen_coder(
-    llm_config=None,
-    code_execution_config=None,
-    kernal="python",
-    config_list=None,
-    max_consecutive_auto_reply=15,
-    temperature=0,
-    cache_seed=42,
-    env_="local",
-    assistant_instruction=None,
-):
-    assistant = ""
-    try:
-        from lionagi.libs import SysUtil
-
-        SysUtil.check_import("autogen", pip_name="pyautogen")
-
-        import autogen
-        from autogen.agentchat.contrib.gpt_assistant_agent import (
-            GPTAssistantAgent,
-        )
-    except Exception as e:
-        raise ImportError(f"Please install autogen. {e}")
-
-    if env_ == "local":
-        assistant = autogen.AssistantAgent(
-            name="assistant",
-            llm_config=llm_config
-            or {
-                "cache_seed": cache_seed,
-                "config_list": config_list,
-                "temperature": temperature,
-            },
-        )
-
-    elif env_ == "oai_assistant":
-        assistant = GPTAssistantAgent(
-            name="Coder Assistant",
-            llm_config={
-                "tools": [{"type": "code_interpreter"}],
-                "config_list": config_list,
-            },
-            instructions=assistant_instruction,
-        )
-
-    if kernal == "python":
-        user_proxy = autogen.UserProxyAgent(
-            name="user_proxy",
-            human_input_mode="NEVER",
-            max_consecutive_auto_reply=max_consecutive_auto_reply,
-            is_termination_msg=lambda x: x.get("content", "")
-            .rstrip()
-            .endswith("TERMINATE"),
-            code_execution_config=code_execution_config
-            or {
-                "work_dir": "coding",
-                "use_docker": False,
-            },
-        )
-        return user_proxy, assistant
-
-    elif kernal == "ipython":
-        user_proxy = get_ipython_user_proxy(
-            "ipython_user_proxy",
-            human_input_mode="NEVER",
-            max_consecutive_auto_reply=max_consecutive_auto_reply,
-            is_termination_msg=lambda x: x.get("content", "")
-            .rstrip()
-            .endswith("TERMINATE")
-            or x.get("content", "").rstrip().endswith('"TERMINATE".'),
-        )
-        return user_proxy, assistant
-
-    # # Sample Usage Pattern
-    # context = "def my_function():\n    pass\n"
-    # task1 = "I need help with the following code:\n"
-    # task2 = "Please write a function that returns the sum of two numbers."
-
-    # user_proxy, assistant = get_autogen_coder()
-    # user_proxy.initiate_chat(assistant, message=task1+context)
-    # user_proxy.send(recipient=assistant, message=task2)

lionagi/integrations/bridge/langchain_/documents.py

@@ -1,138 +0,0 @@
-from collections.abc import Callable
-from typing import Any, Dict, List, TypeVar, Union
-
-from lionfuncs import check_import
-
-from lionagi.libs.sys_util import SysUtil
-
-T = TypeVar("T")
-
-
-def to_langchain_document(datanode: T, **kwargs: Any) -> Any:
-    """
-    Converts a generic data node into a Langchain Document.
-
-    This function transforms a node, typically from another data schema, into a Langchain Document format.
-    It requires the source node to have a `to_dict` method to convert it into a dictionary, then it renames specific keys
-    to match the Langchain Document schema before creating a Langchain Document object.
-
-    Args:
-            datanode (T): The data node to convert. Must have a `to_dict` method.
-            **kwargs: Additional keyword arguments to be passed to the Langchain Document constructor.
-
-    Returns:
-            Any: An instance of `LangchainDocument` populated with data from the input node.
-    """
-
-    LangchainDocument = check_import(
-        "langchain", module_name="schema", import_name="Document"
-    )
-
-    dnode = datanode.to_dict()
-    SysUtil.change_dict_key(dnode, old_key="content", new_key="page_content")
-    SysUtil.change_dict_key(dnode, old_key="lc_id", new_key="id_")
-    dnode = {**dnode, **kwargs}
-    dnode = {k: v for k, v in dnode.items() if v is not None}
-    if "page_content" not in dnode:
-        dnode["page_content"] = ""
-
-    return LangchainDocument(**dnode)
-
-
-def langchain_loader(
-    loader: str | Callable,
-    loader_args: list[Any] = [],
-    loader_kwargs: dict[str, Any] = {},
-) -> Any:
-    """
-    Initializes and uses a specified loader to load data within the Langchain ecosystem.
-
-    This function supports dynamically selecting a loader by name or directly using a loader function.
-    It passes specified arguments and keyword arguments to the loader for data retrieval or processing.
-
-    Args:
-            loader (Union[str, Callable]): A string representing the loader's name or a callable loader function.
-            loader_args (List[Any], optional): A list of positional arguments for the loader.
-            loader_kwargs (Dict[str, Any], optional): A dictionary of keyword arguments for the loader.
-
-    Returns:
-            Any: The result returned by the loader function, typically data loaded into a specified format.
-
-    Raises:
-            ValueError: If the loader cannot be initialized or fails to load data.
-
-    Examples:
-            >>> data = langchain_loader("json_loader", loader_args=["data.json"])
-            >>> isinstance(data, dict)
-            True
-    """
-
-    document_loaders = check_import(
-        "langchain_community",
-        module_name="document_loaders",
-        pip_name="langchain",
-    )
-
-    try:
-        if isinstance(loader, str):
-            loader = getattr(document_loaders, loader)
-        else:
-            loader = loader
-    except Exception as e:
-        raise ValueError(f"Invalid loader: {loader}. Error: {e}")
-
-    try:
-        loader_obj = loader(*loader_args, **loader_kwargs)
-        data = loader_obj.load()
-        return data
-    except Exception as e:
-        raise ValueError(f"Failed to load. Error: {e}")
-
-
-def langchain_text_splitter(
-    data: str | list,
-    splitter: str | Callable,
-    splitter_args: list[Any] = None,
-    splitter_kwargs: dict[str, Any] = None,
-) -> list[str]:
-    """
-    Splits text or a list of texts using a specified Langchain text splitter.
-
-    This function allows for dynamic selection of a text splitter, either by name or as a function, to split text
-    or documents into chunks. The splitter can be configured with additional arguments and keyword arguments.
-
-    Args:
-            data (Union[str, List]): The text or list of texts to be split.
-            splitter (Union[str, Callable]): The name of the splitter function or the splitter function itself.
-            splitter_args (List[Any], optional): Positional arguments to pass to the splitter function.
-            splitter_kwargs (Dict[str, Any], optional): Keyword arguments to pass to the splitter function.
-
-    Returns:
-            List[str]: A list of text chunks produced by the text splitter.
-
-    Raises:
-            ValueError: If the splitter is invalid or fails during the split operation.
-    """
-    splitter_args = splitter_args or []
-    splitter_kwargs = splitter_kwargs or {}
-
-    SysUtil.check_import("langchain")
-    import langchain_text_splitters as text_splitter
-
-    try:
-        if isinstance(splitter, str):
-            splitter = getattr(text_splitter, splitter)
-        else:
-            splitter = splitter
-    except Exception as e:
-        raise ValueError(f"Invalid text splitter: {splitter}. Error: {e}")
-
-    try:
-        splitter_obj = splitter(*splitter_args, **splitter_kwargs)
-        if isinstance(data, str):
-            chunk = splitter_obj.split_text(data)
-        else:
-            chunk = splitter_obj.split_documents(data)
-        return chunk
-    except Exception as e:
-        raise ValueError(f"Failed to split. Error: {e}")