LocalCommandLineCodeExecutor

def __init__(
    self,
    timeout: int = 60,
    virtual_env_context: Optional[SimpleNamespace] = None,
    work_dir: Union[Path, str] = Path(),
    functions: list[Union[FunctionWithRequirements[Any, A], Callable[..., Any], FunctionWithRequirementsStr]] = [],
    functions_module: str = "functions",
    execution_policies: Optional[dict[str, bool]] = None,
):
    """(Experimental) A code executor class that executes or saves LLM generated code a local command line
    environment.

    **This will execute or save LLM generated code on the local machine.**

    Each code block is saved as a file in the working directory. Depending on the execution policy,
    the code may be executed in a separate process.
    The code blocks are executed or save in the order they are received.
    Command line code is sanitized against a list of dangerous commands to prevent self-destructive commands from being executed,
    which could potentially affect the user's environment. Supported languages include Python, shell scripts (bash, shell, sh),
    PowerShell (pwsh, powershell, ps1), HTML, CSS, and JavaScript.
    Execution policies determine whether each language's code blocks are executed or saved only.

    ## Execution with a Python virtual environment
    A python virtual env can be used to execute code and install dependencies. This has the added benefit of not polluting the
    base environment with unwanted modules.
    ```python
    from autogen.code_utils import create_virtual_env
    from autogen.coding import LocalCommandLineCodeExecutor

    venv_dir = ".venv"
    venv_context = create_virtual_env(venv_dir)

    executor = LocalCommandLineCodeExecutor(virtual_env_context=venv_context)
    ```

    Args:
        timeout (int): The timeout for code execution, default is 60 seconds.
        virtual_env_context (Optional[SimpleNamespace]): The virtual environment context to use.
        work_dir (Union[Path, str]): The working directory for code execution, defaults to the current directory.
        functions (List[Union[FunctionWithRequirements[Any, A], Callable[..., Any], FunctionWithRequirementsStr]]): A list of callable functions available to the executor.
        functions_module (str): The module name under which functions are accessible.
        execution_policies (Optional[Dict[str, bool]]): A dictionary mapping languages to execution policies (True for execution, False for saving only). Defaults to class-wide DEFAULT_EXECUTION_POLICY.
    """
    if timeout < 1:
        raise ValueError("Timeout must be greater than or equal to 1.")

    if isinstance(work_dir, str):
        work_dir = Path(work_dir)

    if not functions_module.isidentifier():
        raise ValueError("Module name must be a valid Python identifier")

    self._functions_module = functions_module

    work_dir.mkdir(exist_ok=True)

    self._timeout = timeout
    self._work_dir: Path = work_dir
    self._virtual_env_context: Optional[SimpleNamespace] = virtual_env_context

    self._functions = functions
    # Setup could take some time so we intentionally wait for the first code block to do it.
    if len(functions) > 0:
        self._setup_functions_complete = False
    else:
        self._setup_functions_complete = True

    self.execution_policies = self.DEFAULT_EXECUTION_POLICY.copy()
    if execution_policies is not None:
        self.execution_policies.update(execution_policies)