PikoAi 0.1.8__tar.gz → 0.1.10__tar.gz

{pikoai-0.1.8 → pikoai-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PikoAi
-Version: 0.1.8
+Version: 0.1.10
 Summary: An AI-powered task automation tool
 Home-page: https://github.com/nihaaaar22/OS-Assistant
 Author: Nihar S

pikoai-0.1.10/Src/Agents/Executor/executor.py

@@ -0,0 +1,185 @@
+# the change in this executor is the the tasks will not be iterated in a for loop and execution will not be done one by one
+# instead it would be asked what is the next course of action
+
+import os
+import sys
+import time
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../')))
+from Utils.ter_interface import TerminalInterface
+from Utils.executor_utils import parse_tool_call
+from Agents.Executor.prompts import get_system_prompt, get_task_prompt # Import prompts
+
+from typing import Optional
+from mistralai.models.sdkerror import SDKError # This might be an issue if LiteLLM doesn't use SDKError
+                                              # LiteLLM maps exceptions to OpenAI exceptions.
+                                              # We'll keep it for now and see if errors arise during testing.
+# from Env import python_executor # Will be replaced by BaseEnv
+# from Env.shell import ShellExecutor # Will be replaced by BaseEnv
+from Env.base_env import create_environment, BaseEnv # Added
+from Env import python_executor # Keep for type hint in the old execute method if needed, or remove if execute is fully removed
+from llm_interface.llm import LiteLLMInterface # Import LiteLLMInterface
+
+from Tools import tool_manager
+
+class RateLimiter:
+    def __init__(self, wait_time: float = 5.0, max_retries: int = 3):
+        self.wait_time = wait_time
+        self.max_retries = max_retries
+        self.last_call_time = None
+
+    def wait_if_needed(self):
+        if self.last_call_time is not None:
+            elapsed = time.time() - self.last_call_time
+            if elapsed < 1.0:
+                time.sleep(1.0 - elapsed)
+        self.last_call_time = time.time()
+
+class executor:
+    def __init__(self, user_prompt, max_iter=10):
+        self.user_prompt = user_prompt
+        self.max_iter = max_iter
+        self.rate_limiter = RateLimiter(wait_time=5.0, max_retries=3)
+        self.executor_prompt_init()  # Update system_prompt
+        # self.python_executor = python_executor.PythonExecutor()  # Initialize PythonExecutor
+        # self.shell_executor = ShellExecutor() # Initialize ShellExecutor
+        self.message = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": self.task_prompt}
+        ]
+        self.terminal = TerminalInterface()
+        self.initialize_llm()
+
+    def initialize_llm(self):
+        # Directly instantiate LiteLLMInterface. 
+        # It handles its own configuration loading (including model_name from config.json).
+        self.llm = LiteLLMInterface()
+
+    def get_tool_dir(self):
+        import pkg_resources
+        tool_dir_path = pkg_resources.resource_filename('Tools', 'tool_dir.json')
+        with open(tool_dir_path, "r") as file:
+            return file.read()
+
+    def executor_prompt_init(self):
+        # Load tools details when initializing prompt
+        tools_details = self.get_tool_dir()
+
+        # Read working_directory from config.json
+        # This import needs to be here, or moved to the top if json is used elsewhere
+        import json 
+        with open(os.path.join(os.path.dirname(__file__), '../../../config.json'), "r") as config_file:
+            config = json.load(config_file)
+            working_dir = config.get("working_directory", "")
+
+        self.system_prompt = get_system_prompt(self.user_prompt, working_dir, tools_details)
+        self.task_prompt = get_task_prompt()
+
+    def run_inference(self):
+        retries = 0
+        while retries <= self.rate_limiter.max_retries:
+            try:
+                self.rate_limiter.wait_if_needed()
+
+                response = self.llm.chat(self.message) # LiteLLMInterface.chat() returns the full response string
+
+                # Streaming is handled within LiteLLMInterface.chat()
+                # and TerminalInterface.process_markdown_chunk()
+                self.message.append({"role": "assistant", "content": response})
+                return response
+
+            except Exception as e: # Catching generic Exception as LiteLLM maps to OpenAI exceptions
+                # Check if the error message contains "429" for rate limiting
+                if "429" in str(e) and retries < self.rate_limiter.max_retries:
+                    retries += 1
+                    print(f"\nRate limit error detected. Waiting {self.rate_limiter.wait_time} seconds before retry {retries}/{self.rate_limiter.max_retries}")
+                    time.sleep(self.rate_limiter.wait_time)
+                # Check if the error is an SDKError (though less likely with LiteLLM directly)
+                # or if it's any other exception that we should retry or raise.
+                elif isinstance(e, SDKError) and "429" in str(e) and retries < self.rate_limiter.max_retries: # Added SDKError check just in case
+                    retries += 1
+                    print(f"\nRate limit exceeded (SDKError). Waiting {self.rate_limiter.wait_time} seconds before retry {retries}/{self.rate_limiter.max_retries}")
+                    time.sleep(self.rate_limiter.wait_time)
+                else:
+                    print(f"\nError occurred during inference: {str(e)}")
+                    # You might want to log the full traceback here for debugging
+                    # import traceback
+                    # print(traceback.format_exc())
+                    raise
+        raise Exception("Failed to complete inference after maximum retries")
+
+    def run(self):
+
+        self.run_task()
+
+    def run_task(self):
+        # Remove tools_details parameter since it's in the prompt
+        task_message = self.task_prompt
+
+        self.message.append({"role": "user", "content": task_message})
+
+        iteration = 0
+        task_done = False
+
+        while iteration < self.max_iter and not task_done:
+            # Check for tool calls
+            response = self.run_inference()
+            tool_call = parse_tool_call(response)
+
+            if tool_call:
+                tool_name = tool_call['tool_name']
+                tool_input = tool_call['input']
+                print(f"\nIdentified tool call: {tool_name} with input {tool_input}")
+
+                # Call the tool and append the result (no confirmation or special logic)
+                try:
+                    tool_output_result = tool_manager.call_tool(tool_name, tool_input)
+                    self.terminal.tool_output_log(tool_output_result, tool_name)
+                    print(tool_output_result)
+                    self.message.append({"role": "user", "content": tool_output_result})
+                except ValueError as e:
+                    error_msg = str(e)
+                    print(f"Tool Error: {error_msg}")
+                    self.message.append({"role": "user", "content": f"Tool Error: {error_msg}"})
+
+            else: # Not a tool call, could be a direct response or requires clarification
+                # This part handles responses that are not formatted as tool calls.
+                # It might be a final answer, a question, or just conversational text.
+                # The existing logic for TASK_DONE or asking for next step handles this.
+                # No specific code/shell parsing here anymore as they are tools.
+                pass # Explicitly pass if no tool call and no old code/shell logic.
+
+            # Check if task is done
+            if "TASK_DONE" in response:
+                
+                task_done = True
+
+            else:
+                self.message.append({"role": "user", "content": "If the task i mentioned is complete then output TASK_DONE .If not then run another iteration."})
+                iteration += 1
+
+        if not task_done:
+            print(f"Task could not be completed within {self.max_iter} iterations.")
+
+    # This method is superseded by the BaseEnv approach in run_task
+    # def execute(self, code: str, exec_env: python_executor.PythonExecutor):
+    #     """Executes the given Python code using the provided execution environment."""
+    #     result = exec_env.execute(code)
+    #     return result
+
+if __name__ == "__main__":
+    # e1 = executor("") # Commenting out example usage for now as it might need adjustment
+    # user_prompt = input("Please enter your prompt: ")
+    # e1.user_prompt = user_prompt
+    # e1.executor_prompt_init()  # Update system_prompt
+    # e1.message = [
+    #     {"role": "system", "content": e1.system_prompt},
+    #     {"role": "user", "content": e1.task_prompt}
+    # ]  # Reset message list properly
+    # e1.run()
+
+    # while True:
+    #     user_prompt = input("Please enter your prompt: ")
+    #     e1.message.append({"role": "user", "content": user_prompt})
+    #     # e1.message.append({"role":"user","content":e1.system_prompt})
+    #     e1.run()
+    pass # Placeholder if main execution is commented out

