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

lionagi/experimental/directive/parser/base_parser.py

@@ -1,294 +0,0 @@
-from typing import List, Optional
-
-from lionagi.experimental.directive.tokenizer import BaseToken
-
-from ..template.schema import ForNode, IfNode, TryNode
-
-
-class BaseDirectiveParser:
-    """A base parser with lookahead, error recovery, and backtracking support.
-
-    Attributes:
-        tokens (List[BaseToken]): A list of tokens to be parsed.
-        current_token_index (int): The index of the current token in the tokens list.
-        current_token (Optional[BaseToken]): The current token being processed.
-
-    Examples:
-        >>> tokenizer = BaseTokenizer("IF x > 10 THEN DO something ENDIF")
-        >>> tokens = tokenizer.get_tokens()
-        >>> parser = BaseParser(tokens)
-        >>> print(parser.current_token)
-        BaseToken(KEYWORD, IF)
-    """
-
-    def __init__(self, tokens: list[BaseToken]):
-        self.tokens = tokens
-        self.current_token_index = -1
-        self.current_token: BaseToken | None = None
-        self.next_token()
-
-    def next_token(self) -> None:
-        """Advances to the next token in the list."""
-        self.current_token_index += 1
-        if self.current_token_index < len(self.tokens):
-            self.current_token = self.tokens[self.current_token_index]
-        else:
-            self.current_token = None
-
-    def peek_next_token(self, offset: int = 1) -> BaseToken | None:
-        """Peeks at the next token without consuming it.
-
-        Args:
-            offset (int): The number of tokens to look ahead.
-
-        Returns:
-            Optional[BaseToken]: The token at the specified lookahead offset, or None if end of list.
-        """
-        peek_index = self.current_token_index + offset
-        if peek_index < len(self.tokens):
-            return self.tokens[peek_index]
-        else:
-            return None
-
-    def skip_until(self, token_types: list[str]) -> None:
-        """Skips tokens until a token of the specified type is found.
-
-        Args:
-            token_types (List[str]): A list of token types to stop skipping.
-        """
-        while (
-            self.current_token and self.current_token.type not in token_types
-        ):
-            self.next_token()
-
-    def mark(self) -> int:
-        """Marks the current position in the token list for potential backtracking.
-
-        Returns:
-            int: The current token index.
-        """
-        return self.current_token_index
-
-    def reset_to_mark(self, mark: int) -> None:
-        """Resets the parser to a previously marked position.
-
-        Args:
-            mark (int): The token index to reset to.
-        """
-        self.current_token_index = mark - 1
-        self.next_token()
-
-    def skip_semicolon(self):
-        """Skips a semicolon token if it is the current token."""
-        if self.current_token and self.current_token.value == ";":
-            self.next_token()
-
-    def parse_expression(self):
-        """Parses an expression until a semicolon is encountered.
-
-        Returns:
-            str: The parsed expression as a string.
-
-        Raises:
-            SyntaxError: If a semicolon is not found at the end of the expression.
-        """
-        expr = ""
-        while self.current_token and self.current_token.value != ";":
-            expr += self.current_token.value + " "
-            self.next_token()
-        # Expecting a semicolon at the end of the condition
-        if self.current_token.value != ";":
-            raise SyntaxError("Expected ';' at the end of the condition")
-        self.next_token()  # Move past the semicolon to the next part of the statement
-        return expr.strip()
-
-    def parse_if_block(self):
-        """Parses a block of statements for an IF condition.
-
-        Returns:
-            list: The parsed block of statements as a list of strings.
-        """
-        block = []
-        # Parse the block until 'ELSE', 'ENDIF', ensuring not to include semicolons as part of the block
-        while self.current_token and self.current_token.value not in (
-            "ENDIF",
-            "ELSE",
-        ):
-            if self.current_token.value == "DO":
-                self.next_token()  # Move past 'DO' to get to the action
-            block.append(
-                self.current_token.value
-            )  # Add the action to the block
-            self.next_token()  # Move to the next token, which could be a semicolon or the next action
-            if self.current_token.value == ";":
-                self.next_token()  # Move past the semicolon
-        return block
-
-    def parse_if_statement(self):
-        """Parses an IF statement.
-
-        Returns:
-            IfNode: The parsed IF statement as an IfNode object.
-
-        Raises:
-            SyntaxError: If the IF statement is not properly formed.
-        """
-        if (
-            self.current_token.type != "KEYWORD"
-            or self.current_token.value != "IF"
-        ):
-            raise SyntaxError("Expected IF statement")
-        self.next_token()  # Skip 'IF'
-
-        condition = (
-            self.parse_expression()
-        )  # Now properly ends after the semicolon
-
-        true_block = []
-        if self.current_token.value == "DO":
-            true_block = self.parse_if_block()  # Parse true block after 'DO'
-
-        false_block = None
-        if self.current_token and self.current_token.value == "ELSE":
-            self.next_token()  # Skip 'ELSE', expect 'DO' next for the false block
-            self.skip_semicolon()
-            if self.current_token.value != "DO":
-                raise SyntaxError("Expected 'DO' after 'ELSE'")
-            self.next_token()  # Skip 'DO'
-            false_block = self.parse_if_block()  # Parse false block
-
-        return IfNode(condition, true_block, false_block)
-
-    def parse_for_statement(self):
-        """Parses a FOR statement.
-
-        Returns:
-            ForNode: The parsed FOR statement as a ForNode object.
-
-        Raises:
-            SyntaxError: If the FOR statement is not properly formed.
-        """
-        if (
-            self.current_token.type != "KEYWORD"
-            or self.current_token.value != "FOR"
-        ):
-            raise SyntaxError("Expected FOR statement")
-        self.next_token()  # Skip 'FOR'
-
-        # Parse the iterator variable
-        if self.current_token.type != "IDENTIFIER":
-            raise SyntaxError("Expected iterator variable after FOR")
-        iterator = self.current_token.value
-        self.next_token()  # Move past the iterator variable
-
-        # Expect and skip 'IN' keyword
-        if (
-            self.current_token.type != "KEYWORD"
-            or self.current_token.value != "IN"
-        ):
-            raise SyntaxError("Expected 'IN' after iterator variable")
-        self.next_token()  # Move past 'IN'
-
-        # Parse the collection
-        if self.current_token.type not in ["IDENTIFIER", "LITERAL"]:
-            raise SyntaxError("Expected collection after 'IN'")
-        collection = self.current_token.value
-        self.next_token()  # Move past the collection
-
-        # Now, parse the block of statements to execute
-        true_block = self.parse_for_block()
-
-        # Construct and return a ForNode
-        return ForNode(iterator, collection, true_block)
-
-    def parse_for_block(self):
-        """Parses a block of statements for a FOR loop.
-
-        Returns:
-            list: The parsed block of statements as a list of strings.
-        """
-        block = []
-        # Skip initial 'DO' if present
-        if self.current_token and self.current_token.value == "DO":
-            self.next_token()
-
-        while self.current_token and self.current_token.value not in (
-            "ENDFOR",
-        ):
-            if self.current_token.value == ";":
-                # If a semicolon is encountered, skip it and move to the next token
-                self.next_token()
-                continue
-            # Add the current token to the block unless it's a 'DO' or ';'
-            if self.current_token.value != "DO":
-                block.append(self.current_token.value)
-            self.next_token()
-
-        # The loop exits when 'ENDFOR' is encountered; move past it for subsequent parsing
-        self.next_token()  # Skip 'ENDFOR'
-        return block
-
-    def parse_try_statement(self):
-        """Parses a TRY statement.
-
-        Returns:
-            TryNode: The parsed TRY statement as a TryNode object.
-
-        Raises:
-            SyntaxError: If the TRY statement is not properly formed.
-        """
-        if (
-            self.current_token.type != "KEYWORD"
-            or self.current_token.value != "TRY"
-        ):
-            raise SyntaxError("Expected TRY statement")
-        self.next_token()  # Skip 'TRY'
-
-        try_block = self.parse_try_block(
-            "EXCEPT"
-        )  # Parse the try block until 'EXCEPT'
-
-        # Now expecting 'EXCEPT' keyword
-        if not (self.current_token and self.current_token.value == "EXCEPT"):
-            raise SyntaxError("Expected 'EXCEPT' after try block")
-        self.next_token()  # Move past 'EXCEPT'
-
-        except_block = self.parse_try_block(
-            "ENDTRY"
-        )  # Parse the except block until 'ENDTRY'
-
-        # Ensure we are correctly positioned after 'ENDTRY'
-        if self.current_token and self.current_token.value != "ENDTRY":
-            raise SyntaxError("Expected 'ENDTRY' at the end of except block")
-        self.next_token()  # Move past 'ENDTRY' for subsequent parsing
-
-        return TryNode(try_block, except_block)
-
-    def parse_try_block(self, stop_keyword):
-        """Parses a block of statements for a TRY or EXCEPT clause.
-
-        Args:
-            stop_keyword (str): The keyword that indicates the end of the block.
-
-        Returns:
-            list: The parsed block of statements as a list of strings.
-        """
-        block = []
-        while self.current_token and self.current_token.value != stop_keyword:
-            if self.current_token.value == "DO":
-                self.next_token()  # Move past 'DO' to get to the action
-            elif self.current_token.value == ";":
-                self.next_token()  # Move past the semicolon
-                continue  # Skip adding ';' to the block
-            else:
-                block.append(
-                    self.current_token.value
-                )  # Add the action to the block
-                self.next_token()
-
-        return block
-
-
-# "IF condition1 && condition2; DO action2; ELSE; DO action3; ENDIF;"
-# "FOR input_ IN collections; DO action(input_); ENDFOR;"
-# "TRY; DO action(); EXCEPT; DO action(input_); ENDTRY;"

