opencos-eda 0.2.49__tar.gz → 0.2.51__tar.gz

{opencos_eda-0.2.49/opencos_eda.egg-info → opencos_eda-0.2.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.49
+Version: 0.2.51
 Summary: A simple Python package for wrapping RTL simuliatons and synthesis
 Author-email: Simon Sabato <simon@cognichip.ai>, Drew Ranck <drew@cognichip.ai>
 Project-URL: Homepage, https://github.com/cognichip/opencos

{opencos_eda-0.2.49 → opencos_eda-0.2.51}/opencos/commands/lec.py

@@ -69,16 +69,13 @@ class CommandLec(CommandDesign):
         if self.status_any_error():
             return unparsed
 
-        # add defines for this job type
-        if not self.args['top']:
-            self.args['top'] = 'eda.lec'
-
         # we require there to be two --designs set.
         if not self.args['designs'] and len(self.args['designs']) != 2:
             self.error('Requires two designs via --designs=<target1> --designs=<target2>',
                        f'designs={self.args["designs"]}')
             return []
 
+
         # Before we do anything else, make sure the two designs actually exist.
         for design in self.args['designs']:
             # maybe it's a file?
@@ -89,6 +86,12 @@ class CommandLec(CommandDesign):
             else:
                 self.error(f'--designs={design}, value is not a file or target')
 
+        if not self.args['top']:
+            # Correct the 'top' name so it's eda.<target1>.<target2>.lec (shortnames)
+            _, short_target1 = os.path.split(self.args['designs'][0])
+            _, short_target2 = os.path.split(self.args['designs'][1])
+            self.args['top'] = f'eda.{short_target1}.{short_target2}'
+
         # create our work dir
         self.create_work_dir()
         self.run_dep_commands()

{opencos_eda-0.2.49 → opencos_eda-0.2.51}/opencos/commands/multi.py

@@ -590,7 +590,7 @@ class CommandToolsMulti(CommandMulti):
     def multi_which_tools(self, command):
         '''Overrides CommandMulti.multi_which_tool(command), return a list of all
         possible tools that can run this command'''
-        if self.tools is None or len(self.tools) == 0:
+        if self.tools is None or not self.tools:
             # wasn't set via arg --tools, so use all if possible for this command.
             which_tools = self.all_handler_commands.get(command, [])
         else:

{opencos_eda-0.2.49 → opencos_eda-0.2.51}/opencos/commands/shell.py

@@ -16,6 +16,8 @@ import os
 from opencos import util, export_helper
 from opencos.eda_base import CommandDesign
 
+from opencos.utils import status_constants
+
 
 class CommandShell(CommandDesign):
     '''Base class command handler for: eda sim ...'''
@@ -181,7 +183,6 @@ class CommandShell(CommandDesign):
             _must_strings.append(self.args['pass-pattern'])
 
         if len(_bad_strings) > 0 or len(_must_strings) > 0:
-            hit_bad_string = False
             hit_must_string_dict = dict.fromkeys(_must_strings)
             fname = os.path.join(self.args['work-dir'], filename)
             with open(fname, 'r', encoding='utf-8') as f:
@@ -191,12 +192,14 @@ class CommandShell(CommandDesign):
                             if k in line:
                                 hit_must_string_dict[k] = True
                     if any(bad_str in line for bad_str in _bad_strings):
-                        hit_bad_string = True
-                        self.error(f"log {fname}:{lineno} contains one of {_bad_strings=}")
+                        self.error(
+                            f"log {fname}:{lineno} contains one of {_bad_strings=}",
+                            error_code=status_constants.EDA_SHELL_LOG_HAS_BAD_STRING
+                        )
 
-            if hit_bad_string:
-                self.status += 1
             if any(x is None for x in hit_must_string_dict.values()):
-                self.error(f"Didn't get all passing patterns in log {fname}: {_must_strings=}",
-                           f" {hit_must_string_dict=}")
-                self.status += 1
+                self.error(
+                    f"Didn't get all passing patterns in log {fname}: {_must_strings=}",
+                    f" {hit_must_string_dict=}",
+                    error_code=status_constants.EDA_SHELL_LOG_MISSING_MUST_STRING
+                )

{opencos_eda-0.2.49 → opencos_eda-0.2.51}/opencos/commands/sim.py

@@ -15,6 +15,7 @@ import os
 
 from opencos import util, export_helper
 from opencos.eda_base import CommandDesign, Tool
+from opencos.utils import status_constants
 
 class CommandSim(CommandDesign):
     '''Base class command handler for: eda sim ...'''
@@ -170,13 +171,21 @@ class CommandSim(CommandDesign):
             if log_filename:
                 log_fname = log_filename
 
-            self.exec(work_dir=self.args['work-dir'], command_list=clist, tee_fpath=tee_fpath)
+            _, stdout, _ = self.exec(
+                work_dir=self.args['work-dir'], command_list=clist, tee_fpath=tee_fpath
+            )
 
             if check_logs and log_fname:
                 self.check_logs_for_errors(
-                    filename=log_fname, bad_strings=bad_strings, must_strings=must_strings,
+                    filename='', file_contents_str=stdout,
+                    bad_strings=bad_strings, must_strings=must_strings,
                     use_bad_strings=use_bad_strings, use_must_strings=use_must_strings
                 )
+            if log_fname:
+                self.artifacts_add(
+                    name=os.path.join(self.args['work-dir'], log_fname),
+                    typ='text', description='Simulator stdout/stderr log file'
+                )
 
     def do_export(self) -> None:
         '''CommandSim helper for handling args --export*
@@ -268,8 +277,8 @@ class CommandSim(CommandDesign):
         '''
         return
 
-    def check_logs_for_errors( # pylint: disable=dangerous-default-value
-            self, filename: str,
+    def check_logs_for_errors( # pylint: disable=dangerous-default-value,too-many-locals,too-many-branches
+            self, filename: str = '', file_contents_str: str = '',
             bad_strings: list = [], must_strings: list = [],
             use_bad_strings: bool = True, use_must_strings: bool = True
     ) -> None:
@@ -289,26 +298,38 @@ class CommandSim(CommandDesign):
         if self.args['pass-pattern'] != "":
             _must_strings.append(self.args['pass-pattern'])
 
-        if len(_bad_strings) > 0 or len(_must_strings) > 0:
-            hit_bad_string = False
-            hit_must_string_dict = dict.fromkeys(_must_strings)
+        if len(_bad_strings) == 0 and len(_must_strings) == 0:
+            return
+
+        hit_must_string_dict = dict.fromkeys(_must_strings)
+
+        lines = []
+        fname = ''
+        if file_contents_str:
+            lines = file_contents_str.split('\n')
+        elif filename:
             fname = os.path.join(self.args['work-dir'], filename)
             with open(fname, 'r', encoding='utf-8') as f:
-                for lineno, line in enumerate(f):
-                    if any(must_str in line for must_str in _must_strings):
-                        for k, _ in hit_must_string_dict.items():
-                            if k in line:
-                                hit_must_string_dict[k] = True
-                    if any(bad_str in line for bad_str in _bad_strings):
-                        hit_bad_string = True
-                        self.error(f"log {fname}:{lineno} contains one of {_bad_strings=}")
-
-            if hit_bad_string:
-                self.status += 1
-            if any(x is None for x in hit_must_string_dict.values()):
-                self.error(f"Didn't get all passing patterns in log {fname}: {_must_strings=}",
-                           f" {hit_must_string_dict=}")
-                self.status += 1
+                lines = f.readl.splitlines()
+
+        if lines:
+            for lineno, line in enumerate(lines):
+                if any(must_str in line for must_str in _must_strings):
+                    for k, _ in hit_must_string_dict.items():
+                        if k in line:
+                            hit_must_string_dict[k] = True
+                if any(bad_str in line for bad_str in _bad_strings):
+                    self.error(
+                        f"log {fname}:{lineno} contains one of {_bad_strings=}",
+                        error_code=status_constants.EDA_SIM_LOG_HAS_BAD_STRING
+                    )
+
+        if any(x is None for x in hit_must_string_dict.values()):
+            self.error(
+                f"Didn't get all passing patterns in log {fname}: {_must_strings=}",
+                f" {hit_must_string_dict=}",
+                error_code=status_constants.EDA_SIM_LOG_MISSING_MUST_STRING
+            )
 
     # Methods that derived classes must override:
 

{opencos_eda-0.2.49 → opencos_eda-0.2.51}/opencos/deps/deps_file.py

@@ -10,15 +10,20 @@ from pathlib import Path
 
 import toml
 
+from opencos import util
 from opencos.deps.defaults import DEPS_FILE_EXTS, ROOT_TABLE_KEYS_NOT_TARGETS
 from opencos.util import debug, error
-from opencos.utils.markup_helpers import yaml_safe_load, toml_load_only_root_line_numbers
+from opencos.utils.markup_helpers import yaml_safe_load, toml_load_only_root_line_numbers, \
+    markup_writer, markup_dumper
 from opencos.utils.str_helpers import fnmatch_or_re, dep_str2list
 from opencos.utils.subprocess_helpers import subprocess_run_background
+from opencos.utils.status_constants import EDA_DEPS_FILE_NOT_FOUND, EDA_DEPS_TARGET_NOT_FOUND
 
 
 def deps_data_get_all_targets(data: dict) -> list:
     '''Given extracted DEPS data (dict) get all the root level keys that aren't defaults'''
+    if data is None:
+        return []
     return [x for x in data.keys() if x not in ROOT_TABLE_KEYS_NOT_TARGETS]
 
 
@@ -166,32 +171,43 @@ def deps_target_get_deps_list(
     ret = []
     for dep in deps:
         if isinstance(dep, str):
-            if dep.startswith('#') or dep == '':
+            if not dep or dep.startswith('#'):
                 continue
         ret.append(dep)
     return ret
 
 
 def deps_list_target_sanitize(
-        entry, default_key: str = 'deps', target_node: str = '', deps_file: str = ''
+        entry, default_key: str = 'deps', target_node: str = '', deps_file: str = '',
+        entry_fix_deps_key: bool = True
 ) -> dict:
     '''Returns a sanitized DEPS markup table entry (dict --> dict)
 
     Since we support target entries that can be dict, list, or str(), sanitize
     them so they are a dict, with a key named 'deps' that has a list of deps.
     '''
+    ret = None
     if isinstance(entry, dict):
-        return entry
+        ret = entry
 
     if isinstance(entry, str):
         mylist = dep_str2list(entry) # convert str to list
-        return {default_key: mylist}
+        ret = {default_key: mylist}
 
     if isinstance(entry, list):
         # it's already a list
-        return {default_key: entry}
+        ret = {default_key: entry}
+
+    if ret is not None:
+        if entry_fix_deps_key and 'deps' in ret:
+            ret['deps'] = deps_target_get_deps_list(
+                entry=ret, default_key='deps', deps_file=deps_file,
+                entry_must_have_default_key=True
+            )
+    else:
+        assert False, f"Can't convert to list {entry=} {default_key=} {target_node=} {deps_file=}"
 
-    assert False, f"Can't convert to list {entry=} {default_key=} {target_node=} {deps_file=}"
+    return ret
 
 
 class DepsFile:
@@ -230,7 +246,10 @@ class DepsFile:
             if deps_path and os.path.exists(deps_path):
                 self.rel_deps_file = os.path.join(os.path.relpath(deps_path), deps_leaf)
 
-        self.error = command_design_ref.error # method.
+        self.error = getattr(command_design_ref, 'error', None)
+        if not self.error:
+            self.error = util.error
+
 
     def found(self) -> bool:
         '''Returns true if this DEPS file exists and extracted non-empty data'''
@@ -270,15 +289,18 @@ class DepsFile:
                 if '.' in target_node:
                     # Likely a filename (target_node does not include path)
                     self.error(f'Trying to resolve command-line target={t_full} (file?):',
-                               f'File={t_node} not found in directory={t_path}')
+                               f'File={t_node} not found in directory={t_path}',
+                               error_code=EDA_DEPS_FILE_NOT_FOUND)
                 elif not self.rel_deps_file:
                     # target, but there's no DEPS file
                     self.error(f'Trying to resolve command-line target={t_full}:',
-                               f'but path {t_path} has no DEPS markup file (DEPS.yml)')
+                               f'but path {t_path} has no DEPS markup file (DEPS.yml)',
+                               error_code=EDA_DEPS_FILE_NOT_FOUND)
                 else:
                     self.error(f'Trying to resolve command-line target={t_full}:',
                                f'was not found in deps_file={self.rel_deps_file},',
-                               f'possible targets in deps file = {list(self.data.keys())}')
+                               f'possible targets in deps file = {list(self.data.keys())}',
+                               error_code=EDA_DEPS_TARGET_NOT_FOUND)
             else:
                 # If we have caller_info, then this was a recursive call from another
                 # DEPS file. It should already have the useful error messaging:
@@ -287,16 +309,19 @@ class DepsFile:
                     # Likely a filename (target_node does not include path)
                     self.error(f'Trying to resolve target={t_full} (file?):',
                                f'called from {caller_info},',
-                               f'File={t_node} not found in directory={t_path}')
+                               f'File={t_node} not found in directory={t_path}',
+                               error_code=EDA_DEPS_FILE_NOT_FOUND)
                 elif not self.rel_deps_file:
                     # target, but there's no DEPS file
                     self.error(f'Trying to resolve target={t_full}:',
                                f'called from {caller_info},',
-                               f'but {t_path} has no DEPS markup file (DEPS.yml)')
+                               f'but {t_path} has no DEPS markup file (DEPS.yml)',
+                               error_code=EDA_DEPS_FILE_NOT_FOUND)
                 else:
                     self.error(f'Trying to resolve target={t_full}:',
                                f'called from {caller_info},',
-                               f'Target not found in deps_file={self.rel_deps_file}')
+                               f'Target not found in deps_file={self.rel_deps_file}',
+                               error_code=EDA_DEPS_TARGET_NOT_FOUND)
         else:
             debug(f'Found {target_node=} in deps_file={self.rel_deps_file}')
             found_target = True
@@ -324,3 +349,31 @@ class DepsFile:
         entry.update(entry_sanitized)
 
         return entry
