opencos-eda 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

opencos/eda_base.py

@@ -26,7 +26,7 @@ from opencos import eda_config
 
 from opencos.util import Colors, safe_emoji
 from opencos.utils.str_helpers import sprint_time, strip_outer_quotes, string_or_space, \
-    indent_wrap_long_text, pretty_list_columns_manual
+    indent_wrap_long_text, pretty_list_columns_manual, get_terminal_columns
 from opencos.utils.subprocess_helpers import subprocess_run_background
 from opencos.utils import status_constants
 
@@ -42,6 +42,24 @@ def print_base_help() -> None:
     print(get_argparser_short_help())
 
 
+def print_eda_usage_line(no_targets: bool = False, command_name='COMMAND') -> None:
+    '''Prints line for eda [options] COMMAND [options] FILES|TARGETS,...'''
+    print(f'{safe_emoji("🔦 ")}Usage:')
+    if no_targets:
+        print(
+            (f'    {Colors.bold}{Colors.yellow}eda {Colors.cyan}[options]'
+             f' {Colors.yellow}{command_name} {Colors.cyan}[options]{Colors.normal}')
+        )
+    else:
+        print(
+            (f'    {Colors.bold}{Colors.yellow}eda {Colors.cyan}[options]'
+             f' {Colors.yellow}{command_name} {Colors.cyan}[options]'
+             f' {Colors.yellow}FILES|TARGETS,...{Colors.normal}')
+        )
+    print()
+
+
+
 def get_argparser() -> argparse.ArgumentParser:
     '''Returns the ArgumentParser for general eda CLI'''
     parser = argparse.ArgumentParser(
@@ -82,7 +100,7 @@ def get_argparsers_args_list() -> list:
 
 
 def get_eda_exec(command: str = '') -> str:
-    '''Returns the full path of `eda` executable to be used for a given eda <command>'''
+    '''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'
     # is one of:
     # 1. pip3 install opencos-eda
@@ -133,6 +151,17 @@ def which_tool(command: str, config: dict) -> str:
     return tool
 
 
+def get_class_tool_name(command_obj: object) -> str:
+    '''Attempts to return command_obj._TOOL via command_obj.get_tool_name()'''
+    if f := getattr(command_obj, 'get_tool_name', None):
+        if callable(f):
+            ret = f()
+            if ret and isinstance(ret, str):
+                return ret
+    return ''
+
+
+
 class Tool:
     '''opencos.eda_base.Tool is a base class used by opencos.tools.<name>.
 
@@ -149,6 +178,10 @@ class Tool:
         # a Command object's self.args instead of the class Tool.args. Safely create it
         # if it doesn't exist:
         self._VERSION = None
+
+        self.tool_warning_count = 0
+        self.tool_error_count = 0
+
         if getattr(self, 'args', None) is None:
             self.args = {}
         if getattr(self, 'args_help', None) is None:
@@ -182,6 +215,10 @@ class Tool:
                 util.info(f'Override for {self._TOOL} using exe {exe}')
                 self._EXE = exe
 
+    def get_tool_name(self) -> str:
+        '''Returns _TOOL'''
+        return str(self._TOOL)
+
     def get_full_tool_and_versions(self) -> str:
         '''Returns tool:version, such as: verilator:5.033'''
         if not self._VERSION:
@@ -192,13 +229,31 @@ class Tool:
         '''Sets and returns self._VERSION'''
         return self._VERSION
 
+    def report_tool_warn_error_counts(self) -> None:
+        '''Reports info line based on self.tool_error_count and self.tool_warning_count.'''
+        tool_name = get_class_tool_name(self)
+        if not tool_name:
+            return
+
+        info_color = Colors.green
+        start = ''
+        if self.tool_error_count or self.tool_warning_count:
+            start = safe_emoji('🔶 ')
+            info_color = Colors.yellow
+        util.info(
+            f"{start}Tool - {tool_name}, total counts:",
+            f"{Colors.bold}{self.tool_warning_count} tool warnings{Colors.normal}{info_color},",
+            f"{Colors.bold}{self.tool_error_count} tool errors",
+            color=info_color
+        )
+
     def set_tool_defines(self) -> None:
         '''Derived classes may override, sets any additional defines based on tool.'''
         return
 
 
-class Command: # pylint: disable=too-many-public-methods
-    '''Base class for all: eda <command>
+class Command: # pylint: disable=too-many-public-methods,too-many-instance-attributes
+    '''Base class for all: eda COMMAND
 
     The Command class should be used when you don't require files, otherwise consider
     CommandDesign.
@@ -211,6 +266,8 @@ class Command: # pylint: disable=too-many-public-methods
             self.args = {}
         if getattr(self, 'args_help', None) is None:
             self.args_help = {}
+        if getattr(self, 'args_kwargs', None) is None:
+            self.args_kwargs = {}
         self.args.update({
             "keep" : False,
             "force" : False,
@@ -235,21 +292,54 @@ class Command: # pylint: disable=too-many-public-methods
             'error-unknown-args': True,
         })
         self.args_help.update({
-            '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',
+            'keep': (
+                'Determined by eda <tool>, generally prevents jobs from overwriting artifacts'
+            ),
+            'force': 'Determined by eda <tool>, force override',
+            'fake': (
+                'Determined by eda <tool>, generally is a dry-run that does not execute tool'
+            ),
+            'stop-before-compile': (
+                'stop this run before any compile steps (if possible for tool) and'
+                ' save .sh scripts in eda-dir/'
+            ),
+            'stop-after-compile': (
+                'stop this run after any compile steps (if possible for tool) and'
+                ' save .sh scripts in eda-dir/'
+            ),
+            'stop-after-elaborate': (
+                'stop this run after any elaborate steps (if possible for tool) and'
+                ' save .sh scripts in eda-dir/'
+            ),
+            'lint': 'tool dependent, run with linting options',
+            "job-name" : 'Optional, used to create a sub directory under base work-dir (eda-dir)',
+            "sub-work-dir" : (
+                'Optional, similar to job-name, can be used to name the directory created under'
+                ' eda-dir'
+            ),
+            'eda-dir':   'Optional, relative base 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>'),
+            'work-dir':    ('Optional override for working directory, if unset will often use '
+                            ' ./eda.work/[TOP|TARGET].COMMAND'),
             "work-dir-use-target-dir": ('Set the work-dir to be the same as the in-place location'
                                        ' where the target (DEPS) exists'),
-            '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.'),
+            "suffix": (
+                "Optional, determined by eda COMMAND, used by 'multi' jobs information logging"
+            ),
+            "design": (
+                "Optional, used to override both the work-dir, and if unset the top DEPS target"
+            ),
+            'enable-tags': (
+                'DEPS markup tag names to be force enabled for this'
+                ' command (mulitple appends to list).'
+            ),
+            'disable-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.'),
             'error-unknown-args': (
@@ -266,6 +356,13 @@ class Command: # pylint: disable=too-many-public-methods
         self.tool_changed_respawn = {}
 
 
+    def get_info_job_name(self) -> str:
+        '''Returns an informational string of the job name, using: command - tool - top'''
+        return ' - '.join(
+            x for x in (self.command_name, self.args.get('tool', ''),
+                        self.args.get('top', '')) if x
+        )
+
     def error(self, *args, **kwargs) -> None:
         '''Returns None, child classes can call self.error(..) instead of util.error,
 
@@ -293,7 +390,6 @@ class Command: # pylint: disable=too-many-public-methods
                     f'ERROR: [eda] ({self.command_name}) {" ".join(list(args))}',
                     file=self.errors_log_f
                 )
-
         self.status = util.error(*args, **kwargs) # error_code passed and returned via kwargs
 
     def stop_process_tokens_before_do_it(self) -> bool:
@@ -308,24 +404,28 @@ class Command: # pylint: disable=too-many-public-methods
             return True
         return False
 
-    def status_any_error(self, report=True) -> bool:
+    def status_any_error(self, report: bool = 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()'''
-        if report and self.status > 0:
+        and to not perform the command. Necessary for pytests that use eda.main()
+
+        Note we also check any parent Tool class for tool_error_count > 0
+        '''
+        any_err = False
+        if self.status > 0:
+            any_err = True
+        elif isinstance(self, Tool) and getattr(self, 'tool_error_count', 0):
+            util.warning(f'eda_base.py internal: Command status={self.status}, but',
+                         f'Tool tool_error_count={getattr(self, "tool_error_count", 0)}')
+            any_err = True
+        if report and any_err:
             util.error(f"command '{self.command_name}' has previous errors")
-        return self.status > 0
+        return any_err
 
     def report_pass_fail(self) -> None:
         '''Reports an INFO line with pass/fail information'''
-        job_name = ' - '.join(
-            x for x in (self.command_name, self.args.get('tool', ''),
-                        self.args.get('top', '')) if x
-        )
-        if self.status_any_error():
-            util.info(f'{safe_emoji("❌ ")}{job_name}: Errors observed.', color=Colors.red)
-        else:
-            util.info(f'{safe_emoji("✅ ")}{job_name}: No errors observed.')
-
+        job_name = self.get_info_job_name()
+        if not self.status_any_error():
+            util.info(f'{safe_emoji("✅ ")}{job_name}: {Colors.bold}No errors observed.')
 
     def which_tool(self, command:str) -> str:
         '''Returns a str for the tool name used for the requested command'''
@@ -356,7 +456,7 @@ class Command: # pylint: disable=too-many-public-methods
     ) -> str:
         '''Creates the working directory and populates self.args['work-dir']
 
-        Generally uses ./ self.args['eda-dir'] / <target-name>.<command> /
+        Generally uses ./ self.args['eda-dir'] / TARGET-NAME.COMMAND /
         however, self.args['job-name'] or ['sub-work-dir'] can override that.
 
         Additionally, the work-dir is attempted to be deleted if it already exists
@@ -491,16 +591,17 @@ class Command: # pylint: disable=too-many-public-methods
         if return_code > 0:
             if return_code == 1:
                 self.status = status_constants.EDA_EXEC_NONZERO_RETURN_CODE1
-            if return_code == 255:
+            elif 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})",
                            error_code=self.status)
             else:
-                util.debug(f"{safe_emoji('❌ ')}exec: returned with error (return code:",
-                           f"{return_code})")
+                util.info(f"{safe_emoji('❌ ')}exec: returned with error (return code:",
+                          f"{return_code})")
         else:
             util.debug(f"exec: returned without error (return code: {return_code})")
         return stderr, stdout, return_code
@@ -614,25 +715,42 @@ class Command: # pylint: disable=too-many-public-methods
                 help_kwargs = {'help': f'{type(value).__name__} default={value}'}
             help_kwargs['help'] = help_kwargs['help'].replace('%', '%%')
 
+            # Update with any self.args_kwargs for this key
+            if self.args_kwargs.get(key, {}):
+                help_kwargs.update(self.args_kwargs.get(key, {}))
+
 
             # It's important to set the default=None on these, except for list types where default
             # is []. If the parsed Namespace has values set to None or [], we do not update. This
             # means that as deps are processed that have args set, they cannot override the top
             # level args that were already set, nor be overriden by defaults.
-            if isinstance(value, bool):
-                # For bool, support --key and --no-key with action=argparse.BooleanOptionalAction.
-                # Note, this means you cannot use --some-bool=True, or --some-bool=False, has to
-                # be --some-bool or --no-some-bool.
-                parser.add_argument(
-                    *arguments, default=None, **bool_action_kwargs, **help_kwargs)
-            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)
-            elif value is None:
-                parser.add_argument(*arguments, default=None, **help_kwargs)
-            else:
-                assert False, f'{key=} {value=} how do we do argparse for this type of value?'
+            try:
+                if isinstance(value, bool):
+                    # For bool, support --key and --no-key with
+                    # action=argparse.BooleanOptionalAction. Note, this means you cannot use
+                    # --some-bool=True, or --some-bool=False, has to be --some-bool or
+                    # --no-some-bool.
+                    # Also we cannot have self.args.keys() that start with 'no-', which is
+                    # why this entire thing is wrapped with try/except.
+                    parser.add_argument(
+                        *arguments, default=None, **bool_action_kwargs, **help_kwargs)
+                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)
+                elif value is None:
+                    parser.add_argument(*arguments, default=None, **help_kwargs)
+                else:
+                    assert False, f'{key=} {value=} how do we do argparse for this type of value?'
+            except Exception as e:
+                if isinstance(value, bool):
+                    self.error(f'Could not add argument: {key=} {value=} {type(value)=}',
+                               f'{arguments=} {bool_action_kwargs=} {help_kwargs=} {e=}')
+                else:
+                    self.error(f'Could not add argument: {key=} {value=} {type(value)=}',
+                               f'{arguments=} {help_kwargs=} {e=}')
+
+
 
         return parser
 
