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

opencos/eda_base.py

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

opencos/eda_config.py

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

opencos/eda_config_defaults.yml

@@ -20,11 +20,33 @@ DEFAULT_HANDLERS:
   sweep       : opencos.commands.CommandSweep
   flist       : opencos.commands.CommandFList
   # These commands (waves, export, targets) do not require a tool, or
-  # will self determine the tool:
+  # will self determine the tool. See command_tool_is_optional in this config file.
   waves       : opencos.commands.CommandWaves
   export      : opencos.commands.CommandExport
   shell       : opencos.commands.CommandShell
   targets     : opencos.commands.CommandTargets
+  deps-help   : opencos.commands.CommandDepsHelp
+
+DEFAULT_HANDLERS_HELP:
+  sim:         Simulates a DEPS target.
+  elab:        Elaborates a DEPS target (lint, tool specific).
+  synth:       Synthesizes a DEPS target.
+  flist:       Create dependency from a DEPS target.
+  proj:        Create a project from a DEPS target for GUI sim/waves/debug.
+  multi:       Run multiple DEPS targets, serially or in parallel.
+  tools-multi: Same as 'multi' but run on all available tools, or specfied using --tools.
+  sweep:       Sweep one or more arguments across a range, serially or in parallel.
+  build:       Build for a board, creating a project and running build flow.
+  waves:       Opens waveform from prior simulation.
+  upload:      Uploads a finished design into hardware.
+  open:        Opens a project.
+  export:      Export files related to a target, tool independent.
+  shell:       Runs only commands for DEPS target (like sim or elab, but stops prior to tool).
+  targets:     List all possible targets given glob path.
+  lec:         Run equivalence on two designs.
+  deps-help:   Provide help about DEPS markup files, or schema using --verbose or --help.
+  help:        This help (without args), or i.e. "eda help sim" for specific help.
+
 
 
 defines: { } # Add these defines to every eda call
@@ -40,6 +62,7 @@ dep_command_enables:
 dep_tags_enables:
   with-tools:            true
   with-args:             true
+  with-commands:         true
   args:                  true
   replace-config-tools:  true
   additive-config-tools: true
@@ -83,6 +106,7 @@ command_tool_is_optional:
   - flist
   - export
   - targets
+  - deps-help
 
 
 tools:
@@ -234,6 +258,9 @@ tools:
       - 2555 # 2555 - assignment to input port myname
       - 2583 # 2583 - [SVCHK] - Extra checking for conflicts with always_comb and
              #        always_latch variables is done at vopt time.
+      - 13159 # 13159, 2685, 2718 are all related to module instance port default values.
+      - 2685
+      - 2718
     simulate-waivers:
       - 3009 # 3009: [TSCALE] - Module 'myname' does not have a timeunit/timeprecision
              #       specification in effect, but other modules do.
@@ -256,6 +283,9 @@ tools:
       - 2555 # 2555 - assignment to input port myname
       - 2583 # 2583 - [SVCHK] - Extra checking for conflicts with always_comb and
              #        always_latch variables is done at vopt time.
+      - 13159 # 13159, 2685, 2718 are all related to module instance port default values.
+      - 2685
+      - 2718
     simulate-waivers:
       - 3009 # 3009: [TSCALE] - Module 'myname' does not have a timeunit/timeprecision
              #       specification in effect, but other modules do.
@@ -295,6 +325,10 @@ tools:
       - "Cocotb test completed successfully!"
 
 
+  quartus:
+    defines:
+      OC_TOOL_QUARTUS: null
+
   vivado:
     sim-libraries:
       - xil_defaultlib
@@ -375,6 +409,16 @@ auto_tools_order:
       exe: gtkwave
       handlers: { }
 
+    quartus:
+      exe: quartus_sh
+      handlers:
+        synth: opencos.tools.quartus.CommandSynthQuartus
+        build: opencos.tools.quartus.CommandBuildQuartus
+        flist: opencos.tools.quartus.CommandFListQuartus
+        proj: opencos.tools.quartus.CommandProjQuartus
+        upload: opencos.tools.quartus.CommandUploadQuartus
+        open: opencos.tools.quartus.CommandOpenQuartus
+
     vivado:
       exe: vivado
       handlers:
@@ -425,8 +469,9 @@ auto_tools_order:
       exe: qrun
       requires_vsim_helper: True
       handlers:
