lionagi 0.2.11__py3-none-any.whl → 0.3.1__py3-none-any.whl

lionagi/core/work/worklog.py

@@ -25,7 +25,9 @@ class WorkLog(Progressable):
                 Defaults to 1.
         """
         self.pile = (
-            workpile if workpile and isinstance(workpile, Pile) else pile({}, Work)
+            workpile
+            if workpile and isinstance(workpile, Pile)
+            else pile({}, Work)
         )
         self.pending = progression(workpile) if workpile else progression()
         self.queue = WorkQueue(capacity=capacity, refresh_time=refresh_time)

lionagi/experimental/compressor/llm_compressor.py

@@ -101,7 +101,12 @@ class LLMCompressor(TokenCompressor):
         return a(text, **kwargs)
 
     async def rank_by_pplex(
-        self, items: list, initial_text=None, cumulative=False, n_samples=None, **kwargs
+        self,
+        items: list,
+        initial_text=None,
+        cumulative=False,
+        n_samples=None,
+        **kwargs,
     ):
         """
         rank a list of items according to their perplexity
@@ -180,17 +185,23 @@ class LLMCompressor(TokenCompressor):
 
         if rank_by == "perplexity":
             ranked_items = await self.rank_by_pplex(
-                items=items, initial_text=initial_text, cumulative=cumulative, **kwargs
+                items=items,
+                initial_text=initial_text,
+                cumulative=cumulative,
+                **kwargs,
             )
 