lionagi/experimental/directive/parser/base_syntax.txt

@@ -1,200 +0,0 @@
-
-"""
-# basic syntax
-executeAction(param1, param2) IF condition1 && condition2 || !condition3;
-
-# verb
-DO
-
-# logic operator
-
-AND: &&
-OR: ||
-NOT: !
-GREATER_THAN: >
-LESS_THAN: <
-GREATER_THAN_OR_EQUAL: >=
-LESS_THAN_OR_EQUAL: <=
-EQUAL: ==
-NOT_EQUAL: !=
-
-# conditions
-IF
-ELIF
-ELSE
-
-# loop
-FOR
-IN
-
-# EXCEPTION
-TRY
-EXCEPT
-
-"""
-
-"""
-DO: perform a single action
-THEN: extend directive to include more statment
-IF: condition
-
-FOR
-IN
-END
-BEGIN
-
-TRY
-EXCEPT
-
----
-
-tools 1,2,3
-
-
-
-def main():  <-> compose
-
-    If condition1 && condition2 || !condition3;
-    DO tool1(param1, param2);
-    ENDIF;
-
-    IF  must follow condition, (condition parsing logic);
-    DO ....;
-    ENDIF;
-
-
-
-
-THEN;
-    DO tool2(param1, param2);
-
-THEN;
-
-    TRY; DO ACTION_C;
-    EXCEPT; DO ACTION_D;
-    ENDEXCEPT;
-    ENDTRY;
-
-    RETURN  <-> run
-
-
-
-
-COMPOSE; - indicate the beginning of a script-like block to execute
-
-THEN; - indicate continuation of a script-like block, another statement to execute
-
-RUN; - indicate the end of script-like block, and let the script execute
-
-
-XX;  ; END XX;
-
-
-
-TRY; DO ACTION_A; END TRY;
-
-
-
-COMPOSE;
-
-IF CONDITION_A; DO ACTION_B; ELIF CONDITION_C; DO ACTION_D; ELSE; DO ACTION_E; ENDIF;
-
-THEN TRY; DO ACTION_C; EXCEPT; DO ACTION_D; ENDEXCEPT; ENDTRY;
-
-
-THEN TRY; DO ACTION_C ENDTRY;
-
-
-
-THEN IF EXCEPT; IF CONDITION_C; DO ACTION_D; ENDEXCEPT
-
-;
-THEN FOR ITEM IN COLLECTION; DO ACTION_E(input_.param1, input_.param2); ENDFOR
-RUN;
-
-
-
-DO ACTION B;
-
-IF
-THEN
-
-GROUP
-
-"""
-
-"""syntax:
-
-
-BEGIN; IF condition1 && condition2 || !condition3; THEN DO action(param1, param2); END IF; END;
-
-BEGIN; FOR input_ IN nested_structure; DO action(input_.param1, input_.param2); END FOR; END;
-
-BEGIN; DO action1(param1, param2); DO action2(param3, param4); END GROUP; END;
-
-
-"""
-
-"""
-FOR input_ IN nested_structure DO
-    executeAction(input_.param1, input_.param2);
-END FOR;
-"""
-
-"""
-example 1:
-
-BEGIN; IF condition1 && condition2 || !condition3; DO action1(param1, param2); ENDIF;
-FOR input_ IN collections DO action2(input_.param1, input_.param2); ENDFOR; END;
-
-
-example 2:
-BEGIN; IF condition1; TRY DO action1(param1, param2); EXCEPT DO action2(param3, param4);
-ENDTRY; ELIF condition2; DO action2(param1, param2); ELSE DO action3(param1, param2);
-ENDIF; END;
-
-"""
-
-"""
-BEGIN
-    executeAction1(param1, param2);
-    IF condition2 THEN executeAction2(param3, param4);
-    FOR input_ IN nested_structure DO
-        executeAction3(input_.param1, input_.param2);
-    END FOR;
-END;
-"""
-
-"""
-TRY
-    executeAction(param1, param2);
-EXCEPT
-    handleErrorAction(param1, param2);
-"""
-
-"""
-
-CHAT / REACT
-
-
-DO 1,2
-    session = Li.Session(..., tools=tools)
-    await alcall(session.branches, func_1)
-
-
-THEN DO 3,4
-    session.chat.py(3,4)
-
-
-THEN 5
-    session.chat.py(5)
-
-
-call (1,2,3,4,5)
-
-run 1,2,3,4,5
-
-
-1->2, or 1->3, or 1->4, THEN....
-
-"""

lionagi/experimental/directive/template/base_template.py

@@ -1,71 +0,0 @@
-import re
-from typing import Any, Dict
-
-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

@@ -1,36 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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/README.md

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