opencos-eda 0.2.36__py3-none-any.whl → 0.2.39__py3-none-any.whl

opencos/commands/__init__.py

@@ -17,6 +17,7 @@ from .sweep import CommandSweep
 from .synth import CommandSynth
 from .upload import CommandUpload
 from .waves import CommandWaves
+from .targets import CommandTargets
 
 __all__ = [
     'CommandBuild',
@@ -32,4 +33,5 @@ __all__ = [
     'CommandToolsMulti',
     'CommandUpload',
     'CommandWaves',
+    'CommandTargets',
 ]

opencos/commands/multi.py

@@ -392,7 +392,9 @@ class CommandMulti(CommandParallel):
             # Special case for 'multi' --export-jsonl, run reach child with --export-json
             command_list.append('--export-json')
         if tool and len(all_multi_tools) > 1:
-            command_list.append(f'--sub-work-dir={short_target}.{command}.{tool}')
+            command_list.append(f'--job-name={short_target}.{command}.{tool}')
+        else:
+            command_list.append(f'--job-name={short_target}.{command}')
 
     def append_jobs_from_targets(self, args:list):
         '''Helper method in CommandMulti to apply 'args' (list) to all self.targets,
@@ -430,13 +432,15 @@ class CommandMulti(CommandParallel):
                type(self.args['single-timeout']) in [int, str]:
                 command_list = ['timeout', str(self.args['single-timeout'])] + command_list
 
-            name = target
+            name = self.get_name_from_target(target)
             if tool and (len(all_multi_tools) > 1 or self.command_name == 'tools-multi'):
-                name = f'{short_target} ({tool})'
+                name += f' ({tool})'
 
             this_job_dict = {
                 'name' : name,
                 'index' : len(self.jobs),
+                'command': command,
+                'target': target,
                 'command_list' : command_list
             }
             if tool:

opencos/commands/sweep.py

@@ -113,6 +113,9 @@ class CommandSweep(CommandDesign, CommandParallel):
         util.debug(f"Sweep: arg_tokens: '{arg_tokens}'")
         util.debug(f"Sweep: target:     '{self.sweep_target}'")
 
+        if not self.sweep_target:
+            self.error(f"Sweep can only take one target, found none, args: {unparsed}")
+
         # now create the list of jobs, support one axis
         self.jobs = []
 
@@ -197,15 +200,20 @@ class CommandSweep(CommandDesign, CommandParallel):
                    f"target={self.sweep_target}, arg_tokens={arg_tokens},",
                    f"sweep_axis_list={sweep_axis_list}")
         if not sweep_axis_list:
-            # we aren't sweeping anything, create one job
-            snapshot_name = self.sweep_target.replace('../','').replace('/','_') + sweep_string
+            # we aren't sweeping anything, create one job:
+            # name {target}.{command}[.sweep_value,.sweep_value,...]
+            snapshot_name = self.get_name_from_target(self.sweep_target)
+            snapshot_name = snapshot_name.replace(os.sep, '_') \
+                + f'.{self.single_command}{sweep_string}'
             eda_path = get_eda_exec('sweep')
             self.jobs.append({
                 'name' : snapshot_name,
                 'index' : len(self.jobs),
+                'command': self.single_command,
+                'target': self.sweep_target,
                 'command_list' : (
                     [eda_path, self.single_command, self.sweep_target,
-                     '--job_name', snapshot_name] + arg_tokens
+                     f'--job-name={snapshot_name}'] + arg_tokens
                 )
             })
             return
@@ -221,7 +229,7 @@ class CommandSweep(CommandDesign, CommandParallel):
             this_arg_tokens.append(f'{lhs}{operator}{v}')
 
             v_string = f"{v}".replace('.','p')
-            this_sweep_string = sweep_string + f"_{lhs_trimmed}_{v_string}"
+            this_sweep_string = sweep_string + f".{lhs_trimmed}_{v_string}"
 
             self.expand_sweep_axis(
                 arg_tokens=this_arg_tokens,

opencos/commands/targets.py

@@ -0,0 +1,49 @@
+'''opencos.commands.targets - command handler for: eda targets [args]
+
+Note this command is handled differently than others (such as CommandSim),
+it is generally run as simply
+
+    > eda targets
+    > eda targets <directory>
+    > eda targets [directory/]<pattern> [directory2/]<pattern2> ...
+
+uses no tools and will print a pretty list of targets to stdout.
+'''
+
+# Note - similar code waiver, tricky to eliminate it with inheritance when
+# calling reusable methods.
+# pylint: disable=R0801
+
+import os
+
+from opencos import eda_extract_targets
+from opencos.eda_base import Command
+
+
+class CommandTargets:
+    '''command handler for: eda targets'''
+
+    command_name = 'targets'
+
+    def __init__(self, config: dict):
+        # We don't inherit opencos.eda_base.Command, so we have to set a few
+        # member vars for Command.help to work.
+        self.args = {}
+        self.args_help = {}
+        self.config = config
+        self.status = 0
+
+    def process_tokens( # pylint: disable=unused-argument
+        self, tokens: list, process_all: bool = True,
+        pwd: str = os.getcwd()
+    ) -> list:
+        '''This is effectively our 'run' method, entrypoint from opencos.eda.main'''
+
+        eda_extract_targets.run(partial_paths=tokens, base_path=pwd)
+        return []
+
+    def help(self, tokens: list) -> None:
+        '''Since we don't inherit from opencos.eda_base.Command, need our own help
+        method
+        '''
+        Command.help(self, tokens=tokens)

opencos/eda.py

@@ -10,6 +10,7 @@ import re
 import signal
 import argparse
 import shlex
+import importlib.util
 
 import opencos
 from opencos import util, files
@@ -19,7 +20,6 @@ from opencos.eda_base import Tool, which_tool
 
 # Globals
 
-debug_respawn = False
 util.progname = "EDA"
 
 
@@ -30,37 +30,25 @@ util.progname = "EDA"
 # eda command (such as, command: eda sim) is handled by which class (such as class: CommandSim)
 # These are also overriden depending on the tool, for example --tool verilator sets
 # "sim": CommandSimVerilator.
-def init_config(config: dict,  quiet=False, tool=None) -> dict:
+def init_config(
+        config: dict,  quiet: bool = False, tool=None, run_auto_tool_setup: bool = True
+) -> dict:
     '''Sets or clears entries in config (dict) so tools can be re-loaded.'''
 
-    from opencos.commands import CommandSim, CommandElab, CommandSynth, \
-        CommandFList, CommandProj, CommandMulti, CommandToolsMulti, \
-        CommandSweep, CommandBuild, CommandWaves, CommandUpload, CommandOpen, \
-        CommandExport
-
-    # If config didn't set the auto_tools_order, then use a fully populated default
-    # dict:
-    config = eda_config.get_config_merged_with_defaults(config)
-
-    config['command_handler'] = {
-        "sim"         : CommandSim,
-        "elab"        : CommandElab,
-        "synth"       : CommandSynth,
-        "flist"       : CommandFList,
-        "proj"        : CommandProj,
-        "multi"       : CommandMulti,
-        "tools-multi" : CommandToolsMulti,
-        "sweep"       : CommandSweep,
-        "build"       : CommandBuild,
-        "waves"       : CommandWaves,
-        "upload"      : CommandUpload,
-        "open"        : CommandOpen,
-        "export"      : CommandExport,
-    }
+    # 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():
+        cls = util.import_class_from_string(str_class)
+        if not cls:
+            util.error(f"config DEFAULT_HANDLERS {command=} {str_class=} could not import")
+        else:
+            config['command_handler'][command] = cls
 
     config['auto_tools_found'] = dict()
     config['tools_loaded'] = set()
-    config = auto_tool_setup(config=config, quiet=quiet, tool=tool)
+    if run_auto_tool_setup:
+        config = auto_tool_setup(config=config, quiet=quiet, tool=tool)
     return config
 
 
@@ -154,7 +142,6 @@ def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) ->
       tool='verlator', tool='verilator=/path/to/verilator.exe'
       If so, updates config['auto_tools_order'][tool]['exe']
     '''
-    import importlib.util
 
     tool = eda_config.update_config_auto_tool_order_for_tool(
         tool=tool, config=config
@@ -237,7 +224,6 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
       tool='verlator', tool='verilator=/path/to/verilator.exe'
 
     '''
-    import importlib
 
     tool = eda_config.update_config_auto_tool_order_for_tool(
         tool=tool, config=config
@@ -281,10 +267,7 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
             # skip, already has a tool associated with it, and we're in auto_setup=True
             continue
 
-        if str_class_name not in globals():
-            cls = util.import_class_from_string(str_class_name)
-        else:
-            cls = globals().get(str_class_name, None)
+        cls = util.import_class_from_string(str_class_name)
 
         assert issubclass(cls, Tool), f'{str_class_name=} is does not have Tool class associated with it'
         util.debug(f'Setting {cls=} for {command=} in config.command_handler')
@@ -302,6 +285,7 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
 
     deferred_tokens = []
     command = ""
+    run_auto_tool_setup = True
 
     parser = eda_base.get_argparser()
     try:
@@ -324,22 +308,29 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     if parsed.eda_safe:
         eda_config.update_config_for_eda_safe(config)
 
+    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 value in config['command_uses_no_tools']:
+                run_auto_tool_setup = False
+            unparsed.remove(value)
+            break
+
     if not interactive:
         # Run init_config() now, we deferred it in main(), but only run it
         # for this tool (or tool=None to figure it out)
-        config = init_config(config, tool=parsed.tool)
+        config = init_config(
+            config, tool=parsed.tool,
+            run_auto_tool_setup=run_auto_tool_setup
+        )
         if not config:
             util.error(f'eda.py main: problem loading config, {args=}')
             return 3
 
-
-    util.debug(f'eda process_tokens: {parsed=} {unparsed=}')
-    for value in unparsed:
-        if value in config['command_handler'].keys():
-            command = value
-            unparsed.remove(value)
-            break
-
     # Deal with help, now that we have the command (if it was set).
     if parsed.help:
         if not command:
@@ -363,7 +354,9 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     util.debug(f'{command=}')
     util.debug(f'{sco.config=}')
     util.debug(f'{type(sco)=}')
-    if not parsed.tool and command not in config.get('command_determines_tool', []):
+    if not parsed.tool and \
+       command not in config.get('command_determines_tool', []) and \
+       command not in config.get('command_uses_no_tools', []):
         use_tool = which_tool(command, config)
         util.info(f"--tool not specified, using default for {command=}: {use_tool}")
 
@@ -377,7 +370,7 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     sco.config['eda_original_args'] = original_args
 
     setattr(sco, 'command_name', command) # as a safeguard, b/c 'command' is not always passed to 'sco'
-    unparsed = sco.process_tokens(deferred_tokens)
+    unparsed = sco.process_tokens(tokens=deferred_tokens, pwd=os.getcwd())
 
     # query the status from the Command object (0 is pass, > 0 is fail)
     rc = getattr(sco, 'status', 1)
@@ -439,7 +432,6 @@ def main(*args):
     # Handle --config-yml= arg
     config, unparsed = eda_config.get_eda_config(unparsed)
 
-
     # Note - we used to call: config = init_config(config=config)
     # However, we now defer calling init_config(..) until eda.process_tokens(..)
 
@@ -459,22 +451,8 @@ def main(*args):
                               config=config)
 
 
-def main_cli(support_respawn=False):
+def main_cli() -> None:
     ''' Returns None, will exit with return code. Entry point for package script or __main__.'''
-
-    if support_respawn and '--no-respawn' not in sys.argv:
-        # If someone called eda.py directly (aka, __name__ == '__main__'),
-        # then we still support a legacy mode of operation - where we check
-        # for OC_ROOT (in env, or git repo) to make sure this is the right
-        # location of eda.py by calling main_cli(support_respawn=True).
-        # Otherwise, we do not respawn $OC_ROOT/bin/eda.py
-        # Can also be avoided with --no-respawn.
-
-        # Note - respawn will never work if calling as a package executable script,
-        # which is why our package entrypoint will be main_cli() w/out support_respawn.
-        main_maybe_respawn()
-
-
     signal.signal(signal.SIGINT, signal_handler)
     util.global_exit_allowed = True
     # Strip eda or eda.py from sys.argv, we know who we are if called from __main__:
@@ -482,46 +460,8 @@ def main_cli(support_respawn=False):
     util.exit(rc)
 
 
-def main_maybe_respawn():
-    ''' Returns None, will respawn - run - exit, or will return and the command
-
-    is expected to run in main_cli()'''
-
-    # First we check if we are respawning
-    this_path = os.path.realpath(__file__)
-    if debug_respawn: util.info(f"RESPAWN: this_path : '{this_path}'")
-    oc_root = util.get_oc_root()
-    if debug_respawn: util.info(f"RESPAWN: oc_root   : '{oc_root}'")
-    cwd = util.getcwd()
-    if debug_respawn: util.info(f"RESPAWN: cwd       : '{cwd}'")
-    if oc_root:
-        new_paths = [
-            os.path.join(oc_root, 'opencos', 'eda.py'),
-            os.path.join(oc_root, 'bin', 'eda'),
-        ]
-        if debug_respawn: util.info(f"RESPAWN: {new_paths=} {this_path=}")
-        if this_path not in new_paths and os.path.exists(new_paths[0]):
-            # we are not the correct version of EDA for this Git repo, we should respawn
-            util.info(f"{this_path} respawning {new_paths[0]} in {cwd} with --no-respawn")
-            sys.argv[0] = new_paths[0]
-            sys.argv.insert(1, '--no-respawn')
-            proc = subprocess.Popen(sys.argv, shell=0, cwd=cwd, universal_newlines=True)
-            while True:
-                try:
-                    proc.communicate()
-                    break
-                except KeyboardInterrupt:
-                    continue
-            # get exit status from proc and return it
-            util.exit(proc.returncode, quiet=True)
-        else:
-            if debug_respawn: util.info(f"RESPAWN: {oc_root=} respawn not necessary")
-    else:
-        if debug_respawn: util.info("RESPAWN: respawn not necessary")
-
-
 if __name__ == '__main__':
-    main_cli(support_respawn=True)
+    main_cli()
 
 # IDEAS:
 # * options with no default (i.e. if user doesn't override, THEN we set it, like "seed" or "work-dir") can be given a

opencos/eda_base.py

@@ -11,6 +11,7 @@ import signal
 import sys
 import threading
 import time
+from pathlib import Path
 
 import opencos
 from opencos import seed, deps_helpers, util, files
@@ -184,20 +185,24 @@ class Command:
             'export-json': False,      # generates an export.json suitable for a testrunner, if possible for self.command.
             'enable-tags': [],
             'disable-tags': [],
+            'test-mode': False,
         })
         self.args_help.update({
-            'stop-before-compile': 'stop this run before any compile (if possible for tool) and' \
-            + ' save .sh scripts in eda-dir/',
+            'stop-before-compile': ('stop this run before any compile (if possible for tool) and'
+                                    ' save .sh scripts in eda-dir/'),
             'eda-dir':     'relative directory where eda logs are saved',
             'export':      'export results for these targets in eda-dir',
             'export-run':  'export, and run, results for these targets in eda-dir',
             'export-json': 'export, and save a JSON file per target',
-            'work-dir':    'Optional override for working directory, often defaults to ./eda.work/<top>.<command>',
-            'enable-tags': 'DEPS markup tag names to be force enabled for this' \
-            + ' command (mulitple appends to list).',
-            'diable-tags': 'DEPS markup tag names to be disabled (even if they' \
-            + ' match the criteria) for this command (mulitple appends to list).' \
-            + ' --disable-tags has higher precedence than --enable-tags.'
+            'work-dir':    ('Optional override for working directory, often defaults to'
+                            ' ./eda.work/<top>.<command>'),
+            'enable-tags': ('DEPS markup tag names to be force enabled for this'
+                            ' command (mulitple appends to list).'),
+            'diable-tags': ('DEPS markup tag names to be disabled (even if they'
+                            ' match the criteria) for this command (mulitple appends to list).'
+                            ' --disable-tags has higher precedence than --enable-tags.'),
+            'test-mode': ('command and tool dependent, usually stops the command early without'
+                          ' executing.'),
         })
         self.modified_args = {}
         self.config = copy.deepcopy(config) # avoid external modifications.
@@ -223,8 +228,8 @@ class Command:
 
     def create_work_dir(self):
         util.debug(f"create_work_dir: {self.args['eda-dir']=} {self.args['work-dir']=}")
-        if (not os.path.exists(self.args['eda-dir'])): # use os.path.isfile / isdir also
-            os.mkdir(self.args['eda-dir'])
+        if not os.path.exists(self.args['eda-dir']):
+            util.safe_mkdir(self.args['eda-dir'])
             util.info(f"create_work_dir: created {self.args['eda-dir']}")
         if self.args['design'] == "":
             if ('top' in self.args) and (self.args['top'] != ""):
@@ -250,14 +255,35 @@ class Command:
         if (os.path.exists(self.args['work-dir'])):
             if os.path.exists(keep_file) and not self.args['force']:
                 self.error(f"Cannot remove old work dir due to '{keep_file}'")
-            util.info(f"Removing previous '{self.args['work-dir']}'")
-            shutil.rmtree(self.args['work-dir'])
-        os.mkdir(self.args['work-dir'])
-        util.debug(f'create_work_dir: created {self.args["work-dir"]}')
+            elif os.path.abspath(self.args['work-dir']) in os.getcwd():
+                # This effectively checks if
+                # --work-dir=.
+                # --work-dir=$PWD
+                # --work-dir=/some/path/almost/here
+                # Allow it, but preserve the existing directory, we don't want to blow away
+                # files up-heir from us.
+                # Enables support for --work-dir=.
+                util.info(f"Not removing existing work-dir: '{self.args['work-dir']}' is within {os.getcwd()=}")
+            elif str(Path(self.args['work-dir'])).startswith(str(Path('/'))):
+                # 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 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 ../ paths')
+            else:
+                # 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"]}')
+        else:
+            util.safe_mkdir(self.args['work-dir'])
+            util.debug(f'create_work_dir: created {self.args["work-dir"]}')
         if (self.args['keep']):
             open(keep_file, 'w').close()
-            util.debug(f'create_work_dir: created {keep_file}')
-        util.info(f'create_work_dir: created {self.args["work-dir"]}')
+            util.debug(f'create_work_dir: created {keep_file=}')
         return self.args['work-dir']
 
     def exec(self, work_dir, command_list, background=False, stop_on_error=True,
@@ -550,7 +576,7 @@ class Command:
             self.set_tool_defines()
 
 
-    def help(self, tokens: list = []):
+    def help(self, tokens: list = []) -> None:
         '''Since we don't quite follow standard argparger help()/usage(), we'll format our own
 
         if self.args_help has additional help information.
@@ -569,8 +595,13 @@ class Command:
 
         print_base_help()
         lines = []
+        if not self.args:
+            print(f'Unparsed args: {tokens}')
+            return
+
         if self.command_name:
-            lines.append(f"Generic help for command='{self.command_name}' (using '{self.__class__.__name__}')")
+            lines.append(f"Generic help for command='{self.command_name}'"
+                         f" (using '{self.__class__.__name__}')")
         else:
             lines.append(f"Generic help (from class Command):")
 
@@ -752,7 +783,7 @@ class CommandDesign(Command):
         #   token = '\'+define+OC_ROOT="/foo/bar/opencos"\''
         # So we strip all outer ' or " on the plusarg:
         plusarg = util.strip_outer_quotes(plusarg)
-        if pwd is None:
+        if not pwd:
             pwd = ''
 
         if plusarg.startswith('+define+'):
@@ -1356,6 +1387,8 @@ class CommandParallel(Command):
         fancy_mode = util.args['fancy'] and (num_parallel > 1) and (num_parallel <= (lines-6))
         multi_cwd = util.getcwd() + os.sep
 
+        self.patch_jobs_for_duplicate_target_names()
+
         if run_parallel:
             # we are doing this multi-threaded
             util.info(f"Parallel: Running multi-threaded, starting {num_parallel} workers")
@@ -1514,6 +1547,10 @@ class CommandParallel(Command):
             self.status = 0 if len(self.jobs_status) == 0 else max(self.jobs_status)
         util.fancy_stop()
 
+    @staticmethod
+    def get_name_from_target(target: str) -> str:
+        return target.replace('../', '').lstrip('./')
+
 
     def update_args_list(self, args: list, tool: str) -> None:
         '''Modfies list args, using allow-listed known top-level args:
@@ -1567,3 +1604,58 @@ class CommandParallel(Command):
         # Remove unparsed args starting with '+', since those are commonly sent downstream to
         # single job (example, CommandSim plusargs).
         return [x for x in single_cmd_unparsed if not x.startswith('+')]
+
+
+    def patch_jobs_for_duplicate_target_names(self) -> None:
+        '''Examines list self.jobs, and if leaf target names are duplicate will
+        patch each command's job-name to:
+            --job-name=path.leaf.command[.tool]
+        '''
+
+        def get_job_name(job_dict: dict) -> str:
+            '''Fishes the job-name out of an entry in self.jobs'''
+            for i, item in enumerate(job_dict['command_list']):
+                if item.startswith('--job-name='):
+                    _, name = item.split('--job-name=')
+                    return name
+                elif item == '--job-name':
+                    return job_dict['command_list'][i + 1]
+            return ''
+
+        def replace_job_name(job_dict: dict, new_job_name: str) -> dict:
+            '''Replaces the job-name in an entry in self.jobs'''
+            for i, item in enumerate(job_dict['command_list']):
+                if item.startswith('--job-name='):
+                    job_dict['command_list'][i] = '--job-name=' + new_job_name
+                    return job_dict
+                elif item == '--job-name':
+                    job_dict['command_list'][i + 1] = new_job_name
+                    return job_dict
+            return job_dict
+
+
+        job_names_count_dict = {}
+        for job_dict in self.jobs:
+
+            key = get_job_name(job_dict)
+            if not key:
+                self.error(f'{job_dict=} needs to have a --job-name= arg attached')
+            if key not in job_names_count_dict:
+                job_names_count_dict[key] = 1
+            else:
+                job_names_count_dict[key] += 1
+
+        for i, job_dict in enumerate(self.jobs):
+            key = get_job_name(job_dict)
+            if job_names_count_dict[key] < 2:
+                continue
+
+            tpath, _ = os.path.split(job_dict['target'])
+
+            # prepend path information to job-name:
+            patched_sub_work_dir = False
+            patched_target_path = os.path.relpath(tpath).replace(os.sep, '_')
+            new_job_name = f'{patched_target_path}.{key}'
+            new_job_dict = replace_job_name(job_dict, new_job_name)
+            self.jobs[i] = new_job_dict
+            util.debug(f'Patched job {job_dict["name"]}: --job-name={new_job_name}')

opencos/eda_config.py

@@ -15,9 +15,11 @@ class Defaults:
     home_override_config_yml = os.path.join(
         os.environ.get('HOME', ''), '.opencos-eda', 'EDA_CONFIG.yml'
     )
-    config_yml = 'eda_config_defaults.yml'
+    opencos_config_yml = 'eda_config_defaults.yml'
+    config_yml = ''
 
     supported_config_keys = set([
+        'DEFAULT_HANDLERS',
         'defines',
         'dep_command_enables',
         'dep_tags_enables',
@@ -26,10 +28,11 @@ class Defaults:
         'bare_plusarg_supported',
         'dep_sub',
         'vars',
-        'tools',
-        'auto_tools_order',
         'file_extensions',
         'command_determines_tool',
+        'command_uses_no_tools',
+        'tools',
+        'auto_tools_order',
     ])
     supported_config_auto_tools_order_keys = set([
         'exe', 'handlers', 'requires_env', 'requires_py', 'requires_cmd',
@@ -53,6 +56,14 @@ class Defaults:
     ])
 
 
+if os.path.exists(Defaults.environ_override_config_yml):
+    Defaults.config_yml = Defaults.environ_override_config_yml
+elif os.path.exists(Defaults.home_override_config_yml):
+    Defaults.config_yml = Defaults.home_override_config_yml
+else:
+    Defaults.config_yml = Defaults.opencos_config_yml
+
+
 def find_eda_config_yml_fpath(filename:str, package_search_only=False, package_search_enabled=True) -> str:
     '''Locates the filename (.yml) either from fullpath provided or from the sys.path
     opencos package paths.'''
@@ -192,15 +203,9 @@ def get_config_merged_with_defaults(config:dict) -> dict:
     return default_config
 
 def get_argparser() -> argparse.ArgumentParser:
-    if os.path.exists(Defaults.environ_override_config_yml):
-        default_config_yml = Defaults.environ_override_config_yml
-    elif os.path.exists(Defaults.home_override_config_yml):
-        default_config_yml = Defaults.home_override_config_yml
-    else:
-        default_config_yml = Defaults.config_yml
     parser = argparse.ArgumentParser(prog='opencos eda config options', add_help=False, allow_abbrev=False)
-    parser.add_argument('--config-yml', type=str, default=default_config_yml,
-                        help=f'YAML filename to use for configuration (default {default_config_yml})')
+    parser.add_argument('--config-yml', type=str, default=Defaults.config_yml,
+                        help=f'YAML filename to use for configuration (default {Defaults.config_yml})')
     return parser
 
 def get_argparser_short_help() -> str:
@@ -213,6 +218,8 @@ def get_eda_config(args:list, quiet=False) -> (dict, list):
 
     Handles args for:
       --config-yml=<YAMLFILE>
+
+    This will merge the result with the default config (if overriden)
     '''
 
     parser = get_argparser()
@@ -237,5 +244,7 @@ def get_eda_config(args:list, quiet=False) -> (dict, list):
     else:
         config = None
 
+    if parsed.config_yml != Defaults.config_yml:
+        config = get_config_merged_with_defaults(config)
 
     return config, unparsed