-        elab: opencos.tools.queta.CommandElabQuesta
-        sim: opencos.tools.queta.CommandSimQuesta
+        elab: opencos.tools.questa.CommandElabQuesta
+        sim: opencos.tools.questa.CommandSimQuesta
+        flist: opencos.tools.questa.CommandFListQuesta
 
     riviera:
       exe: vsim
@@ -450,6 +495,7 @@ auto_tools_order:
       handlers:
         elab: opencos.tools.questa_fse.CommandElabQuestaFse
         sim:  opencos.tools.questa_fse.CommandSimQuestaFse
+        flist: opencos.tools.questa_fse.CommandFListQuestaFse
 
     iverilog:
       exe: iverilog

opencos/eda_extract_targets.py

@@ -10,68 +10,11 @@ import os
 from pathlib import Path
 
 from opencos.deps.deps_file import get_all_targets
+from opencos.utils.str_helpers import print_columns_manual
 
 PATH_LPREFIX = str(Path('.')) + os.path.sep
 
 
-def get_terminal_columns():
-    """
-    Retrieves the number of columns (width) of the terminal window.
-
-    Returns:
-        int: The number of columns in the terminal, or a default value (e.g., 80)
-             if the terminal size cannot be determined.
-    """
-    try:
-        size = os.get_terminal_size()
-        return size.columns
-    except OSError:
-        # Handle cases where the terminal size cannot be determined (e.g., not in a TTY)
-        return 80  # Default to 80 columns
-
-    return 80 # else default to 80.
-
-
-def print_columns_manual(data: list, num_columns: int = 4, auto_columns: bool = True) -> None:
-    """Prints a list of strings in columns, manually aligning them."""
-
-    if not data:
-        print()
-        return
-
-    _spacing = 2
-
-    # Calculate maximum width for each column
-    max_lengths = [0] * num_columns
-    max_item_len = 0
-    for i, item in enumerate(data):
-        col_index = i % num_columns
-        max_lengths[col_index] = max(max_lengths[col_index], len(item))
-        max_item_len = max(max_item_len, len(item))
-
-    if auto_columns and num_columns > 1:
-        window_cols = get_terminal_columns()
-        max_line_len = 0
-        for x in max_lengths:
-            max_line_len += x + _spacing
-        if max_line_len > window_cols:
-            # subtract a column (already >= 2):
-            print_columns_manual(data=data, num_columns=num_columns-1, auto_columns=True)
-            return
-        if max_line_len + max_item_len + _spacing < window_cols:
-            # add 1 more column if we're guaranteed to have room.
-            print_columns_manual(data=data, num_columns=num_columns+1, auto_columns=True)
-            return
-        # else continue
-
-    # Print data in columns
-    for i, item in enumerate(data):
-        col_index = i % num_columns
-        print(item.ljust(max_lengths[col_index] + _spacing), end="")  # Add padding
-        if col_index == num_columns - 1 or i == len(data) - 1:
-            print() # New line at the end of a row or end of data
-
-
 def get_path_and_pattern(partial_path: str = '', base_path=str(Path('.'))) -> (str, str):
     '''Returns tuple of (partial_path, partial_target or filter)'''
 

opencos/tests/helpers.py

@@ -12,6 +12,22 @@ from contextlib import redirect_stdout, redirect_stderr
 from opencos import eda
 from opencos import deps_schema
 from opencos.utils.markup_helpers import yaml_safe_load
+from opencos.utils import status_constants
+
+
+def eda_wrap_is_sim_fail(rc: int, quiet: bool = False) -> bool:
+    '''Because eda_wrap calls eda_main(..) and will continue running
+
+    after the first error, we may get a higher return code.'''
+    if not quiet:
+        print(f'eda_wrap_is_sim_fail({rc=})')
+    return rc in (
+        status_constants.EDA_COMMAND_MISSING_TOP,
+        status_constants.EDA_SIM_LOG_HAS_BAD_STRING,
+        status_constants.EDA_SIM_LOG_MISSING_MUST_STRING,
+        status_constants.EDA_EXEC_NONZERO_RETURN_CODE2,
+        status_constants.EDA_DEFAULT_ERROR
+    )
 
 def can_run_eda_command(*commands, config: dict) -> bool:
     '''Returns True if we have any installed tool that can run: eda <command>'''