{pikoai-0.1.8 → pikoai-0.1.10}/Src/Agents/Executor/prompts.py

@@ -17,9 +17,7 @@ You have access to the following tools:
 
 Your primary objective is to accomplish the user's goal by performing step-by-step actions. These actions can include:
 1. Calling a tool
-2. Executing Python code
-3. Executing Shell commands
-4. Providing a direct response
+2. Providing a direct response
 
 You must break down the user's goal into smaller steps and perform one action at a time. After each action, carefully evaluate the output to determine the next step.
 
@@ -33,14 +31,9 @@ You must break down the user's goal into smaller steps and perform one action at
     }}
   }}
   <<END_TOOL_CALL>>
-- **Code Execution**: Write Python code when no tool is suitable or when custom logic is needed. Format:
-  <<CODE>>
-  your_python_code_here
-  <<CODE>>
-- **Shell Command Execution**: Execute shell commands when needed. Format:
-  <<SHELL_COMMAND>>
-  your_shell_command_here
-  <<END_SHELL_COMMAND>>
+  This includes executing Python code and shell commands:
+  `execute_python_code`: {{"code": "your_python_code_here"}}
+  `execute_shell_command`: {{"command": "your_shell_command_here"}}
 - **Direct Response**: Provide a direct answer if the task doesn't require tools or code.
 
 ### Important Notes:
@@ -68,16 +61,7 @@ Following are the things that you must read carefully and remember:
             }
         }
         <<END_TOOL_CALL>>
-
-        - For code execution, use:
-        <<CODE>>
-        your_python_code_here
-        <<CODE>>
-
-        - For shell command execution, use:
-        <<SHELL_COMMAND>>
-        your_shell_command_here
-        <<END_SHELL_COMMAND>>
+        Remember that executing Python code and shell commands is now done through specific tool calls (`execute_python_code` and `execute_shell_command`).
 
         After each action, always evaluate the output to decide your next step. Only include 'TASK_DONE'
         When the entire task is completed. Do not end the task immediately after a tool call or code execution without

{pikoai-0.1.8 → pikoai-0.1.10}/Src/Env/base_env.py

@@ -1,25 +1,30 @@
-from Env.js_executor import JavaScriptExecutor #class import
-from Env.python_executor import PythonExecutor #class import
-
 # to perform funciton ask whether to execute code
     
 
 class BaseEnv:
 
 
-    def __init__(self, language,code):
-        self.language = language
+    def __init__(self):
+        pass
+
 
+    def execute(self, code_or_command: str):
+        raise NotImplementedError("This method should be overridden by subclasses")
 
-    def execute(self):
+    def stop_execution(self):
         raise NotImplementedError("This method should be overridden by subclasses")
 
       
 def create_environment(language):
+    # Moved imports inside the function to avoid circular dependencies during testing
+    from Env.js_executor import JavaScriptExecutor #class import
+    from Env.python_executor import PythonExecutor #class import
+    from Env.shell import ShellExecutor #class import
+
     if language == "python":
         return PythonExecutor()
-    elif language == "javascript":
-        return JavaScriptExecutor()
+    elif language == "shell":
+        return ShellExecutor()
     else:
         raise ValueError(f"Unsupported language: {language}")
     

pikoai-0.1.10/Src/Env/python_executor.py

