opencos-eda 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

opencos/eda.py

@@ -9,7 +9,6 @@ markup files
 import subprocess
 import os
 import sys
-import shutil
 import re
 import signal
 import argparse
@@ -20,10 +19,11 @@ from pathlib import Path
 
 import opencos
 from opencos import util, eda_config, eda_base
+from opencos.eda_base import Command, Tool, which_tool, print_eda_usage_line
+from opencos.eda_tool_helper import pretty_info_handler_tools
+from opencos.files import safe_shutil_which
 from opencos.util import safe_emoji, Colors
-from opencos.eda_base import Tool, which_tool, get_eda_exec, print_eda_usage_line
 from opencos.utils import vsim_helper, vscode_helper
-from opencos.utils.subprocess_helpers import subprocess_run_background
 from opencos.utils import status_constants, str_helpers, subprocess_helpers
 
 # Configure util:
@@ -44,17 +44,30 @@ util.global_log.default_log_disable_with_args.extend([
 # These are also overriden depending on the tool, for example --tool verilator sets
 # "sim": CommandSimVerilator.
 def init_config(
-        config: dict,  quiet: bool = False, tool=None, run_auto_tool_setup: bool = True
+        config: dict,  quiet: bool = False, tool=None, command: str = '', sub_command: str = '',
+        run_auto_tool_setup: bool = True
 ) -> dict:
-    '''Sets or clears entries in config (dict) so tools can be re-loaded.'''
+    '''Sets or clears entries in config (dict) so tools can be re-loaded.
 
-    # For key DEFAULT_HANDLERS, we'll update config['command_handler'] with
-    # the actual class using importlib (via opencos.util)
+    - For key DEFAULT_HANDLERS, we'll update config['command_handler'] with
+      the actual class using importlib (via opencos.util)
+    - 'command', 'sub_command', and 'run_auto_tool_setup' are passed by the config dict,
+      the args exist are more for test hooks and debug.
+    '''
 
     eda_config.update_config_auto_tool_order_for_tool(tool=tool, config=config)
 
+    if not command and 'command' in config:
+        command = config.get('command', '')
+    if not sub_command and 'sub_command' in config:
+        sub_command = config.get('sub_command', '')
+    if 'run_auto_tool_setup' in config:
+        run_auto_tool_setup = config.get('run_auto_tool_setup', True)
+
     config['command_handler'] = {}
     for _cmd, str_class in config['DEFAULT_HANDLERS'].items():
+        if (command or sub_command) and _cmd not in (command, sub_command):
+            continue # don't bother importing a default handler class if we won't use it.
         cls = util.import_class_from_string(str_class)
         if not cls:
             util.error(f"config DEFAULT_HANDLERS command={_cmd} {str_class=} could not import")
@@ -63,8 +76,23 @@ def init_config(
 
     config['auto_tools_found'] = {}
     config['tools_loaded'] = set()
+
+    # If this is a sub_command sitation, then use that for setting up tools, otherwise
+    # use the command. If there's no command, blank str is fine will load all the tools, or
+    # just the specified 'tool'.
+    _command_for_tool_setup = command
+    if sub_command:
+        _command_for_tool_setup = sub_command
+
     if run_auto_tool_setup:
-        config = auto_tool_setup(config=config, quiet=quiet, tool=tool)
+        # Run this with quiet=True, we will print tool/version/path later.
+        config = auto_tool_setup(
+            config=config, quiet=True, tool=tool, command=_command_for_tool_setup
+        )
+
+    if not quiet:
+        pretty_info_handler_tools(config=config, command=_command_for_tool_setup)
+
     return config
 
 
@@ -117,11 +145,11 @@ def usage(tokens: list, config: dict, command: str = "", tool: str = "") -> int:
         return 0
 
     if command in config['command_handler'].keys():
-        sco = config['command_handler'][command](config=config) # sub command object
-        sco_tool = getattr(sco, '_TOOL', '')
-        if tool and tool != sco_tool:
+        cmd_obj = config['command_handler'][command](config=config) # command object
+        cmd_obj_tool = getattr(cmd_obj, '_TOOL', '')
+        if tool and tool != cmd_obj_tool:
             util.warning(f'{tool=} does not support {command=}')
-        sco.help(tokens=tokens)
+        cmd_obj.help(tokens=tokens)
         return util.exit(0)
 
     util.info("Valid commands are:")
@@ -137,7 +165,11 @@ def interactive(config: dict) -> int:
     '''
     rc = 0
     while True:
-        line = input('EDA->')
+        try:
+            line = input('EDA->')
+        except EOFError:
+            util.info('End of input reached unexpectedly, exiting')
+            return 0
         m = re.match(r'^([^\#]*)\#.*$', line)
         if m:
             line = m.group(1)
@@ -154,41 +186,73 @@ def interactive(config: dict) -> int:
 
 
 def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
-        warnings: bool = True, config = None, quiet: bool = False, tool: str = ''
+        config = None, quiet: bool = False, tool: str = '',
+        command: str = ''
 ) -> dict:
-    '''Returns an updated config, uses config['auto_tools_order'][0] dict, calls tool_setup(..)
+    '''Returns an updated config, uses config['auto_tools_order'] dict and
+    config['tools'] dict, calls tool_setup(..)
 
     -- adds items to config['tools_loaded'] set
     -- updates config['command_handler'][command] with a Tool class
 
     Input arg tool can be in the form (for example):
       tool='verlator', tool='verilator=/path/to/verilator.exe'
-      If so, updates config['auto_tools_order'][tool]['exe']
+      If so, updates config['tools'][tool]['exe']
     '''
 
     tool = eda_config.tool_arg_remove_path_information(tool)
 
     assert 'auto_tools_order' in config
-    assert isinstance(config['auto_tools_order'], list)
-    assert isinstance(config['auto_tools_order'][0], dict)
+    assert isinstance(config['auto_tools_order'], dict)
+    assert 'tools' in config
+    assert isinstance(config['tools'], dict)
+
+    if 'auto_tools_found' not in config:
+        config['auto_tools_found'] = {}
+    if 'tools_loaded' not in config:
+        config['tools_loaded'] = set()
+
+    util.debug(f'Calling auto_tool_setup for {tool=} {command=}')
+
+    if command:
+        util.info(f'Auto tool setup for command: {Colors.byellow}{command}')
+
+    # We'd like to achieve two things:
+    # 1. Load tool(s) based on args tool, command, config (and what's in config['tools']
+    # 2. Select the handling class for a command based on config['auto_tools_order']
+
+    # Step 1 - Load tools (do not set config['command_handler'][command])
+
+    for name, tool_cfg in config['tools'].items():
 
-    for name, value in config['auto_tools_order'][0].items():
         if tool and tool != name:
-            continue # if called with tool=(some_name), then only load that tool.
+            # if called with tool=(some_name), then only load that tool (which is not
+            # this one)
+            continue
+
+        if name in config['auto_tools_found']:
+            # we already loaded this tool.
+            continue
+
+        handlers = config['tools'].get(name, {}).get('handlers', {})
+        if command and command not in handlers and \
+           command not in config.get('command_has_subcommands', []):
+            util.debug(f"Skipping tool {name} because it cannot handle {command=}")
+            continue
 
         util.debug(f"Checking for ability to run tool: {name}")
-        exe = value.get('exe', str())
+
+        exe = tool_cfg.get('exe', str())
         if isinstance(exe, list):
             exe_list = exe
         elif isinstance(exe, str):
             exe_list = [exe] # make it a list
         else:
-            util.error(f'eda.py: config["auto_tools_order"][0] for {name=} {value=} has bad type'
-                       f'for {exe=}')
+            util.error(f'eda.py: config["tools"] for {name=} has bad type for {exe=}')
             continue
 
         has_all_py = True
-        requires_py_list = value.get('requires_py', [])
+        requires_py_list = tool_cfg.get('requires_py', [])
         for pkg in requires_py_list:
             spec = importlib.util.find_spec(pkg)
             if not spec:
@@ -196,7 +260,7 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
                 util.debug(f"... No, missing pkg {spec}")
 
         has_all_env = True
-        requires_env_list = value.get('requires_env', [])
+        requires_env_list = tool_cfg.get('requires_env', [])
         for env in requires_env_list:
             if not os.environ.get(env, ''):
                 has_all_env = False
@@ -206,20 +270,20 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
         has_all_in_exe_path = True
         exe_path = None
         for exe in exe_list:
-            assert exe != '', f'{name=} {value=} value missing "exe" {exe=}'
-            p = shutil.which(exe)
+            assert exe != '', f'{name=} value missing "exe" {exe=}'
+            p = safe_shutil_which(exe)
             if not exe_path:
                 exe_path = p # set on first required exe
             if not p:
                 has_all_exe = False
                 util.debug(f"... No, missing exe {exe}")
-            for req in value.get('requires_in_exe_path', []):
+            for req in tool_cfg.get('requires_in_exe_path', []):
                 if p and req and str(Path(req)) not in str(Path(p)):
                     has_all_in_exe_path = False
                     util.debug(f"... No, missing path requirement {req}")
 
         has_vsim_helper = True
-        if value.get('requires_vsim_helper', False):
+        if tool_cfg.get('requires_vsim_helper', False):
             # This tool name must be in opencos.utils.vsim_helper.TOOL_PATH[name].
             # Special case for vsim being used by a lot of tools.
             vsim_helper.init() # only runs checks once internally
@@ -227,7 +291,7 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
             has_vsim_helper = bool(exe_path)
 
         has_vscode_helper = True
-        needs_vscode_extensions = value.get('requires_vscode_extension', None)
+        needs_vscode_extensions = tool_cfg.get('requires_vscode_extension', None)
         if needs_vscode_extensions:
             if not isinstance(needs_vscode_extensions, list):
                 util.error(
@@ -240,16 +304,15 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
                 )
 
         if has_all_exe:
-            requires_cmd_list = value.get('requires_cmd', [])
+            requires_cmd_list = tool_cfg.get('requires_cmd', [])
             for cmd in requires_cmd_list:
                 cmd_list = shlex.split(cmd)
                 try:
                     proc = subprocess.run(cmd_list, capture_output=True, check=False,
                                           input=b'exit\n\n')
                     if proc.returncode != 0:
-                        if not quiet:
-                            util.debug(f"For tool {name} missing required command",
-                                       f"({proc.returncode=}): {cmd_list=}")
+                        util.debug(f"For tool {name} missing required command",
+                                   f"({proc.returncode=}): {cmd_list=}")
                         has_all_exe = False
                 except Exception as e:
                     has_all_exe = False
@@ -261,83 +324,129 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
             if exe_path:
                 p = exe_path
             else:
-                p = shutil.which(exe_list[0])
+                p = safe_shutil_which(exe_list[0])
             config['auto_tools_found'][name] = p # populate key-value pairs w/ first exe in list
+            config['tools_loaded'].add(name)
             if not quiet:
                 util.info(f"Detected {name} ({p})")
-            tool_setup(
-                tool=name, quiet=True, auto_setup=True, warnings=warnings, config=config
+        else:
+            util.debug(f'Tool {name} is missing one of: {has_all_py=} {has_all_env=}',
+                       f'{has_all_exe=} {has_all_in_exe_path=} {has_vsim_helper=}',
+                       f'{has_vscode_helper=}')
+
+    # Step 2 - set command handlers for command/tool pairs.
+
+    # If --tool was specified (this function's arg, tool) then we don't need to check
+    # config['auto_tools_order'], simply load the handlers this tool supports.
+    if tool:
+        handlers = config['tools'].get(tool, {}).get('handlers', {})
+        if command and command in handlers:
+            # --tool and command were set, only load that one handler:
+            set_command_handler(
+                command=command, tool=tool, config=config, auto_setup=False,
+            )
+            return config
+
+        for _command, _ in handlers.items():
+            # set all handlers, command was not set or was not in handlers.
+            set_command_handler(
+                command=_command, tool=tool, config=config, auto_setup=False,
             )
+        return config
+
+    # If --tool was not set, look at config['auto_tools_found'] should be populated based on
+    # config['tools'], and if we called this method (auto_tool_setup(...)) with tool= and command=
+    # arg(s). Call set_command_handlers for each command/tool we need to:
+    for _command, list_of_tools in config['auto_tools_order'].items():
+
+        for _tool in list_of_tools:
+            if _tool not in config['tools_loaded']:
+                continue
+
+            set_command_handler(
+                command=_command, tool=_tool, config=config, auto_setup=(not tool),
+            )
+
 
     return config
 
 
-def tool_setup(
-        tool: str, config: dict, quiet: bool = False, auto_setup: bool = False,
-        warnings: bool = True
+def set_command_handler( # pylint: disable=too-many-branches
+        command: str, tool: str, config: dict, auto_setup: bool = False
 ):
-    ''' Adds items to config["tools_loaded"] (set) and updates config['command_handler'].
-
-    config is potentially updated for entry ['command_handler'][command] with a Tool class.
+    '''Updates config['command_handler'] with Command/Tool class
 
     Input arg tool can be in the form (for example):
       tool='verlator', tool='verilator=/path/to/verilator.exe'
 
     '''
 
-    tool = eda_config.tool_arg_remove_path_information(tool)
-
-    if not quiet and not auto_setup:
-        util.info(f"Setup for tool: '{tool}'")
 
+    tool = eda_config.tool_arg_remove_path_information(tool)
     if not tool:
         return
 
-    if tool not in config['auto_tools_order'][0]:
-        tools = list(config.get('auto_tools_order', [{}])[0].keys())
-        cfg_yaml_fname = config.get('config-yml', None)
-        util.warning(f'Unknown tool: {tool}')
-        if tools:
-            util.info('Known tools:')
-            pretty_tools = str_helpers.pretty_list_columns_manual(data=tools)
-            for row in pretty_tools:
-                if row:
-                    util.info(row)
-        util.error(f"Don't know how to run tool_setup({tool=}), is not in",
-                   f"config['auto_tools_order'] from {cfg_yaml_fname}")
-        return
-
-    if tool not in config['auto_tools_found']:
-        cfg_yaml_fname = config.get('config-yml', None)
-        util.error(f"Don't know how to run tool_setup({tool=}), is not in",
-                   f"{config['auto_tools_found']=} from {cfg_yaml_fname}")
-        return
-
-    if auto_setup and tool is not None and tool in config['tools_loaded']:
-        # Do I realy need to warn if a tool was loaded from auto_tool_setup(),
-        # but then I also called it via --tool verilator? Only warn if auto_setup=True:
-        if warnings:
-            util.warning(f"tool_setup: {auto_setup=} already setup for {tool}?")
-
-    entry = config['auto_tools_order'][0].get(tool, {})
+    entry = config['tools'][tool]
     tool_cmd_handler_dict = entry.get('handlers', {})
 
-    for command, str_class_name in tool_cmd_handler_dict.items():
-        current_handler_cls = config['command_handler'].get(command, None)
+    current_handler_cls = config['command_handler'].get(command, None)
 
-        if auto_setup and current_handler_cls is not None and issubclass(current_handler_cls, Tool):
-            # If we're not in auto_setup, then always override (aka arg --tool=<this tool>)
-            # skip, already has a tool associated with it, and we're in auto_setup=True
-            continue
+    if auto_setup and current_handler_cls is not None and issubclass(current_handler_cls, Tool):
+        # If we're not in auto_setup, then always override (aka arg --tool=<this tool>)
+        # skip, already has a tool associated with it, and we're in auto_setup=True
+        return
 
-        cls = util.import_class_from_string(str_class_name)
+    str_class_name = tool_cmd_handler_dict.get(command, '')
+    if not str_class_name:
+        # This tool doesn't have a handler for this command
+        return
+
+    cls = util.import_class_from_string(str_class_name)
 
+    if command in config.get('command_determines_tool', []) + \
+       config.get('command_tool_is_optional', []):
+        # we don't need to confirm the handler parent is a Tool class.
+        pass
+    else:
         assert issubclass(cls, Tool), \
             f'{str_class_name=} is does not have Tool class associated with it'
+
+    if not auto_setup or \
+       command not in config.get('command_determines_tool', []):
+        # If not auto_setup - then someone called this --tool by name on the command line,
+        # then update the command handler
+        # otherwise, if --tool was not set, and command determines tool, leave it with
+        # the default handler.
         util.debug(f'Setting {cls=} for {command=} in config.command_handler')
         config['command_handler'][command] = cls
 
-    config['tools_loaded'].add(tool)
+
+
+def get_and_remove_command_from_tokens(
+        tokens: list, config: dict, is_sub_command: bool = False
+) -> str:
+    '''Attempts to get and remove an eda command (sim, flist, multi, etc) from list
+
+    - if is_sub_command=True and a sub command was found and not alread set, then add it
+      to config['sub_command']
+    - if is_sub_command=False, and a command is not already set, then add the found command
+      to config['command']
+    '''
+
+    command = ''
+    for value in tokens:
+        if value in config['DEFAULT_HANDLERS'].keys():
+            if is_sub_command and value in config['command_has_subcommands']:
+                continue # only 1 sub command allowed, not a chain.
+            command = value
+            tokens.remove(value) # remove command (flist, export, targets, etc)
+            if not is_sub_command and not config.get('command', ''):
+                config['command'] = value
+            if is_sub_command and not config.get('sub_command', ''):
+                config['sub_command'] = value
+            break
+
+    return command
 
 
 def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-many-locals,too-many-return-statements
@@ -357,8 +466,7 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
 
     deferred_tokens = []
     command = ""
-    run_auto_tool_setup = True
-    process_tokens_cwd = os.getcwd()
+    sub_command = ""
 
     parser = eda_base.get_argparser()
     try:
@@ -383,26 +491,31 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
 
     util.debug(f'eda process_tokens: {parsed=} {unparsed=}')
 
-    # Attempt to get the 'command' in the unparsed args before we've even
-    # set the command handlers (some commands don't use tools).
-    for value in unparsed:
-        if value in config['DEFAULT_HANDLERS'].keys():
-            command = value
-            if not parsed.tool and value in config['command_tool_is_optional']:
-                # only do this if --tool was not set.
-                run_auto_tool_setup = False
-            unparsed.remove(value) # remove command (flist, export, targets, etc)
-            break
+    # Attempt to get the 'command' and optional sub-command. It is removed
+    # from unparsed if found, and if a sub_command is found it is set in
+    # config['sub_command']
+    command = get_and_remove_command_from_tokens(
+        tokens=unparsed, config=config, is_sub_command=False
+    )
+    if command and command in config.get('command_has_subcommands', []):
+        sub_command = get_and_remove_command_from_tokens(
+            tokens=unparsed, config=config, is_sub_command=True
+        )
+
+    if not parsed.tool:
+        if not sub_command and command and command in config['command_tool_is_optional']:
+            # --tool not set, and tool was optional for primary command
+            config['run_auto_tool_setup'] = False
+        if sub_command and sub_command in config['command_tool_is_optional']:
+            # --tool not set, and tool was optional for secondary command
+            config['run_auto_tool_setup'] = False
 
     if not is_interactive:
         # Run init_config() now, we deferred it in main(), but only run it
         # for this tool (or tool=None to figure it out)
         # This will handle any --tool=<name>=/path/to/bin also, so don't have to
         # run tool_setup(..) on its own.
-        config = init_config(
-            config, tool=parsed.tool,
-            run_auto_tool_setup=run_auto_tool_setup
-        )
+        config = init_config(config, tool=parsed.tool)
         if not config:
             util.error(f'eda.py main: problem loading config, {tokens=}')
             return 3
@@ -424,107 +537,192 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
                    "valid commands)!")
         return 2
 
-    sco = config['command_handler'][command](config=config) # sub command object
+    cmd_obj = config['command_handler'][command](config=config) # command object
     if not parsed.tool:
         # then what was the auto selected tool?
-        sco_tool = getattr(sco, '_TOOL', '')
-        if sco_tool in config['auto_tools_order'][0] and \
-           config['auto_tools_order'][0][sco_tool].get('disable-auto', False):
-            util.error(f'Cannot use tool={sco_tool} without arg --tool, it cannot be selected',
+        cmd_obj_tool = getattr(cmd_obj, '_TOOL', '')
+        if cmd_obj_tool in config['auto_tools_found'] and \
+           config['tools'].get(cmd_obj_tool, {}).get('disable-auto', False):
+            util.error(f'Cannot use tool={cmd_obj_tool} without arg --tool, it cannot be selected',
                        'automatically')
             return status_constants.EDA_COMMAND_OR_ARGS_ERROR
 
-    util.debug(f'{command=}')
-    util.debug(f'{sco.config=}')
-    util.debug(f'{type(sco)=}')
+    util.debug(f'{command=} {sub_command=}')
+    util.debug(f'{cmd_obj.config=}')
+    util.debug(f'{type(cmd_obj)=}')
     if not parsed.tool and \
        command not in config.get('command_determines_tool', []) and \
        command not in config.get('command_tool_is_optional', []):
+        # --tool not set, tool was not optional, so we have to use the tool from the handler cmd_obj
+        # (our best guess at tool to use)
         use_tool = which_tool(command, config)
         if use_tool:
-            util.info(f"--tool not specified, using default for {command=}: {use_tool}")
+            util.info(f"--tool not specified, using default for {command=}:",
+                      f"{Colors.bgreen}{use_tool}")
         else:
             # Not all commands have a hard requirement on tool (such as 'multi') because we
             # haven't examined sub-commands yet.
-            util.info(f'--tool not specified, will attempt to determine tool(s) for {command=}.')
-        setattr(sco, 'auto_tool_applied', True)
-
-    rc = check_command_handler_cls(command_obj=sco, command=command, parsed_args=parsed)
+            util.info('--tool not specified, will attempt to determine tool(s) for',
+                      f'{Colors.bgreen}{command=}.')
+        setattr(cmd_obj, 'auto_tool_applied', True)
+
+    # For command (and optional sub_command) make sure our handler class is checked to run,
+    # (does it require a Tool class, etc)
+    rc = check_command_handler_cls(command_obj=cmd_obj, command=command, parsed_args=parsed)
+    if sub_command:
+        sub_cmd_obj = config['command_handler'][sub_command](config=config) # command object
+        rc |= check_command_handler_cls(
+            command_obj=sub_cmd_obj, command=sub_command, parsed_args=parsed
+        )
     if rc > 0:
-        util.debug(f'Return from main process_tokens({tokens=}), {rc=}, {type(sco)=},'
+        util.debug(f'Return from main process_tokens({tokens=}), {rc=}, {type(cmd_obj)=},'
                    f'unparsed={deferred_tokens}')
         return rc
 
     # Add the original, nothing-parsed args to the Command.config dict.
-    sco.config['eda_original_args'] = original_args
+    cmd_obj.config['eda_original_args'] = original_args
 
-    setattr(sco, 'command_name', command) # as a safeguard, 'command' is not always passed to 'sco'
-    unparsed = sco.process_tokens(tokens=deferred_tokens, pwd=os.getcwd())
+    # as a safeguard, the command_name is not always passed to 'cmd_obj', so let's do that now.
+    setattr(cmd_obj, 'command_name', command)
+    unparsed = cmd_obj.process_tokens(tokens=deferred_tokens, pwd=os.getcwd())
 
     # query the status from the Command object (0 is pass, > 0 is fail, but we'd prefer to avoid
     # rc=1 because that's the python exception rc)
-    rc = getattr(sco, 'status', 2)
-    util.debug(f'Return from main process_tokens({tokens=}), {rc=}, {type(sco)=}, {unparsed=}')
-
-    if rc == 0 and not parsed.tool and getattr(sco, 'tool_changed_respawn', False):
-        use_tool = sco.args.get('tool', '')
-        if not use_tool:
-            util.error(f'Unable to change tool from {parsed.tool}, internal eda problem.')
-            return status_constants.EDA_DEFAULT_ERROR
-
-        # close the util.log:
-        util.stop_log()
-        # respawn the original job, but with --tool=<use_tool> applied:
-        _command_list = [get_eda_exec(command), f"--tool={use_tool}"] + original_args
-        util.info(f'eda: respawn for tool change: {" ".join(_command_list)};',
-                  f' (running from: {process_tokens_cwd})')
-        subprocess_run_background(
-            work_dir=process_tokens_cwd,
-            command_list=_command_list,
-            background=util.args.get('quiet', False)
+    rc = getattr(cmd_obj, 'status', 2)
+    util.debug(f'Return from main process_tokens({tokens=}), {rc=}, {type(cmd_obj)=}, {unparsed=}')
+
+    if rc == 0 and not parsed.tool and getattr(cmd_obj, 'tool_changed_respawn', False):
+        return respawn_new_command_object(
+            cmd_obj=cmd_obj, parsed=parsed, config=config, command=command, tokens=tokens,
+            deferred_tokens=deferred_tokens
         )
 
     return rc
 
 
-def check_command_handler_cls(command_obj:object, command:str, parsed_args) -> int:
+def respawn_new_command_object(
+        cmd_obj: Command, parsed: argparse.Namespace, config: dict, command: str,
+        tokens: list, deferred_tokens: list
+) -> int:
+    '''Returns retcode (int). Creates a new Command object, presumably using a different tool,
+
+    due to args changes from DEPS parsing that led to --tool=<different value> vs the automatic
+    value if --tool was not originally set. Will run process_tokens(..) on the new commmand
+    object.
+    '''
+
+    use_tool = cmd_obj.args.get('tool', '')
+
+    if not use_tool:
+        util.error(f'Unable to change tool from {parsed.tool}, internal eda problem.')
+        return status_constants.EDA_DEFAULT_ERROR
+
+    util.info(f'Changing {Colors.bcyan}--tool{Colors.normal}{Colors.green} --->',
+              f'{Colors.bcyan}{use_tool}{Colors.normal}{Colors.green} for command:',
+              f'{Colors.byellow}{command}')
+
+    # Update the command handler(s) with this new tool. We don't really respawn, just
+    # try to swap out the cmd_obj (Command obj handle)
+    entry = config['tools'].get(use_tool, {})
+    tool_cmd_handler_dict = entry.get('handlers', {})
+
+    for _command, str_class_name in tool_cmd_handler_dict.items():
+        if _command and command and _command != command:
+            # This isn't the command we care about (it's just one of the commands
+            # this tool supports, so don't bother loading a handler for it:
+            continue
+
+        cls = util.import_class_from_string(str_class_name)
+        if _command in config.get('command_determines_tool', []) + \
+           config.get('command_tool_is_optional', []):
+            # we don't need to confirm the handler parent is a Tool class.
+            pass
+        else:
+            assert issubclass(cls, Tool), \
+                f'command {_command} {str_class_name=} does not have Tool class associated with it'
+
+        util.debug(f'Setting {cls=} for command={_command} in config.command_handler')
+        config['command_handler'][_command] = cls
+
+    old_cmd_obj = cmd_obj
+    cmd_obj = config['command_handler'][command](config=config) # command object
+    util.debug(f'No longer using handler: {type(old_cmd_obj)}; now using: {type(cmd_obj)}')
+    cmd_obj.config['eda_original_args'] = old_cmd_obj.config['eda_original_args']
+    del old_cmd_obj
+
+    rc = check_command_handler_cls(command_obj=cmd_obj, command=command, parsed_args=parsed)
+    if rc > 0:
+        util.debug(f'Return from main process_tokens({tokens=}), {rc=}, {type(cmd_obj)=},'
+                   f'unparsed={deferred_tokens}')
+        return rc
+
+    setattr(cmd_obj, 'command_name', command) # as a safeguard, 'command' set in 'cmd_obj'
+    util.info(f'--tool={use_tool}: running command: {Colors.byellow}eda {command} ',
+              ' '.join(deferred_tokens))
+    unparsed = cmd_obj.process_tokens(tokens=deferred_tokens, pwd=os.getcwd())
+
+    # query the status from the Command object (0 is pass, > 0 is fail, but we'd prefer to
+    # avoid rc=1 because that's the python exception rc)
+    rc = getattr(cmd_obj, 'status', 2)
+    util.debug(f'Return from main process_tokens({tokens=}), {rc=}, {type(cmd_obj)=}, {unparsed=}')
+    return rc
+
+
+def check_command_handler_cls(command_obj: object, command: str, parsed_args) -> int:
     '''Returns bash/sh return code, checks that a command handling class has all
 
     internal CHECK_REQUIRES list items. For example, sim.py has CHECK_REQUIRES=[Tool],
     so if a 'sim' command handler does not also inherit a Tool class, then reports this as an
     error.
     '''
-    sco = command_obj
-    for cls in getattr(sco, 'CHECK_REQUIRES', []):
-        if not isinstance(sco, cls):
-            # If someone set --tool verilator for command=synth, then our 'sco' will have defaulted
-            # to CommandSynth with no tool attached. If we don't have a tool set, error and return.
+    cmd_obj = command_obj
+    for cls in getattr(cmd_obj, 'CHECK_REQUIRES', []):
+        if not isinstance(cmd_obj, cls):
+            # If someone set --tool verilator for command=synth, then our 'cmd_obj' will have
+            # defaulted to CommandSynth with no tool attached. If we don't have a tool set, and one
+            # is requires, error and return.
             parsed_tool =  getattr(parsed_args, 'tool', '')
-            auto_tool_entry = command_obj.config.get(
-                'auto_tools_order', [{}])[0].get(parsed_tool, {})
-            if parsed_tool and not auto_tool_entry:
+            tool_entry = command_obj.config.get(
+                'tools', {}).get(parsed_tool, {})
+            if parsed_tool and not tool_entry:
                 util.warning(
-                    f"{command=} for tool '{parsed_tool}' is using handling class '{type(sco)}',",
-                    f"but missing requirement {cls}, likely because the tool was not loaded",
-                    "(not in PATH) or mis-configured (such as missing a Tool based class)"
+                    f"{command=} for tool '{parsed_tool}' is using handling class",
+                    f"'{type(cmd_obj)}', but missing requirement {cls}, likely because the tool",
+                    "was not loaded (not in PATH) or mis-configured (such as missing a Tool based",
+                    "class)"
                 )
                 return util.error(
                     f"EDA {command=} for tool '{parsed_tool}' cannot be run because tool",
                     f"'{parsed_tool}' is not known to `eda`. It does not exist in the config:",
                     "see informational message for --config-yml, and check that file's",
-                    "auto_tools_order."
+                    "tools config."
                 )
             if parsed_tool:
+                # Does the tool_entry even have handlers for this command?
+                if command not in tool_entry.get('handlers', {}):
+                    util.warning(
+                        f"{command=} for tool '{parsed_tool}' does not have a handler defined in",
+                        "the config: see informational message for --config-yml, and check that",
+                        f"file's tools config. Known handlers for {parsed_tool} are: ",
+                        f"{tool_entry.get('handlers', '')}"
+                    )
+                    return util.error(
+                        f"{command=} for tool '{parsed_tool}' does not have a handler defined in",
+                        "the config"
+                    )
+
+                # It does have a handler defined, maybe it wasn't loaded due to other reasons?
                 util.warning(
-                    f"{command=} for tool '{parsed_tool}' is using handling class '{type(sco)}',",
-                    f"but missing requirement {cls}, likely because the tool was not loaded",
-                    "(not in PATH) or mis-configured (such as missing a Tool based class)"
+                    f"{command=} for tool '{parsed_tool}' is using handling class",
+                    f"'{type(cmd_obj)}', but missing requirement {cls}, likely because the tool",
+                    "was not loaded (not in PATH) or mis-configured (such as missing a Tool based",
+                    "class)"
                 )
-                for k,v in auto_tool_entry.items():
+                for k,v in tool_entry.items():
                     if k == 'exe' or k.startswith('requires_cmd'):
                         util.warning(
                             f"tool '{parsed_tool}' has requirements that may not have been met --",
-                            f"{k}: {v}"
+                            f"{k}: {v} (Perhaps not in PATH?)"
                         )
                     if k == 'requires_vsim_helper':
                         if found_tool := vsim_helper.found():
@@ -543,8 +741,8 @@ def check_command_handler_cls(command_obj:object, command:str, parsed_args) -> i
             # No parsed_tool.
             util.warning(
                 f"{command=} for default tool (--tool not set) is using handling class",
-                f"'{type(sco)}', but missing requirement {cls}, likely because the tool was not",
-                "loaded (not in PATH) or mis-configured (such as missing a Tool based class)"
+                f"'{type(cmd_obj)}', but missing requirement {cls}, likely because the tool was",
+                "not loaded (not in PATH) or mis-configured (such as missing a Tool based class)"
             )
             return util.error(
                 f"EDA {command=} for default tool (--tool not set) is not supported (default",
@@ -595,7 +793,11 @@ def main(*args):
     if not util.args['quiet']:
         util.info(f'eda: version {opencos.__version__}', color=Colors.bcyan)
         # And show the command that was run (all args):
-        util.info(f"main: eda {' '.join(args)}; (run from {os.getcwd()})")
+        util.info(f"main: {Colors.byellow}eda {' '.join(args)}{Colors.normal}{Colors.green};",
+                  f"(run from {os.getcwd()})")
+        # And show python version:
+        util.info(f'python: version {sys.version_info.major}.{sys.version_info.minor}.'
+                  f'{sys.version_info.micro}')
 
     # Handle --config-yml= arg
     config, unparsed = eda_config.get_eda_config(unparsed)
@@ -657,6 +859,7 @@ def main_cli() -> None:
     util.global_exit_allowed = True
     # Strip eda or eda.py from sys.argv, we know who we are if called from __main__:
     rc = main()
+    subprocess_helpers.cleanup_all()
     util.exit(rc)