opencos-eda 0.2.52__py3-none-any.whl → 0.2.53__py3-none-any.whl

opencos/deps/deps_processor.py

@@ -103,6 +103,37 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 self.command_design_ref.incdirs.append(abspath)
                 debug(f'Added include dir {abspath} from {self.caller_info}')
 
+
+    def _apply_args_check_tools(self, tokens: list) -> list:
+        '''Helper for apply_args(list), returns list strips --tool args under certain conditions'''
+
+        _orig_tool = self.args.get('tool', '')
+        if not self.command_design_ref.auto_tool_applied and \
+           any(x.startswith('--tool') for x in tokens) and _orig_tool:
+            warn_tool = ''
+            for i, item in enumerate(list(tokens)):
+                if item == '--tool':
+                    if tokens[i + 1] != _orig_tool:
+                        warn_tool = tokens[i + 1]
+                    tokens[i : i+2] = ['', ''] # remove this and next arg
+                elif item.startswith('--tool='):
+                    if item[7:] != _orig_tool:
+                        warn_tool = item
+                    tokens[i] = '' # remove just this arg.
+
+            if warn_tool:
+                warning(
+                    f'Attempting to set --tool {warn_tool} from DEPS',
+                    f'(file={self.deps_file}:{self.target_node})',
+                    f'however the tool was already chosen as: {_orig_tool}. The --tool arg will',
+                    f'not be applied from: {tokens}'
+                )
+
+            tokens = [item for item in tokens if item != ''] # remove blanks
+
+        return tokens
+
+
     def apply_args(self, args_list:list) -> list:
         '''Given args_list, applies them to our self.command_design_ref obj
 
@@ -114,9 +145,20 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             self.error(f"{args_list=} is not type str/list, can't apply args",
                        f"in {self.caller_info}")
         tokens = dep_str2list(args_list)
+
         # We're going to run an ArgumentParser here, which is not the most efficient
         # thing to do b/c it runs on all of self.command_design_ref.args (dict) even
         # if we're applying a single token.
+
+        # We have to special-case anything with --tool[=value] in tokens, otherwise
+        # the user may think they were allowed to set --tool, but in our flow the Command handler
+        # (self.command_design_ref) has already been chosen, so setting the tool can have
+        # strange side-effects.
+        _orig_tool = self.args.get('tool', '')
+        tokens = self._apply_args_check_tools(tokens=tokens)
+        if not tokens:
+            return []
+
         debug(f'deps_processor - custom apply_args with {tokens=}',
               f'from {self.caller_info}')
         _, unparsed = self.command_design_ref.run_argparser_on_list(
@@ -135,6 +177,16 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             # flist from that target.
             warning(f'For {self.command_design_ref.command_name}:' \
                     + f' in {self.caller_info} has unknown args {unparsed=}')
+
+        if self.command_design_ref.auto_tool_applied and _orig_tool != self.args.get('tool', ''):
+            debug(f'deps_processor.apply_args: tool changed, {self.args["tool"]=}, will attempt',
+                  f'to respawn the job using original args: {self.config["eda_original_args"]}')
+            self.command_design_ref.tool_changed_respawn = {
+                'tool': self.args['tool'],
+                'orig_tool': _orig_tool,
+                'from': self.caller_info,
+            }
+
         return unparsed
 
     def apply_reqs(self, reqs_list:list) -> None:
@@ -213,6 +265,10 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             elif key == 'deps':
                 remaining_deps_list += self.process_deps_return_discovered_deps()
 
+            if self.command_design_ref.tool_changed_respawn:
+                # Stop now, and have eda.py respawn the command.
+                return []
+
         # We return the list of deps that still need to be resolved (['full_path/some_target', ...])
         return remaining_deps_list
 
@@ -260,6 +316,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
 
             apply_tag_items_tools = False
+            apply_tag_items_commands = False
             apply_tag_items_with_args = False
 
             tool = self.args.get('tool', None)
@@ -276,6 +333,12 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                     warning(f'{tagname=} in {self.caller_info}:',
                             ' skipped due to with-tools disabled.')
 
+                with_commands = dep_str2list(value.get('with-commands', []))
+                if with_commands and not deps_tags_enables.get('with-commands', None):
+                    with_commands = []
+                    warning(f'{tagname=} in {self.caller_info}:',
+                            ' skipped due to with-commands disabled.')
+
                 with_args = value.get('with-args', {})
                 if not isinstance(with_args, dict):
                     error(f'{tagname=} in {self.caller_info}:',
@@ -299,6 +362,12 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                         if tool_full_version and tool_full_version in with_tools:
                             apply_tag_items_tools = True
 
+                # check with-commands?
+                if not with_commands:
+                    apply_tag_items_commands = True # no with-commands present
+                elif getattr(self.command_design_ref, 'command_name', '') in with_commands:
+                    apply_tag_items_commands = True # with-commands present and we matched.
+
                 # check with-args?
                 with_args_matched_list = []
                 for k,v in with_args.items():
@@ -336,7 +405,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             elif enable_tags_matched:
                 apply_tag_items = True
             else:
-                apply_tag_items = apply_tag_items_tools and apply_tag_items_with_args
+                apply_tag_items = all([apply_tag_items_tools, apply_tag_items_with_args,
+                                       apply_tag_items_commands])
 
             if not apply_tag_items:
                 debug(f'process_tags(): {tagname=} in {self.caller_info}',
@@ -370,7 +440,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                         if args_list:
                             # This will apply knowns args to the target dep:
                             info(f'{tagname=} in {self.caller_info=}:',
-                                 f'applying args b/c {with_tools=} for {args_list=}')
+                                 f'applying args for {args_list=}')
                             self.apply_args(args_list)
 
                     elif key == 'reqs':

opencos/deps_schema.py

@@ -111,6 +111,8 @@ my_target_name:
     <str>:                           <---- string user name for this tag
       with-tools:                    <---- optional array (or string) of tools this tag requires
                                            for the tag to be applied.
+      with-commands:                 <---- optional array (or string) of command this tag requires
+                                           for the tag to be applied.
       with-args:                     <---- optional table of args values that must match for
                                            this tag to be applied.
       args:                          <---- optional array of args to be applied to this target
@@ -217,6 +219,7 @@ TARGET_EDA_COMMAND = {
 TARGET_TAGS_TABLE = {
     Optional(str): {
         Optional('with-tools'): ARRAY_OR_SPACE_SEPARATED_STRING,
+        Optional('with-commands'): ARRAY_OR_SPACE_SEPARATED_STRING,
         Optional('with-args'): dict,
         Optional('args'): ARRAY_OR_SPACE_SEPARATED_STRING,
         Optional('deps'): ARRAY_OR_SPACE_SEPARATED_STRING,

opencos/eda.py

@@ -20,13 +20,19 @@ from pathlib import Path
 
 import opencos
 from opencos import util, eda_config, eda_base
-from opencos.eda_base import Tool, which_tool
+from opencos.eda_base import Tool, which_tool, get_eda_exec
 from opencos.utils import vsim_helper, vscode_helper
+from opencos.utils.subprocess_helpers import subprocess_run_background
+from opencos.utils import status_constants
 
 # Configure util:
 util.progname = "EDA"
 util.global_log.default_log_enabled = True
 util.global_log.default_log_filepath = os.path.join('eda.work', 'eda.log')
+util.global_log.default_log_disable_with_args.extend([
+    # avoid default log on certain eda commands
+    'help', 'waves', 'deps-help', 'targets'
+])
 
 
 # ******************************************************************************
@@ -44,12 +50,12 @@ def init_config(
     # For key DEFAULT_HANDLERS, we'll update config['command_handler'] with
     # the actual class using importlib (via opencos.util)
     config['command_handler'] = {}
-    for command, str_class in config['DEFAULT_HANDLERS'].items():
+    for _cmd, str_class in config['DEFAULT_HANDLERS'].items():
         cls = util.import_class_from_string(str_class)
         if not cls:
-            util.error(f"config DEFAULT_HANDLERS {command=} {str_class=} could not import")
+            util.error(f"config DEFAULT_HANDLERS command={_cmd} {str_class=} could not import")
         else:
-            config['command_handler'][command] = cls
+            config['command_handler'][_cmd] = cls
 
     config['auto_tools_found'] = {}
     config['tools_loaded'] = set()
@@ -58,6 +64,18 @@ def init_config(
     return config
 
 
+def get_all_commands_help_str(config: dict) -> str:
+    '''Returns a str of help based on what commands eda supports, from config'''
+    all_commands_help = []
+    max_command_str_len = max(len(s) for s in config.get('DEFAULT_HANDLERS_HELP', {}).keys())
+    for key, value in config.get('DEFAULT_HANDLERS_HELP', {}).items():
+        all_commands_help.append(f'    {key:<{max_command_str_len}} - {value.strip()}')
+    if all_commands_help:
+        all_commands_help = [
+            'Where <command> is one of:',
+            '',
+        ] + all_commands_help
+    return '\n'.join(all_commands_help)
 
 
 def usage(tokens: list, config: dict, command="") -> int:
@@ -77,26 +95,11 @@ def usage(tokens: list, config: dict, command="") -> int:
 """
 Usage:
     eda [<options>] <command> [options] <files|targets, ...>
-
-Where <command> is one of:
-
-    sim          - Simulates a DEPS target
-    elab         - Elaborates a DEPS target (sort of sim based LINT)
-    synth        - Synthesizes a DEPS target
-    flist        - Create dependency from a DEPS target
-    proj         - Create a project from a DEPS target for GUI sim/waves/debug
-    multi        - Run multiple DEPS targets, serially or in parallel
-    tools-multi  - Same as 'multi' but run on all available tools, or specfied using --tools
-    sweep        - Sweep one or more arguments across a range, serially or in parallel
-    build        - Build for a board, creating a project and running build flow
-    waves        - Opens waveform from prior simulation
-    upload       - Uploads a finished design into hardware
-    open         - Opens a project
-    export       - Export files related to a target, tool independent
-    shell        - Runs only commands for DEPS target (like sim or elab, but stops prior to tool)
-    targets      - list all possible targets given glob path.
-    help         - This help (without args), or i.e. "eda help sim" for specific help
-
+"""
+        )
+        print(get_all_commands_help_str(config=config))
+        print(
+"""
 And <files|targets, ...> is one or more source file or DEPS markup file target,
     such as .v, .sv, .vhd[l], .cpp files, or a target key in a DEPS.[yml|yaml|toml|json].
     Note that you can prefix source files with `sv@`, `v@`, `vhdl@` or `cpp@` to
@@ -249,7 +252,7 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
             p = shutil.which(exe)
             config['auto_tools_found'][name] = exe # populate key-value pairs w/ first exe in list
             if not quiet:
-                util.info(f"Detected {name} ({p}), auto-setting up tool {name}")
+                util.info(f"Detected {name} ({p})")
             tool_setup(tool=name, quiet=True, auto_setup=True, warnings=warnings, config=config)
 
     return config
@@ -317,7 +320,7 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
     config['tools_loaded'].add(tool)
 
 
-def process_tokens( # pylint: disable=too-many-branches,too-many-statements
+def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-many-locals
         tokens: list, original_args: list, config: dict, is_interactive=False
 ) -> int:
     '''Returns bash/sh style return code int (0 pass, non-zero fail).