@@ -0,0 +1,136 @@
+# from .base_executor import BaseExecutor
+
+# class PythonExecutor():
+#     def execute(self, code: str) -> str:
+#         """Executes Python code and returns the result or an error message."""
+
+#         # if not self.validate_code(code):
+#         #     return "Code validation failed: Unsafe code detected."
+
+#         local_vars = {}
+#         try:
+#             exec(code, {}, local_vars)  # Execute code in an isolated environment
+#             return local_vars.get("output", "Code executed successfully.")
+#         except Exception as e:
+#             # return self.handle_error(e)
+#             print("error in running python code", e)
+
+import subprocess
+import tempfile
+import os
+from typing import Dict
+import textwrap
+import sys
+from Src.Env.base_env import BaseEnv
+import time
+
+class PythonExecutor(BaseEnv):
+    def __init__(self):
+        super().__init__()
+        self.process = None
+        self.forbidden_terms = [
+            'import os', 'import sys', 'import subprocess',
+            'open(', 'exec(', 'eval(',
+        ]
+
+    def basic_code_check(self, code: str) -> bool:
+        """Simple check for potentially dangerous code"""
+        code_lower = code.lower()
+        return not any(term.lower() in code_lower for term in self.forbidden_terms)
+
+    def execute(self, code_or_command: str) -> Dict[str, str]:
+        """Executes Python code in a separate process and returns the result"""
+        
+        # Basic safety check
+        if not self.basic_code_check(code_or_command):
+            return {
+                'success': False,
+                'output': 'Error: Code contains potentially unsafe operations. You can try and use tools to achieve same functionality.',
+                'error': 'Security check failed'
+            }
+
+        # Properly indent the code to fit inside the try block
+        indented_code = textwrap.indent(code_or_command, '    ')
+        # Wrap the indented code to capture output
+        wrapped_code = f"""
+try:
+{indented_code}
+except Exception as e:
+    print(f"Error: {{str(e)}}")
+"""
+           
+
+        try:
+            # Execute the code in a subprocess
+            self.process = subprocess.Popen(
+                [sys.executable, "-u", "-c", wrapped_code],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,  # Line buffered
+                universal_newlines=True
+            )
+            
+            stdout_data = []
+            stderr_data = []
+            start_time = time.time()
+            
+            # First read all stdout
+            for line in self.process.stdout:
+                # Check for timeout
+                if time.time() - start_time > 30:
+                    self.process.kill()
+                    return {
+                        'success': False,
+                        'output': 'Execution timed out after 30 seconds',
+                        'error': 'Timeout error'
+                    }
+                
+                stdout_data.append(line)
+                print(line, end='', flush=True)  # Print in real-time
+            
+            # Then read all stderr
+            for line in self.process.stderr:
+                # Check for timeout
+                if time.time() - start_time > 30:
+                    self.process.kill()
+                    return {
+                        'success': False,
+                        'output': 'Execution timed out after 30 seconds',
+                        'error': 'Timeout error'
+                    }
+                
+                stderr_data.append(line)
+                print(line, end='', file=sys.stderr, flush=True)  # Print in real-time
+            
+            # Wait for process to complete
+            returncode = self.process.wait()
+            
+            return {
+                'success': returncode == 0,
+                'output': ''.join(stdout_data) if returncode == 0 else ''.join(stderr_data),
+                'error': ''.join(stderr_data) if returncode != 0 else ''
+            }
+
+        except Exception as e:
+            return {
+                'success': False,
+                'output': f'Error: {str(e)}',
+                'error': str(e)
+            }
+        finally:
+            self.process = None # Reset process
+
+
+    def stop_execution(self):
+        if self.process and hasattr(self.process, 'pid') and self.process.pid is not None:
+            try:
+                self.process.terminate()
+                print(f"Attempted to terminate Python process with PID: {self.process.pid}")
+            except Exception as e:
+                print(f"Error terminating Python process with PID {self.process.pid}: {e}")
+            finally:
+                self.process = None
+        else:
+            print("No active Python process to stop.")
+

pikoai-0.1.10/Src/Env/shell.py

