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

lionagi/core/executor/base_executor.py

@@ -0,0 +1,90 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from pydantic import Field
+
+from lionagi.core.collections.abc import Element, Progressable, Executable
+from lionagi.core.collections import Exchange
+from lionagi.core.mail.mail import Mail, Package
+
+
+class BaseExecutor(Element, Progressable, Executable, ABC):
+    """
+    BaseExecutor is an abstract base class that defines the structure for executors
+    handling mails, execution control, and context management within the LionAGI system.
+    """
+
+    mailbox: Exchange = Field(
+        default_factory=Exchange[Mail], description="The pending mails."
+    )
+
+    execute_stop: bool = Field(
+        False, description="A flag indicating whether to stop execution."
+    )
+
+    context: dict | str | list | None = Field(
+        None, description="The context buffer for the next instruction."
+    )
+
+    execution_responses: list = Field(
+        default_factory=list, description="The list of responses."
+    )
+
+    context_log: list = Field(default_factory=list, description="The context log.")
+
+    verbose: bool = Field(
+        True, description="A flag indicating whether to provide verbose output."
+    )
+
+    def send(
+        self, recipient: str, category: str, package: Any, request_source: str = None
+    ) -> None:
+        """
+        Sends a mail to a recipient.
+
+        Args:
+            recipient (str): The ID of the recipient.
+            category (str): The category of the mail.
+            package (Any): The package to send in the mail.
+            request_source (str): The source of the request.
+        """
+        pack = Package(
+            category=category, package=package, request_source=request_source
+        )
+        mail = Mail(
+            sender=self.ln_id,
+            recipient=recipient,
+            package=pack,
+        )
+        self.mailbox.include(mail, "out")
+
+    @abstractmethod
+    async def execute(self, *args: Any, **kwargs: Any) -> Any:
+        """
+        Execute the executor's main function.
+
+        Args:
+            *args (Any): Positional arguments.
+            **kwargs (Any): Keyword arguments.
+
+        Returns:
+            Any: The result of the execution.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """
+        raise NotImplementedError("The execute method must be implemented.")
+
+    @abstractmethod
+    async def forward(self, *args: Any, **kwargs: Any) -> None:
+        """
+        Forward the execution flow.
+
+        Args:
+            *args (Any): Positional arguments.
+            **kwargs (Any): Keyword arguments.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """
+        raise NotImplementedError("The forward method must be implemented.")

lionagi/core/{execute/structure_executor.py → executor/graph_executor.py}

@@ -1,24 +1,19 @@
-from typing import overload
-
-from abc import ABC
 from collections import deque
 
 from lionagi.libs import AsyncUtil, convert
 
-from lionagi.core.generic import BaseNode, ActionNode, ActionSelection, Edge
-from lionagi.core.tool import Tool
-from lionagi.core.mail.schema import BaseMail
-from lionagi.core.execute.base_executor import BaseExecutor
+from lionagi.core.generic.node import Node
+from lionagi.core.generic.edge import Edge
+from lionagi.core.executor.base_executor import BaseExecutor
 
-from lionagi.libs import AsyncUtil
-from lionagi.core.generic import Node, ActionSelection, Edge
-from lionagi.core.tool import Tool
+from lionagi.core.action import Tool, DirectiveSelection, ActionNode
 
-from lionagi.core.mail.schema import BaseMail
-from lionagi.core.graph.graph import Graph
+from lionagi.core.mail import Mail
+from lionagi.core.generic.graph import Graph
+from lionagi.core.collections.progression import progression
 
 
-class StructureExecutor(BaseExecutor, Graph):
+class GraphExecutor(BaseExecutor, Graph):
     """
     Executes tasks within a graph structure, handling dynamic node flows and conditional edge logic.
 
@@ -45,10 +40,12 @@ class StructureExecutor(BaseExecutor, Graph):
         Raises:
             ValueError: If the source_type of the condition is invalid.
         """
-        if edge.condition.source_type == "structure":
-            return edge.condition(self)
+        if edge.condition.source == "structure" or isinstance(
+            edge.condition.source, Node
+        ):
+            return await edge.check_condition(self)
 
-        elif edge.condition.source_type == "executable":
+        elif edge.condition.source == "executable":
             return await self._check_executable_condition(
                 edge, executable_id, request_source
             )