-            prompt_tokens = sum([i[1]["num_prompt_tokens"] for i in ranked_items])
+            prompt_tokens = sum(
+                [i[1]["num_prompt_tokens"] for i in ranked_items]
+            )
 
             num_completion_tokens = sum(
                 [i[1]["num_completion_tokens"] for i in ranked_items]
             )
 
             price = (
-                prompt_tokens * 0.5 / 1000000 + num_completion_tokens * 1.5 / 1000000
+                prompt_tokens * 0.5 / 1000000
+                + num_completion_tokens * 1.5 / 1000000
             )
 
             selected_items = self.select_by_pplex(
@@ -227,7 +238,11 @@ class LLMCompressor(TokenCompressor):
         raise ValueError(f"Ranking method {rank_by} is not supported")
 
     def select_by_pplex(
-        self, ranked_items, target_compression_ratio, original_length, min_pplex=None
+        self,
+        ranked_items,
+        target_compression_ratio,
+        original_length,
+        min_pplex=None,
     ):
         min_pplex = min_pplex or 0
 

lionagi/experimental/directive/README.md

@@ -1 +1 @@
-TODO
+TODO

lionagi/experimental/directive/parser/base_parser.py

@@ -21,10 +21,10 @@ class BaseDirectiveParser:
         BaseToken(KEYWORD, IF)
     """
 
-    def __init__(self, tokens: List[BaseToken]):
+    def __init__(self, tokens: list[BaseToken]):
         self.tokens = tokens
         self.current_token_index = -1
-        self.current_token: Optional[BaseToken] = None
+        self.current_token: BaseToken | None = None
         self.next_token()
 
     def next_token(self) -> None:
@@ -50,13 +50,15 @@ class BaseDirectiveParser:
         else:
             return None
 
-    def skip_until(self, token_types: List[str]) -> 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:
+        while (
+            self.current_token and self.current_token.type not in token_types
+        ):
             self.next_token()
 
     def mark(self) -> int:
@@ -108,10 +110,15 @@ class BaseDirectiveParser:
         """
         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"):
+        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
+            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
@@ -126,11 +133,16 @@ class BaseDirectiveParser:
         Raises:
             SyntaxError: If the IF statement is not properly formed.
         """
-        if self.current_token.type != "KEYWORD" or self.current_token.value != "IF":
+        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
+        condition = (
+            self.parse_expression()
+        )  # Now properly ends after the semicolon
 
         true_block = []
         if self.current_token.value == "DO":
@@ -156,7 +168,10 @@ class BaseDirectiveParser:
         Raises:
             SyntaxError: If the FOR statement is not properly formed.
         """
-        if self.current_token.type != "KEYWORD" or self.current_token.value != "FOR":
+        if (
+            self.current_token.type != "KEYWORD"
+            or self.current_token.value != "FOR"
+        ):
             raise SyntaxError("Expected FOR statement")
         self.next_token()  # Skip 'FOR'
 
@@ -167,7 +182,10 @@ class BaseDirectiveParser:
         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":
+        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'
 
@@ -194,7 +212,9 @@ class BaseDirectiveParser:
         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",):
+        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()
@@ -217,11 +237,16 @@ class BaseDirectiveParser:
         Raises:
             SyntaxError: If the TRY statement is not properly formed.
         """
-        if self.current_token.type != "KEYWORD" or self.current_token.value != "TRY":
+        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'
+        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"):
@@ -256,7 +281,9 @@ class BaseDirectiveParser:
                 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
+                block.append(
+                    self.current_token.value
+                )  # Add the action to the block
                 self.next_token()
 
         return block

lionagi/experimental/directive/parser/base_syntax.txt

@@ -24,11 +24,11 @@ ELIF
 ELSE
 
 # loop
-FOR 
+FOR
 IN
 
 # EXCEPTION
-TRY 
+TRY
 EXCEPT
 
 """
@@ -54,33 +54,33 @@ tools 1,2,3
 
 def main():  <-> compose
 
-    If condition1 && condition2 || !condition3; 
+    If condition1 && condition2 || !condition3;
     DO tool1(param1, param2);
     ENDIF;
-    
+
     IF  must follow condition, (condition parsing logic);
     DO ....;
     ENDIF;
-    
-    
-    
-    
-THEN; 
+
+
+
+
+THEN;
     DO tool2(param1, param2);
-    
+
 THEN;
-    
-    TRY; DO ACTION_C; 
-    EXCEPT; DO ACTION_D;    
-    ENDEXCEPT; 
-    ENDTRY; 
+
+    TRY; DO ACTION_C;
+    EXCEPT; DO ACTION_D;
+    ENDEXCEPT;
+    ENDTRY;
 
     RETURN  <-> run
 
 
 
 
-COMPOSE; - indicate the beginning of a script-like block to execute 
+COMPOSE; - indicate the beginning of a script-like block to execute
 
 THEN; - indicate continuation of a script-like block, another statement to execute
 
@@ -91,7 +91,7 @@ XX;  ; END XX;
 
 
 
-TRY; DO ACTION_A; END TRY; 
+TRY; DO ACTION_A; END TRY;
 
 
 
@@ -108,15 +108,15 @@ 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; 
+DO ACTION B;
 
-IF 
+IF
 THEN
 
 GROUP
@@ -150,7 +150,7 @@ 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); 
+ENDTRY; ELIF condition2; DO action2(param1, param2); ELSE DO action3(param1, param2);
 ENDIF; END;
 
 """
@@ -180,7 +180,7 @@ 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)
@@ -197,4 +197,4 @@ run 1,2,3,4,5
 
 1->2, or 1->3, or 1->4, THEN....
 
-"""
+"""

lionagi/experimental/directive/template/base_template.py

@@ -11,9 +11,11 @@ class DirectiveTemplate:
         self.template_str = template_str
         self.evaluator = BaseEvaluator()
 
-    def _render_conditionals(self, context: Dict[str, Any]) -> str:
+    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)
+        pattern = re.compile(
+            r"\{if (.*?)\}(.*?)\{else\}(.*?)\{endif\}", re.DOTALL
+        )
 
         def evaluate_condition(match):
             condition, if_text, else_text = match.groups()
@@ -24,9 +26,11 @@ class DirectiveTemplate:
 
         return pattern.sub(evaluate_condition, self.template_str)
 
-    def _render_loops(self, template: str, context: Dict[str, Any]) -> 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)
+        loop_pattern = re.compile(
+            r"\{for (\w+) in (\w+)\}(.*?)\{endfor\}", re.DOTALL
+        )
 
         def render_loop(match):
             iterator_var, collection_name, loop_body = match.groups()
@@ -46,7 +50,9 @@ class DirectiveTemplate:
 
         return loop_pattern.sub(render_loop, template)
 
-    def fill(self, template_str: str = "", context: Dict[str, Any] = {}) -> str:
+    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
@@ -54,7 +60,9 @@ class DirectiveTemplate:
         # 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)
+        template_with_loops = self._render_loops(
+            template_with_conditionals, context
+        )
         # Finally, substitute the placeholders with context values
         try:
             return template_with_loops.format(**context)

lionagi/experimental/directive/tokenizer.py

@@ -44,7 +44,9 @@ class BaseTokenizer:
                     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]}")
+                raise SyntaxError(
+                    f"Unexpected character: {self.script[position]}"
+                )
                 # break
 
     def get_tokens(self):

lionagi/experimental/evaluator/README.md

@@ -1 +1 @@
-TODO
+TODO

lionagi/experimental/evaluator/ast_evaluator.py

@@ -26,7 +26,9 @@ class ASTEvaluator:
             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}")
+            raise ValueError(
+                f"Failed to evaluate expression: {expression}. Error: {e}"
+            )
 
     def _evaluate_node(self, node, context):
         if isinstance(node, ast.Compare):
@@ -104,7 +106,9 @@ class ASTEvaluationEngine:
                 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):
+            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)

lionagi/experimental/evaluator/base_evaluator.py

@@ -1,6 +1,7 @@
 import ast
 import operator
-from typing import Any, Callable, Dict, Tuple
+from collections.abc import Callable
+from typing import Any, Dict, Tuple
 
 from lionagi.libs.ln_convert import to_dict
 
@@ -16,7 +17,7 @@ class BaseEvaluator:
 
     def __init__(self) -> None:
         """Initializes the evaluator with supported operators and an empty cache."""
-        self.allowed_operators: Dict[type, Any] = {
+        self.allowed_operators: dict[type, Any] = {
             ast.Add: operator.add,
             ast.Sub: operator.sub,
             ast.Mult: operator.mul,
@@ -34,9 +35,9 @@ class BaseEvaluator:
             ast.Not: operator.not_,
             ast.USub: operator.neg,
         }
-        self.cache: Dict[Tuple[str, Tuple], Any] = {}
+        self.cache: dict[tuple[str, tuple], Any] = {}
 
-    def evaluate(self, expression: str, context: Dict[str, Any]) -> Any:
+    def evaluate(self, expression: str, context: dict[str, Any]) -> Any:
         """
         Evaluates a given expression string using the provided context.
 