@@ -730,7 +848,7 @@ class Command: # pylint: disable=too-many-public-methods
     def get_command_from_unparsed_args(
             self, tokens: list, error_if_no_command: bool = True
     ) -> str:
-        '''Given a list of unparsed args, try to fish out the eda <command> value.
+        '''Given a list of unparsed args, try to fish out the eda COMMAND value.
 
         This will remove the value from the tokens list.
         '''
@@ -742,7 +860,7 @@ class Command: # pylint: disable=too-many-public-methods
                 break
 
         if not ret and error_if_no_command:
-            self.error(f"Looking for a valid eda {self.command_name} <command>",
+            self.error(f"Looking for a valid eda {self.command_name} COMMAND",
                        f"but didn't find one in {tokens=}",
                        error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
         return ret
@@ -808,19 +926,16 @@ class Command: # pylint: disable=too-many-public-methods
         if self.args_help has additional help information.
         '''
 
-        # Indent long lines (>100) to indent=56 (this is where we leave off w/ {vstr:12} below.
-        def indent_me(text:str):
-            return indent_wrap_long_text(text, width=100, indent=56)
+        # Indent long lines (>100) to indent=24 (this is where usual argparse help leaves off)
+        def indent_me(text: str, initial_indent: int = 23):
+            return indent_wrap_long_text(
+                ' ' * initial_indent + text, width=get_terminal_columns(), indent=24
+            )
 