@@ -63,20 +60,20 @@ class StructureExecutor(BaseExecutor, Graph):
         Args:
             edge_id (str): The ID of the edge.
         """
-        for key in list(self.pending_ins.keys()):
-            skipped_requests = deque()
-            while self.pending_ins[key]:
-                mail: BaseMail = self.pending_ins[key].popleft()
+        for key in list(self.mailbox.pending_ins.keys()):
+            skipped_requests = progression()
+            while self.mailbox.pending_ins[key].size() > 0:
+                mail_id = self.mailbox.pending_ins[key].popleft()
+                mail = self.mailbox.pile[mail_id]
                 if (
                     mail.category == "condition"
-                    and mail.package["package"]["edge_id"] == edge_id
+                    and mail.package.package["edge_id"] == edge_id
                 ):
-                    self.condition_check_result = mail.package["package"][
-                        "check_result"
-                    ]
+                    self.mailbox.pile.pop(mail_id)
+                    self.condition_check_result = mail.package.package["check_result"]
                 else:
                     skipped_requests.append(mail)
-            self.pending_ins[key] = skipped_requests
+            self.mailbox.pending_ins[key] = skipped_requests
 
     async def _check_executable_condition(
         self, edge: Edge, executable_id, request_source
@@ -93,19 +90,20 @@ class StructureExecutor(BaseExecutor, Graph):
             bool: The result of the condition check.
         """
         self.send(
-            recipient_id=executable_id,
+            recipient=executable_id,
             category="condition",
-            package={"request_source": request_source, "package": edge},
+            package=edge,
+            request_source=request_source,
         )
         while self.condition_check_result is None:
             await AsyncUtil.sleep(0.1)
-            self._process_edge_condition(edge.id_)
+            self._process_edge_condition(edge.ln_id)
             continue
         check_result = self.condition_check_result
         self.condition_check_result = None
         return check_result
 
-    async def _handle_node_id(self, mail: BaseMail):
+    async def _handle_node_id(self, mail: Mail):
         """
         Processes the node identified by its ID in the mail's package, ensuring it exists and retrieving the next set of
         nodes based on the current node.
@@ -116,17 +114,17 @@ class StructureExecutor(BaseExecutor, Graph):
         Raises:
             ValueError: If the node does not exist within the structure.
         """
-        if mail.package["package"] not in self.internal_nodes:
+        if mail.package.package not in self.internal_nodes:
             raise ValueError(
-                f"Node {mail.package} does not exist in the structure {self.id_}"
+                f"Node {mail.package.package}: Node does not exist in the structure {self.ln_id}"
             )
         return await self._next_node(
-            self.internal_nodes[mail.package["package"]],
-            mail.sender_id,
-            mail.package["request_source"],
+            self.internal_nodes[mail.package.package],
+            mail.sender,
+            mail.package.request_source,
         )
 
-    async def _handle_node(self, mail: BaseMail):
+    async def _handle_node(self, mail: Mail):
         """
         Processes the node specified in the mail's package, ensuring it exists within the structure.
 
@@ -136,15 +134,15 @@ class StructureExecutor(BaseExecutor, Graph):
         Raises:
             ValueError: If the node does not exist within the structure.
         """
-        if not self.node_exist(mail.package["package"]):
+        if not self.node_exist(mail.package.package):
             raise ValueError(
-                f"Node {mail.package} does not exist in the structure {self.id_}"
+                f"Node {mail.package.package.ln_id}: does not exist in the structure {self.ln_id}"
             )
         return await self._next_node(
-            mail.package["package"], mail.sender_id, mail.package["request_source"]
+            mail.package.package, mail.sender, mail.package.request_source
         )
 
-    async def _handle_mail(self, mail: BaseMail):
+    async def _handle_mail(self, mail: Mail):
         """
         Processes incoming mail based on its category, initiating node execution or structure operations accordingly.
 
@@ -165,9 +163,9 @@ class StructureExecutor(BaseExecutor, Graph):
             try:
                 return await self._handle_node_id(mail)
             except Exception as e:
-                raise ValueError(f"Error handling node id: {e}") from e
+                raise ValueError(f"Error handling node_id: {e}") from e
 
-        elif mail.category == "node" and isinstance(mail.package["package"], BaseNode):
+        elif mail.category == "node" and isinstance(mail.package.package, Node):
             try:
                 return await self._handle_node(mail)
             except Exception as e:
@@ -188,7 +186,7 @@ class StructureExecutor(BaseExecutor, Graph):
             list[Node]: The next step nodes.
         """
         next_nodes = []
