tinyagent-py 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

tinyagent/code_agent/utils.py

@@ -0,0 +1,120 @@
+import sys
+import cloudpickle
+from typing import Dict, Any
+
+
+def clean_response(resp: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Clean the response from code execution, keeping only relevant fields.
+    
+    Args:
+        resp: Raw response dictionary from code execution
+        
+    Returns:
+        Cleaned response with only essential fields
+    """
+    return {k: v for k, v in resp.items() if k in ['printed_output', 'return_value', 'stderr', 'error_traceback']}
+
+
+def make_session_blob(ns: dict) -> bytes:
+    """
+    Create a serialized blob of the session namespace, excluding unserializable objects.
+    
+    Args:
+        ns: Namespace dictionary to serialize
+        
+    Returns:
+        Serialized bytes of the clean namespace
+    """
+    clean = {}
+    for name, val in ns.items():
+        try:
+            # Try serializing just this one object
+            cloudpickle.dumps(val)
+        except Exception:
+            # drop anything that fails
+            continue
+        else:
+            clean[name] = val
+
+    return cloudpickle.dumps(clean)
+
+
+def _run_python(code: str, globals_dict: Dict[str, Any] = None, locals_dict: Dict[str, Any] = None):
+    """
+    Execute Python code in a controlled environment with proper error handling.
+    
+    Args:
+        code: Python code to execute
+        globals_dict: Global variables dictionary
+        locals_dict: Local variables dictionary
+        
+    Returns:
+        Dictionary containing execution results
+    """
+    import contextlib
+    import traceback
+    import io
+    import ast
+    
+    # Make copies to avoid mutating the original parameters
+    globals_dict = globals_dict or {}
+    locals_dict = locals_dict or {}
+    updated_globals = globals_dict.copy()
+    updated_locals = locals_dict.copy()
+    
+    # Pre-import essential modules into the global namespace
+    # This ensures they're available for imports inside functions
+    essential_modules = ['requests', 'json', 'os', 'sys', 'time', 'datetime', 're', 'random', 'math']
+    
+    for module_name in essential_modules:
+        try:
+            module = __import__(module_name)
+            updated_globals[module_name] = module
+            #print(f"✓ {module_name} module loaded successfully")
+        except ImportError:
+            print(f"⚠️  Warning: {module_name} module not available")
+    
+    tree = ast.parse(code, mode="exec")
+    compiled = compile(tree, filename="<ast>", mode="exec")
+    stdout_buf = io.StringIO()
+    stderr_buf = io.StringIO()
+
+    # Execute with stdout+stderr capture and exception handling
+    error_traceback = None
+    output = None
+
+    with contextlib.redirect_stdout(stdout_buf), contextlib.redirect_stderr(stderr_buf):
+        try:
+            # Merge all variables into globals to avoid scoping issues with generator expressions
+            # When exec() is called with both globals and locals, generator expressions can't
+            # access local variables. By using only globals, everything runs in global scope.
+            merged_globals = updated_globals.copy()
+            merged_globals.update(updated_locals)
+            
+            # Execute with only globals - this fixes generator expression scoping issues
+            output = exec(code, merged_globals)
+            
+            # Update both dictionaries with any new variables created during execution
+            for key, value in merged_globals.items():
+                if key not in updated_globals and key not in updated_locals:
+                    updated_locals[key] = value
+                elif key in updated_locals or key not in updated_globals:
+                    updated_locals[key] = value
+                updated_globals[key] = value
+        except Exception:
+            # Capture the full traceback as a string
+            error_traceback = traceback.format_exc()
+
+    printed_output = stdout_buf.getvalue()
+    stderr_output = stderr_buf.getvalue()
+    error_traceback_output = error_traceback
+
+    return {
+        "printed_output": printed_output, 
+        "return_value": output, 
+        "stderr": stderr_output, 
+        "error_traceback": error_traceback_output,
+        "updated_globals": updated_globals,
+        "updated_locals": updated_locals
+    } 

tinyagent/hooks/__init__.py

@@ -1,4 +1,5 @@
 #from .rich_ui_agent import RichUICallback
 from .rich_ui_callback import RichUICallback
+from .rich_code_ui_callback import RichCodeUICallback
 from .logging_manager import LoggingManager
-__all__ = ["RichUICallback", "LoggingManager"]
+__all__ = ["RichUICallback", "RichCodeUICallback", "LoggingManager"]

tinyagent/hooks/gradio_callback.py

@@ -157,7 +157,7 @@ class GradioCallback:
 
                     # Add to detailed tool call info if not already present by ID
                     if not any(tc['id'] == tool_id for tc in self.tool_call_details):
-                        self.tool_call_details.append({
+                        tool_detail = {
                             "id": tool_id,
                             "name": tool_name,
                             "arguments": formatted_args,
@@ -166,7 +166,25 @@ class GradioCallback:
                             "result_token_count": 0,
                             "timestamp": current_time,
                             "result_timestamp": None
-                        })
+                        }
+                        
+                        # Special handling for run_python tool - extract code_lines
+                        if tool_name == "run_python":
+                            try:
+                                # Look for code in different possible field names
+                                code_content = None
+                                for field in ['code_lines', 'code', 'script', 'python_code']:
+                                    if field in parsed_args:
+                                        code_content = parsed_args[field]
+                                        break
+                                
+                                if code_content is not None:
+                                    tool_detail["code_lines"] = code_content
+                                    self.logger.debug(f"Stored code content for run_python tool {tool_id}")
+                            except Exception as e:
+                                self.logger.error(f"Error processing run_python arguments: {e}")
+                        
+                        self.tool_call_details.append(tool_detail)
                         self.logger.debug(f"Added tool call detail: {tool_name} (ID: {tool_id}, Tokens: {token_count})")
                         
                         # If this is a final_answer or ask_question tool, we'll handle it specially later
@@ -386,19 +404,127 @@ class GradioCallback:
                 f"O {self.token_usage['completion_tokens']} | " +
                 f"Total {self.token_usage['total_tokens']}")
 
+    def _format_run_python_tool(self, tool_detail: dict) -> str:
+        """
+        Format run_python tool call with proper markdown formatting for code and output.
+        
+        Args:
+            tool_detail: Tool call detail dictionary
+            
+        Returns:
+            Formatted markdown string
+        """
+        tool_name = tool_detail["name"]
+        tool_id = tool_detail.get("id", "unknown")
+        code_lines = tool_detail.get("code_lines", [])
+        result = tool_detail.get("result")
+        input_tokens = tool_detail.get("token_count", 0)
+        output_tokens = tool_detail.get("result_token_count", 0)
+        total_tokens = input_tokens + output_tokens
+        
+        # Start building the formatted content
+        parts = []
+        
+        # Handle different code_lines formats
+        combined_code = ""
+        if code_lines:
+            if isinstance(code_lines, list):
+                # Standard case: list of code lines
+                combined_code = "\n".join(code_lines)
+            elif isinstance(code_lines, str):
+                # Handle case where code_lines is a single string
+                combined_code = code_lines
+            else:
+                # Convert other types to string
+                combined_code = str(code_lines)
+        
+        # If we have code content, show it as Python code block
+        if combined_code.strip():
+            parts.append(f"**Python Code:**\n```python\n{combined_code}\n```")
+        else:
+            # Try to extract code from arguments as fallback
+            try:
+                args_dict = json.loads(tool_detail['arguments'])
+                # Check for different possible code field names
+                code_content = None
+                for field in ['code_lines', 'code', 'script', 'python_code']:
+                    if field in args_dict:
+                        code_content = args_dict[field]
+                        break
+                
+                if code_content:
+                    if isinstance(code_content, list):
+                        combined_code = "\n".join(code_content)
+                    else:
+                        combined_code = str(code_content)
+                    
+                    if combined_code.strip():
+                        parts.append(f"**Python Code:**\n```python\n{combined_code}\n```")
+                    else:
+                        # Final fallback to showing raw arguments
+                        parts.append(f"**Input Arguments:**\n```json\n{tool_detail['arguments']}\n```")
+                else:
+                    # No code found, show raw arguments
+                    parts.append(f"**Input Arguments:**\n```json\n{tool_detail['arguments']}\n```")
+            except (json.JSONDecodeError, KeyError):
+                # If we can't parse arguments, show them as-is
+                parts.append(f"**Input Arguments:**\n```json\n{tool_detail['arguments']}\n```")
+        
+        # Add the output if available
+        if result is not None:
+            parts.append(f"\n**Output:** ({output_tokens} tokens)")
+            
+            try:
+                # Try to parse result as JSON for better formatting
+                result_json = json.loads(result)
+                parts.append(f"```json\n{json.dumps(result_json, indent=2)}\n```")
+            except (json.JSONDecodeError, TypeError):
+                # Handle plain text result
+                if isinstance(result, str):
+                    # Replace escaped newlines with actual newlines for better readability
+                    formatted_result = result.replace("\\n", "\n")
+                    parts.append(f"```\n{formatted_result}\n```")
+                else:
+                    parts.append(f"```\n{str(result)}\n```")
+        else:
+            parts.append(f"\n**Status:** ⏳ Processing...")
+        
+        # Add token information
+        parts.append(f"\n**Token Usage:** {total_tokens} total ({input_tokens} input + {output_tokens} output)")
+        
+        return "\n".join(parts)
+
     async def interact_with_agent(self, user_input_processed, chatbot_history):
         """
         Process user input, interact with the agent, and stream updates to Gradio UI.
         Each tool call and response will be shown as a separate message.
         """
         self.logger.info(f"Starting interaction for: {user_input_processed[:50]}...")
+        
+        # Reset state for new interaction to prevent showing previous content
+        self.thinking_content = ""
+        self.tool_calls = []
+        self.tool_call_details = []
+        self.assistant_text_responses = []
+        self.token_usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+        self.is_running = True
+        self.last_update_yield_time = 0
+        self.logger.debug("Reset interaction state for new conversation turn")
  
         # 1. Add user message to chatbot history as a ChatMessage
         chatbot_history.append(
             ChatMessage(role="user", content=user_input_processed)
         )
  
-        # Initial yield to show user message
+        # 2. Add typing indicator immediately after user message
+        typing_message = ChatMessage(
+            role="assistant", 
+            content="🤔 Thinking..."
+        )
+        chatbot_history.append(typing_message)
+        typing_message_index = len(chatbot_history) - 1
+ 
+        # Initial yield to show user message and typing indicator
         yield chatbot_history, self._get_token_usage_text()
  
         # Kick off the agent in the background
@@ -407,7 +533,7 @@ class GradioCallback:
  
         displayed_tool_calls = set()
         displayed_text_responses = set()
-        thinking_message_added = False
+        thinking_removed = False
         update_interval = 0.3
         min_yield_interval = 0.2
         
@@ -420,6 +546,14 @@ class GradioCallback:
                 sorted_tool_details = sorted(self.tool_call_details, key=lambda x: x.get("timestamp", 0))
                 sorted_text_responses = sorted(self.assistant_text_responses, key=lambda x: x.get("timestamp", 0))
  
+                # Remove typing indicator once we have actual content to show
+                if not thinking_removed and (sorted_text_responses or sorted_tool_details):
+                    # Remove the typing indicator
+                    if typing_message_index < len(chatbot_history):
+                        chatbot_history.pop(typing_message_index)
+                        thinking_removed = True
+                        self.logger.debug("Removed typing indicator")
+ 
                 # → New assistant text chunks
                 for resp in sorted_text_responses:
                     content = resp["content"]
@@ -430,22 +564,6 @@ class GradioCallback:
                         displayed_text_responses.add(content)
                         self.logger.debug(f"Added new text response: {content[:50]}...")
  
-                # → Thinking placeholder (optional)
-                if self.show_thinking and self.thinking_content \
-                   and not thinking_message_added \
-                   and not displayed_text_responses:
-                    thinking_msg = (
-                        "Working on it...\n\n"
-                        "```"
-                        f"{self.thinking_content}"
-                        "```"
-                    )
-                    chatbot_history.append(
-                        ChatMessage(role="assistant", content=thinking_msg)
-                    )
-                    thinking_message_added = True
-                    self.logger.debug("Added thinking message")
- 
                 # → Show tool calls with "working..." status when they start
                 if self.show_tool_calls:
                     for tool in sorted_tool_details:
@@ -455,11 +573,18 @@ class GradioCallback:
                         # If we haven't displayed this tool call yet
                         if tid not in displayed_tool_calls and tid not in in_progress_tool_calls:
                             in_tok = tool.get("token_count", 0)
+                            
                             # Create "working..." message for this tool call
-                            body = (
-                                f"**Input Arguments:**\n```json\n{tool['arguments']}\n```\n\n"
-                                f"**Output:** ⏳ Working...\n"
-                            )
+                            if tname == "run_python":
+                                # Special formatting for run_python
+                                body = self._format_run_python_tool(tool)
+                            else:
+                                # Standard formatting for other tools
+                                body = (
+                                    f"**Input Arguments:**\n```json\n{tool['arguments']}\n```\n\n"
+                                    f"**Output:** ⏳ Working...\n"
+                                )
+                            
                             # Add to chatbot with "working" status
                             msg = ChatMessage(
                                 role="assistant",
@@ -483,10 +608,16 @@ class GradioCallback:
                             tot_tok = in_tok + out_tok
                             
                             # Update the message with completed status and result
-                            body = (
-                                f"**Input Arguments:**\n```json\n{tool['arguments']}\n```\n\n"
-                                f"**Output:** ({out_tok} tokens)\n```json\n{tool['result']}\n```\n"
-                            )
+                            if tname == "run_python":
+                                # Special formatting for completed run_python
+                                body = self._format_run_python_tool(tool)
+                            else:
+                                # Standard formatting for other completed tools
+                                body = (
+                                    f"**Input Arguments:**\n```json\n{tool['arguments']}\n```\n\n"
+                                    f"**Output:** ({out_tok} tokens)\n```json\n{tool['result']}\n```\n"
+                                )
+                            
                             # Update the existing message
                             chatbot_history[pos] = ChatMessage(
                                 role="assistant",
@@ -508,6 +639,11 @@ class GradioCallback:
  
             await asyncio.sleep(update_interval)
  
+        # Remove typing indicator if still present when agent finishes
+        if not thinking_removed and typing_message_index < len(chatbot_history):
+            chatbot_history.pop(typing_message_index)
+            self.logger.debug("Removed typing indicator at end")
+ 
         # once the agent_task is done, add its final result if any
         try:
             final_text = await agent_task
@@ -772,8 +908,8 @@ class GradioCallback:
         return app
 
     def clear_conversation(self):
-        """Clear the conversation history (UI + agent), reset state, and update UI."""
-        self.logger.debug("Clearing conversation (UI + agent)")
+        """Clear the conversation history (UI + agent), reset state completely, and update UI."""
+        self.logger.debug("Clearing conversation completely (UI + agent with new session)")
         # Reset UI‐side state
         self.thinking_content = ""
         self.tool_calls = []
@@ -782,13 +918,52 @@ class GradioCallback:
         self.token_usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
         self.is_running = False
 
-        # Also clear the agent's conversation history
+        # Completely reset the agent state with a new session
         try:
-            if self.current_agent and hasattr(self.current_agent, "clear_conversation"):
-                self.current_agent.clear_conversation()
-                self.logger.debug("Cleared TinyAgent internal conversation.")
+            if self.current_agent:
+                # Generate a new session ID for a fresh start
+                import uuid
+                new_session_id = str(uuid.uuid4())
+                self.current_agent.session_id = new_session_id
+                self.logger.debug(f"Generated new session ID: {new_session_id}")
+                
+                # Reset all agent state
+                # 1. Clear conversation history (preserve system message)
+                if self.current_agent.messages:
+                    system_msg = self.current_agent.messages[0]
+                    self.current_agent.messages = [system_msg]
+                else:
+                    # Rebuild default system prompt if missing
+                    default_system_prompt = (
+                        "You are a helpful AI assistant with access to a variety of tools. "
+                        "Use the tools when appropriate to accomplish tasks. "
+                        "If a tool you need isn't available, just say so."
+                    )
+                    self.current_agent.messages = [{
+                        "role": "system",
+                        "content": default_system_prompt
+                    }]
+                
+                # 2. Reset session state
+                self.current_agent.session_state = {}
+                
+                # 3. Reset token usage in metadata
+                if hasattr(self.current_agent, 'metadata') and 'usage' in self.current_agent.metadata:
+                    self.current_agent.metadata['usage'] = {
+                        "prompt_tokens": 0, 
+                        "completion_tokens": 0, 
+                        "total_tokens": 0
+                    }
+                
+                # 4. Reset any other accumulated state that might affect behavior
+                self.current_agent.is_running = False
+                
+                # 5. Reset session load flag to prevent any deferred loading of old session
+                self.current_agent._needs_session_load = False
+                
+                self.logger.info(f"Completely reset TinyAgent with new session: {new_session_id}")
         except Exception as e:
-            self.logger.error(f"Failed to clear TinyAgent conversation: {e}")
+            self.logger.error(f"Failed to reset TinyAgent completely: {e}")
 
         # Return cleared UI components: empty chat + fresh token usage
         return [], self._get_token_usage_text()

{tinyagent_py-0.0.7.dist-info → tinyagent_py-0.0.9.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tinyagent-py
-Version: 0.0.7
-Summary: Tiny Agent with MCP Client and Extendable Hooks, Tiny but powerful
+Version: 0.0.9
+Summary: TinyAgent with MCP Client, Code Agent (Thinking, Planning, and Executing in Python), and Extendable Hooks, Tiny but powerful
 Author-email: Mahdi Golchin <golchin@askdev.ai>
 Project-URL: Homepage, https://github.com/askbudi/tinyagent
 Project-URL: Bug Tracker, https://github.com/askbudi/tinyagent/issues
@@ -25,10 +25,19 @@ Provides-Extra: sqlite
 Requires-Dist: aiosqlite>=0.18.0; extra == "sqlite"
 Provides-Extra: gradio
 Requires-Dist: gradio>=3.50.0; extra == "gradio"
+Provides-Extra: code
+Requires-Dist: jinja2; extra == "code"
+Requires-Dist: pyyaml; extra == "code"
+Requires-Dist: cloudpickle; extra == "code"
+Requires-Dist: modal; extra == "code"
 Provides-Extra: all
 Requires-Dist: asyncpg>=0.27.0; extra == "all"
 Requires-Dist: aiosqlite>=0.18.0; extra == "all"
 Requires-Dist: gradio>=3.50.0; extra == "all"
+Requires-Dist: jinja2; extra == "all"
+Requires-Dist: pyyaml; extra == "all"
+Requires-Dist: cloudpickle; extra == "all"
+Requires-Dist: modal; extra == "all"
 Dynamic: license-file
 
 # TinyAgent
@@ -52,7 +61,11 @@ Inspired by:
 - [Build your own Tiny Agent](https://askdev.ai/github/askbudi/tinyagent)
 
 ## Overview
-This is a tiny agent that uses MCP and LiteLLM to interact with a model. You have full control over the agent, you can add any tools you like from MCP and extend the agent using its event system.
+This is a tiny agent framework that uses MCP and LiteLLM to interact with language models. You have full control over the agent, you can add any tools you like from MCP and extend the agent using its event system.
+
+**Two Main Components:**
+- **TinyAgent**: Core agent with MCP tool integration and extensible hooks
+- **TinyCodeAgent**: Specialized agent for secure Python code execution with pluggable providers
 
 ## Installation
 
@@ -64,6 +77,10 @@ pip install tinyagent-py
 # Install with all optional dependencies
 pip install tinyagent-py[all]
 
+# Install with Code Agent support
+pip install tinyagent-py[code]
+
+
 # Install with PostgreSQL support
 pip install tinyagent-py[postgres]
 
@@ -73,6 +90,10 @@ pip install tinyagent-py[sqlite]
 # Install with Gradio UI support
 pip install tinyagent-py[gradio]
 
+
+
+
+
 ```
 
 ### Using uv
@@ -80,6 +101,10 @@ pip install tinyagent-py[gradio]
 # Basic installation
 uv pip install tinyagent-py
 
+# Install with Code Agent support
+uv pip install tinyagent-py[code]
+
+
 # Install with PostgreSQL support
 uv pip install tinyagent-py[postgres]
 
@@ -92,11 +117,11 @@ uv pip install tinyagent-py[gradio]
 # Install with all optional dependencies
 uv pip install tinyagent-py[all]
 
-# Install with development tools
-uv pip install tinyagent-py[dev]
 ```
 
 ## Usage
+
+### TinyAgent (Core Agent)
 [![AskDev.AI | Chat with TinyAgent](https://img.shields.io/badge/AskDev.AI-Chat_with_TinyAgent-blue?style=flat-square)](https://askdev.ai/github/askbudi/tinyagent)
 
 
@@ -133,6 +158,114 @@ I need accommodation in Toronto between 15th to 20th of May. Give me 5 options f
 await test_agent(task, model="gpt-4.1-mini")
 ```
 
+## TinyCodeAgent - Code Execution Made Easy
+
+TinyCodeAgent is a specialized agent for executing Python code with enterprise-grade reliability and extensible execution providers.
+
+### Quick Start with TinyCodeAgent
+
+```python
+import asyncio
+from tinyagent import TinyCodeAgent
+
+async def main():
+    # Initialize with minimal configuration
+    agent = TinyCodeAgent(
+        model="gpt-4.1-mini",
+        api_key="your-openai-api-key"
+    )
+    
+    try:
+        # Ask the agent to solve a coding problem
+        result = await agent.run("Calculate the factorial of 10 and explain the algorithm")
+        print(result)
+    finally:
+        await agent.close()
+
+asyncio.run(main())
+```
+
+### TinyCodeAgent with Gradio UI
+
+Launch a complete web interface for interactive code execution:
+
+```python
+from tinyagent.code_agent.example import run_example
+import asyncio
+
+# Run the full example with Gradio interface
+asyncio.run(run_example())
+```
+
+### Key Features
+
+- **🔒 Secure Execution**: Sandboxed Python code execution using Modal.com or other providers
+- **🔧 Extensible Providers**: Switch between Modal, Docker, local execution, or cloud functions
+- **🎯 Built for Enterprise**: Production-ready with proper logging, error handling, and resource cleanup  
+- **📁 File Support**: Upload and process files through the Gradio interface
+- **🛠️ Custom Tools**: Add your own tools and functions easily
+- **📊 Session Persistence**: Code state persists across executions
+
+### Provider System
+
+TinyCodeAgent uses a pluggable provider system - change execution backends with minimal code changes:
+
+```python
+# Use Modal (default) - great for production
+agent = TinyCodeAgent(provider="modal")
+
+# Future providers (coming soon)
+# agent = TinyCodeAgent(provider="docker")
+# agent = TinyCodeAgent(provider="local") 
+# agent = TinyCodeAgent(provider="lambda")
+```
+
+### Example Use Cases
+
+**Web Scraping:**
+```python
+result = await agent.run("""
+What are trending spaces on huggingface today?
+""")
+# Agent will create a python tool to request HuggingFace API and find trending spaces
+```
+
+**Use code to solve a task:**
+```python
+response = await agent.run(dedent("""
+Suggest me 13 tags for my Etsy Listing, each tag should be multiworded and maximum 20 characters. Each word should be used only once in the whole corpus, And tags should cover different ways people are searching for the product on Etsy.
+- You should use your coding abilities to check your answer pass the criteria and continue your job until you get to the answer.
+                                
+My Product is **Wedding Invitation Set of 3, in sage green color, with a gold foil border.**
+"""),max_turns=20)
+
+print(response)
+# LLM is not good at this task, counting characters, avoid duplicates, but with the power of code, tiny model like gpt-4.1-mini can do it without any problem.
+```
+
+
+### Configuration Options
+
+```python
+from tinyagent import TinyCodeAgent
+from tinyagent.code_agent.tools import get_weather, get_traffic
+
+# Full configuration example
+agent = TinyCodeAgent(
+    model="gpt-4.1-mini",
+    api_key="your-api-key", 
+    provider="modal",
+    tools=[get_weather, get_traffic],
+    authorized_imports=["requests", "pandas", "numpy"],
+    provider_config={
+        "pip_packages": ["requests", "pandas"],
+        "sandbox_name": "my-code-sandbox"
+    }
+)
+```
+
+For detailed documentation, see the [TinyCodeAgent README](tinyagent/code_agent/README.md).
+
 ## How the TinyAgent Hook System Works
 
 TinyAgent is designed to be **extensible** via a simple, event-driven hook (callback) system. This allows you to add custom logic, logging, UI, memory, or any other behavior at key points in the agent's lifecycle.