@@ -0,0 +1,182 @@
+import subprocess
+import time
+import sys
+from Src.Env.base_env import BaseEnv
+import re
+
+class ShellExecutor(BaseEnv):
+    def __init__(self):
+        super().__init__()
+        self.process = None
+
+    def execute(self, code_or_command: str) -> dict:
+        """
+        Executes a shell command and streams its output in real-time.
+        Strictly prevents execution of harmful commands and access to sensitive directories.
+
+        Args:
+            code_or_command: The shell command to execute.
+
+        Returns:
+            A dictionary with the following keys:
+            - 'output': The captured standard output (string).
+            - 'error': The captured standard error (string).
+            - 'success': A boolean indicating whether the command executed successfully.
+        """
+        try:
+            # Strict security check for harmful commands and sensitive directories
+            forbidden_patterns = [
+                r'rm\s+-rf\s+/?(\s|$)',
+                r'rm\s+-rf\s+--no-preserve-root',
+                r'rm\s+-rf\s+/\\?',
+                r'shutdown(\s|$)',
+                r'reboot(\s|$)',
+                r'halt(\s|$)',
+                r':(){:|:&};:',  # fork bomb
+                r'chmod\s+777\s+/(\s|$)',
+                r'chown\s+root',
+                r'\bmkfs\b',
+                r'\bdd\b.*\bif=\/dev\/zero\b',
+                r'\bdd\b.*\bof=\/dev\/sda',
+                r'\bpoweroff\b',
+                r'\binit\s+0\b',
+                r'\bsudo\s+rm\s+-rf\s+/?',
+                r'\bsudo\s+shutdown',
+                r'\bsudo\s+reboot',
+                r'\bsudo\s+halt',
+                r'\bsudo\s+mkfs',
+                r'\bsudo\s+dd',
+                r'\bsudo\s+init\s+0',
+                r'\bsudo\s+poweroff',
+                r'\bsudo\s+chmod\s+777\s+/',
+                r'\bsudo\s+chown\s+root',
+                r'\bdel\b.*\/s.*\/q.*\/f.*C:\\',  # Windows
+                r'format\s+C:',
+                r'rd\s+/?s\s+/?q\s+C:\\',
+                r'\bshutdown\b.*\/s',
+                r'\bshutdown\b.*\/r',
+                r'\bshutdown\b.*\/f',
+                r'\bshutdown\b.*\/p',
+                r'\bshutdown\b.*\/t',
+                r'\bshutdown\b.*\/a',
+                r'\bnet\s+user\s+.*\s+/delete',
+                r'\bnet\s+user\s+administrator\s+/active:no',
+                r'\bnet\s+user\s+administrator\s+/active:yes',
+                r'\bnet\s+localgroup\s+administrators\s+.*\s+/delete',
+                r'\bnet\s+localgroup\s+administrators\s+.*\s+/add',
+            ]
+            sensitive_dirs = [
+                '/', '/etc', '/bin', '/usr', '/var', '/root', '/boot', '/dev', '/proc', '/sys', '/lib', '/lib64',
+                'C:\\', 'C:/', 'C:\\Windows', 'C:/Windows', 'C:\\System32', 'C:/System32',
+                'D:\\', 'D:/', 'E:\\', 'E:/'
+            ]
+            # Check for forbidden patterns
+            for pattern in forbidden_patterns:
+                if re.search(pattern, code_or_command, re.IGNORECASE):
+                    return {
+                        'success': False,
+                        'output': 'Blocked potentially harmful command.',
+                        'error': f'Command matches forbidden pattern: {pattern}'
+                    }
+            # Check for sensitive directory access
+            for sensitive_dir in sensitive_dirs:
+                # Only block if the command is trying to directly access or operate on the sensitive dir
+                if re.search(rf'\b{sensitive_dir}\b', code_or_command, re.IGNORECASE):
+                    return {
+                        'success': False,
+                        'output': f'Blocked access to sensitive directory: {sensitive_dir}',
+                        'error': f'Attempted access to sensitive directory: {sensitive_dir}'
+                    }
+            
+            # Execute the command in a subprocess
+            self.process = subprocess.Popen(
+                code_or_command,
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,  # Line buffered
+                universal_newlines=True
+            )
+            
+            stdout_data = []
+            stderr_data = []
+            start_time = time.time()
+            
+            # First read all stdout
+            for line in self.process.stdout:
+                # Check for timeout
+                if time.time() - start_time > 30:
+                    self.process.kill()
+                    return {
+                        'success': False,
+                        'output': 'Execution timed out after 30 seconds',
+                        'error': 'Timeout error'
+                    }
+                
+                stdout_data.append(line)
+                print(line, end='', flush=True)  # Print in real-time
+            
+            # Then read all stderr
+            for line in self.process.stderr:
+                # Check for timeout
+                if time.time() - start_time > 30:
+                    self.process.kill()
+                    return {
+                        'success': False,
+                        'output': 'Execution timed out after 30 seconds',
+                        'error': 'Timeout error'
+                    }
+                
+                stderr_data.append(line)
+                print(line, end='', file=sys.stderr, flush=True)  # Print in real-time
+            
+            # Wait for process to complete
+            returncode = self.process.wait()
+            
+            return {
+                'success': returncode == 0,
+                'output': ''.join(stdout_data) if returncode == 0 else ''.join(stderr_data),
+                'error': ''.join(stderr_data) if returncode != 0 else ''
+            }
+
+        except Exception as e:
+            return {
+                'success': False,
+                'output': f'Error: {str(e)}',
+                'error': str(e)
+            }
+        finally:
+            self.process = None  # Reset process
+
+    def stop_execution(self):
+        if self.process and hasattr(self.process, 'pid') and self.process.pid is not None:
+            try:
+                self.process.terminate()
+                print(f"Attempted to terminate shell process with PID: {self.process.pid}")
+            except Exception as e:
+                print(f"Error terminating shell process with PID {self.process.pid}: {e}")
+            finally:
+                self.process = None
+        else:
+            print("No active shell process to stop.")
+
+if __name__ == '__main__':
+    # Example usage (optional, for testing)
+    executor = ShellExecutor()
+
+    # Test case 1: Successful command
+    result1 = executor.execute("echo 'Hello, World!'")
+    print(f"Test Case 1 Result: {result1}")
+
+    # Test case 2: Command with an error
+    result2 = executor.execute("ls non_existent_directory")
+    print(f"Test Case 2 Result: {result2}")
+
+    # Test case 3: Command that succeeds but writes to stderr (e.g. some warnings)
+    result3 = executor.execute("echo 'Error output' >&2")
+    print(f"Test Case 3 Result: {result3}")
+
+    # Test case 4: Command that produces no output
+    result4 = executor.execute(":") # The ':' command is a no-op in bash
+    print(f"Test Case 4 Result: {result4}")