-        next_edges = self.get_node_edges(current_node, node_as="out")
+        next_edges = self.get_node_edges(current_node, direction="out")
         for edge in convert.to_list(list(next_edges.values())):
             if edge.bundle:
                 continue
@@ -199,7 +197,7 @@ class StructureExecutor(BaseExecutor, Graph):
                 if not check:
                     continue
             node = self.internal_nodes[edge.tail]
-            further_edges = self.get_node_edges(node, node_as="out")
+            further_edges = self.get_node_edges(node, direction="out")
             bundled_nodes = deque()
             for f_edge in convert.to_list(list(further_edges.values())):
                 if f_edge.bundle:
@@ -209,7 +207,7 @@ class StructureExecutor(BaseExecutor, Graph):
             next_nodes.append(node)
         return next_nodes
 
-    def _send_mail(self, next_nodes: list | None, mail: BaseMail):
+    def _send_mail(self, next_nodes: list | None, mail: Mail):
         """
         Sends mails to the next nodes or signals the end of execution if no next nodes exist.
 
@@ -219,31 +217,25 @@ class StructureExecutor(BaseExecutor, Graph):
         """
         if not next_nodes:  # tail
             self.send(
-                recipient_id=mail.sender_id,
+                recipient=mail.sender,
                 category="end",
-                package={
-                    "request_source": mail.package["request_source"],
-                    "package": "end",
-                },
+                package="end",
+                request_source=mail.package.request_source,
             )
         else:
             if len(next_nodes) == 1:
                 self.send(
-                    recipient_id=mail.sender_id,
+                    recipient=mail.sender,
                     category="node",
-                    package={
-                        "request_source": mail.package["request_source"],
-                        "package": next_nodes[0],
-                    },
+                    package=next_nodes[0],
+                    request_source=mail.package.request_source,
                 )
             else:
                 self.send(
-                    recipient_id=mail.sender_id,
+                    recipient=mail.sender,
                     category="node_list",
-                    package={
-                        "request_source": mail.package["request_source"],
-                        "package": next_nodes,
-                    },
+                    package=next_nodes,
+                    request_source=mail.package.request_source,
                 )
 
     @staticmethod
@@ -271,9 +263,9 @@ class StructureExecutor(BaseExecutor, Graph):
         action_node = ActionNode(instruction=instruction)
         while bundled_nodes:
             node = bundled_nodes.popleft()
-            if isinstance(node, ActionSelection):
-                action_node.action = node.action
-                action_node.action_kwargs = node.action_kwargs
+            if isinstance(node, DirectiveSelection):
+                action_node.directive = node.directive
+                action_node.directive_kwargs = node.directive_kwargs
             elif isinstance(node, Tool):
                 action_node.tools.append(node)
             else:
@@ -284,9 +276,10 @@ class StructureExecutor(BaseExecutor, Graph):
         """
         Process the pending incoming mails and perform the corresponding actions.
         """
-        for key in list(self.pending_ins.keys()):
-            while self.pending_ins[key]:
-                mail: BaseMail = self.pending_ins[key].popleft()
+        for key in list(self.mailbox.pending_ins.keys()):
+            while self.mailbox.pending_ins[key].size() > 0:
+                mail_id = self.mailbox.pending_ins[key].popleft()
+                mail = self.mailbox.pile.pop(mail_id)
                 try:
                     if mail.category == "end":
                         self.execute_stop = True
@@ -295,6 +288,8 @@ class StructureExecutor(BaseExecutor, Graph):
                     self._send_mail(next_nodes, mail)
                 except Exception as e:
                     raise ValueError(f"Error handling mail: {e}") from e
+            if self.mailbox.pending_ins[key].size() == 0:
+                self.mailbox.pending_ins.pop(key)
 
     async def execute(self, refresh_time=1):
         """
@@ -306,7 +301,7 @@ class StructureExecutor(BaseExecutor, Graph):
         Raises:
             ValueError: If the graph structure is found to be cyclic, which is unsupported.
         """