-        util.info('Help:')
+        util.info('Help:', color=Colors.cyan)
         # using bare 'print' here, since help was requested, avoids --color and --quiet
         print()
-        print(f'{safe_emoji("🔦 ")}Usage:')
-        if no_targets:
-            print(f'    eda [options] {self.command_name} [options]')
-        else:
-            print(f'    eda [options] {self.command_name} [options] [files|targets, ...]')
-        print()
+        print_eda_usage_line(no_targets=no_targets, command_name=self.command_name)
 
         print_base_help()
         lines = []
@@ -829,10 +944,18 @@ class Command: # pylint: disable=too-many-public-methods
             return
 
         if self.command_name:
-            lines.append(f"{safe_emoji('🔧 ')}Generic help for command='{self.command_name}'"
-                         f" (using '{self.__class__.__name__}')")
+            line = (
+                f"{safe_emoji('🔧 ')}{Colors.cyan}Generic help for"
+                f" command={Colors.byellow}{self.command_name}{Colors.cyan}"
+            )
+            if tool := get_class_tool_name(self):
+                line += f" tool={Colors.byellow}{tool}"
+            line += f" {Colors.normal}(using '{self.__class__.__name__}')"
+            lines.append(line)
         else:
-            lines.append("{safe_emoji('🔧 ')}Generic help (from class Command):")
+            lines.append(
+                f"{safe_emoji('🔧 ')}{Colors.cyan}Generic help:{Colors.normal}"
+            )
 
         # Attempt to run argparser on args, but don't error if it fails.
         unparsed = []
@@ -842,44 +965,46 @@ class Command: # pylint: disable=too-many-public-methods
             except Exception:
                 pass
 
-        for k in sorted(self.args.keys()):
-            v = self.args[k]
-            vstr = str(v)
-            khelp = self.args_help.get(k, '')
-            if khelp:
-                khelp = f'  - {khelp}'
-            if isinstance(v, bool):
-                lines.append(indent_me(f"  --{k:20} : boolean    : {vstr:12}{khelp}"))
-            elif isinstance(v, int):
-                lines.append(indent_me(f"  --{k:20} : integer    : {vstr:12}{khelp}"))
-            elif isinstance(v, list):
-                lines.append(indent_me(f"  --{k:20} : list       : {vstr:12}{khelp}"))
-            elif isinstance(v, str):
-                vstr = "'" + v + "'"
-                lines.append(indent_me(f"  --{k:20} : string     : {vstr:12}{khelp}"))
-            else:
-                lines.append(indent_me(f"  --{k:20} : <unknown>  : {vstr:12}{khelp}"))
+        short_help_lines = util.get_argparser_short_help(
+            parser=self.get_argparser(support_underscores=False)
+        ).split('\n')
+        short_help_lines.pop(0) # Strip first line w/ argparser prog name
+        lines.extend(short_help_lines)
+
+        # For these custom args, -GParameter=Value, +define+Name[=value] +incdir+path
+        # make colors to look like python >= 3.14, if that is our version.
+        color = Colors()
+        if sys.version_info.major < 3 or \
+           (sys.version_info.major == 3 and sys.version_info.minor < 14):
+            color.disable() # strip our color object if < 3.14
+
 
         lines.append('')