pikoai-0.1.10/Src/Env/tests/test_python_executor.py

@@ -0,0 +1,70 @@
+import unittest
+from Src.Env.python_executor import PythonExecutor
+import time
+import threading
+
+class TestPythonExecutor(unittest.TestCase):
+
+    def test_execute_simple_script(self):
+        executor = PythonExecutor()
+        result = executor.execute("print('hello python')")
+        self.assertTrue(result["success"])
+        self.assertEqual(result["output"].strip(), "hello python")
+        self.assertEqual(result["error"], "")
+
+    def test_execute_script_with_error(self):
+        executor = PythonExecutor()
+        result = executor.execute("1/0")
+        self.assertFalse(result["success"])
+        self.assertTrue("ZeroDivisionError" in result["output"]) # Error message goes to stdout for python_executor
+        self.assertEqual(result["error"], "") # stderr should be empty as Popen merges stderr to stdout in this case
+
+    def test_stop_execution_long_script(self):
+        executor = PythonExecutor()
+        long_script = "import time; time.sleep(5); print('should not print')"
+
+        execute_result = {}
+        def target():
+            res = executor.execute(long_script)
+            execute_result.update(res)
+
+        thread = threading.Thread(target=target)
+        thread.start()
+
+        time.sleep(1) # Give the script time to start
+        executor.stop_execution()
+
+        thread.join(timeout=2) # Wait for the thread to finish (should be quick after stop)
+
+        self.assertFalse(execute_result.get("success", True), "Script execution should have failed or been stopped.")
+        # Depending on timing, the process might be killed before it produces output,
+        # or it might produce a timeout error, or a specific error from being terminated.
+        # We check if the output indicates it didn't complete normally.
+        output = execute_result.get("output", "")
+        error = execute_result.get("error", "")
+
+        # Check if 'should not print' is NOT in the output
+        self.assertNotIn("should not print", output, "Script should have been terminated before completion.")
+
+        # Check for signs of termination or timeout
+        # This part is a bit tricky as the exact message can vary.
+        # If basic_code_check fails, output is "Error: Code contains potentially unsafe operations..."
+        # If timeout in communicate(), output is "Execution timed out..."
+        # If process is terminated, output might be empty or contain partial error.
+        # For now, we'll accept that if "should not print" is not there, it's a good sign.
+        # A more robust check might involve looking for specific error messages related to termination if available.
+
+        # A simple check that process is no longer listed in executor
+        self.assertIsNone(executor.process, "Executor process should be None after stopping.")
+
+
+    def test_stop_execution_no_script(self):
+        executor = PythonExecutor()
+        try:
+            executor.stop_execution()
+        except Exception as e:
+            self.fail(f"stop_execution with no script raised an exception: {e}")
+        self.assertIsNone(executor.process, "Executor process should be None.")
+
+if __name__ == '__main__':
+    unittest.main()