-        if not self.acyclic:
+        if not self.is_acyclic():
             raise ValueError("Structure is not acyclic")
 
         while not self.execute_stop:
@@ -331,4 +326,5 @@ class StructureExecutor(BaseExecutor, Graph):
                        the file writing process or data formatting.
         """
         from lionagi.integrations.storage.to_excel import to_excel
+
         to_excel(self, structure_name, dir)

lionagi/core/{execute → executor}/neo4j_executor.py

@@ -2,16 +2,16 @@ from collections import deque
 import json
 from typing import Callable
 
-from lionagi.core.execute.base_executor import BaseExecutor
+from lionagi.core.executor.base_executor import BaseExecutor
 from lionagi.integrations.storage.neo4j import Neo4j
 from lionagi.integrations.storage.storage_util import ParseNode
-from lionagi.core.generic import ActionNode
 from lionagi.core.agent.base_agent import BaseAgent
-from lionagi.core.execute.instruction_map_executor import InstructionMapExecutor
+from lionagi.core.engine.instruction_map_engine import InstructionMapEngine
 
-from lionagi.core.mail.schema import BaseMail
-from lionagi.core.tool import Tool
-from lionagi.core.generic import ActionSelection, Edge
+from lionagi.core.mail import Mail
+from lionagi.core.action import Tool, DirectiveSelection, ActionNode
+from lionagi.core.generic.edge import Edge
+from lionagi.core.collections.progression import progression
 
 from lionagi.libs import AsyncUtil
 
@@ -33,9 +33,12 @@ class Neo4jExecutor(BaseExecutor):
     structure_id: str = None
     structure_name: str = None
     middle_agents: list | None = None
-    default_agent_executable: BaseExecutor = InstructionMapExecutor()
+    default_agent_executable: BaseExecutor = InstructionMapEngine()
     condition_check_result: bool | None = None
 
+    class Config:
+        arbitrary_types_allowed = True
+
     async def check_edge_condition(
         self, condition, executable_id, request_source, head, tail
     ):
@@ -52,9 +55,9 @@ class Neo4jExecutor(BaseExecutor):
         Returns:
             bool: Result of the condition check.
         """
-        if condition.source_type == "structure":
-            return condition(self)
-        elif condition.source_type == "executable":
+        if condition.source == "structure":
+            return condition.applies(self)
+        elif condition.source == "executable":
             return await self._check_executable_condition(
                 condition, executable_id, head, tail, request_source
             )
@@ -66,20 +69,20 @@ class Neo4jExecutor(BaseExecutor):
         Args:
             edge_id (str): The ID of the edge.
         """
-        for key in list(self.pending_ins.keys()):
-            skipped_requests = deque()
-            while self.pending_ins[key]:
-                mail: BaseMail = self.pending_ins[key].popleft()
+        for key in list(self.mailbox.pending_ins.keys()):
+            skipped_requests = progression()
+            while self.mailbox.pending_ins[key].size() > 0:
+                mail_id = self.mailbox.pending_ins[key].popleft()
+                mail = self.mailbox.pile[mail_id]
                 if (
                     mail.category == "condition"
-                    and mail.package["package"]["edge_id"] == edge_id
+                    and mail.package.package["edge_id"] == edge_id
                 ):
-                    self.condition_check_result = mail.package["package"][
-                        "check_result"
-                    ]
+                    self.mailbox.pile.pop(mail_id)
+                    self.condition_check_result = mail.package.package["check_result"]
                 else:
                     skipped_requests.append(mail)
-            self.pending_ins[key] = skipped_requests
+            self.mailbox.pending_ins[key] = skipped_requests
 
     async def _check_executable_condition(
         self, condition, executable_id, head, tail, request_source
@@ -99,13 +102,14 @@ class Neo4jExecutor(BaseExecutor):
         """
         edge = Edge(head=head, tail=tail, condition=condition)
         self.send(
-            recipient_id=executable_id,
+            recipient=executable_id,
             category="condition",
-            package={"request_source": request_source, "package": edge},
+            package=edge,
+            request_source=request_source,
         )
         while self.condition_check_result is None:
             await AsyncUtil.sleep(0.1)