+
+    def get_all_targets(self) -> list:
+        '''Returns list of all targets in this obj, skipping keys like DEFAULTS and METADATA'''
+        return deps_data_get_all_targets(self.data)
+
+    def get_sanitized_data(self) -> dict:
+        '''Returns a sanitized dict of self.data, resolves DEFAULTS, METADATA, and implicit
+
+        space-separated-str, lists for 'deps' in a target entry
+        '''
+        new_data = {}
+        targets = self.get_all_targets()
+        for target in targets:
+            new_data[target] = self.get_entry(target)
+        return new_data
+
+    def write_sanitized_markup(self, filepath: str) -> None:
+        '''Writes the sanitized dict of self.data as JSON/YAML (filepath extension)'''
+        markup_writer(data=self.get_sanitized_data(), filepath=filepath)
+
+    def str_sanitized_markup(self, as_yaml: bool = False) -> str:
+        '''Returns str sanitized YAML or JSON str of self.data'''
+        return markup_dumper(self.get_sanitized_data(), as_yaml=as_yaml)
+
+
+    def print_sanitized_markup(self, as_yaml: bool = False) -> None:
+        '''Prints sanitized JSON str of self.data to STDOUT'''
+        print(self.str_sanitized_markup(as_yaml=as_yaml))

{opencos_eda-0.2.49 → opencos_eda-0.2.51}/opencos/eda.py