@@ -335,6 +338,7 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements
     deferred_tokens = []
     command = ""
     run_auto_tool_setup = True
+    process_tokens_cwd = os.getcwd()
 
     parser = eda_base.get_argparser()
     try:
@@ -409,6 +413,7 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements
        command not in config.get('command_tool_is_optional', []):
         use_tool = which_tool(command, config)
         util.info(f"--tool not specified, using default for {command=}: {use_tool}")
+        setattr(sco, 'auto_tool_applied', True)
 
     rc = check_command_handler_cls(command_obj=sco, command=command, parsed_args=parsed)
     if rc > 0:
@@ -426,6 +431,25 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements
     # 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)
+        )
+
     return rc
 
 

opencos/eda_base.py

@@ -26,7 +26,7 @@ from opencos import eda_config
 
 from opencos.util import Colors
 from opencos.utils.str_helpers import sprint_time, strip_outer_quotes, string_or_space, \
-    indent_wrap_long_text
+    indent_wrap_long_text, pretty_list_columns_manual
 from opencos.utils.subprocess_helpers import subprocess_run_background
 from opencos.utils import status_constants
 
@@ -68,6 +68,17 @@ def get_argparser_short_help() -> str:
     return util.get_argparser_short_help(parser=get_argparser())
 
 