-            self._process_edge_condition(edge.id_)
+            self._process_edge_condition(edge.ln_id)
             continue
         check_result = self.condition_check_result
         self.condition_check_result = None
@@ -126,27 +130,27 @@ class Neo4jExecutor(BaseExecutor):
         bundled_nodes = deque()
         for node_labels, node_properties in bundle_list:
             try:
-                if "ActionSelection" in node_labels:
-                    node = ParseNode.parse_actionSelection(node_properties)
+                if "DirectiveSelection" in node_labels:
+                    node = ParseNode.parse_directiveSelection(node_properties)
                     bundled_nodes.append(node)
                 elif "Tool" in node_labels:
                     node = ParseNode.parse_tool(node_properties)
                     bundled_nodes.append(node)
                 else:
                     raise ValueError(
-                        f"Invalid bundle node {node_properties.id}. Valid nodes are ActionSelection or Tool"
+                        f"Invalid bundle node {node_properties.ln_id}. Valid nodes are ActionSelection or Tool"
                     )
             except Exception as e:
                 raise ValueError(
-                    f"Failed to parse ActionSelection or Tool node {node_properties.id}. Error: {e}"
+                    f"Failed to parse ActionSelection or Tool node {node_properties.ln_id}. Error: {e}"
                 )
 
         action_node = ActionNode(instruction=instruction)
         while bundled_nodes:
             node = bundled_nodes.popleft()
-            if isinstance(node, ActionSelection):
-                action_node.action = node.action
-                action_node.action_kwargs = node.action_kwargs
+            if isinstance(node, DirectiveSelection):
+                action_node.directive = node.directive
+                action_node.directive_kwargs = node.directive_kwargs
             elif isinstance(node, Tool):
                 action_node.tools.append(node)
         return action_node
@@ -161,7 +165,11 @@ class Neo4jExecutor(BaseExecutor):
         Returns:
             BaseAgent: An agent executor configured with the given properties.
         """
-        output_parser = ParseNode.convert_to_def(node_properties["outputParser"])
+        output_parser = (
+            ParseNode.convert_to_def(node_properties["outputParser"])
+            if "outputParser" in node_properties
+            else None
+        )
 
         structure = Neo4jExecutor(
             driver=self.driver, structure_id=node_properties["structureId"]
@@ -170,9 +178,9 @@ class Neo4jExecutor(BaseExecutor):
             structure=structure,
             executable=self.default_agent_executable,
             output_parser=output_parser,
+            ln_id=node_properties["ln_id"],
+            timestamp=node_properties["timestamp"],
         )
-        agent.id_ = node_properties["id"]
-        agent.timestamp = node_properties["timestamp"]
         return agent
 
     async def _next_node(
@@ -202,7 +210,7 @@ class Neo4jExecutor(BaseExecutor):
                     condition_obj = ParseNode.parse_condition(condition, condition_cls)
 
                     head = node_id
-                    tail = node_properties["id"]
+                    tail = node_properties["ln_id"]
                     check = await self.check_edge_condition(
                         condition_obj, executable_id, request_source, head, tail
                     )
@@ -210,7 +218,7 @@ class Neo4jExecutor(BaseExecutor):
                         continue
                 except Exception as e:
                     raise ValueError(
-                        f"Failed to use condition {edge_properties['condition']} from {node_id} to {node_properties['id']}, Error: {e}"
+                        f"Failed to use condition {edge_properties['condition']} from {node_id} to {node_properties['ln_id']}, Error: {e}"
                     )
 
             try:
@@ -223,14 +231,14 @@ class Neo4jExecutor(BaseExecutor):
 
                 else:
                     raise ValueError(
-                        f"Invalid start node {node_properties.id}. Valid nodes are System or Instruction"
+                        f"Invalid start node {node_properties.ln_id}. Valid nodes are System or Instruction"
                     )
             except Exception as e:
                 raise ValueError(
-                    f"Failed to parse System or Instruction node {node_properties.id}. Error: {e}"
+                    f"Failed to parse System or Instruction node {node_properties.ln_id}. Error: {e}"
                 )
 
-            bundle_list = await self.driver.get_bundle(node.id_)
+            bundle_list = await self.driver.get_bundle(node.ln_id)
 
             if bundle_list and "System" in node_labels:
                 raise ValueError("System node does not support bundle edge")
@@ -247,10 +255,10 @@ class Neo4jExecutor(BaseExecutor):
             ValueError: If there is an issue with finding or starting the structure.
         """
         try:
-            id, head_list = await self.driver.get_heads(
+            id_, head_list = await self.driver.get_heads(
                 self.structure_name, self.structure_id
             )
-            self.structure_id = id
+            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}")
@@ -273,12 +281,12 @@ class Neo4jExecutor(BaseExecutor):
         node_list = await self.driver.get_forwards(node_id)
         return await self._next_node(node_list, node_id, executable_id, request_source)
 
-    async def _handle_mail(self, mail: BaseMail):
+    async def _handle_mail(self, mail: Mail):
         """
         Processes incoming mail, determining the next action based on the mail's category and content.
 
         Args:
-            mail (BaseMail): The incoming mail to be processed.
+            mail (Mail): The incoming mail to be processed.
 
         Raises:
             ValueError: If there is an error processing the mail.
@@ -295,9 +303,9 @@ class Neo4jExecutor(BaseExecutor):
 
         elif mail.category == "node_id":
             try:
-                node_id = mail.package["package"]
-                executable_id = mail.sender_id
-                request_source = mail.package["request_source"]
+                node_id = mail.package.package
+                executable_id = mail.sender
+                request_source = mail.package.request_source
                 return await self._handle_node_id(
                     node_id, executable_id, request_source
                 )
@@ -305,9 +313,9 @@ class Neo4jExecutor(BaseExecutor):
                 raise ValueError(f"Error in handling node_id: {e}")
         elif mail.category == "node":
             try:
-                node_id = mail.package["package"].id_
-                executable_id = mail.sender_id
-                request_source = mail.package["request_source"]
+                node_id = mail.package.package.ln_id
+                executable_id = mail.sender
+                request_source = mail.package.request_source
                 return await self._handle_node_id(
                     node_id, executable_id, request_source
                 )
@@ -316,50 +324,45 @@ class Neo4jExecutor(BaseExecutor):
         else:
             raise ValueError(f"Invalid mail type for structure")
 
-    def _send_mail(self, next_nodes: list | None, mail: BaseMail):
+    def _send_mail(self, next_nodes: list | None, mail: Mail):
         """
         Sends out mail to the next nodes or marks the execution as ended if there are no next nodes.
 
         Args:
             next_nodes (list | None): List of next nodes to which mail should be sent.
-            mail (BaseMail): The current mail being processed.
+            mail (Mail): The current mail being processed.
         """
         if not next_nodes:  # tail
             self.send(
-                recipient_id=mail.sender_id,
+                recipient=mail.sender,
                 category="end",
-                package={
-                    "request_source": mail.package["request_source"],
-                    "package": "end",
-                },
+                package="end",
+                request_source=mail.package.request_source,
             )
         else:
             if len(next_nodes) == 1:
                 self.send(
-                    recipient_id=mail.sender_id,
+                    recipient=mail.sender,
                     category="node",
-                    package={
-                        "request_source": mail.package["request_source"],
-                        "package": next_nodes[0],
-                    },
+                    package=next_nodes[0],
+                    request_source=mail.package.request_source,
                 )
             else:
                 self.send(
-                    recipient_id=mail.sender_id,
+                    recipient=mail.sender,
                     category="node_list",
-                    package={
-                        "request_source": mail.package["request_source"],
-                        "package": next_nodes,
-                    },
+                    package=next_nodes,
+                    request_source=mail.package.request_source,
                 )
 
     async def forward(self) -> None:
         """
         Forwards execution by processing all pending mails and advancing to next nodes or actions.
         """
-        for key in list(self.pending_ins.keys()):
-            while self.pending_ins[key]:
-                mail: BaseMail = self.pending_ins[key].popleft()
+        for key in list(self.mailbox.pending_ins.keys()):
+            while self.mailbox.pending_ins[key].size() > 0:
+                mail_id = self.mailbox.pending_ins[key].popleft()
+                mail = self.mailbox.pile.pop(mail_id)
                 try:
                     if mail == "end":
                         self.execute_stop = True