lionagi 0.2.10__py3-none-any.whl → 0.3.0__py3-none-any.whl

lionagi/core/collections/pile.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Iterable
+from collections.abc import AsyncIterator, Callable, Iterable
 from functools import wraps
-from typing import Any, AsyncIterator, Callable, Generic, Type, TypeVar
+from typing import Any, Generic, Type, TypeVar
 
 from pydantic import Field, field_validator
 
@@ -55,7 +55,7 @@ class Pile(Element, Record, Generic[T]):
 
     use_obj: bool = False
     pile: dict[str, T] = Field(default_factory=dict)
-    item_type: set[Type[Element]] | None = Field(default=None)
+    item_type: set[type[Element]] | None = Field(default=None)
     name: str | None = None
     order: list[str] = Field(default_factory=list)
     index: Any = None
@@ -91,7 +91,7 @@ class Pile(Element, Record, Generic[T]):
             )
         self.order = order
 
-    def __getitem__(self, key) -> T | "Pile[T]":
+    def __getitem__(self, key) -> T | Pile[T]:
         """
         Retrieve items from the pile using a key.
 
@@ -117,7 +117,11 @@ class Pile(Element, Record, Generic[T]):
                 _key = self.order[key]
                 _key = [_key] if isinstance(key, int) else _key
                 _out = [self.pile.get(i) for i in _key]
-                return _out[0] if len(_out) == 1 else pile(_out, self.item_type, _key)
+                return (
+                    _out[0]
+                    if len(_out) == 1
+                    else pile(_out, self.item_type, _key)
+                )
         except IndexError as e:
             raise ItemNotFoundError(key) from e
 
@@ -130,7 +134,9 @@ class Pile(Element, Record, Generic[T]):
                 keys[idx] = item.ln_id
 
         if not all(keys):
-            raise LionTypeError("Invalid item type. Expected LionIDable object(s).")
+            raise LionTypeError(
+                "Invalid item type. Expected LionIDable object(s)."
+            )
 
         try:
             if len(keys) == 1:
@@ -164,7 +170,9 @@ class Pile(Element, Record, Generic[T]):
                 raise e
 
             if isinstance(_key, str) and len(item) != 1:
-                raise ValueError("Cannot assign multiple items to a single item.")
+                raise ValueError(
+                    "Cannot assign multiple items to a single item."
+                )
 
             if isinstance(_key, list) and len(item) != len(_key):
                 raise ValueError(
@@ -173,7 +181,9 @@ class Pile(Element, Record, Generic[T]):
 
             for k, v in item.items():
                 if self.item_type and type(v) not in self.item_type:
-                    raise LionTypeError(f"Invalid item type. Expected {self.item_type}")
+                    raise LionTypeError(
+                        f"Invalid item type. Expected {self.item_type}"
+                    )
 
                 self.pile[k] = v
                 self.order[key] = k
@@ -181,7 +191,9 @@ class Pile(Element, Record, Generic[T]):
             return
 
         if len(to_list_type(key)) != len(item):
-            raise ValueError("The length of keys does not match the length of values")
+            raise ValueError(
+                "The length of keys does not match the length of values"
+            )
 
         self.pile.update(item)
         self.order.extend(item.keys())
@@ -210,7 +222,7 @@ class Pile(Element, Record, Generic[T]):
 
         return True
 
-    def pop(self, key: Any, default=...) -> T | "Pile[T]" | None:
+    def pop(self, key: Any, default=...) -> T | Pile[T] | None:
         """
         Remove and return item(s) associated with given key.
 
@@ -247,7 +259,7 @@ class Pile(Element, Record, Generic[T]):
 
         return pile(items) if len(items) > 1 else items[0]
 
-    def get(self, key: Any, default=...) -> T | "Pile[T]" | None:
+    def get(self, key: Any, default=...) -> T | Pile[T] | None:
         """
         Retrieve item(s) associated with given key.
 
@@ -366,7 +378,7 @@ class Pile(Element, Record, Generic[T]):
         """
         return len(self.pile)
 
-    def __add__(self, other: T) -> "Pile":
+    def __add__(self, other: T) -> Pile:
         """Create a new pile by including item(s) using `+`.
 
         Returns a new `Pile` with all items from the current pile plus
@@ -387,7 +399,7 @@ class Pile(Element, Record, Generic[T]):
             return _copy
         raise LionValueError("Item cannot be included in the pile.")
 
-    def __sub__(self, other) -> "Pile":
+    def __sub__(self, other) -> Pile:
         """
         Create a new pile by excluding item(s) using `-`.
 
@@ -412,7 +424,7 @@ class Pile(Element, Record, Generic[T]):
             raise LionValueError("Item cannot be excluded from the pile.")
         return _copy
 
-    def __iadd__(self, other: T) -> "Pile":
+    def __iadd__(self, other: T) -> Pile:
         """
         Include item(s) in the current pile in place using `+=`.
 
@@ -425,7 +437,7 @@ class Pile(Element, Record, Generic[T]):
 
         return self + other
 
-    def __isub__(self, other: LionIDable) -> "Pile":
+    def __isub__(self, other: LionIDable) -> Pile:
         """
         Exclude item(s) from the current pile using `-=`.
 
@@ -440,7 +452,7 @@ class Pile(Element, Record, Generic[T]):
         """
         return self - other
 
-    def __radd__(self, other: T) -> "Pile":
+    def __radd__(self, other: T) -> Pile:
         return other + self
 
     def __ior__(self, other: Any | Pile) -> Pile:
@@ -630,7 +642,9 @@ class Pile(Element, Record, Generic[T]):
                 )
 
         if len(value) != len(set(value)):
-            raise LionValueError("Detected duplicated item types in item_type.")
+            raise LionValueError(
+                "Detected duplicated item types in item_type."
+            )
 
         if len(value) > 0:
             return set(value)
@@ -716,7 +730,9 @@ class Pile(Element, Record, Generic[T]):
 
         raise ValueError("Invalid index type")
 
-    def create_query_engine(self, index_type="llama_index", engine_kwargs={}, **kwargs):
+    def create_query_engine(
+        self, index_type="llama_index", engine_kwargs={}, **kwargs
+    ):
         """
         Create a query engine for the pile.
 
@@ -730,7 +746,9 @@ class Pile(Element, Record, Generic[T]):
         """
         if index_type == "llama_index":
             if "node_postprocessor" in kwargs:
-                engine_kwargs["node_postprocessor"] = kwargs.pop("node_postprocessor")
+                engine_kwargs["node_postprocessor"] = kwargs.pop(
+                    "node_postprocessor"
+                )
             if "llm" in kwargs:
                 engine_kwargs["llm"] = kwargs.pop("llm")
             if not self.index:
@@ -740,7 +758,9 @@ class Pile(Element, Record, Generic[T]):
         else:
             raise ValueError("Invalid index type")
 
-    def create_chat_engine(self, index_type="llama_index", engine_kwargs={}, **kwargs):
+    def create_chat_engine(
+        self, index_type="llama_index", engine_kwargs={}, **kwargs
+    ):
         """
         Create a chat engine for the pile.
 
@@ -754,7 +774,9 @@ class Pile(Element, Record, Generic[T]):
         """
         if index_type == "llama_index":
             if "node_postprocessor" in kwargs:
-                engine_kwargs["node_postprocessor"] = kwargs.pop("node_postprocessor")
+                engine_kwargs["node_postprocessor"] = kwargs.pop(
+                    "node_postprocessor"
+                )
             if "llm" in kwargs:
                 engine_kwargs["llm"] = kwargs.pop("llm")
             if not self.index:
@@ -764,7 +786,9 @@ class Pile(Element, Record, Generic[T]):
         else:
             raise ValueError("Invalid index type")
 
-    async def query_pile(self, query, engine_kwargs={}, return_dict=False, **kwargs):
+    async def query_pile(
+        self, query, engine_kwargs={}, return_dict=False, **kwargs
+    ):
         """
         Query the pile using the created query engine.
 
@@ -784,7 +808,9 @@ class Pile(Element, Record, Generic[T]):
             return to_dict(response)
         return str(response)
 
-    async def chat_pile(self, query, engine_kwargs={}, return_dict=False, **kwargs):
+    async def chat_pile(
+        self, query, engine_kwargs={}, return_dict=False, **kwargs
+    ):
         """
         Chat with the pile using the created chat engine.
 
@@ -805,7 +831,12 @@ class Pile(Element, Record, Generic[T]):
         return str(response)
 
     async def embed_pile(
-        self, imodel=None, field="content", embed_kwargs={}, verbose=True, **kwargs
+        self,
+        imodel=None,
+        field="content",
+        embed_kwargs={},
+        verbose=True,
+        **kwargs,
     ):
         """
         Embed the items in the pile.
@@ -829,7 +860,9 @@ class Pile(Element, Record, Generic[T]):
         @cd.max_concurrency(max_concurrency)
         async def _embed_item(item):
             try:
-                return await imodel.embed_node(item, field=field, **embed_kwargs)
+                return await imodel.embed_node(
+                    item, field=field, **embed_kwargs
+                )
             except ModelLimitExceededError:
                 pass
             return None
@@ -933,10 +966,14 @@ class Pile(Element, Record, Generic[T]):
 
         async def query(query: str):
             if query_type == "query":
-                return await self.query_pile(query, return_dict=return_dict, **kwargs)
+                return await self.query_pile(
+                    query, return_dict=return_dict, **kwargs
+                )
 
             elif query_type == "chat":
-                return await self.chat_pile(query, return_dict=return_dict, **kwargs)
+                return await self.chat_pile(
+                    query, return_dict=return_dict, **kwargs
+                )
 
         name = name or "query"
         tool = func_to_tool(query)[0]
@@ -1157,7 +1194,7 @@ class Pile(Element, Record, Generic[T]):
 
 def pile(
     items: Iterable[T] | None = None,
-    item_type: set[Type] | None = None,
+    item_type: set[type] | None = None,
     order=None,
     use_obj=None,
     csv_file=None,

lionagi/core/collections/progression.py

@@ -47,8 +47,7 @@ class Progression(Element, Ordering):
         yield from self.order
 
     def items(self):
-        for idx, item in enumerate(self.order):
-            yield idx, item
+        yield from enumerate(self.order)
 
     def size(self):
         return len(self)

lionagi/core/collections/util.py

@@ -1,7 +1,14 @@
 from collections import deque
 from collections.abc import Generator, Mapping
 
-from .abc import Component, Element, LionTypeError, Ordering, Record, get_lion_id
+from .abc import (
+    Component,
+    Element,
+    LionTypeError,
+    Ordering,
+    Record,
+    get_lion_id,
+)
 
 
 def to_list_type(value):
@@ -21,7 +28,9 @@ def to_list_type(value):
     Raises:
         TypeError: If the value cannot be converted to a list.
     """
-    if isinstance(value, Component) and not isinstance(value, (Record, Ordering)):
+    if isinstance(value, Component) and not isinstance(
+        value, (Record, Ordering)
+    ):
         return [value]
     if isinstance(value, (Mapping, Record)):
         return list(value.values())

lionagi/core/director/README.md

@@ -1 +1 @@
-director is an agent specialized in writing directives
+director is an agent specialized in writing directives

lionagi/core/engine/branch_engine.py

@@ -122,7 +122,9 @@ class BranchExecutor(Branch, BaseExecutor):
                     request_source=self.ln_id,
                 )
             except Exception as e:
-                raise ValueError(f"Invalid mail to process. Mail:{mail}, Error: {e}")
+                raise ValueError(
+                    f"Invalid mail to process. Mail:{mail}, Error: {e}"
+                )
 
     def _process_node_list(self, mail: Mail):
         """
@@ -134,9 +136,16 @@ class BranchExecutor(Branch, BaseExecutor):
         Raises:
             ValueError: When trying to process multiple paths which is currently unsupported.
         """
-        self.send(mail.sender, category="end", package="end", request_source=self.ln_id)
+        self.send(
+            mail.sender,
+            category="end",
+            package="end",
+            request_source=self.ln_id,
+        )
         self.execute_stop = True
-        raise ValueError("Multiple path selection is not supported in BranchExecutor")
+        raise ValueError(
+            "Multiple path selection is not supported in BranchExecutor"
+        )
 
     async def _process_condition(self, mail: Mail):
         """
@@ -159,7 +168,9 @@ class BranchExecutor(Branch, BaseExecutor):
             request_source=self.ln_id,
         )
 
-    def _system_process(self, system: System, verbose=True, context_verbose=False):
+    def _system_process(
+        self, system: System, verbose=True, context_verbose=False
+    ):
         """
         Processes a system node, possibly displaying its content and context if verbose is enabled.
 
@@ -174,7 +185,9 @@ class BranchExecutor(Branch, BaseExecutor):
         from IPython.display import Markdown, display
 
         if verbose:
-            print(f"------------------Welcome: {system.sender}--------------------")
+            print(
+                f"------------------Welcome: {system.sender}--------------------"
+            )
             with contextlib.suppress(Exception):
                 system.content = ParseUtil.fuzzy_parse_json(system.content)
             display(Markdown(f"system: {convert.to_str(system.system_info)}"))
@@ -201,7 +214,9 @@ class BranchExecutor(Branch, BaseExecutor):
 
         if verbose:
             with contextlib.suppress(Exception):
-                instruction.content = ParseUtil.fuzzy_parse_json(instruction.content)
+                instruction.content = ParseUtil.fuzzy_parse_json(
+                    instruction.content
+                )
             display(
                 Markdown(
                     f"{instruction.sender}: {convert.to_str(instruction.instruct)}"
@@ -210,11 +225,15 @@ class BranchExecutor(Branch, BaseExecutor):
 
         if self.context:
             result = await self.chat(
-                instruction=instruction.instruct, context=self.context, **kwargs
+                instruction=instruction.instruct,
+                context=self.context,
+                **kwargs,
             )
             self.context = None
         else:
-            result = await self.chat(instruction=instruction.instruct, **kwargs)
+            result = await self.chat(
+                instruction=instruction.instruct, **kwargs
+            )
             # instruction._add_context(context=self.context)
             # self.context_log.append(self.context)
             # self.context = None
@@ -224,7 +243,9 @@ class BranchExecutor(Branch, BaseExecutor):
             if "assistant_response" in result.keys():
                 result = result["assistant_response"]
         if verbose:
-            display(Markdown(f"assistant {self.ln_id}: {convert.to_str(result)}"))
+            display(
+                Markdown(f"assistant {self.ln_id}: {convert.to_str(result)}")
+            )
             print("-----------------------------------------------------")
 
         self.execution_responses.append(result)
@@ -276,7 +297,11 @@ class BranchExecutor(Branch, BaseExecutor):
 
         if verbose:
             if action.directive == "chat":
-                display(Markdown(f"assistant {self.ln_id}: {convert.to_str(result)}"))
+                display(
+                    Markdown(
+                        f"assistant {self.ln_id}: {convert.to_str(result)}"
+                    )
+                )
             else:
                 display(Markdown(f"assistant {self.ln_id}:\n"))
                 for k, v in result.work_fields.items():

lionagi/core/engine/instruction_map_engine.py

@@ -23,9 +23,12 @@ class InstructionMapEngine(BaseExecutor):
     """
 
     branches: Pile[BranchExecutor] = Field(
-        default_factory=dict, description="The branches of the instruction mapping."
+        default_factory=dict,
+        description="The branches of the instruction mapping.",
+    )
+    structure_id: str = Field(
+        "", description="The ID of the executable structure."
     )
-    structure_id: str = Field("", description="The ID of the executable structure.")
     mail_transfer: Exchange = Field(
         default_factory=Exchange, description="The mail transfer."
     )
@@ -106,7 +109,9 @@ class InstructionMapEngine(BaseExecutor):
         self.mail_manager.add_sources([branch])
         self.structure_id = start_mail.package.package["structure_id"]
 
-        pack = Package(category="start", package="start", request_source=branch.ln_id)
+        pack = Package(
+            category="start", package="start", request_source=branch.ln_id
+        )
         mail = Mail(
             sender=self.ln_id,
             recipient=self.structure_id,
@@ -129,7 +134,9 @@ class InstructionMapEngine(BaseExecutor):
         base_branch = self.branches[source_branch_id]
 
         pack = Package(
-            category="node", package=node_list[0], request_source=source_branch_id
+            category="node",
+            package=node_list[0],
+            request_source=source_branch_id,
         )
         mail = Mail(
             sender=self.mail_transfer.ln_id,
@@ -167,7 +174,9 @@ class InstructionMapEngine(BaseExecutor):
             self.branches[branch.ln_id] = branch
             self.mail_manager.add_sources([branch])
             node_pacakge = Package(
-                category="node", package=node_list[i], request_source=source_branch_id
+                category="node",
+                package=node_list[i],
+                request_source=source_branch_id,
             )
             node_mail = Mail(
                 sender=self.mail_transfer.ln_id,

lionagi/core/engine/sandbox_.py

@@ -6,7 +6,9 @@ class SandboxTransformer(ast.NodeTransformer):
     """AST transformer to enforce restrictions in sandbox mode."""
 
     def visit_Import(self, node):
-        raise RuntimeError("Import statements are not allowed in sandbox mode.")
+        raise RuntimeError(
+            "Import statements are not allowed in sandbox mode."
+        )
 
     def visit_Exec(self, node):
         raise RuntimeError("Exec statements are not allowed in sandbox mode.")

lionagi/core/engine/script_engine.py

@@ -37,9 +37,13 @@ class ScriptEngine:
                 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):
+            elif isinstance(stmt, ast.Expr) and isinstance(
+                stmt.value, ast.Call
+            ):
                 func_name = stmt.value.func.id
-                arg = self._evaluate_expression(ast.unparse(stmt.value.args[0]))
+                arg = self._evaluate_expression(
+                    ast.unparse(stmt.value.args[0])
+                )
                 result = self._execute_function(func_name, arg)
                 # For demonstration, manually update 'x' to simulate expected behavior
                 if func_name == "processData":

lionagi/core/executor/base_executor.py

@@ -30,14 +30,21 @@ class BaseExecutor(Element, Progressable, Executable, ABC):
         default_factory=list, description="The list of responses."
     )
 
-    context_log: list = Field(default_factory=list, description="The context log.")
+    context_log: list = Field(
+        default_factory=list, description="The context log."
+    )
 
     verbose: bool = Field(
-        True, description="A flag indicating whether to provide verbose output."
+        True,
+        description="A flag indicating whether to provide verbose output.",
     )
 
     def send(
-        self, recipient: str, category: str, package: Any, request_source: str = None
+        self,
+        recipient: str,
+        category: str,
+        package: Any,
+        request_source: str = None,
     ) -> None:
         """
         Sends a mail to a recipient.

lionagi/core/executor/graph_executor.py

@@ -21,7 +21,9 @@ class GraphExecutor(BaseExecutor, Graph):
 
     condition_check_result: bool | None = None
 
-    async def check_edge_condition(self, edge: Edge, executable_id, request_source):
+    async def check_edge_condition(
+        self, edge: Edge, executable_id, request_source
+    ):
         """
         Evaluates the condition associated with an edge, determining if execution should proceed along that edge based
         on the condition's source type.
@@ -67,7 +69,9 @@ class GraphExecutor(BaseExecutor, Graph):
                     and mail.package.package["edge_id"] == edge_id
                 ):
                     self.mailbox.pile.pop(mail_id)
-                    self.condition_check_result = mail.package.package["check_result"]
+                    self.condition_check_result = mail.package.package[
+                        "check_result"
+                    ]
                 else:
                     skipped_requests.append(mail)
             self.mailbox.pending_ins[key] = skipped_requests
@@ -162,7 +166,9 @@ class GraphExecutor(BaseExecutor, Graph):
             except Exception as e:
                 raise ValueError(f"Error handling node_id: {e}") from e
 
-        elif mail.category == "node" and isinstance(mail.package.package, Node):
+        elif mail.category == "node" and isinstance(
+            mail.package.package, Node
+        ):
             try:
                 return await self._handle_node(mail)
             except Exception as e:
@@ -171,7 +177,9 @@ class GraphExecutor(BaseExecutor, Graph):
         else:
             raise ValueError(f"Invalid mail type for structure")
 
-    async def _next_node(self, current_node: Node, executable_id, request_source):
+    async def _next_node(
+        self, current_node: Node, executable_id, request_source
+    ):
         """
         Get the next step nodes based on the current node.
 

lionagi/core/executor/neo4j_executor.py

@@ -1,6 +1,6 @@
 import json
 from collections import deque
-from typing import Callable
+from collections.abc import Callable
 
 from lionagi.core.action import ActionNode, DirectiveSelection, Tool
 from lionagi.core.agent.base_agent import BaseAgent
@@ -77,7 +77,9 @@ class Neo4jExecutor(BaseExecutor):
                     and mail.package.package["edge_id"] == edge_id
                 ):
                     self.mailbox.pile.pop(mail_id)
-                    self.condition_check_result = mail.package.package["check_result"]
+                    self.condition_check_result = mail.package.package[
+                        "check_result"
+                    ]
                 else:
                     skipped_requests.append(mail)
             self.mailbox.pending_ins[key] = skipped_requests
@@ -205,12 +207,18 @@ class Neo4jExecutor(BaseExecutor):
                     condition_cls = await self.driver.get_condition_cls_code(
                         condition["class"]
                     )
-                    condition_obj = ParseNode.parse_condition(condition, condition_cls)
+                    condition_obj = ParseNode.parse_condition(
+                        condition, condition_cls
+                    )
 
                     head = node_id
                     tail = node_properties["ln_id"]
                     check = await self.check_edge_condition(
-                        condition_obj, executable_id, request_source, head, tail
+                        condition_obj,
+                        executable_id,
+                        request_source,
+                        head,
+                        tail,
                     )
                     if not check:
                         continue
@@ -259,7 +267,9 @@ class Neo4jExecutor(BaseExecutor):
             self.structure_id = id_
             return await self._next_node(head_list)
         except Exception as e:
-            raise ValueError(f"Error in searching for structure in Neo4j. Error: {e}")
+            raise ValueError(
+                f"Error in searching for structure in Neo4j. Error: {e}"
+            )
 
     async def _handle_node_id(self, node_id, executable_id, request_source):
         """
@@ -277,7 +287,9 @@ class Neo4jExecutor(BaseExecutor):
         if not check:
             raise ValueError(f"Node {node_id} if not found in the database")
         node_list = await self.driver.get_forwards(node_id)
-        return await self._next_node(node_list, node_id, executable_id, request_source)
+        return await self._next_node(
+            node_list, node_id, executable_id, request_source
+        )
 
     async def _handle_mail(self, mail: Mail):
         """

lionagi/core/generic/edge.py

@@ -2,7 +2,12 @@ from typing import Any
 
 from pydantic import Field, field_validator
 
-from lionagi.core.collections.abc import Component, Condition, LionIDable, get_lion_id
+from lionagi.core.collections.abc import (
+    Component,
+    Condition,
+    LionIDable,
+    get_lion_id,
+)
 from lionagi.core.generic.edge_condition import EdgeCondition
 
 
@@ -94,7 +99,7 @@ class Edge(Component):
                 ):
                     return inspect.getfile(member)
             else:
-                raise TypeError("Source for {!r} not found".format(object))
+                raise TypeError(f"Source for {object!r} not found")
 
         inspect.getfile = new_getfile