+def get_argparsers_args_list() -> list:
+    '''Returns list of all args that we know about from eda_config, util, eda.
+
+    All items will include the -- prefix (--help, etc)'''
+    return util.get_argparsers_args_list(parsers=[
+        eda_config.get_argparser(),
+        util.get_argparser(),
+        get_argparser()
+    ])
+
+
 def get_eda_exec(command: str = '') -> str:
     '''Returns the full path of `eda` executable to be used for a given eda <command>'''
     # NOTE(drew): This is kind of flaky. 'eda multi' reinvokes 'eda'. But the executable for 'eda'
@@ -184,7 +195,7 @@ class Tool:
         return
 
 
-class Command:
+class Command: # pylint: disable=too-many-public-methods
     '''Base class for all: eda <command>
 
     The Command class should be used when you don't require files, otherwise consider
@@ -245,6 +256,8 @@ class Command:
         self.target_path = ""
         self.status = 0
         self.errors_log_f = None
+        self.auto_tool_applied = False
+        self.tool_changed_respawn = {}
 
 
     def error(self, *args, **kwargs) -> None:
@@ -267,7 +280,7 @@ class Command:
                         typ='text', description='EDA reported errors'
                     )
 
-                except FileNotFoundError:
+                except Exception:
                     pass
             if self.errors_log_f:
                 print(
@@ -277,6 +290,18 @@ class Command:
 
         self.status = util.error(*args, **kwargs) # error_code passed and returned via kwargs
 
+    def stop_process_tokens_before_do_it(self) -> bool:
+        '''Used by derived classes process_tokens() to know an error was reached
+        and to not perform the command (avoid calling do_it())
+
+        Also used to know if a DEPS target requested a --tool=<value> change and that
+        we should respawn the job.'''
+        util.debug('stop_process_tokens_before_do_it:',
+                   f'{self.status=} {self.tool_changed_respawn=} {self.args.get("tool", "")=}')
+        if self.tool_changed_respawn or self.status_any_error():
+            return True
+        return False
+
     def status_any_error(self, report=True) -> bool:
         '''Used by derived classes process_tokens() to know an error was reached
         and to not perform the command. Necessary for pytests that use eda.main()'''
@@ -288,6 +313,26 @@ class Command:
         '''Returns a str for the tool name used for the requested command'''
         return which_tool(command, config=self.config)
 
+    def safe_which_tool(self, command: str = '') -> str:
+        '''Returns a str for the tool name used for the requested command,
+
+        avoids NotImplementedError (for CommandMulti)'''
+
+        if getattr(self, '_TOOL', ''):
+            return self._TOOL
+
+        if not command:
+            command = getattr(self, 'command_name', '')
+
+        try:
+            if getattr(self, 'which_tool', None):
+                return self.which_tool(command)
+        except NotImplementedError:
+            pass
+
+        return which_tool(command, config=self.config)
+
+
     def create_work_dir( # pylint: disable=too-many-branches,too-many-statements
             self
     ) -> str:
@@ -361,7 +406,7 @@ class Command:
                 # Do not allow other absolute path work dirs if it already exists.
                 # This prevents you from --work-dir=~ and eda wipes out your home dir.
                 self.error(f'Cannot use work-dir={self.args["work-dir"]} starting with',
-                           'fabsolute path "/"')
+                           'absolute path "/"')
             elif str(Path('..')) in str(Path(self.args['work-dir'])):
                 # Do not allow other ../ work dirs if it already exists.
                 self.error(f'Cannot use work-dir={self.args["work-dir"]} with up-hierarchy'
@@ -370,9 +415,16 @@ class Command:
                 # If we made it this far, on a directory that exists, that appears safe
                 # to delete and re-create:
                 util.info(f"Removing previous '{self.args['work-dir']}'")
-                shutil.rmtree(self.args['work-dir'])
-                util.safe_mkdir(self.args['work-dir'])
-                util.debug(f'create_work_dir: created {self.args["work-dir"]}')
+                try:
+                    shutil.rmtree(self.args['work-dir'])
+                    util.safe_mkdir(self.args['work-dir'])
+                    util.debug(f'create_work_dir: created {self.args["work-dir"]}')
+                except PermissionError as e:
+                    self.error('Could not remove existing dir and create new due to filesystem',
+                               f'PermissionError: {self.args["work-dir"]}; exception: {e}')
+                except Exception as e:
+                    self.error('Could not remove existing dir and create new due to internal',
+                               f'Exception: {self.args["work-dir"]}; exception: {e}')
         else:
             util.safe_mkdir(self.args['work-dir'])
             util.debug(f'create_work_dir: created {self.args["work-dir"]}')
@@ -492,12 +544,14 @@ class Command:
 
 
     def get_argparser( # pylint: disable=too-many-branches
-            self, parser_arg_list=None
+            self, parser_arg_list=None, support_underscores: bool = True,
     ) -> argparse.ArgumentParser:
         ''' Returns an argparse.ArgumentParser() based on self.args (dict)
 
         If parser_arg_list is not None, the ArgumentParser() is created using only the keys in
         self.args provided by the list parser_arg_list.
+
+        If support_underscores=False, then only return an ArgumentParser() with --arg-posix-dashes
         '''
 
         # Preference is --args-with-dashes, which then become parsed.args_with_dashes, b/c
@@ -519,9 +573,9 @@ class Command:
                 util.warning(f'{key=} has _ chars, prefer -')
 
             keys = [key] # make a list
-            if '_' in key:
+            if support_underscores and '_' in key:
                 keys.append(key.replace('_', '-')) # switch to POSIX dashes for argparse
-            elif '-' in key:
+            elif support_underscores and '-' in key:
                 keys.append(key.replace('-', '_')) # also support --some_arg_with_underscores
 
             arguments = [] # list supplied to parser.add_argument(..) so one liner supports both.
@@ -546,7 +600,7 @@ class Command:
                 # be --some-bool or --no-some-bool.
                 parser.add_argument(
                     *arguments, default=None, **bool_action_kwargs, **help_kwargs)
-            elif isinstance(value, list):
+            elif isinstance(value, (list, set)):
                 parser.add_argument(*arguments, default=value, action='append', **help_kwargs)
             elif isinstance(value, (int, str)):
                 parser.add_argument(*arguments, default=value, type=type(value), **help_kwargs)
@@ -637,7 +691,8 @@ class Command:
         '''
 
         _, unparsed = self.run_argparser_on_list(tokens)
-        if process_all and len(unparsed) > 0:
+        if process_all and unparsed:
+            self.warning_show_known_args()
             self.error(f"Didn't understand argument: '{unparsed=}' in",
                        f" {self.command_name=} context, {pwd=}",
                        error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
@@ -718,7 +773,7 @@ class Command:
 
 
     def help( # pylint: disable=dangerous-default-value,too-many-branches
-            self, tokens: list = []
+            self, tokens: list = [], no_targets: bool = False
     ) -> None:
         '''Since we don't quite follow standard argparger help()/usage(), we'll format our own
 
@@ -733,7 +788,10 @@ class Command:
         # using bare 'print' here, since help was requested, avoids --color and --quiet
         print()
         print('Usage:')
-        print(f'    eda [options] {self.command_name} [options] [files|targets, ...]')
+        if no_targets:
+            print(f'    eda [options] {self.command_name} [options]')
+        else:
+            print(f'    eda [options] {self.command_name} [options] [files|targets, ...]')
         print()
 
         print_base_help()
@@ -780,6 +838,53 @@ class Command:
         if unparsed:
             print(f'Unparsed args: {unparsed}')
 
+    def get_argparsers_args_list(self) -> list:
+        '''Returns list of all args that we know about from eda_config, util, eda, and our self.args
+
+        All items will include the -- prefix (--help, etc)'''
+        return util.get_argparsers_args_list(parsers=[
+            eda_config.get_argparser(),
+            util.get_argparser(),
+            get_argparser(),
+            self.get_argparser(support_underscores=False)
+        ])
+
+    def pretty_str_known_args(self, command: str = '') -> str:
+        '''Returns multiple line column organized string of all known args'''
+        _command = command
+        if not _command:
+            _command = self.command_name
+
+        _args_list = self.get_argparsers_args_list()
+        _pretty_args_list = pretty_list_columns_manual(data=_args_list)
+        return (f"Known args for command '{_command}' :\n"
+                "  " + "\n  ".join(_pretty_args_list)
+                )
+
+    def warning_show_known_args(self, command: str = '') -> None:
+        '''Print a helpful warning showing available args for this eda command (or commands)'''
+
+        if not command:
+            commands = [self.command_name]
+        else:
+            commands = command.split() # support for command="multi sim"
+
+        _tool = self.safe_which_tool(commands[0]) # use first command if > 1 presented
+        lines = []
+        if _tool:
+            lines.append(f"To see all args for command(s) {commands}, tool '{_tool}', run:")
+        else:
+            lines.append(f"To see all args for command(s) {commands}, run:")
+
+        for cmd in commands:
+            if _tool:
+                lines.append(f"  eda {cmd} --tool={_tool} --help")
+            else:
+                lines.append(f"  eda {cmd} --help")
+
+        lines.append(self.pretty_str_known_args(command=commands[-1])) # use last command if > 1
+        util.warning("\n".join(lines))
+
 
 class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
     '''CommandDesign is the eda base class for command handlers that need to track files.
@@ -1345,10 +1450,11 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 plusarg = strip_outer_quotes(token)
                 self.process_plusarg(plusarg, pwd=pwd)
                 remove_list.append(token)
+
         for x in remove_list:
             unparsed.remove(x)
 
-        if not unparsed and self.error_on_no_files_or_targets:
+        if self.error_on_no_files_or_targets and not unparsed:
             # derived classes can set error_on_no_files_or_targets=True
             # For example: CommandSim will error (requires files/targets),
             # CommandWaves does not (files/targets not required)
@@ -1367,13 +1473,27 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                         util.warning(f"For command '{self.command_name}' no files or targets were",
                                      f"presented at the command line, so using '{target}' from",
                                      f"{deps.deps_file}")
-            if len(unparsed) == 0:
+            if not unparsed:
                 # If unparsed is still empty, then error.
                 self.error(f"For command '{self.command_name}' no files or targets were",
                            f"presented at the command line: {orig_tokens}",
                            error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
 
         # by this point hopefully this is a target ... is it a simple filename?
+
+        # Before we look for files, check for stray --some-arg in unparsed, we don't want to treat
+        # these as potential targets if process_all=True, but someone might have a file named
+        # --my_file.sv, so those are technically allowed until the tool would fail on them.
+        possible_unparsed_args = [
+            x for x in unparsed if x.startswith('--') and not os.path.isfile(x)
+        ]
+        if process_all and possible_unparsed_args:
+            _tool = self.safe_which_tool()
+            self.warning_show_known_args()
+            self.error(f"Didn't understand unparsed args: {possible_unparsed_args}, for command",
+                       f"'{self.command_name}', tool '{_tool}'",
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+
         remove_list = []
         last_potential_top_file = ('', '')   # (top, fpath)
         last_potential_top_target = ('', '') # (top, path/to/full-target-name)
@@ -1405,6 +1525,10 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
             # we appear to be dealing with a target name which needs to be resolved (usually
             # recursively)
+            if token.startswith('-'):
+                # We are not going to handle targets that start with a -, it's likely
+                # an unparsed arg.
+                continue
             if token.startswith(os.sep):
                 target_name = token # if it's absolute path, don't prepend anything
             else:
@@ -1424,8 +1548,10 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
             unparsed.remove(x)
 
         # we were unable to figure out what this command line token is for...
-        if process_all and len(unparsed) > 0:
-            self.error(f"Didn't understand command remaining tokens {unparsed=} in CommandDesign",
+        if process_all and unparsed:
+            self.warning_show_known_args()
+            self.error(f"Didn't understand remaining args or targets {unparsed=} for command",
+                       f"'{self.command_name}'",
                        error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
 
         # handle a missing self.args['top'] with last filepath or last target:
@@ -1462,6 +1588,14 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                        f"'{self.command_name}' for tool={self.args.get('tool', None)}",
                        error_code=status_constants.EDA_COMMAND_MISSING_TOP)
 
+        if self.tool_changed_respawn:
+            util.warning(
+                'CommandDesign: need to respawn due to tool change to',
+                f'\'{self.tool_changed_respawn["tool"]}\' from',
+                f'\'{self.tool_changed_respawn["orig_tool"]}\'',
+                f'(from DEPS, {self.tool_changed_respawn["from"]})'
+            )
+
         return unparsed
 
 
@@ -1961,6 +2095,7 @@ class CommandParallel(Command):
         # There should not be any single_cmd_unparsed args starting with '-'
         bad_remaining_args = [x for x in single_cmd_unparsed if x.startswith('-')]
         if bad_remaining_args:
+            self.warning_show_known_args(command=f'{self.command_name} {command}')
             self.error(f'for {self.command_name} {command=} the following args are unknown',
                        f'{bad_remaining_args}',
                        error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
@@ -2020,8 +2155,12 @@ class CommandParallel(Command):
             tpath, _ = os.path.split(job_dict['target'])
 
             # prepend path information to job-name:
-            patched_target_path = os.path.relpath(tpath).replace(os.sep, '_')
-            new_job_name = f'{patched_target_path}.{key}'
+            patched_target_path = os.path.relpath(tpath).replace(os.sep, '_').lstrip('.')
+            if patched_target_path:
+                new_job_name = f'{patched_target_path}.{key}'
+            else:
+                continue # there's nothing to "patch", our job-name will be unchanged.
+
             replace_job_arg(job_dict, arg_name='job-name', new_value=new_job_name)
 
             # prepend path information to force-logfile (if present):

opencos/eda_config.py

@@ -28,7 +28,7 @@ class Defaults:
     config_yml = ''
 
     supported_config_keys = set([
-        'DEFAULT_HANDLERS',
+        'DEFAULT_HANDLERS', 'DEFAULT_HANDLERS_HELP',
         'defines',
         'dep_command_enables',
         'dep_tags_enables',