+        lines.append(
+            f"  {color.cyan}-G{color.byellow}<parameterName>{color.normal}=" \
+            + f"{color.yellow}<value>{color.normal}"
+        )
         lines.append(indent_me((
-            "  -G<parameterName>=<value>      "
             " Add parameter to top level, support bit/int/string types only."
             " Example: -GDEPTH=8 (DEPTH treated as SV int/integer)."
             " -GENABLE=1 (ENABLED treated as SV bit/int/integer)."
             " -GName=eda (Name treated as SV string \"eda\")."
         )))
+
+        lines.append(f"  {color.cyan}+define+{color.byellow}<defineName>{color.normal}")
         lines.append(indent_me((
-            "  +define+<defineName>           "
             " Add define w/out value to tool ahead of SV sources"
             " Example: +define+SIM_SPEEDUP"
         )))
+        lines.append(
+            f"  {color.cyan}+define+{color.byellow}<defineName>{color.normal}=" \
+            + f"{color.yellow}<value>{color.normal}")
         lines.append(indent_me((
-            "  +define+<defineName>=<value>   "
             " Add define w/ value to tool ahead of SV sources"
             " Example: +define+TECH_LIB=2 +define+FULL_NAME=\"E D A\""
         )))
+        lines.append(f"  {color.cyan}+incdir+{color.byellow}PATH{color.normal}")
         lines.append(indent_me((
-            "  +incdir+<path>                 "
             " Add path (absolute or relative) for include directories"
             " for SystemVerilog `include \"<some-file>.svh\""
             " Example: +incdir+../lib"
@@ -954,6 +1079,26 @@ class Command: # pylint: disable=too-many-public-methods
             util.warning(*msg)
 
 
+    def update_tool_warn_err_counts_from_log_lines(
+            self, log_lines: list, bad_strings: list, warning_strings: list
+    ) -> None:
+        '''Given lines (list of str) from a log, update self.tool_[error|warning]_count values
+
+        Since Tool class is not always a parent in Command/CommandDesign/CommandSim, we
+        have to modfiy these member names safely for pylint.
+
+        Derived classes may override this, especially if the Tool is known and reports
+        the complete error/warning summary counts in a certain way.
+        '''
+        if not isinstance(self, Tool):
+            return
+        for line in log_lines:
+            if any(bad_str in line for bad_str in bad_strings):
+                setattr(self, 'tool_error_count', getattr(self, 'tool_error_count', 0) + 1)
+            if any(warn_str in line for warn_str in warning_strings):
+                setattr(self, 'tool_warning_count', getattr(self, 'tool_warning_count', 0) + 1)
+
+
 class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
     '''CommandDesign is the eda base class for command handlers that need to track files.
 

opencos/eda_config.py

@@ -57,6 +57,7 @@ class Defaults:
         'defines',
         'log-bad-strings',
         'log-must-strings',
+        'log-warning-strings',
         'sim-libraries',
         'compile-args',
         'compile-waves-args',

opencos/eda_config_defaults.yml

@@ -154,6 +154,8 @@ tools:
 
   verilator:
     defines: { }
+    log-warning-strings:
+      - "%Warning"
     log-bad-strings:
       - "%Error"
       - "%Fatal"
@@ -239,8 +241,11 @@ tools:
     defines:
       OC_TOOL_RIVIERA: 1
       RIVIERA: 1
+    log-warning-strings:
+      - "Warning: "
     log-bad-strings:
-      - "Error:"
+      - "Error: "
+      - "Fatal: "
     log-must-strings:
       - "VSIM: Simulation has finished"
     compile-args: |
@@ -261,8 +266,11 @@ tools:
     defines:
       OC_ASSERT_PROPERTY_NOT_SUPPORTED: 1
       OC_TOOL_MODELSIM_ASE: 1
+    log-warning-strings:
+      - "Warning: "
     log-bad-strings:
-      - "Error:"
+      - "Error: "
+      - "Fatal: "
     log-must-strings:
       - " vsim "
       - "Errors: 0"
@@ -286,8 +294,11 @@ tools:
   questa_fse:
     defines:
       OC_TOOL_QUESTA_FSE: 1
+    log-warning-strings:
+      - "Warning: "
     log-bad-strings:
-      - "Error:"
+      - "Error: "
+      - "Fatal: "
     log-must-strings:
       - " vsim "
       - "Errors: 0"
@@ -309,6 +320,9 @@ tools:
 
 
   iverilog:
+    log-warning-strings:
+      - "Warning:"
+      - "WARNING:"
     log-bad-strings:
       - "Error:"
       - "ERROR:"
@@ -328,6 +342,9 @@ tools:
   cocotb:
     defines:
       OC_TOOL_COCOTB: null
+    log-warning-strings:
+      - "Warning:"
+      - "WARNING:"
     log-bad-strings:
       - "ERROR"
       - "FAILED"
@@ -344,6 +361,14 @@ tools:
       OC_TOOL_QUARTUS: null
 
   vivado:
+    log-warning-strings:
+      - "WARNING: "
+      - "Warning: "
+    log-bad-strings:
+      - "FATAL: "
+      - "Fatal: "
+      - "ERROR: "
+      - "Error: "
     sim-libraries:
       - xil_defaultlib
       - unisims_ver

opencos/tests/deps_files/command_order/DEPS.yml

@@ -29,3 +29,16 @@ target_test_with_post_tool_commands:
           run-after-tool: true
     - target_echo_hi_bye
   top: foo
+
+
+test_run_from_work_dir:
+  deps:
+    - commands:
+        - shell: echo "pwd=$PWD"
+          run-from-work-dir: true
+
+test_run_from_work_dir_false:
+  deps:
+    - commands:
+        - shell: echo "pwd=$PWD"
+          run-from-work-dir: false

opencos/tests/helpers.py

@@ -10,8 +10,8 @@ from pathlib import Path
 from contextlib import redirect_stdout, redirect_stderr
 
 from opencos import eda, eda_tool_helper, deps_schema
-from opencos.utils.markup_helpers import yaml_safe_load
 from opencos.utils import status_constants
+from opencos.utils.markup_helpers import yaml_safe_load
 from opencos.utils.subprocess_helpers import subprocess_run_background
 
 # Figure out what tools the system has available, without calling eda.main(..)
@@ -238,7 +238,7 @@ class Helpers:
 
     def log_it(
             self, command_str: str, logfile=None, use_eda_wrap: bool = True,
-            run_in_subprocess: bool = False,
+            run_in_subprocess: bool = False, include_default_log: bool = False,
             preserve_env: bool = False
     ) -> int:
         '''Replacement for calling eda.main or eda_wrap, when you want an internal logfile
@@ -257,13 +257,17 @@ class Helpers:
         logfile = self._resolve_logfile(logfile)
         rc = 50
 
+        eda_log_arg = '--no-default-log'
+        if include_default_log:
+            eda_log_arg = ''
+
         # TODO(drew): There are some issues with log_it redirecting stdout from vivado
         # and modelsim_ase. So this may not work for all tools, you may have to directly
         # look at eda.work/{target}.sim/sim.log or xsim.log.
         print(f'{os.getcwd()=}')
         print(f'{command_str=}')
         if run_in_subprocess or self.RUN_IN_SUBPROCESS:
-            command_list = ['eda', '--no-default-log'] + command_str.split()
+            command_list = ['eda', eda_log_arg] + command_str.split()
             _, _, rc = subprocess_run_background(
                 work_dir=self.DEFAULT_DIR,
                 command_list=command_list,
@@ -275,9 +279,9 @@ class Helpers:
             with open(logfile, 'w', encoding='utf-8') as f:
                 with redirect_stdout(f), redirect_stderr(f):
                     if use_eda_wrap or self.USE_EDA_WRAP:
-                        rc = eda_wrap('--no-default-log', *(command_str.split()))
+                        rc = eda_wrap(eda_log_arg, *(command_str.split()))
                     else:
-                        rc = eda.main('--no-default-log', *(command_str.split()))
+                        rc = eda.main(eda_log_arg, *(command_str.split()))
                 print(f'Wrote: {os.path.abspath(logfile)=}')
 
         if self.PRESERVE_ENV or preserve_env:

opencos/tests/test_eda.py

@@ -648,7 +648,7 @@ class TestsRequiresIVerilog(Helpers):
         print(f'{rc=}')
         assert rc == 0
         assert self.is_in_log('Detected iverilog')
-        assert self.is_in_log("Generic help for command='sim' (using 'CommandSimIverilog')")
+        assert self.is_in_log("Generic help for command=sim tool=iverilog")
 
     def test_iverilog_sim(self):
         '''Test for command sim'''