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

lionagi/experimental/directive/template/base_template.py

@@ -0,0 +1,79 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Any, Dict
+import re
+
+from ..evaluator.base_evaluator import BaseEvaluator
+
+
+class DirectiveTemplate:
+    """Enhanced base template class for processing templates with conditionals and loops."""
+
+    def __init__(self, template_str: str):
+        self.template_str = template_str
+        self.evaluator = BaseEvaluator()
+
+    def _render_conditionals(self, context: Dict[str, Any]) -> str:
+        """Processes conditional statements with improved logic and support for 'else'."""
+        pattern = re.compile(r"\{if (.*?)\}(.*?)\{else\}(.*?)\{endif\}", re.DOTALL)
+
+        def evaluate_condition(match):
+            condition, if_text, else_text = match.groups()
+            if self.evaluator.evaluate(condition, context):
+                return if_text
+            else:
+                return else_text
+
+        return pattern.sub(evaluate_condition, self.template_str)
+
+    def _render_loops(self, template: str, context: Dict[str, Any]) -> str:
+        """Processes loop statements within the template."""
+        loop_pattern = re.compile(r"\{for (\w+) in (\w+)\}(.*?)\{endfor\}", re.DOTALL)
+
+        def render_loop(match):
+            iterator_var, collection_name, loop_body = match.groups()
+            collection = context.get(collection_name, [])
+            if not isinstance(collection, (list, range)):
+                raise ValueError(
+                    f"Expected list or range for '{collection_name}', got {type(collection).__name__}."
+                )
+
+            loop_result = ""
+            for item in collection:
+                loop_context = context.copy()
+                loop_context[iterator_var] = item
+                loop_result += self.fill(loop_body, loop_context)
+
+            return loop_result
+
+        return loop_pattern.sub(render_loop, template)
+
+    def fill(self, template_str: str = "", context: Dict[str, Any] = {}) -> str:
+        """Fills the template with values from context after processing conditionals and loops."""
+        if not template_str:  # Use the instance's template if not provided
+            template_str = self.template_str
+
+        # First, process conditionals with 'else'
+        template_with_conditionals = self._render_conditionals(template_str)
+        # Then, process loops
+        template_with_loops = self._render_loops(template_with_conditionals, context)
+        # Finally, substitute the placeholders with context values
+        try:
+            return template_with_loops.format(**context)
+        except KeyError as e:
+            print(f"Missing key in context: {e}")
+            return template_with_loops

lionagi/experimental/directive/template/schema.py

@@ -0,0 +1,36 @@
+class Node:
+    """Base class for all nodes in the abstract syntax tree (AST)."""
+
+    pass
+
+
+class IfNode(Node):
+    """Represents an 'IF' statement in the AST."""
+
+    def __init__(self, condition, true_block, false_block=None):
+        self.condition = condition
+        self.true_block = true_block
+        self.false_block = false_block
+
+
+class ForNode(Node):
+    """Represents a 'FOR' loop in the AST."""
+
+    def __init__(self, iterator, collection, block):
+        self.iterator = iterator
+        self.collection = collection
+        self.block = block
+
+
+class TryNode(Node):
+    """Represents a 'TRY-EXCEPT' block in the AST."""
+
+    def __init__(self, try_block, except_block):
+        self.try_block = try_block
+        self.except_block = except_block
+
+
+class ActionNode(Node):
+
+    def __init__(self, action) -> None:
+        self.action = action

lionagi/experimental/directive/tokenizer.py

@@ -0,0 +1,73 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import re
+
+
+class BaseToken:
+    def __init__(self, type_, value):
+        self.type = type_
+        self.value = value
+
+    def __repr__(self):
+        return f"BaseDirectiveToken({self.type}, {self.value})"
+
+
+class BaseTokenizer:
+    TOKEN_TYPES = {
+        "KEYWORD": r"\b(BEGIN|END|IF|ELSE|FOR|IN|TRY|EXCEPT|ENDIF|ENDFOR|ENDTRY|DO)\b",
+        "OPERATOR": r"(==|!=|>=|<=|>|<|&&|\|\||!)",
+        "FUNCTION_CALL": r"\b[a-zA-Z_][a-zA-Z0-9_]*\b\((.*?)\)",
+        "LITERAL": r'(\d+|\'.*?\'|".*?")',
+        "IDENTIFIER": r"\b[a-zA-Z_][a-zA-Z0-9_]*\b",
+        "PUNCTUATION": r"(;|,|\(|\))",
+        "WHITESPACE": r"\s+",
+    }
+
+    def __init__(self, script):
+        self.script = script
+        self.tokens = []
+        self.tokenize()
+
+    @property
+    def is_empty(self):
+        return self.tokens == []
+
+    def tokenize(self):
+        position = 0
+        while position < len(self.script):
+            match = None
+            for type_, pattern in self.TOKEN_TYPES.items():
+                regex = re.compile(pattern)
+                match = regex.match(self.script, position)
+                if match:
+                    if type_ != "WHITESPACE":  # Ignore whitespace
+                        token = BaseToken(type_, match.group())
+                        self.tokens.append(token)
+                    position = match.end()  # Move past the matched token
+                    break
+            if not match:  # No match found, unrecognized token
+                raise SyntaxError(f"Unexpected character: {self.script[position]}")
+                # break
+
+    def get_tokens(self):
+        if self.is_empty:
+            try:
+                self.tokenize()
+            except SyntaxError as e:
+                print(e)
+                return []
+        return self.tokens

lionagi/experimental/evaluator/ast_evaluator.py

@@ -0,0 +1,131 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+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

@@ -0,0 +1,218 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import ast
+import operator
+from typing import Any, Dict, Tuple, Callable
+
+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, "r") 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, "r") 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

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

lionagi/experimental/strategies/base.py

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

lionagi/integrations/bridge/autogen_/autogen_.py

@@ -0,0 +1,124 @@
+from typing import Dict, Union
+
+
+def get_ipython_user_proxy():
+
+    try:
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("autogen", pip_name="pyautogen")
+
+        import autogen
+        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) -> Union[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)