opencos-eda 0.2.50__tar.gz → 0.2.52__tar.gz

{opencos_eda-0.2.50/opencos_eda.egg-info → opencos_eda-0.2.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.50
+Version: 0.2.52
 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
@@ -15,4 +15,5 @@ Requires-Dist: schema>=0.7.7
 Requires-Dist: toml>=0.10.2
 Requires-Dist: yamllint>=1.35.1
 Requires-Dist: PySerial>=3.5
+Requires-Dist: cocotb>=2.0.0b1
 Dynamic: license-file

{opencos_eda-0.2.50 → opencos_eda-0.2.52}/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.50 → opencos_eda-0.2.52}/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.50 → opencos_eda-0.2.52}/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,11 +171,14 @@ 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:
@@ -273,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:
@@ -294,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.50 → opencos_eda-0.2.52}/opencos/commands/waves.py

@@ -32,6 +32,8 @@ class CommandWaves(CommandDesign):
 
     VSIM_TOOLS = set([
         'questa',
+        'questa_fse',
+        'riviera',
         'modelsim_ase',
     ])
 
@@ -137,13 +139,21 @@ class CommandWaves(CommandDesign):
                 self.error(f"Don't know how to open {wave_file} without one of",
                            f"{self.VSIM_TOOLS} in PATH")
         elif wave_file.endswith('.fst'):
-            if 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
+            if ('vaporview' in self.config['tools_loaded'] or \
+                'surfer' in self.config['tools_loaded']) and shutil.which('code'):
+                command_list = ['code', '-n', '.', wave_file]
+                self.exec(os.path.dirname(wave_file), command_list)
+            elif 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
                 command_list = ['gtkwave', wave_file]
                 self.exec(os.path.dirname(wave_file), command_list)
             else:
                 self.error(f"Don't know how to open {wave_file} without GtkWave in PATH")
         elif wave_file.endswith('.vcd'):
-            if 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
+            if ('vaporview' in self.config['tools_loaded'] or \
+                'surfer' in self.config['tools_loaded']) and shutil.which('code'):
+                command_list = ['code', '-n', '.', wave_file]
+                self.exec(os.path.dirname(wave_file), command_list)
+            elif 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
                 command_list = ['gtkwave', wave_file]
                 self.exec(os.path.dirname(wave_file), command_list)
             elif self._vsim_available(from_tools=self.VSIM_VCD_TOOLS):

{opencos_eda-0.2.50 → opencos_eda-0.2.52}/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.50 → opencos_eda-0.2.52}/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, vscode_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,36 @@ 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)
+
+        has_vscode_helper = True
+        needs_vscode_extensions = value.get('requires_vscode_extension', None)
+        if needs_vscode_extensions:
+            if not isinstance(needs_vscode_extensions, list):
+                util.error(
+                    f'eda config issue, tool {name}: requires_vscode_extension must be a list'
+                )
+            else:
+                vscode_helper.init() # only runs checks once internally
+                has_vscode_helper = all(
+                    x in vscode_helper.EXTENSIONS for x in needs_vscode_extensions
+                )
+
         if has_all_exe:
             requires_cmd_list = value.get('requires_cmd', [])
             for cmd in requires_cmd_list:
@@ -219,7 +243,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, has_vscode_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.50 → opencos_eda-0.2.52}/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
@@ -274,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
@@ -416,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:
@@ -437,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]
 
@@ -568,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)
 
@@ -630,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
 
@@ -650,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
 
 
@@ -692,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
@@ -1006,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+'):
@@ -1018,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)
@@ -1032,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
 
 
@@ -1224,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
@@ -1354,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 = []
@@ -1408,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', ''):
@@ -1441,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
 
@@ -1943,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).
@@ -1985,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.50 → opencos_eda-0.2.52}/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', 'requires_vscode_extension',
         'disable-tools-multi',
     ])
     supported_config_tool_keys = set([