@@ -16,9 +16,12 @@ import argparse
 import shlex
 import importlib.util
 
+from pathlib import Path
+
 import opencos
 from opencos import util, eda_config, eda_base
 from opencos.eda_base import Tool, which_tool
+from opencos.utils import vsim_helper
 
 # Configure util:
 util.progname = "EDA"
@@ -151,6 +154,7 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
       If so, updates config['auto_tools_order'][tool]['exe']
     '''
 
+
     tool = eda_config.update_config_auto_tool_order_for_tool(
         tool=tool, config=config
     )
@@ -192,16 +196,23 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
         has_all_exe = True
         has_all_in_exe_path = True
         for exe in exe_list:
-            assert exe != '', f'{tool=} {value=} value missing "exe" {exe=}'
+            assert exe != '', f'{name=} {value=} value missing "exe" {exe=}'
             p = shutil.which(exe)
             if not p:
                 has_all_exe = False
                 util.debug(f"... No, missing exe {exe}")
             for req in value.get('requires_in_exe_path', []):
-                if p and req and str(req).lower() not in str(p).lower():
+                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):
+            # This tool name must be in opencos.utils.vsim_helper.TOOL_IS[name].
+            # Special case for vsim being used by a lot of tools.
+            vsim_helper.init() # only runs checks once internally
+            has_vsim_helper = vsim_helper.TOOL_IS.get(name, False)
+
         if has_all_exe:
             requires_cmd_list = value.get('requires_cmd', [])
             for cmd in requires_cmd_list:
@@ -219,7 +230,8 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
                     util.debug(f"... No, exception {e} running {cmd_list}")
 
 
-        if all([has_all_py, has_all_env, has_all_exe, has_all_in_exe_path]):
+        if all([has_all_py, has_all_env, has_all_exe, has_all_in_exe_path,
+                has_vsim_helper]):
             exe = exe_list[0]
             p = shutil.which(exe)
             config['auto_tools_found'][name] = exe # populate key-value pairs w/ first exe in list

{opencos_eda-0.2.49 → opencos_eda-0.2.51}/opencos/eda_base.py

@@ -28,6 +28,7 @@ from opencos.util import Colors
 from opencos.utils.str_helpers import sprint_time, strip_outer_quotes, string_or_space, \
     indent_wrap_long_text
 from opencos.utils.subprocess_helpers import subprocess_run_background
+from opencos.utils import status_constants
 
 from opencos.deps.deps_file import DepsFile, deps_data_get_all_targets
 from opencos.deps.deps_processor import DepsProcessor
@@ -257,10 +258,15 @@ class Command:
         if self.args['work-dir']:
             if not self.errors_log_f:
                 try:
+                    fullpath = os.path.join(self.args['work-dir'], 'eda.errors.log')
                     self.errors_log_f = open( # pylint: disable=consider-using-with
-                        os.path.join(self.args['work-dir'], 'eda.errors.log'), 'w',
-                        encoding='utf-8'
+                        fullpath, 'w', encoding='utf-8'
                     )
+                    util.artifacts.add(
+                        name=fullpath,
+                        typ='text', description='EDA reported errors'
+                    )
+
                 except FileNotFoundError:
                     pass
             if self.errors_log_f:
@@ -269,7 +275,7 @@ class Command:
                     file=self.errors_log_f
                 )
 
-        self.status = util.error(*args, **kwargs)
+        self.status = util.error(*args, **kwargs) # error_code passed and returned via kwargs
 
     def status_any_error(self, report=True) -> bool:
         '''Used by derived classes process_tokens() to know an error was reached
@@ -374,8 +380,16 @@ class Command:
         if self.args['keep']:
             open(keep_file, 'w', encoding='utf-8').close() # pylint: disable=consider-using-with
             util.debug(f'create_work_dir: created {keep_file=}')
+
+        # Set the util.artifacts path with our work-dir:
+        util.artifacts.set_artifacts_json_dir(self.args['work-dir'])
+
         return self.args['work-dir']
 
+    def artifacts_add(self, name: str, typ: str, description: str) -> None:
+        '''Adds a file to util.artifacts, derived classes may override'''
+        util.artifacts.add(name=name, typ=typ, description=description)
+
 
     def exec(self, work_dir: str, command_list: list, background: bool = False,
              stop_on_error: bool = True, quiet: bool = False, tee_fpath: str = '',
@@ -403,10 +417,16 @@ class Command:
             shell=shell
         )
 
-        if return_code:
-            self.status += return_code
+        if return_code > 0:
+            if return_code == 1:
+                self.status = status_constants.EDA_EXEC_NONZERO_RETURN_CODE1
+            if return_code == 255:
+                self.status = status_constants.EDA_EXEC_NONZERO_RETURN_CODE255
+            else:
+                self.status = status_constants.EDA_EXEC_NONZERO_RETURN_CODE2
             if stop_on_error:
-                self.error(f"exec: returned with error (return code: {return_code})")
+                self.error(f"exec: returned with error (return code: {return_code})",
+                           error_code=self.status)
             else:
                 util.debug(f"exec: returned with error (return code: {return_code})")
         else:
@@ -424,7 +444,8 @@ class Command:
         # Do some minimal type handling, preserving the type(self.args[key])
         if key not in self.args:
             self.error(f'set_arg, {key=} not in self.args {value=}',
-                       f'({self.command_name=}, {self.__class__.__name__=})')
+                       f'({self.command_name=}, {self.__class__.__name__=})',
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
 
         cur_value = self.args[key]
 
@@ -555,7 +576,8 @@ class Command:
             parsed, unparsed = parser.parse_known_args(tokens + [''])
             unparsed = list(filter(None, unparsed))
         except argparse.ArgumentError:
-            self.error(f'problem {self.command_name=} attempting to parse_known_args for {tokens=}')
+            self.error(f'problem {self.command_name=} attempting to parse_known_args for {tokens=}',
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
 
         parsed_as_dict = vars(parsed)
 
@@ -617,7 +639,8 @@ class Command:
         _, unparsed = self.run_argparser_on_list(tokens)
         if process_all and len(unparsed) > 0:
             self.error(f"Didn't understand argument: '{unparsed=}' in",
-                       f" {self.command_name=} context, {pwd=}")
+                       f" {self.command_name=} context, {pwd=}",
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
 
         return unparsed
 
@@ -637,7 +660,8 @@ class Command:
 
         if not ret and error_if_no_command:
             self.error(f"Looking for a valid eda {self.command_name} <command>",
-                       f"but didn't find one in {tokens=}")
+                       f"but didn't find one in {tokens=}",
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
         return ret
 
 
@@ -679,7 +703,8 @@ class Command:
         process_tokens(..) is the starting entrypoint from eda.py'''
         self.write_eda_config_and_args()
         self.error(f"No tool bound to command '{self.command_name}', you",
-                   " probably need to setup tool, or use '--tool <name>'")
+                   " probably need to setup tool, or use '--tool <name>'",
+                   error_code=status_constants.EDA_CONFIG_ERROR)
 
     def command_safe_set_tool_defines(self) -> None:
         '''Safe wrapper for calling self.set_tool_defines() in case a Tool parent class is
@@ -993,7 +1018,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 self.defines[k] = v
                 util.debug(f"Defined {k}={v}")
                 return None
-            self.error(f"Didn't understand +define+: '{plusarg}'")
+            self.error(f"Didn't understand +define+: '{plusarg}'",
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
             return None
 
         if plusarg.startswith('+incdir+'):
@@ -1005,7 +1031,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                     self.incdirs.append(os.path.abspath(incdir))
                     util.debug(f"Added include dir '{os.path.abspath(incdir)}'")
                 return None
-            self.error(f"Didn't understand +incdir+: '{plusarg}'")
+            self.error(f"Didn't understand +incdir+: '{plusarg}'",
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
             return None
 
         # remaining plusargs as stored in self.args['unprocessed-plusargs'] (list)
@@ -1019,7 +1046,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 # derived classes have the option to handle it
                 return plusarg
 
-        self.error(f"Didn't understand +plusarg: '{plusarg}'")
+        self.error(f"Didn't understand +plusarg: '{plusarg}'",
+                   error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
         return None
 
 
@@ -1211,7 +1239,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                     found_target = True
                     break # move on to the next target
             if not found_target: # if STILL not found_this_target...
-                self.error(f"Unable to resolve {target=}")
+                self.error(f"Unable to resolve {target=}",
+                           error_code=status_constants.EDA_DEPS_TARGET_NOT_FOUND)
 
         # if we've found any target since being called, it means we found the one we were called for
         return found_target
@@ -1341,7 +1370,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
             if len(unparsed) == 0:
                 # 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}")
+                           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?
         remove_list = []
@@ -1395,7 +1425,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         # 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")
+            self.error(f"Didn't understand command remaining tokens {unparsed=} in CommandDesign",
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
 
         # handle a missing self.args['top'] with last filepath or last target:
         if not self.args.get('top', ''):
@@ -1428,7 +1459,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         if self.error_on_missing_top and not self.args.get('top', ''):
             self.error("Did not get a --top or DEPS top, required to run command",
-                       f"'{self.command_name}' for tool={self.args.get('tool', None)}")
+                       f"'{self.command_name}' for tool={self.args.get('tool', None)}",
+                       error_code=status_constants.EDA_COMMAND_MISSING_TOP)
 
         return unparsed
 
@@ -1930,7 +1962,8 @@ class CommandParallel(Command):
         bad_remaining_args = [x for x in single_cmd_unparsed if x.startswith('-')]
         if bad_remaining_args:
             self.error(f'for {self.command_name} {command=} the following args are unknown',
-                       f'{bad_remaining_args}')
+                       f'{bad_remaining_args}',
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
 
         # Remove unparsed args starting with '+', since those are commonly sent downstream to
         # single job (example, CommandSim plusargs).
@@ -1972,7 +2005,8 @@ class CommandParallel(Command):
 
             key = get_job_arg(job_dict, arg_name='job-name')
             if not key:
-                self.error(f'{job_dict=} needs to have a --job-name= arg attached')
+                self.error(f'{job_dict=} needs to have a --job-name= arg attached',
+                           error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
             if key not in job_names_count_dict:
                 job_names_count_dict[key] = 1
             else:

{opencos_eda-0.2.49 → opencos_eda-0.2.51}/opencos/eda_config.py

@@ -46,6 +46,7 @@ class Defaults:
     supported_config_auto_tools_order_keys = set([
         'exe', 'handlers',
         'requires_env', 'requires_py', 'requires_cmd', 'requires_in_exe_path',
+        'requires_vsim_helper',
         'disable-tools-multi',
     ])
     supported_config_tool_keys = set([
@@ -308,6 +309,11 @@ def write_eda_config_and_args(
         # Use deep copy b/c otherwise these are references to opencos.eda.
         data[x] = copy.deepcopy(getattr(command_obj_ref, x, ''))
 
+    # copy util.args
+    data['util'] = {
+        'args': util.args
+    }
+
     # fix some burried class references in command_obj_ref.config,
     # otherwise we won't be able to safe load this yaml, so cast as str repr.
     for k, v in getattr(command_obj_ref, 'config', {}).items():