@@ -60,9 +61,11 @@ class BaseEvaluator:
             self.cache[cache_key] = result
             return result
         except Exception as e:
-            raise ValueError(f"Failed to evaluate expression: {expression}. Error: {e}")
+            raise ValueError(
+                f"Failed to evaluate expression: {expression}. Error: {e}"
+            )
 
-    def _evaluate_node(self, node: ast.AST, context: Dict[str, Any]) -> Any:
+    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)
@@ -87,7 +90,9 @@ class BaseEvaluator:
                     break
                 left = right
         elif isinstance(node, ast.BoolOp):
-            values = [self._evaluate_node(value, context) for value in node.values]
+            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):
@@ -104,12 +109,14 @@ class BaseEvaluator:
         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.")
+            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:
+            with open(file_path) as file:
                 last_result = None
                 for line in file:
                     line = line.strip()
@@ -117,7 +124,7 @@ class BaseEvaluator:
                         last_result = self.evaluate(line, context)
                 return last_result
         elif format == "json":
-            with open(file_path, "r") as file:
+            with open(file_path) as file:
                 data = to_dict(file)
                 last_result = None
                 for expression in data:
@@ -153,8 +160,8 @@ class BaseEvaluator:
 
 class BaseEvaluationEngine:
     def __init__(self) -> None:
-        self.variables: Dict[str, Any] = {}
-        self.functions: Dict[str, Callable] = {
+        self.variables: dict[str, Any] = {}
+        self.functions: dict[str, Callable] = {
             "print": print,
         }
 
@@ -181,16 +188,20 @@ class BaseEvaluationEngine:
         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._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 = [
+            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:

lionagi/integrations/bridge/autogen_/autogen_.py

@@ -18,14 +18,16 @@ def get_ipython_user_proxy():
             super().__init__(name, **kwargs)
             self._ipython = get_ipython()
 
-        def generate_init_message(self, *args, **kwargs) -> Union[str, Dict]:
+        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)
+            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:
@@ -60,7 +62,9 @@ def get_autogen_coder(
         SysUtil.check_import("autogen", pip_name="pyautogen")
 
         import autogen
-        from autogen.agentchat.contrib.gpt_assistant_agent import GPTAssistantAgent
+        from autogen.agentchat.contrib.gpt_assistant_agent import (
+            GPTAssistantAgent,
+        )
     except Exception as e:
         raise ImportError(f"Please install autogen. {e}")
 

lionagi/integrations/bridge/langchain_/documents.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Dict, List, TypeVar, Union
+from collections.abc import Callable
+from typing import Any, Dict, List, TypeVar, Union
 
 from lionfuncs import check_import
 
@@ -39,9 +40,9 @@ def to_langchain_document(datanode: T, **kwargs: Any) -> Any:
 
 
 def langchain_loader(
-    loader: Union[str, Callable],
-    loader_args: List[Any] = [],
-    loader_kwargs: Dict[str, Any] = {},
+    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.
@@ -67,7 +68,9 @@ def langchain_loader(
     """
 
     document_loaders = check_import(
-        "langchain_community", module_name="document_loaders", pip_name="langchain"
+        "langchain_community",
+        module_name="document_loaders",
+        pip_name="langchain",
     )
 
     try:
@@ -87,11 +90,11 @@ def langchain_loader(
 
 
 def langchain_text_splitter(
-    data: Union[str, List],
-    splitter: Union[str, Callable],
-    splitter_args: List[Any] = None,
-    splitter_kwargs: Dict[str, Any] = None,
-) -> List[str]:
+    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.