opencos-eda 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

opencos/eda_base.py

@@ -24,9 +24,9 @@ from pathlib import Path
 from opencos import seed, util, files
 from opencos import eda_config
 
-from opencos.util import Colors
+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,9 +42,29 @@ 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(prog='eda options', add_help=False, allow_abbrev=False)
+    parser = argparse.ArgumentParser(
+        prog=f'{safe_emoji("🔎 ")}eda options', add_help=False, allow_abbrev=False
+    )
     parser.add_argument('-q', '--quit', action='store_true',
                         help=(
                             'For interactive mode (eda called with no options, command, or'
@@ -80,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
@@ -131,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>.
 
@@ -180,6 +211,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:
@@ -196,7 +231,7 @@ class Tool:
 
 
 class Command: # pylint: disable=too-many-public-methods
-    '''Base class for all: eda <command>
+    '''Base class for all: eda COMMAND
 
     The Command class should be used when you don't require files, otherwise consider
     CommandDesign.
@@ -233,21 +268,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': (
@@ -313,6 +381,18 @@ class Command: # pylint: disable=too-many-public-methods
             util.error(f"command '{self.command_name}' has previous errors")
         return self.status > 0
 
+    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.')
+
+
     def which_tool(self, command:str) -> str:
         '''Returns a str for the tool name used for the requested command'''
         return which_tool(command, config=self.config)
@@ -342,7 +422,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
@@ -462,7 +542,8 @@ class Command: # pylint: disable=too-many-public-methods
         if not tee_fpath and getattr(command_list, 'tee_fpath', None):
             tee_fpath = getattr(command_list, 'tee_fpath', '')
         if not quiet:
-            util.info(f"exec: {' '.join(command_list)} (in {work_dir}, {tee_fpath=})")
+            util.info(f"{safe_emoji('⏩ ')}exec: {' '.join(command_list)}",
+                      f"(in {work_dir}, {tee_fpath=})")
 
         stdout, stderr, return_code = subprocess_run_background(
             work_dir=work_dir,
@@ -484,7 +565,8 @@ class Command: # pylint: disable=too-many-public-methods
                 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})")
+                util.debug(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
@@ -564,7 +646,9 @@ class Command: # pylint: disable=too-many-public-methods
         # parsed.args-with-dashes is not legal python. Some of self.args.keys() still have - or _,
         # so this will handle both.
         # Also, preference is for self.args.keys(), to be str with - dashes
-        parser = argparse.ArgumentParser(prog='eda', add_help=False, allow_abbrev=False)
+        parser = argparse.ArgumentParser(
+            prog=f'{safe_emoji("🔎 ")}eda', add_help=False, allow_abbrev=False
+        )
         bool_action_kwargs = util.get_argparse_bool_action_kwargs()
 
         if not parser_arg_list:
@@ -601,20 +685,33 @@ class Command: # pylint: disable=too-many-public-methods
             # 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
 
@@ -712,7 +809,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.
         '''
@@ -724,7 +821,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
@@ -790,19 +887,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('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 = []
@@ -811,10 +905,18 @@ class Command: # pylint: disable=too-many-public-methods
             return
 
         if self.command_name:
-            lines.append(f"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("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 = []
@@ -824,44 +926,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"
@@ -980,6 +1084,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         self.files_vhd = []
         self.files_cpp = []
         self.files_sdc = []
+        self.files_py = []
+        self.files_makefile = []
         self.files_non_source = []
         self.files_caller_info = {}
         self.dep_shell_commands = [] # each list entry is a {}
@@ -1139,7 +1245,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 self.files[new_key] = True
 
         my_file_lists_list = [self.files_v, self.files_sv, self.files_vhd, self.files_cpp,
-                              self.files_sdc]
+                              self.files_sdc, self.files_py, self.files_makefile]
         for my_file_list in my_file_lists_list:
             for i,value in enumerate(my_file_list):
                 if value and isinstance(value, str) and \
@@ -1157,9 +1263,11 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         need to be copied or linked to the work-dir. For example, if some SV assumes it
         can $readmemh('file_that_is_here.txt') but we're running out of work-dir. Linking
         is the easy work-around vs trying to run-in-place of all SV files.
+
+        Note that we also include .py and Makefile(s) in this.
         '''
 
-        for fname in self.files_non_source:
+        for fname in self.files_non_source + self.files_py + self.files_makefile:
             _, leaf_fname = os.path.split(fname)
             destfile = os.path.join(self.args['work-dir'], leaf_fname)
             relfname = os.path.relpath(fname)
@@ -1518,7 +1626,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         # if we've found any target since being called, it means we found the one we were called for
         return found_target
 
-    def add_file( # pylint: disable=too-many-locals,too-many-branches
+    def add_file( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
             self, filename: str, use_abspath: bool = True, add_to_non_sources: bool = False,
             caller_info: str = '', forced_extension: str = ''
     ) -> str:
@@ -1543,6 +1651,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         cpp_file_ext_list = known_file_ext_dict.get('cpp', [])
         sdc_file_ext_list = known_file_ext_dict.get('synth_constraints', [])
         dotf_file_ext_list = known_file_ext_dict.get('dotf', [])
+        py_file_ext_list = known_file_ext_dict.get('python', [])
+        makefile_ext_list = known_file_ext_dict.get('makefile', [])
 
         if forced_extension:
             # If forced_extension='systemverilog', then use the first known extension for
@@ -1582,6 +1692,12 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                                caller_info=caller_info)
             dp.apply_args(args_list=[f'-f={file_abspath}'])
             del dp
+        elif file_ext in py_file_ext_list:
+            self.files_py.append(file_abspath)
+            util.debug(f"Added Python file {filename} as {file_abspath}")
+        elif file_ext in makefile_ext_list or os.path.split(filename)[1] == 'Makefile':
+            self.files_makefile.append(file_abspath)
+            util.debug(f"Added Makefile {filename} as {file_abspath}")
         else:
             # unknown file extension. In these cases we link the file to the working directory
             # so it is available (for example, a .mem file that is expected to exist with relative
@@ -2114,21 +2230,22 @@ class CommandParallel(Command):
                     work_queue.put((jobs_launched, command_list, job['name'], cwd))
                     suffix = "<START>"
                     if fancy_mode:
-                        util.fancy_print(job_text+suffix, worker)
+                        util.fancy_print(job_text + suffix, worker)
                     elif failed_jobs:
                         # if we aren't in fancy mode, we will print a START line, periodic RUNNING
                         # lines, and PASS/FAIL line per-job
-                        util.print_orange(job_text + Colors.yellow + suffix)
+                        util.print_yellow(job_text, end='')
+                        util.print_foreground_color(suffix)
                     else:
-                        util.print_yellow(job_text + Colors.yellow + suffix)
+                        util.print_foreground_color(job_text + suffix)
                 else:
                     # single-threaded job launch, we are going to print out job info as we start
                     # each job... no newline. since non-verbose silences the job and prints only
                     # <PASS>/<FAIL> after the trailing "..." we leave here
                     if failed_jobs:
-                        util.print_orange(job_text, end="")
-                    else:
                         util.print_yellow(job_text, end="")
+                    else:
+                        util.print_foreground_color(job_text, end="")
                     job_done_number = jobs_launched
                     job_done_name = job['name']
                     job_start_time = time.time()
@@ -2182,9 +2299,10 @@ class CommandParallel(Command):
                         if fancy_mode:
                             util.fancy_print(f"{job_text}{suffix}", t['worker'])
                         elif failed_jobs:
-                            util.print_orange(job_text + Colors.yellow + suffix)
+                            util.print_yellow(job_text, end='')
+                            util.print_foreground_color(suffix)
                         else:
-                            util.print_yellow(job_text + Colors.yellow + suffix)
+                            util.print_foreground_color(job_text + suffix)
 
             # shared job completion code
             # single or multi-threaded, we can arrive here to harvest <= 1 jobs, and need
@@ -2192,36 +2310,52 @@ class CommandParallel(Command):
             # printed, ready for pass/fail
             if job_done:
                 jobs_complete += 1
+                this_job_failed = False
                 if job_done_return_code is None or job_done_return_code:
-                    # embed the color code, to change color of pass/fail during the
-                    # util.print_orange/yellow below
                     if job_done_return_code == 124:
                         # bash uses 124 for bash timeout errors, if that was preprended to the
                         # command list.
-                        suffix = f"{Colors.red}<TOUT: {sprint_time(job_done_run_time)}>"
+                        suffix = (
+                            f"<TOUT{safe_emoji(' ❌')}:"
+                            f" {sprint_time(job_done_run_time)}>"
+                        )
+                        this_job_failed = True
                     else:
-                        suffix = f"{Colors.red}<FAIL: {sprint_time(job_done_run_time)}>"
+                        suffix = (
+                            f"<FAIL{safe_emoji(' ❌')}:"
+                            f" {sprint_time(job_done_run_time)}>"
+                        )
+                        this_job_failed = True
                     failed_jobs.append(job_done_name)
                 else:
-                    suffix = f"{Colors.green}<PASS: {sprint_time(job_done_run_time)}>"
+                    suffix = (
+                        f"<PASS{safe_emoji(' ✅')}:"
+                        f" {sprint_time(job_done_run_time)}>"
+                    )
                     passed_jobs.append(job_done_name)
                 # we want to print in one shot, because in fancy modes that's all that we're allowed
                 job_done_text = "" if job_done_quiet else sprint_job_line(job_done_number,
                                                                           job_done_name)
-                if failed_jobs:
-                    util.print_orange(f"{job_done_text}{suffix}")
-                else:
+                if this_job_failed:
+                    util.print_red(f"{job_done_text}{suffix}")
+                elif failed_jobs:
                     util.print_yellow(f"{job_done_text}{suffix}")
+                else:
+                    util.print_green(f"{job_done_text}{suffix}")
                 self.jobs_status[job_done_number-1] = job_done_return_code
 
             if not anything_done:
                 time.sleep(0.25) # if nothing happens for an iteration, chill out a bit
 
         if total_jobs:
-            emoji = "< :) >" if (len(passed_jobs) == total_jobs) else "< :( >"
-            util.info(sprint_job_line(final=True, job_name="jobs passed") + emoji, start="")
+            if len(passed_jobs) == total_jobs:
+                emojitxt = safe_emoji('😀', ':)')
+            else:
+                emojitxt = safe_emoji('😦', ':(')
+            util.info(sprint_job_line(final=True, job_name="jobs passed") + f"< {emojitxt} >",
+                      start="")
         else:
-            util.info("Parallel: <No jobs found>")
+            util.info(f"Parallel: <{safe_emoji('❓ ')}No jobs found>")
         # Make sure all jobs have a set status:
         for i, rc in enumerate(self.jobs_status):
             if rc is None or not isinstance(rc, int):

opencos/eda_config.py

@@ -15,6 +15,7 @@ import shutil
 import mergedeep
 
 from opencos import util
+from opencos.util import safe_emoji
 from opencos.utils.markup_helpers import yaml_safe_load, yaml_safe_writer
 
 class Defaults:
@@ -231,7 +232,7 @@ def get_config_merged_with_defaults(config:dict) -> dict:
 def get_argparser() -> argparse.ArgumentParser:
     '''Returns an ArgumentParser, handles --config-yml=<filename> arg'''
     parser = argparse.ArgumentParser(
-        prog='opencos eda config options', add_help=False, allow_abbrev=False
+        prog=f'{safe_emoji("🔎 ")}opencos eda config options', add_help=False, allow_abbrev=False
     )
     parser.add_argument('--config-yml', type=str, default=Defaults.config_yml,
                         help=('YAML filename to use for configuration (default'

opencos/eda_config_defaults.yml

@@ -94,6 +94,11 @@ file_extensions:
   dotf:
     - .f
     - .vc
+  python:
+    - .py
+  makefile:
+    - .mk
+
 
   inferred_top:
     # file extensions that we can infer "top" module from, if --top omitted.
@@ -332,7 +337,6 @@ tools:
       - "COCOTB_TEST_FAILED"
     log-must-strings:
       - "passed"
-      - "Cocotb test completed successfully!"
 
 
   quartus: