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

lionagi/integrations/storage/neo4j.py

@@ -37,15 +37,15 @@ class Neo4j:
 
         Args:
             tx: The Neo4j transaction.
-            node (dict): The properties of the node to be added, including 'id' and 'timestamp'.
+            node (dict): The properties of the node to be added, including 'ln_id' and 'timestamp'.
             name (str): The name of the structure, which is set on the node.
         """
         query = """
-            MERGE (n:Structure:LionNode {id:$id})
+            MERGE (n:Structure:LionNode {ln_id:$ln_id})
             SET n.timestamp = $timestamp
             SET n.name = $name
             """
-        await tx.run(query, id=node["id"], timestamp=node["timestamp"], name=name)
+        await tx.run(query, ln_id=node["ln_id"], timestamp=node["timestamp"], name=name)
         # heads=node['head_nodes'],
         # nodes=node['nodes'],
         # edges=node['edges'])
@@ -57,22 +57,18 @@ class Neo4j:
 
         Args:
             tx: The Neo4j transaction.
-            node (dict): The properties of the system node including 'id', 'timestamp', 'content', 'sender', and 'recipient'.
+            node (dict): The properties of the system node including 'ln_id', 'timestamp', 'content', 'sender', and 'recipient'.
         """
         query = """
-            MERGE (n:System:LionNode {id: $id})
+            MERGE (n:System:LionNode {ln_id: $ln_id})
             SET n.timestamp = $timestamp
             SET n.content = $content
-            SET n.sender = $sender
-            SET n.recipient = $recipient
             """
         await tx.run(
             query,
-            id=node["id"],
+            ln_id=node["ln_id"],
             timestamp=node["timestamp"],
             content=node["content"],
-            sender=node["sender"],
-            recipient=node["recipient"],
         )
 
     @staticmethod
@@ -82,22 +78,18 @@ class Neo4j:
 
         Args:
             tx: The Neo4j transaction.
-            node (dict): The properties of the instruction node including 'id', 'timestamp', 'content', 'sender', and 'recipient'.
+            node (dict): The properties of the instruction node including 'ln_id', 'timestamp', 'content', 'sender', and 'recipient'.
         """
         query = """
-            MERGE (n:Instruction:LionNode {id: $id})
+            MERGE (n:Instruction:LionNode {ln_id: $ln_id})
             SET n.timestamp = $timestamp
             SET n.content = $content
-            SET n.sender = $sender
-            SET n.recipient = $recipient
             """
         await tx.run(
             query,
-            id=node["id"],
+            ln_id=node["ln_id"],
             timestamp=node["timestamp"],
             content=node["content"],
-            sender=node["sender"],
-            recipient=node["recipient"],
         )
 
     # TODO: tool.manual
@@ -108,41 +100,41 @@ class Neo4j:
 
         Args:
             tx: The Neo4j transaction.
-            node (dict): The properties of the tool node including 'id', 'timestamp', 'function', and 'parser'.
+            node (dict): The properties of the tool node including 'ln_id', 'timestamp', 'function', and 'parser'.
         """
         query = """
-            MERGE (n:Tool:LionNode {id: $id})
+            MERGE (n:Tool:LionNode {ln_id: $ln_id})
             SET n.timestamp = $timestamp
             SET n.function = $function
             SET n.parser = $parser
             """
         await tx.run(
             query,
-            id=node["id"],
+            ln_id=node["ln_id"],
             timestamp=node["timestamp"],
             function=node["function"],
             parser=node["parser"],
         )
 
     @staticmethod
-    async def add_actionSelection_node(tx, node):
+    async def add_directiveSelection_node(tx, node):
         """
-        Asynchronously adds an action selection node to the graph.
+        Asynchronously adds an directive selection node to the graph.
 
         Args:
             tx: The Neo4j transaction.
-            node (dict): The properties of the action selection node including 'id', 'action', and 'actionKwargs'.
+            node (dict): The properties of the directive selection node including 'ln_id', 'directive', and 'directiveKwargs'.
         """
         query = """
-            MERGE (n:ActionSelection:LionNode {id: $id})
-            SET n.action = $action
-            SET n.actionKwargs = $actionKwargs
+            MERGE (n:DirectiveSelection:LionNode {ln_id: $ln_id})
+            SET n.directive = $directive
+            SET n.directiveKwargs = $directiveKwargs
             """
         await tx.run(
             query,
-            id=node["id"],
-            action=node["action"],
-            actionKwargs=node["action_kwargs"],
+            ln_id=node["ln_id"],
+            directive=node["directive"],
+            directiveKwargs=node["directive_kwargs"],
         )
 
     @staticmethod
@@ -152,17 +144,17 @@ class Neo4j:
 
         Args:
             tx: The Neo4j transaction.
-            node (dict): The properties of the agent node including 'id', 'timestamp', 'structureId', and 'outputParser'.
+            node (dict): The properties of the agent node including 'ln_id', 'timestamp', 'structureId', and 'outputParser'.
         """
         query = """
-            MERGE (n:Agent:LionNode {id:$id})
+            MERGE (n:Agent:LionNode {ln_id:$ln_id})
             SET n.timestamp = $timestamp
             SET n.structureId = $structureId
             SET n.outputParser = $outputParser
             """
         await tx.run(
             query,
-            id=node["id"],
+            ln_id=node["ln_id"],
             timestamp=node["timestamp"],
             structureId=node["structure_id"],
             outputParser=node["output_parser"],
@@ -175,20 +167,20 @@ class Neo4j:
 
         Args:
             tx: The Neo4j transaction.
-            edge (dict): The properties of the edge including 'id', 'timestamp', 'head', 'tail', 'label', and 'condition'.
+            edge (dict): The properties of the edge including 'ln_id', 'timestamp', 'head', 'tail', 'label', and 'condition'.
         """
         query = """
-            MATCH (m:LionNode) WHERE m.id = $head
-            MATCH (n:LionNode) WHERE n.id = $tail
+            MATCH (m:LionNode) WHERE m.ln_id = $head
+            MATCH (n:LionNode) WHERE n.ln_id = $tail
             MERGE (m)-[r:FORWARD]->(n)
-            SET r.id = $id
+            SET r.ln_id = $ln_id
             SET r.timestamp = $timestamp
             SET r.label = $label
             SET r.condition = $condition
             """
         await tx.run(
             query,
-            id=edge["id"],
+            ln_id=edge["ln_id"],
             timestamp=edge["timestamp"],
             head=edge["head"],
             tail=edge["tail"],
@@ -203,20 +195,20 @@ class Neo4j:
 
         Args:
             tx: The Neo4j transaction.
-            edge (dict): The properties of the edge including 'id', 'timestamp', 'head', 'tail', 'label', and 'condition'.
+            edge (dict): The properties of the edge including 'ln_id', 'timestamp', 'head', 'tail', 'label', and 'condition'.
         """
         query = """
-            MATCH (m:LionNode) WHERE m.id = $head
-            MATCH (n:LionNode) WHERE n.id = $tail
+            MATCH (m:LionNode) WHERE m.ln_id = $head
+            MATCH (n:LionNode) WHERE n.ln_id = $tail
             MERGE (m)-[r:BUNDLE]->(n)
-            SET r.id = $id
+            SET r.ln_id = $ln_id
             SET r.timestamp = $timestamp
             SET r.label = $label
             SET r.condition = $condition
             """
         await tx.run(
             query,
-            id=edge["id"],
+            ln_id=edge["ln_id"],
             timestamp=edge["timestamp"],
             head=edge["head"],
             tail=edge["tail"],
@@ -234,13 +226,13 @@ class Neo4j:
             structure: The structure node from which head relationships are established.
         """
         for head in structure.get_heads():
-            head_id = head.id_
+            head_id = head.ln_id
             query = """
-                MATCH (m:Structure) WHERE m.id = $structureId
-                MATCH (n:LionNode) WHERE n.id = $headId
+                MATCH (m:Structure) WHERE m.ln_id = $structureId
+                MATCH (n:LionNode) WHERE n.ln_id = $headId
                 MERGE (m)-[:HEAD]->(n)
                 """
-            await tx.run(query, structureId=structure.id_, headId=head_id)
+            await tx.run(query, structureId=structure.ln_id, headId=head_id)
 
     @staticmethod
     async def add_single_condition_cls(tx, condCls):
@@ -252,7 +244,7 @@ class Neo4j:
             condCls (dict): The properties of the condition class node including 'className' and 'code'.
         """
         query = """
-            MERGE (n:Condition:LionNode {className: $className})
+            MERGE (n:EdgeCondition:LionNode {className: $className})
             SET n.code = $code
             """
         await tx.run(query, className=condCls["class_name"], code=condCls["class"])
@@ -274,7 +266,7 @@ class Neo4j:
         """
         for node in node_dict:
             node_list = node_dict[node]
-            if node == "StructureExecutor":
+            if node == "GraphExecutor":
                 [
                     await self.add_structure_node(tx, i, structure_name)
                     for i in node_list
@@ -285,8 +277,8 @@ class Neo4j:
                 [await self.add_instruction_node(tx, i) for i in node_list]
             elif node == "Tool":
                 [await self.add_tool_node(tx, i) for i in node_list]
-            elif node == "ActionSelection":
-                [await self.add_actionSelection_node(tx, i) for i in node_list]
+            elif node == "DirectiveSelection":
+                [await self.add_directiveSelection_node(tx, i) for i in node_list]
             elif node == "BaseAgent":
                 [await self.add_baseAgent_node(tx, i) for i in node_list]
             else:
@@ -335,7 +327,7 @@ class Neo4j:
     @staticmethod
     async def check_id_constraint(tx):
         """
-        Asynchronously applies a unique constraint on the 'id' attribute for all nodes of type 'LionNode' in the graph.
+        Asynchronously applies a unique constraint on the 'ln_id' attribute for all nodes of type 'LionNode' in the graph.
 
         This constraint ensures that each node in the graph has a unique identifier.
 
@@ -344,7 +336,7 @@ class Neo4j:
         """
         query = """
             CREATE CONSTRAINT node_id IF NOT EXISTS
-            FOR (n:LionNode) REQUIRE (n.id) IS UNIQUE
+            FOR (n:LionNode) REQUIRE (n.ln_id) IS UNIQUE
             """
         await tx.run(query)
 
@@ -421,10 +413,10 @@ class Neo4j:
             A dictionary containing the properties of the node if found, otherwise None.
         """
         query = """
-            MATCH (n:LionNode) WHERE n.id = $id
+            MATCH (n:LionNode) WHERE n.ln_id = $ln_id
             RETURN labels(n), n{.*}
             """
-        result = await tx.run(query, id=node_id)
+        result = await tx.run(query, ln_id=node_id)
         result = [record.values() async for record in result]
         if result:
             return result[0]
@@ -445,7 +437,7 @@ class Neo4j:
         """
         query = """
             MATCH (n:Structure) WHERE n.name = $name
-            RETURN n.id
+            RETURN n.ln_id
             """
         result = await tx.run(query, name=name)
         result = [record.values() async for record in result]
@@ -465,7 +457,7 @@ class Neo4j:
             A list of dictionaries representing the properties and labels of each head node connected to the structure.
         """
         query = """
-            MATCH (n:Structure)-[r:HEAD]->(m) WHERE n.id = $nodeId
+            MATCH (n:Structure)-[r:HEAD]->(m) WHERE n.ln_id = $nodeId
             RETURN r{.*}, labels(m), m{.*}
             """
         result = await tx.run(query, nodeId=node_id)
@@ -485,7 +477,7 @@ class Neo4j:
             A list of dictionaries representing the properties and labels of each node connected by a forward relationship.
         """
         query = """
-            MATCH (n:LionNode)-[r:FORWARD]->(m) WHERE n.id = $nodeId
+            MATCH (n:LionNode)-[r:FORWARD]->(m) WHERE n.ln_id = $nodeId
             RETURN r{.*}, labels(m), m{.*}
             """
         result = await tx.run(query, nodeId=node_id)
@@ -505,7 +497,7 @@ class Neo4j:
             A list of dictionaries representing the properties and labels of each node connected by a bundle relationship.
         """
         query = """
-            MATCH (n:LionNode)-[r:BUNDLE]->(m) WHERE n.id = $nodeId
+            MATCH (n:LionNode)-[r:BUNDLE]->(m) WHERE n.ln_id = $nodeId
             RETURN labels(m), m{.*}
             """
         result = await tx.run(query, nodeId=node_id)
@@ -525,7 +517,7 @@ class Neo4j:
             The code of the condition class if found, otherwise None.
         """
         query = """
-            MATCH (n:Condition) WHERE n.className = $name
+            MATCH (n:EdgeCondition) WHERE n.className = $name
             RETURN n.code
             """
         result = await tx.run(query, name=name)
@@ -557,7 +549,7 @@ class Neo4j:
                 to any existing structure.
         """
         if not structure_name and not structure_id:
-            raise ValueError("Please provide the structure name or id")
+            raise ValueError("Please provide the structure name or ln_id")
         if structure_name:
             id = await self.match_structure_id(tx, structure_name)
             if not id:

lionagi/integrations/storage/storage_util.py

@@ -2,13 +2,11 @@ import json
 import inspect
 import re
 
-from lionagi.core import System, Instruction
-from lionagi.core.tool import Tool
-from lionagi.core.generic.action import ActionSelection
+from lionagi.core.message import System, Instruction, RoledMessage
+from lionagi.core.action import Tool, DirectiveSelection, func_to_tool
+from lionagi.core.action import DirectiveSelection
 from lionagi.core.agent.base_agent import BaseAgent
-from lionagi.core.generic.condition import Condition
-
-from lionagi.core import func_to_tool
+from lionagi.core.generic.edge_condition import EdgeCondition
 
 
 def output_node_list(structure):
@@ -27,38 +25,42 @@ def output_node_list(structure):
     output = {}
 
     structure_output = {
-        "id": structure.id_,
+        "ln_id": structure.ln_id,
         "timestamp": structure.timestamp,
         "type": structure.class_name,
     }
     summary_list.append(structure_output.copy())
-    structure_output["head_nodes"] = json.dumps([i.id_ for i in structure.get_heads()])
+    structure_output["head_nodes"] = json.dumps(
+        [i.ln_id for i in structure.get_heads()]
+    )
     # structure_output['nodes'] = json.dumps([i for i in structure.internal_nodes.keys()])
     # structure_output['edges'] = json.dumps([i for i in structure.internal_edges.keys()])
     output[structure_output["type"]] = [structure_output]
     for node in structure.internal_nodes.values():
         node_output = {
-            "id": node.id_,
+            "ln_id": node.ln_id,
             "timestamp": node.timestamp,
             "type": node.class_name,
         }
         summary_list.append(node_output.copy())
         if isinstance(node, System) or isinstance(node, Instruction):
             node_output["content"] = json.dumps(node.content)
-            node_output["sender"] = node.sender
-            node_output["recipient"] = node.recipient
+            # node_output["sender"] = node.sender
+            # node_output["recipient"] = node.recipient
         elif isinstance(node, Tool):
-            node_output["function"] = inspect.getsource(node.func)
+            node_output["function"] = inspect.getsource(node.function)
             # node_output['manual'] = node.manual
             node_output["parser"] = (
                 inspect.getsource(node.parser) if node.parser else None
             )
-        elif isinstance(node, ActionSelection):
-            node_output["action"] = node.action
-            node_output["action_kwargs"] = json.dumps(node.action_kwargs)
+        elif isinstance(node, DirectiveSelection):
+            node_output["directive"] = node.directive
+            node_output["directive_kwargs"] = json.dumps(node.directive_kwargs)
         elif isinstance(node, BaseAgent):
-            node_output["structure_id"] = node.structure.id_
-            node_output["output_parser"] = inspect.getsource(node.output_parser)
+            node_output["structure_id"] = node.structure.ln_id
+            node_output["output_parser"] = (
+                inspect.getsource(node.output_parser) if node.output_parser else None
+            )
         else:
             raise ValueError("Not supported node type detected")
         if node_output["type"] not in output:
@@ -84,7 +86,7 @@ def output_edge_list(structure):
     edge_cls_dict = {}
     for edge in structure.internal_edges.values():
         edge_output = {
-            "id": edge.id_,
+            "ln_id": edge.ln_id,
             "timestamp": edge.timestamp,
             "head": edge.head,
             "tail": edge.tail,
@@ -183,12 +185,8 @@ class ParseNode:
         Returns:
             System: An instantiated System node filled with properties from info_dict.
         """
-        node = System(" ")
-        node.id_ = info_dict["id"]
-        node.timestamp = info_dict["timestamp"]
-        node.content = json.loads(info_dict["content"])
-        node.sender = info_dict["sender"]
-        node.recipient = info_dict["recipient"]
+        info_dict["system"] = json.loads(info_dict.pop("content"))["system_info"]
+        node = System.from_obj(info_dict)
         return node
 
     @staticmethod
@@ -202,18 +200,14 @@ class ParseNode:
         Returns:
             Instruction: An instantiated Instruction node filled with properties from info_dict.
         """
-        node = Instruction(" ")
-        node.id_ = info_dict["id"]
-        node.timestamp = info_dict["timestamp"]
-        node.content = json.loads(info_dict["content"])
-        node.sender = info_dict["sender"]
-        node.recipient = info_dict["recipient"]
+        info_dict["instruction"] = json.loads(info_dict.pop("content"))["instruction"]
+        node = Instruction.from_obj(info_dict)
         return node
 
     @staticmethod
-    def parse_actionSelection(info_dict):
+    def parse_directiveSelection(info_dict):
         """
-        Parses dictionary information into an ActionSelection node object.
+        Parses dictionary information into an DirectiveSelection node object.
 
         Args:
             info_dict (dict): A dictionary containing properties of an action selection node.
@@ -221,15 +215,14 @@ class ParseNode:
         Returns:
             ActionSelection: An instantiated ActionSelection node filled with properties from info_dict.
         """
-        node = ActionSelection()
-        node.id_ = info_dict["id"]
-        node.action = info_dict["action"]
-        if "action_kwargs" in info_dict:
-            if info_dict["action_kwargs"]:
-                node.action_kwargs = json.loads(info_dict["action_kwargs"])
-        elif "actionKwargs" in info_dict:
-            if info_dict["actionKwargs"]:
-                node.action_kwargs = json.loads(info_dict["actionKwargs"])
+        node = DirectiveSelection(ln_id=info_dict["ln_id"])
+        node.directive = info_dict["directive"]
+        if "directive_kwargs" in info_dict:
+            if info_dict["directive_kwargs"]:
+                node.directive_kwargs = json.loads(info_dict["directive_kwargs"])
+        elif "directiveKwargs" in info_dict:
+            if info_dict["directiveKwargs"]:
+                node.directive_kwargs = json.loads(info_dict["directiveKwargs"])
         return node
 
     @staticmethod
@@ -253,14 +246,19 @@ class ParseNode:
             )
 
         func = ParseNode.convert_to_def(func_code)
-        tool = func_to_tool(func)
+        tool = func_to_tool(
+            func, ln_id=info_dict["ln_id"], timestamp=info_dict["timestamp"]
+        )
         if func.__doc__:
             if re.search(r":param \w+:", func.__doc__):
-                tool = func_to_tool(func, docstring_style="reST")
+                tool = func_to_tool(
+                    func,
+                    docstring_style="reST",
+                    ln_id=info_dict["ln_id"],
+                    timestamp=info_dict["timestamp"],
+                )
 
         tool = tool[0]
-        tool.id_ = info_dict["id"]
-        tool.timestamp = info_dict["timestamp"]
         return tool
 
     @staticmethod
@@ -286,4 +284,4 @@ class ParseNode:
             if key == "self":
                 continue
             init_params[key] = args[key]
-        return cls(**init_params)
+        return cls(**init_params)

lionagi/integrations/storage/structure_excel.py

@@ -3,10 +3,10 @@ import json
 from pathlib import Path
 
 from lionagi.integrations.storage.storage_util import ParseNode
-from lionagi.core.execute.structure_executor import StructureExecutor
+from lionagi.core.executor.graph_executor import GraphExecutor
 from lionagi.core.agent.base_agent import BaseAgent
-from lionagi.core.execute.base_executor import BaseExecutor
-from lionagi.core.execute.instruction_map_executor import InstructionMapExecutor
+from lionagi.core.executor.base_executor import BaseExecutor
+from lionagi.core.engine.instruction_map_engine import InstructionMapEngine
 
 
 def excel_reload(structure_name=None, structure_id=None, dir="structure_storage"):
@@ -52,10 +52,13 @@ class StructureExcel:
         parse(node_list, parent_node=None): Recursively parses nodes and their relationships from the structure.
         reload(): Reloads the structure from the Excel file based on the initially provided parameters.
     """
-    structure: StructureExecutor = StructureExecutor()
-    default_agent_executable: BaseExecutor = InstructionMapExecutor()
 
-    def __init__(self, structure_name=None, structure_id=None, file_path="structure_storage"):
+    structure: GraphExecutor = GraphExecutor()
+    default_agent_executable: BaseExecutor = InstructionMapEngine()
+
+    def __init__(
+        self, structure_name=None, structure_id=None, file_path="structure_storage"
+    ):
         """
         Initializes the StructureExcel class with specified parameters.
 
@@ -91,7 +94,8 @@ class StructureExcel:
                     continue
             if len(filename) > 1:
                 raise ValueError(
-                    f"Multiple files starting with the same structure name {structure_name} has found, please specify the structure id")
+                    f"Multiple files starting with the same structure name {structure_name} has found, please specify the structure id"
+                )
             self.filename = f"{file_path}/{filename[0]}"
             self.file = pd.read_excel(self.filename, sheet_name=None)
         elif structure_id and not structure_name:
@@ -100,7 +104,8 @@ class StructureExcel:
             filename = [file.name for file in files]
             if len(filename) > 1:
                 raise ValueError(
-                    f"Multiple files with the same structure id {structure_id} has found, please double check the stored structure")
+                    f"Multiple files with the same structure id {structure_id} has found, please double check the stored structure"
+                )
             self.filename = f"{file_path}/{filename[0]}"
             self.file = pd.read_excel(self.filename, sheet_name=None)
         self.nodes = self.file["Nodes"]
@@ -115,7 +120,7 @@ class StructureExcel:
         Returns:
             list: A list of identifiers for the head nodes in the structure.
         """
-        structure_df = self.file["StructureExecutor"]
+        structure_df = self.file["GraphExecutor"]
         head_list = json.loads(structure_df["head_nodes"].iloc[0])
         return head_list
 
@@ -132,9 +137,9 @@ class StructureExcel:
         Returns:
             dict: A dictionary containing the properties and values for the specified node.
         """
-        node_type = self.nodes[self.nodes["id"] == node_id]["type"].iloc[0]
+        node_type = self.nodes[self.nodes["ln_id"] == node_id]["type"].iloc[0]
         node_file = self.file[node_type]
-        row = node_file[node_file["id"] == node_id].iloc[0]
+        row = node_file[node_file["ln_id"] == node_id].iloc[0]
         info_dict = row.to_dict()
         return info_dict
 
@@ -154,12 +159,18 @@ class StructureExcel:
         """
         output_parser = ParseNode.convert_to_def(info_dict["output_parser"])
 
-        structure_excel = StructureExcel(structure_id=info_dict["structure_id"], file_path=self.file_path)
+        structure_excel = StructureExcel(
+            structure_id=info_dict["structure_id"], file_path=self.file_path
+        )
         structure_excel.reload()
         structure = structure_excel.structure
-        agent = BaseAgent(structure=structure, executable=self.default_agent_executable, output_parser=output_parser)
-        agent.id_ = info_dict["id"]
-        agent.timestamp = info_dict["timestamp"]
+        agent = BaseAgent(
+            structure=structure,
+            executable=self.default_agent_executable,
+            output_parser=output_parser,
+            ln_id=info_dict["ln_id"],
+            timestamp=info_dict["timestamp"],
+        )
         return agent
 
     def parse_node(self, info_dict):
@@ -181,8 +192,8 @@ class StructureExcel:
             return ParseNode.parse_instruction(info_dict)
         elif info_dict["type"] == "Tool":
             return ParseNode.parse_tool(info_dict)
-        elif info_dict["type"] == "ActionSelection":
-            return ParseNode.parse_actionSelection(info_dict)
+        elif info_dict["type"] == "DirectiveSelection":
+            return ParseNode.parse_directiveSelection(info_dict)
         elif info_dict["type"] == "BaseAgent":
             return self.parse_agent(info_dict)
 
@@ -217,19 +228,25 @@ class StructureExcel:
         """
         if not parent_node:
             return
-        row = self.edges[(self.edges["head"] == parent_node.id_) & (self.edges["tail"] == node.id_)]
+        row = self.edges[
+            (self.edges["head"] == parent_node.ln_id)
+            & (self.edges["tail"] == node.ln_id)
+        ]
         if len(row) > 1:
             raise ValueError(
-                f"currently does not support handle multiple edges between two nodes, Error node: from {parent_node.id_} to {node.id_}")
-        if row['condition'].isna().any():
-            self.structure.relate_nodes(parent_node, node)
+                f"currently does not support handle multiple edges between two nodes, Error node: from {parent_node.ln_id} to {node.ln_id}"
+            )
+        if row["condition"].isna().any():
+            self.structure.add_edge(parent_node, node)
         else:
             cond = json.loads(row["condition"].iloc[0])
             cond_cls = cond["class"]
-            cond_row = self.file["EdgesCondClass"][self.file["EdgesCondClass"]["class_name"] == cond_cls]
+            cond_row = self.file["EdgesCondClass"][
+                self.file["EdgesCondClass"]["class_name"] == cond_cls
+            ]
             cond_code = cond_row["class"].iloc[0]
             condition = ParseNode.parse_condition(cond, cond_code)
-            self.structure.relate_nodes(parent_node, node, condition=condition)
+            self.structure.add_edge(parent_node, node, condition=condition)
 
     def parse(self, node_list, parent_node=None):
         """
@@ -249,7 +266,7 @@ class StructureExcel:
             info_dict = self._reload_info_dict(node_id)
             node = self.parse_node(info_dict)
 
-            if node.id_ not in self.structure.internal_nodes:
+            if node.ln_id not in self.structure.internal_nodes:
                 self.structure.add_node(node)
             self.relate(parent_node, node)
 
@@ -263,6 +280,6 @@ class StructureExcel:
         This method initializes a new StructureExecutor and uses the Excel data to rebuild the entire structure,
         starting from the head nodes and recursively parsing and connecting all nodes defined within.
         """
-        self.structure = StructureExecutor()
+        self.structure = GraphExecutor()
         heads = self.get_heads()
-        self.parse(heads)
+        self.parse(heads)