opencos-eda 0.2.46__py3-none-any.whl → 0.2.48__py3-none-any.whl

opencos/commands/multi.py

@@ -68,7 +68,7 @@ class CommandMulti(CommandParallel):
         return command, level
 
 
-    def resolve_path_and_target_patterns(
+    def resolve_path_and_target_patterns( # pylint: disable=too-many-locals
             self, base_path: str, target: str, level: int = -1
     ) -> dict:
         '''Returns a dict of: key = matching path, value = set of matched targets.
@@ -91,10 +91,20 @@ class CommandMulti(CommandParallel):
 
         matching_targets_dict = {}
 
+        # Let's not glob.glob if the path_pattern and target_pattern are
+        # exact, aka if it does not have special characters for glob: * or ?
+        # for the target, we also support re, so: * + ?
+        if any(x in path_pattern for x in ['*', '?']):
+            paths_from_pattern = list(glob.glob(path_pattern, recursive=True))
+        else:
+            paths_from_pattern = [path_pattern]
+
+        target_pattern_needs_lookup = any(x in target_pattern for x in ['*', '?', '+'])
+
         # resolve the path_pattern portion using glob.
         # we'll have to check for DEPS markup files in path_pattern, to match the target_wildcard
         # using fnmatch or re.
-        for path in glob.glob(path_pattern, recursive=True):
+        for path in paths_from_pattern:
 
             if self.path_hidden_or_work_dir(path):
                 continue
@@ -108,7 +118,11 @@ class CommandMulti(CommandParallel):
                 debug(f'in {rel_path=} looking for {target_pattern=} in {deps_targets=}')
 
                 for t in deps_targets:
-                    if deps_helpers.fnmatch_or_re(pattern=target_pattern, string=t):
+                    if target_pattern_needs_lookup:
+                        matched = deps_helpers.fnmatch_or_re(pattern=target_pattern, string=t)
+                    else:
+                        matched = t == target_pattern
+                    if matched:
                         if rel_path not in matching_targets_dict:
                             matching_targets_dict[rel_path] = set()
                         matching_targets_dict[rel_path].add(t)
@@ -392,9 +406,13 @@ class CommandMulti(CommandParallel):
             # Special case for 'multi' --export-jsonl, run reach child with --export-json
             command_list.append('--export-json')
         if tool and len(all_multi_tools) > 1:
-            command_list.append(f'--job-name={short_target}.{command}.{tool}')
+            jobname = f'{short_target}.{command}.{tool}'
         else:
-            command_list.append(f'--job-name={short_target}.{command}')
+            jobname = f'{short_target}.{command}'
+        command_list.append(f'--job-name={jobname}')
+        logfile = os.path.join(self.args['eda-dir'], f'eda.{jobname}.log')
+        command_list.append(f'--force-logfile={logfile}')
+
 
     def append_jobs_from_targets(self, args:list):
         '''Helper method in CommandMulti to apply 'args' (list) to all self.targets,

opencos/commands/sweep.py

@@ -206,14 +206,18 @@ class CommandSweep(CommandDesign, CommandParallel):
             snapshot_name = snapshot_name.replace(os.sep, '_') \
                 + f'.{self.single_command}{sweep_string}'
             eda_path = get_eda_exec('sweep')
+            logfile = os.path.join(self.args['eda-dir'], f'eda.{snapshot_name}.log')
             self.jobs.append({
                 'name' : snapshot_name,
                 'index' : len(self.jobs),
                 'command': self.single_command,
                 'target': self.sweep_target,
                 'command_list' : (
-                    [eda_path, self.single_command, self.sweep_target,
-                     f'--job-name={snapshot_name}'] + arg_tokens
+                    [
+                        eda_path, self.single_command, self.sweep_target,
+                        f'--job-name={snapshot_name}',
+                        f'--force-logfile={logfile}',
+                    ] + arg_tokens
                 )
             })
             return

opencos/commands/waves.py

@@ -143,7 +143,7 @@ class CommandWaves(CommandDesign):
             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('gktwave'):
+            if '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/deps_helpers.py

@@ -68,7 +68,9 @@ class Defaults:
         'shell',
         'work-dir-add-srcs', 'work-dir-add-sources',
         'peakrdl',
-        'run-from-work-dir',
+        'run-from-work-dir',     # default True
+        'filepath-subst-target-dir', # default True
+        'dirpath-subst-target-dir',  # default False
         'var-subst-args',
         'var-subst-os-env',
         'tee',
@@ -384,7 +386,13 @@ def deps_list_target_sanitize(entry, default_key:str='deps', target_node:str='',
     assert False, f"Can't convert to list {entry=} {default_key=} {target_node=} {deps_file=}"
 
 
-def path_substitutions_relative_to_work_dir(exec_list : list, info_str : str, target_path : str):
+def path_substitutions_relative_to_work_dir(
+        exec_list: list, info_str: str, target_path: str,
+        enable_filepath_subst: bool, enable_dirpath_subst: bool
+) -> list:
+
+    if not enable_filepath_subst and not enable_dirpath_subst:
+        return exec_list
 
     # Look for path substitutions, b/c we later "work" in self.args['work-dir'], but
     # files should be relative to our target_path.
@@ -398,10 +406,18 @@ def path_substitutions_relative_to_work_dir(exec_list : list, info_str : str, ta
             # need this, and we can't assume dir levels in the work-dir.
             try:
                 try_path = os.path.abspath(os.path.join(os.path.abspath(target_path), m.group(1)))
-                if os.path.isfile(try_path) or os.path.isdir(try_path):
+                if enable_filepath_subst and  os.path.isfile(try_path):
+                    # make the substitution
+                    exec_list[i] = word.replace(m.group(1), try_path)
+                    debug(f'file path substitution {info_str=} {target_path=}: replaced - {word=}'
+                          f'is now ={exec_list[i]}. This can be disabled in DEPS with:',
+                          '"filepath-subst-targetdir: false"')
+                elif enable_dirpath_subst and os.path.isdir(try_path):
                     # make the substitution
                     exec_list[i] = word.replace(m.group(1), try_path)
-                    debug(f'path substitution {info_str=} {target_path=}: replaced - {word=} is now ={exec_list[i]}')
+                    debug(f'dir path substitution {info_str=} {target_path=}: replaced - {word=}'
+                          f'is now ={exec_list[i]}. This can be disabled in DEPS with:',
+                          '"dirpath-subst-targetdir: false"')
             except:
                 pass
 
@@ -1034,7 +1050,10 @@ class DepsProcessor:
 
 
 
-def parse_deps_shell_str(line : str, target_path : str, target_node : str, enable : bool = True):
+def parse_deps_shell_str(line: str, target_path: str, target_node: str,
+                         enable_filepath_subst_target_dir: bool = True,
+                         enable_dirpath_subst_target_dir: bool = False,
+                         enable: bool = True) -> dict:
     '''Returns None or a dict of a possible shell command from line (str)
 
      Examples of 'line' str:
@@ -1050,25 +1069,30 @@ def parse_deps_shell_str(line : str, target_path : str, target_node : str, enabl
     target_node (str) -- from dependency parsing, the target containing this 'line' str.
     '''
     if not enable:
-        return None
+        return {}
 
     m = re.match(r'^\s*shell\@(.*)\s*$', line)
     if not m:
-        return None
+        return {}
 
     exec_str = m.group(1)
     exec_list = exec_str.split()
 
     # Look for path substitutions, b/c we later "work" in self.args['work-dir'], but
     # files should be relative to our target_path.
-    exec_list = path_substitutions_relative_to_work_dir(exec_list=exec_list, info_str='shell@', target_path=target_path)
+    # Note this can be disable in DEPS via path-subst-target-dir=False
+    exec_list = path_substitutions_relative_to_work_dir(
+        exec_list=exec_list, info_str='shell@', target_path=target_path,
+        enable_filepath_subst=enable_filepath_subst_target_dir,
+        enable_dirpath_subst=enable_dirpath_subst_target_dir
+    )
 
-    d = {'target_path': os.path.abspath(target_path),
-         'target_node': target_node,
-         'run_from_work_dir': True,
-         'exec_list': exec_list,
-         }
-    return d
+    return {
+        'target_path': os.path.abspath(target_path),
+        'target_node': target_node,
+        'run_from_work_dir': True, # may be overriden later.
+        'exec_list': exec_list,
+    }
 
 
 def parse_deps_work_dir_add_srcs(line : str, target_path : str, target_node : str, enable : bool = True):
@@ -1100,8 +1124,12 @@ def parse_deps_work_dir_add_srcs(line : str, target_path : str, target_node : st
     return d
 
 
-def parse_deps_peakrdl(line : str, target_path : str, target_node : str, enable : bool = True,
-                       tool : str = ''):
+def parse_deps_peakrdl(
+        line: str, target_path: str, target_node: str, enable: bool = True,
+        enable_filepath_subst_target_dir: bool = True,
+        enable_dirpath_subst_target_dir: bool = False,
+        tool: str = ''
+) -> dict:
     '''Returns None or a dict describing a PeakRDL CSR register generator dependency
 
      Examples of 'line' str:
@@ -1172,10 +1200,13 @@ def parse_deps_peakrdl(line : str, target_path : str, target_node : str, enable
     # Make these look like a dep_shell_command:
     for one_cmd_as_list in shell_commands:
         ret_dict['shell_commands_list'].append(
-            parse_deps_shell_str(line = ' shell@ ' + ' '.join(one_cmd_as_list),
-                                 target_path = target_path,
-                                 target_node = target_node
-                                 )
+            parse_deps_shell_str(
+                line=(' shell@ ' + ' '.join(one_cmd_as_list)),
+                target_path=target_path,
+                target_node=target_node,
+                enable_filepath_subst_target_dir=enable_filepath_subst_target_dir,
+                enable_dirpath_subst_target_dir=enable_dirpath_subst_target_dir
+            )
         )
 
     # Make the work_dir_add_srcs dict:
@@ -1237,14 +1268,22 @@ def deps_commands_handler(config: dict, eda_args: dict,
             var_subst_dict = eda_args
 
         tee_fpath = command.get('tee', None)
-        run_from_work_dir = command.get('run-from-work-dir', True) # for shell, default True
+
+        # These are both optional bools, default True, would have to explicitly be set to False
+        # to take effect:
+        run_from_work_dir = command.get('run-from-work-dir', True)
+        filepath_subst_target_dir = command.get('filepath-subst-target-dir', True)
+        dirpath_subst_target_dir = command.get('dirpath-subst-target-dir', False)
 
         for key,item in command.items():
 
-            # skip the var-subst-* keys, since these types are bools
-            if key.startswith('var-subst') or \
-               key.startswith('tee') or \
-               key.startswith('run-from-work-dir'):
+            # skip the tee and var-subst-* keys, since these types are bools and not commands.
+            if key in ['tee',
+                       'var-subst-os-env',
+                       'var-subst-args',
+                       'run-from-work-dir',
+                       'filepath-subst-target-dir',
+                       'dirpath-subst-target-dir']:
                 continue
 
             # Optional variable substituion in commands
@@ -1255,9 +1294,11 @@ def deps_commands_handler(config: dict, eda_args: dict,
             if key == 'shell':
                 # For now, piggyback on parse_deps_shell_str:
                 ret_dict = parse_deps_shell_str(
-                    line = 'shell@ ' + item,
-                    target_path = target_path,
-                    target_node = target_node,
+                    line=('shell@ ' + item),
+                    target_path=target_path,
+                    target_node=target_node,
+                    enable_filepath_subst_target_dir=filepath_subst_target_dir,
+                    enable_dirpath_subst_target_dir=dirpath_subst_target_dir,
                     enable=config['dep_command_enables']['shell'],
                 )
                 # To support 'tee: <some-file>' need to append it to last
@@ -1286,6 +1327,8 @@ def deps_commands_handler(config: dict, eda_args: dict,
                     line = 'peakrdl@ ' + item,
                     target_path = target_path,
                     target_node = target_node,
+                    enable_filepath_subst_target_dir=filepath_subst_target_dir,
+                    enable_dirpath_subst_target_dir=dirpath_subst_target_dir,
                     enable=config['dep_command_enables']['peakrdl'],
                     tool=eda_args.get('tool', '')
                 )

opencos/deps_schema.py

@@ -71,6 +71,12 @@ my_target_name:
         var-subst-os-env:            <---- bool, perform var substitution using os.environ
         run-from-work-dir:           <---- bool, default True, if False runs from target dir
                                            instead of work-dir.
+        filepath-subst-target-dir:   <---- bool, default True, if False does not perform
+                                           file path substitution relative to target dir
+                                           (if substituted file exists).
+        dirpath-subst-target-dir:    <---- bool, default False, if True performs
+                                           directory path substitution relative to target dir
+                                           (if substituted directory exists).
         tee:                         <---- string, filename to write logs to
       - work-dir-add-sources:        <---- work-dir-add-sources, optional list (or string)
         - some_file_gen_from_sh.sv   <---- string filename that we created with sh command
@@ -153,6 +159,8 @@ DEPS_COMMANDS_LIST = [
         Optional('var-subst-args'): bool,
         Optional('var-subst-os-env'): bool,
         Optional('run-from-work-dir'): bool,
+        Optional('filepath-subst-target-dir'): bool,
+        Optional('dirpath-subst-target-dir'): bool,
         Optional('tee'): Or(str, type(None)),
     },
     {

opencos/eda.py

@@ -18,9 +18,10 @@ from opencos import eda_config
 from opencos import eda_base
 from opencos.eda_base import Tool, which_tool
 
-# Globals
-
+# Configure util:
 util.progname = "EDA"
+util.global_log.default_log_enabled = True
+util.global_log.default_log_filepath = os.path.join('eda.work', 'eda.log')
 
 
 # ******************************************************************************
@@ -453,10 +454,14 @@ def main(*args):
         if not config:
             util.error(f'eda.py main: problem loading config, {args=}')
             return 3
-        return interactive(config=config)
+        main_ret = interactive(config=config)
     else:
-        return process_tokens(tokens=list(unparsed), original_args=original_args,
+        main_ret =  process_tokens(tokens=list(unparsed), original_args=original_args,
                               config=config)
+    # Stop the util log, needed for pytests that call eda.main directly that otherwise
+    # won't close the log file via util's atexist.register(stop_log)
+    util.global_log.stop()
+    return main_ret
 
 
 def main_cli() -> None:

opencos/eda_base.py

@@ -212,12 +212,30 @@ class Command:
         self.target = ""
         self.target_path = ""
         self.status = 0
+        self.errors_log_f = None
 
-    def error(self, *args, **kwargs):
-        '''Returns None, child classes can call self.error(..) instead of util.error, which updates their self.status.
+    def error(self, *args, **kwargs) -> None:
+        '''Returns None, child classes can call self.error(..) instead of util.error,
 
-        Please consider using Command.error(..) (or self.error(..)) in place of util.error so self.status is updated.
+        which updates their self.status. Also will write out to eda.errors.log if the work-dir
+        exists. Please consider using Command.error(..) (or self.error(..)) in place of util.error
+        so self.status is updated.
         '''
+
+        if self.args['work-dir']:
+            if not self.errors_log_f:
+                try:
+                    self.errors_log_f = open(
+                        os.path.join(self.args['work-dir'], 'eda.errors.log'), 'w'
+                    )
+                except:
+                    pass
+            if self.errors_log_f:
+                print(
+                    f'ERROR: [eda] ({self.command_name}) {" ".join(list(args))}',
+                    file=self.errors_log_f
+                )
+
         self.status = util.error(*args, **kwargs)
 
     def status_any_error(self, report=True) -> bool:
@@ -1480,6 +1498,9 @@ class CommandParallel(Command):
                 jobs_launched += 1
                 anything_done = True
                 job = self.jobs.pop(0)
+                # TODO(drew): it might be nice to pass more items on 'job' dict, like
+                # logfile or job-name, so CommandSweep or CommandMulti don't have to set
+                # via args. on their command_list.
                 if job['name'].startswith(multi_cwd): job['name'] = job['name'][len(multi_cwd):]
                 # in all but fancy mode, we will print this text at the launch of a job.  It may get a newline below
                 job_text = sprint_job_line(jobs_launched, job['name'], hide_stats=run_parallel)
@@ -1663,34 +1684,36 @@ class CommandParallel(Command):
         '''Examines list self.jobs, and if leaf target names are duplicate will
         patch each command's job-name to:
             --job-name=path.leaf.command[.tool]
+
+        Also do for --force-logfile
         '''
 
-        def get_job_name(job_dict: dict) -> str:
-            '''Fishes the job-name out of an entry in self.jobs'''
+        def get_job_arg(job_dict: dict, arg_name: str) -> str:
+            '''Fishes the arg_name out of an entry in self.jobs'''
             for i, item in enumerate(job_dict['command_list']):
-                if item.startswith('--job-name='):
-                    _, name = item.split('--job-name=')
+                if item.startswith(f'--{arg_name}='):
+                    _, name = item.split(f'--{arg_name}=')
                     return name
-                elif item == '--job-name':
+                elif item == f'--{arg_name}':
                     return job_dict['command_list'][i + 1]
             return ''
 
-        def replace_job_name(job_dict: dict, new_job_name: str) -> dict:
-            '''Replaces the job-name in an entry in self.jobs'''
+        def replace_job_arg(job_dict: dict, arg_name: str, new_value: str) -> bool:
+            '''Replaces the arg_name's value in an entry in self.jobs'''
             for i, item in enumerate(job_dict['command_list']):
-                if item.startswith('--job-name='):
-                    job_dict['command_list'][i] = '--job-name=' + new_job_name
-                    return job_dict
-                elif item == '--job-name':
-                    job_dict['command_list'][i + 1] = new_job_name
-                    return job_dict
-            return job_dict
+                if item.startswith(f'--{arg_name}='):
+                    job_dict['command_list'][i] = f'--{arg_name}=' + new_value
+                    return True
+                elif item == f'--{arg_name}':
+                    job_dict['command_list'][i + 1] = new_value
+                    return True
+            return False
 
 
         job_names_count_dict = {}
         for job_dict in self.jobs:
 
-            key = get_job_name(job_dict)
+            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')
             if key not in job_names_count_dict:
@@ -1699,7 +1722,7 @@ class CommandParallel(Command):
                 job_names_count_dict[key] += 1
 
         for i, job_dict in enumerate(self.jobs):
-            key = get_job_name(job_dict)
+            key = get_job_arg(job_dict, 'job-name')
             if job_names_count_dict[key] < 2:
                 continue
 
@@ -1709,6 +1732,20 @@ class CommandParallel(Command):
             patched_sub_work_dir = False
             patched_target_path = os.path.relpath(tpath).replace(os.sep, '_')
             new_job_name = f'{patched_target_path}.{key}'
-            new_job_dict = replace_job_name(job_dict, new_job_name)
-            self.jobs[i] = new_job_dict
+            replace_job_arg(job_dict, arg_name='job-name', new_value=new_job_name)
+
+            # prepend path information to force-logfile (if present):
+            force_logfile = get_job_arg(job_dict, arg_name='force-logfile')
+            if force_logfile:
+                left, right = os.path.split(force_logfile)
+                new_force_logfile = os.path.join(left, f'{patched_target_path}.{right}')
+                replace_job_arg(
+                    job_dict, arg_name='force-logfile', new_value=new_force_logfile
+                )
+                util.debug(
+                    f'Patched job {job_dict["name"]}: --force-logfile={new_force_logfile}'
+                )
+
+
+            self.jobs[i] = job_dict
             util.debug(f'Patched job {job_dict["name"]}: --job-name={new_job_name}')

opencos/tests/helpers.py

@@ -124,20 +124,35 @@ def assert_export_jsonl_good(filepath:str, jsonl:bool=True) -> list:
 class Helpers:
     '''We do so much with logging in this file, might as well make it reusable'''
     DEFAULT_DIR = ''
-    DEFAULT_LOG = 'eda.log'
+    DEFAULT_LOG_DIR = os.getcwd()
+    DEFAULT_LOG = os.path.join(DEFAULT_LOG_DIR, '.pytest.eda.log')
     def chdir(self):
         '''Changes directory to self.DEFAULT_DIR and removes eda.work, eda.export paths'''
         chdir_remove_work_dir('', self.DEFAULT_DIR)
 
+    def _resolve_logfile(self, logfile=None) -> str:
+        '''Returns the logfile's filepath'''
+        ret = logfile
+        if ret is None:
+            ret = self.DEFAULT_LOG
+        else:
+            left, right = os.path.split(logfile)
+            if not left or left in [os.path.sep, '.', '..']:
+                # relative logfile put in DEFAULT_LOG_DIR:
+                ret = os.path.join(self.DEFAULT_LOG_DIR, right)
+        return ret
+
     def log_it(self, command_str:str, logfile=None, use_eda_wrap=True) -> int:
         '''Replacement for calling eda.main or eda_wrap, when you want an internal logfile
 
         Usage:
-            rc = self.log_it('sim foo', logfile='yes.log')
+            rc = self.log_it('sim foo')
             assert rc == 0
+
+        Note this will run with --no-default-log to avoid a Windows problem with stomping
+        on a log file.
         '''
-        if logfile is None:
-            logfile = self.DEFAULT_LOG
+        logfile = self._resolve_logfile(logfile)
         rc = 50
 
         # TODO(drew): There are some issues with log_it redirecting stdout from vivado
@@ -148,16 +163,15 @@ class Helpers:
         with open(logfile, 'w', encoding='utf-8') as f:
             with redirect_stdout(f), redirect_stderr(f):
                 if use_eda_wrap:
-                    rc = eda_wrap(*(command_str.split()))
+                    rc = eda_wrap('--no-default-log', *(command_str.split()))
                 else:
-                    rc = eda.main(*(command_str.split()))
+                    rc = eda.main('--no-default-log', *(command_str.split()))
             print(f'Wrote: {os.path.abspath(logfile)=}')
         return rc
 
     def is_in_log(self, *want_str, logfile=None, windows_path_support=False):
         '''Check if any of want_str args are in the logfile, or self.DEFAULT_LOG'''
-        if logfile is None:
-            logfile = self.DEFAULT_LOG
+        logfile = self._resolve_logfile(logfile)
         want_str0 = ' '.join(list(want_str))
         want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
@@ -169,8 +183,7 @@ class Helpers:
 
     def get_log_lines_with(self, *want_str, logfile=None, windows_path_support=False):
         '''gets all log lines with any of want_str args are in the logfile, or self.DEFAULT_LOG'''
-        if logfile is None:
-            logfile = self.DEFAULT_LOG
+        logfile = self._resolve_logfile(logfile)
         ret_list = []
         want_str0 = ' '.join(list(want_str))
         want_str1 = want_str0.replace('/', '\\')
@@ -186,8 +199,7 @@ class Helpers:
         '''gets all log lines with any of *want_str within a single word
         in the logfile or self.DEFAULT_LOG
         '''
-        if logfile is None:
-            logfile = self.DEFAULT_LOG
+        logfile = self._resolve_logfile(logfile)
         ret_list = []
         want_str0 = ' '.join(list(want_str))
         want_str1 = want_str0.replace('/', '\\')

opencos/tests/test_deps_helpers.py

@@ -14,7 +14,7 @@ from opencos import eda_tool_helper, deps_helpers
 
 THISPATH = os.path.dirname(__file__)
 
-# Figure out what tools the system has available, without calling eda.main(..)
+# Figure out what tools the system has avail, without calling eda.main(..)
 config, tools_loaded = eda_tool_helper.get_config_and_tools_loaded()
 
 
@@ -58,63 +58,100 @@ def test_get_all_targets_eda_multi():
 def test_parse_deps_shell_str__no_parse():
     line = 'some_file.sv'
     d = deps_helpers.parse_deps_shell_str(line, '', '')
-    assert d is None, f'{d=}'
+    assert not d, f'{d=}'
 
     line = 'some_target:'
     d = deps_helpers.parse_deps_shell_str(line, '', '')
-    assert d is None, f'{d=}'
+    assert not d, f'{d=}'
 
     line = '   csr@some_file.sv'
     d = deps_helpers.parse_deps_shell_str(line, '', '')
-    assert d is None, f'{d=}'
+    assert not d, f'{d=}'
 
 def test_parse_deps_shell_str__cp():
     line = '    shell@ cp ./oclib_fifo_test.sv oclib_fifo_test_COPY.sv ;'
     d = deps_helpers.parse_deps_shell_str(line, '', '')
-    assert d is not None, f'{d=}'
+    assert d, f'{d=}'
     assert d['exec_list'] == ['cp', './oclib_fifo_test.sv', 'oclib_fifo_test_COPY.sv', ';'], f'{d=}'
 
 def test_parse_deps_shell_str__echo():
     line = '    shell@echo "hello world"'
     d = deps_helpers.parse_deps_shell_str(line, '', '')
-    assert d is not None, f'{d=}'
+    assert d, f'{d=}'
     assert d['exec_list'] == ['echo', '"hello', 'world"'], f'{d=}'
 
-def test_parse_deps_shell_str__path_replacement():
+def test_parse_deps_shell_str__enable_filepath_replacement():
     # Dealing w/ relative paths, change the current working directory to the module directory
+    # Default is enabled.
     module_dir = os.path.dirname(os.path.abspath(__file__))
     os.chdir(module_dir)
     line = 'shell@cp ../deps_helpers.py foo.py'
     d = deps_helpers.parse_deps_shell_str(line, target_path='./', target_node='foo_target')
-    assert d is not None, f'{d=}'
+    assert d, f'{d=}'
     assert d['exec_list'] == ['cp', os.path.abspath('../deps_helpers.py'), 'foo.py'], f'{d=}'
     assert d['target_node'] == 'foo_target'
     assert d['target_path'] == os.path.abspath('./')
 
+def test_parse_deps_shell_str__disable_filepath_replacement():
+    # Dealing w/ relative paths, change the current working directory to the module directory
+    module_dir = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(module_dir)
+    line = 'shell@cp ../deps_helpers.py foo.py'
+    d = deps_helpers.parse_deps_shell_str(line, target_path='./', target_node='foo_target',
+                                          enable_filepath_subst_target_dir=False)
+    assert d, f'{d=}'
+    assert d['exec_list'] == ['cp', '../deps_helpers.py', 'foo.py'], f'{d=}'
+    assert d['target_node'] == 'foo_target'
+    assert d['target_path'] == os.path.abspath('./')
+
+def test_parse_deps_shell_str__enable_dirpath_replacement():
+    # Dealing w/ relative paths, change the current working directory to the module directory
+    module_dir = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(module_dir)
+    line = 'shell@ls -ltr ./'
+    d = deps_helpers.parse_deps_shell_str(line, target_path='./', target_node='foo_target',
+                                          enable_dirpath_subst_target_dir=True)
+    assert d, f'{d=}'
+    assert d['exec_list'] == ['ls', '-ltr', os.path.abspath('./')], f'{d=}'
+    assert d['target_node'] == 'foo_target'
+    assert d['target_path'] == os.path.abspath('./')
+
+def test_parse_deps_shell_str__disable_dirpath_replacement():
+    # Dealing w/ relative paths, change the current working directory to the module directory
+    # Default is disabled.
+    module_dir = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(module_dir)
+    line = 'shell@ls -ltr ./'
+    d = deps_helpers.parse_deps_shell_str(line, target_path='./', target_node='foo_target')
+    assert d, f'{d=}'
+    assert d['exec_list'] == ['ls', '-ltr', './'], f'{d=}'
+    assert d['target_node'] == 'foo_target'
+    assert d['target_path'] == os.path.abspath('./')
+
 
 def test_parse_deps_work_dir_add_srcs__no_parse():
     line = 'some_file.sv'
     d = deps_helpers.parse_deps_work_dir_add_srcs(line, '', '')
-    assert d is None, f'{d=}'
+    assert not d, f'{d=}'
 
     line = 'some_target:'
     d = deps_helpers.parse_deps_work_dir_add_srcs(line, '', '')
-    assert d is None, f'{d=}'
+    assert not d, f'{d=}'
 
     line = '   csr@some_file.sv'
     d = deps_helpers.parse_deps_work_dir_add_srcs(line, '', '')
-    assert d is None, f'{d=}'
+    assert not d, f'{d=}'
 
 def test_parse_deps_work_dir_add_srcs__single_file():
     line = '    work_dir_add_srcs@ single_file.txt'
     d = deps_helpers.parse_deps_work_dir_add_srcs(line, '', '')
-    assert d is not None, f'{d=}'
+    assert d, f'{d=}'
     assert d['file_list'] == ['single_file.txt']
 
 def test_parse_deps_work_dir_add_srcs__several_file():
     line = '    work_dir_add_srcs@ single_file.txt another.sv  gen-verilog/mine.v ./gen-vhdl/wordy.vhdl'
     d = deps_helpers.parse_deps_work_dir_add_srcs(line, '', '')
-    assert d is not None, f'{d=}'
+    assert d, f'{d=}'
     assert d['file_list'] == [
         'single_file.txt', 'another.sv', 'gen-verilog/mine.v', './gen-vhdl/wordy.vhdl'
     ]
@@ -123,33 +160,33 @@ def test_parse_deps_work_dir_add_srcs__several_file():
 def test_parse_deps_peakrdl__no_parse():
     line = 'some_file.sv'
     d = deps_helpers.parse_deps_peakrdl(line, '', '')
-    assert d is None, f'{d=}'
+    assert not d, f'{d=}'
 
     line = 'some_target:'
     d = deps_helpers.parse_deps_peakrdl(line, '', '')
-    assert d is None, f'{d=}'
+    assert not d, f'{d=}'
 
     line = '   csr@some_file.sv'
     d = deps_helpers.parse_deps_peakrdl(line, '', '')
-    assert d is None, f'{d=}'
+    assert not d, f'{d=}'
 
 def test_parse_deps_peakrdl__with_top():
     line = '    peakrdl@ --cpuif axi4-lite-flat --top   my_fancy_csrs ./my_csrs.rdl'
     d = deps_helpers.parse_deps_peakrdl(line, '', '')
-    assert d is not None, f'{d=}'
+    assert d, f'{d=}'
     assert len(d['shell_commands_list']) > 0
     assert d['work_dir_add_srcs']['file_list'] == ['peakrdl/my_fancy_csrs_pkg.sv', 'peakrdl/my_fancy_csrs.sv']
 
 def test_parse_deps_peakrdl__with_top2():
     line = '    peakrdl@ --cpuif axi4-lite-flat --top=my_fancy_csrs ./my_csrs.rdl'
     d = deps_helpers.parse_deps_peakrdl(line, '', '')
-    assert d is not None, f'{d=}'
+    assert d, f'{d=}'
     assert len(d['shell_commands_list']) > 0
     assert d['work_dir_add_srcs']['file_list'] == ['peakrdl/my_fancy_csrs_pkg.sv', 'peakrdl/my_fancy_csrs.sv']
 
 def test_parse_deps_peakrdl__infer_top():
     line = '    peakrdl@ --cpuif axi4-lite-flat ./my_csrs.rdl'
     d = deps_helpers.parse_deps_peakrdl(line, '', '')
-    assert d is not None, f'{d=}'
+    assert d, f'{d=}'
     assert len(d['shell_commands_list']) > 0
     assert d['work_dir_add_srcs']['file_list'] == ['peakrdl/my_csrs_pkg.sv', 'peakrdl/my_csrs.sv']

opencos/tests/test_eda.py

@@ -422,7 +422,6 @@ class TestsRequiresVerilator( # pylint: disable=too-many-public-methods
 class TestMissingDepsFileErrorMessages(Helpers):
     '''Test for missing DEPS.yml file, using 'eda export' to avoid tools.'''
     DEFAULT_DIR = os.path.join(THISPATH, 'deps_files', 'no_deps_here', 'empty')
-    DEFAULT_LOG = 'eda.log'
 
     def test_bad0(self):
         '''Looks for target_bad0, but there is no DEPS file in .'''
@@ -444,7 +443,6 @@ class TestDepsResolveErrorMessages(Helpers):
     linenumber information is printed when available.'''
 
     DEFAULT_DIR = os.path.join(THISPATH, 'deps_files', 'error_msgs')
-    DEFAULT_LOG = 'eda.log'
 
     # files foo.sv, foo2.sv, target_bad0.sv, and target_bad1.sv exist.
     # files missing*.sv and targets missing* do not exist.
@@ -741,13 +739,15 @@ def test_deps_command_order(command):
     work_dir = os.path.join(
         THISPATH, 'deps_files', 'command_order', 'eda.work', f'target_test.{command}'
     )
+    # Note that eda will write out the returncode INFO line to tee'd log files, so
+    # there is more in the log file than "hi" or "bye".
     with open(os.path.join(work_dir, 'target_echo_hi__shell_0.log'), encoding='utf-8') as f:
-        text = ''.join(f.readlines()).strip()
-        assert text in ['hi', '"hi"', '\\"hi\\"']
+        text = ' '.join(f.readlines()).strip()
+        assert any(text.startswith(x) for x in ['hi', '"hi"', '\\"hi\\"'])
     # Added check, one of the targets uses a custom 'tee' file name, instead of the default log.
     with open(os.path.join(work_dir, 'custom_tee_echo_bye.log'), encoding='utf-8') as f:
         text = ''.join(f.readlines()).strip()
-        assert text in ['bye', '"bye"', '\\"bye\\"']
+        assert any(text.startswith(x) for x in ['bye', '"bye"', '\\"bye\\"'])
 
 
 @pytest.mark.skipif('verilator' not in tools_loaded, reason="requires verilator")
@@ -833,14 +833,13 @@ class TestDepsNoFilesTargets(Helpers):
 class TestDepsTags(Helpers):
     '''Series of tests for DEPS - target - tags, in ./deps_files/tags_with_tools'''
     DEFAULT_DIR = os.path.join(THISPATH, 'deps_files', 'tags_with_tools')
-    DEFAULT_LOG = 'eda.log'
 
     @pytest.mark.skipif('verilator' not in tools_loaded, reason="requires verilator")
     def test_tags_with_tools_verilator(self):
         '''test for DEPS target that hits with-tools: verilator, so that
         additional args are applied from the DEPS tag.'''
         self.chdir()
-        logfile = 'verilator_eda.log'
+        logfile = '.pytest.verilator_eda.log'
         rc = self.log_it('sim --tool verilator target_test', logfile=logfile)
         assert rc == 0
 
@@ -859,7 +858,7 @@ class TestDepsTags(Helpers):
         AKA, lets you replace all the Verilator waivers to the DEPS target that only affect
         with-tools: verilator'''
         self.chdir()
-        logfile = 'target_with_replace_config_tools_test.log'
+        logfile = '.pytest.target_with_replace_config_tools_test.log'
         rc = self.log_it('sim --tool verilator target_with_replace_config_tools_test',
                          logfile=logfile)
         assert rc == 0
@@ -877,7 +876,7 @@ class TestDepsTags(Helpers):
         AKA, lets you add Verilator waivers to the DEPS target that only affect
         with-tools: verilator'''
         self.chdir()
-        logfile = 'target_with_additive_config_tools_test.log'
+        logfile = '.pytest.target_with_additive_config_tools_test.log'
         rc = self.log_it('sim --tool verilator --debug target_with_additive_config_tools_test',
                          logfile=logfile)
         assert rc == 0
@@ -897,7 +896,7 @@ class TestDepsTags(Helpers):
         apply the arg --lint-only in the DEPS tag, and instead run the
         full simulation.'''
         self.chdir()
-        logfile = 'vivado_eda.log'
+        logfile = '.pytest.vivado_eda.log'
         rc = self.log_it('sim --tool vivado target_test', logfile=logfile)
         assert rc == 0
 
@@ -916,7 +915,7 @@ class TestDepsTags(Helpers):
     def test_tags_with_tools_add_incdirs(self):
         '''test for DEPS target with tag that adds incdirs'''
         self.chdir()
-        logfile = 'target_foo_sv_add_incdirs.log'
+        logfile = '.pytest.target_foo_sv_add_incdirs.log'
         rc = self.log_it('elab --tool verilator target_foo_sv_add_incdirs',
                          logfile=logfile)
         assert rc == 0
@@ -931,7 +930,7 @@ class TestDepsTags(Helpers):
     def test_tags_with_tools_add_defines(self):
         '''test for DEPS target with tag that adds defines'''
         self.chdir()
-        logfile = 'target_foo_sv_add_defines.log'
+        logfile = '.pytest.target_foo_sv_add_defines.log'
         rc = self.log_it('elab --tool verilator --debug target_foo_sv_add_defines',
                          logfile=logfile)
         assert rc == 0

opencos/tools/vivado.py

@@ -136,7 +136,7 @@ class CommandSimVivado(CommandSim, ToolVivado):
     def __init__(self, config: dict):
         CommandSim.__init__(self, config)
         ToolVivado.__init__(self, config=self.config)
-        # add args specific to this simulator
+        # add args specific to this tool
         self.args.update({
             'gui':        False,
             'tcl-file':   'sim.tcl',
@@ -349,7 +349,7 @@ class CommandElabVivado(CommandSimVivado):
     '''CommandElabVivado is a command handler for: eda elab --tool=vivado, uses xvlog, xelab'''
     def __init__(self, config: dict):
         CommandSimVivado.__init__(self, config)
-        # add args specific to this simulator
+        # add args specific to this tool
         self.args['stop-after-elaborate'] = True
 
 
@@ -358,7 +358,7 @@ class CommandSynthVivado(CommandSynth, ToolVivado):
     def __init__(self, config: dict):
         CommandSynth.__init__(self, config)
         ToolVivado.__init__(self, config=self.config)
-        # add args specific to this simulator
+        # add args specific to this tool
         self.args['gui'] = False
         self.args['tcl-file'] = "synth.tcl"
         self.args['xdc'] = ""
@@ -401,9 +401,7 @@ class CommandSynthVivado(CommandSynth, ToolVivado):
         defines = ""
         for key, value in self.defines.items():
             defines += (f"-verilog_define {key}" + (" " if value is None else f"={value} "))
-        incdirs = ""
-        if self.incdirs:
-            incdirs = " -include_dirs " + ";".join(self.incdirs)
+        incdirs = ' '.join([f'-include_dirs {x}' for x in self.incdirs])
         flatten = ""
         if self.args['flatten-all']:
             flatten = "-flatten_hierarchy full"
@@ -547,7 +545,7 @@ class CommandProjVivado(CommandProj, ToolVivado):
     def __init__(self, config: dict):
         CommandProj.__init__(self, config)
         ToolVivado.__init__(self, config=self.config)
-        # add args specific to this simulator
+        # add args specific to this tool
         self.args['gui'] = True
         self.args['oc-vivado-tcl'] = True
         self.args['tcl-file'] = "proj.tcl"
@@ -630,10 +628,11 @@ class CommandBuildVivado(CommandBuild, ToolVivado):
     def __init__(self, config: dict):
         CommandBuild.__init__(self, config)
         ToolVivado.__init__(self, config=self.config)
-        # add args specific to this simulator
+        # add args specific to this tool
         self.args['gui'] = False
         self.args['fpga'] = ""
         self.args['proj'] = False
+        self.args['resynth'] = False
         self.args['reset'] = False
         self.args['all-sv'] = False
 
@@ -705,6 +704,8 @@ class CommandBuildVivado(CommandBuild, ToolVivado):
         ]
         if self.args['proj']:
             command_list += ['--proj']
+        if self.args['resynth']:
+            command_list += ['--resynth']
         if self.args['reset']:
             command_list += ['--reset']
 
@@ -732,7 +733,7 @@ class CommandUploadVivado(CommandUpload, ToolVivado):
     def __init__(self, config: dict):
         CommandUpload.__init__(self, config)
         ToolVivado.__init__(self, config=self.config)
-        # add args specific to this simulator
+        # add args specific to this tool
         self.args.update({
             'gui': False,
             'bitfile': "",
@@ -743,8 +744,10 @@ class CommandUploadVivado(CommandUpload, ToolVivado):
             'device': -1,
             'host': "localhost",
             'port': 3121,
-            'tcl-file': "upload.tcl",
             'all-sv': False,
+            'tcl-file': "eda_upload.tcl",
+            'log-file': "eda_upload.log",
+            'test-mode': False,
         })
         # TODO(drew): Add self.args_help.update({...})
 
@@ -825,7 +828,7 @@ class CommandUploadVivado(CommandUpload, ToolVivado):
 
         # ── Generate TCL script ───────────────────────────────────────────────────
         script_file = Path(self.args['tcl-file'])
-        log_file    = Path("eda_upload.log")
+        log_file    = Path(self.args['log-file'])
 
         try:
             with script_file.open("w", encoding="utf-8") as fout:
@@ -924,6 +927,9 @@ class CommandUploadVivado(CommandUpload, ToolVivado):
             command_list.append('-notrace')
         self.exec(Path(util.getcwd()), command_list)
 
+        if not self.args['keep']:
+            os.unlink(self.args['tcl-file'])
+
         util.info("Upload done")
 
 
@@ -935,7 +941,7 @@ class CommandOpenVivado(CommandOpen, ToolVivado):
     def __init__(self, config: dict):
         CommandOpen.__init__(self, config)
         ToolVivado.__init__(self, config=self.config)
-        # add args specific to this simulator
+        # add args specific to this tool
         self.args['gui'] = True
         self.args['file'] = False
         self.args['all-sv'] = False

opencos/util.py

@@ -19,10 +19,85 @@ from opencos import eda_config
 global_exit_allowed = False
 progname = "UNKNOWN"
 progname_in_message = True
-logfile = None
-loglast = 0
 debug_level = 0
 
+class UtilLogger:
+    file = None
+    filepath = ''
+    time_last = 0 #timestamp via time.time()
+
+    # disabled by default, eda.py enables it. Can also be disabled via
+    # util's argparser: --no-default-log, --logfile=<name>, or --force-logfile=<name>
+    default_log_enabled = False
+    default_log_filepath = os.path.join('eda.work', 'eda.log')
+
+    def clear(self) -> None:
+        self.file = None
+        self.filepath = ''
+        self.time_last = 0
+
+    def stop(self) -> None:
+        if self.file:
+            self.write_timestamp(f'stop - {self.filepath}')
+            info(f"Closing logfile: {self.filepath}")
+            self.file.close()
+        self.clear()
+
+    def start(self, filename: str, force: bool = False) -> None:
+        if not filename:
+            error(f'Trying to start a logfile, but filename is missing')
+            return
+        if os.path.exists(filename):
+            if force:
+                debug(f"Overwriting logfile '{filename}', which exists, due to --force-logfile.")
+            else:
+                error(f"The --logfile path '{filename}' exists.  Use --force-logfile",
+                      "(vs --logfile) to override.")
+                return
+        else:
+            safe_mkdir_for_file(filename)
+        try:
+            self.file = open(filename, 'w')
+            debug(f"Opened logfile '{filename}' for writing")
+            self.filepath = filename
+            self.write_timestamp(f'start - {self.filepath}')
+        except Exception as e:
+            error(f"Error opening '{filename}' for writing, {e}")
+            self.clear()
+
+    def write_timestamp(self, text: str = "") -> None:
+        dt = datetime.datetime.now().ctime()
+        print(f"INFO: [{progname}] Time: {dt} {text}", file=self.file)
+        self.time_last = time.time()
+
+    def write(self, text: str, end: str) -> None:
+        sw = text.startswith(f"INFO: [{progname}]")
+        if (((time.time() - self.time_last) > 10) and
+            (text.startswith(f"DEBUG: [{progname}]") or
+             text.startswith(f"INFO: [{progname}]") or
+             text.startswith(f"WARNING: [{progname}]") or
+             text.startswith(f"ERROR: [{progname}]"))):
+            self.write_timestamp()
+        print(text, end=end, file=self.file)
+        self.file.flush()
+        os.fsync(self.file)
+
+
+global_log = UtilLogger()
+
+
+def start_log(filename, force=False):
+    global_log.start(filename=filename, force=force)
+
+def write_log(text, end):
+    global_log.write(text=text, end=end)
+
+def stop_log():
+    global_log.stop()
+
+atexit.register(stop_log)
+
+
 EDA_OUTPUT_CONFIG_FNAME = 'eda_output_config.yml'
 
 args = {
@@ -137,45 +212,6 @@ def yaml_safe_writer(data:dict, filepath:str) -> None:
         warning(f'{filepath=} to be written for this extension not implemented.')
 
 
-
-def start_log(filename, force=False):
-    global logfile, loglast
-    if os.path.exists(filename):
-        if force:
-            info(f"Overwriting '{filename}', which exists, due to --force-logfile.")
-        else:
-            error(f"The --logfile path '{filename}' exists.  Use --force-logfile (vs --logfile) to override.")
-    try:
-        logfile = open( filename, 'w')
-        debug(f"Opened logfile '{filename}' for writing")
-    except Exception as e:
-        error(f"Error opening '{filename}' for writing!")
-
-def write_log(text, end):
-    global logfile, loglast
-    sw = text.startswith(f"INFO: [{progname}]")
-    if (((time.time() - loglast) > 10) and
-        (text.startswith(f"DEBUG: [{progname}]") or
-         text.startswith(f"INFO: [{progname}]") or
-         text.startswith(f"WARNING: [{progname}]") or
-         text.startswith(f"ERROR: [{progname}]"))):
-        dt = datetime.datetime.now().ctime()
-        print(f"INFO: [{progname}] Time: {dt}", file=logfile)
-        loglast = time.time()
-    print(text, end=end, file=logfile)
-    logfile.flush()
-    os.fsync(logfile)
-
-def stop_log():
-    global logfile, loglast
-    if logfile:
-        debug(f"Closing logfile")
-        logfile.close()
-    logfile = None
-    loglast = 0
-
-atexit.register(stop_log)
-
 def get_argparse_bool_action_kwargs() -> dict:
     bool_kwargs = dict()
     x = getattr(argparse, 'BooleanOptionalAction', None)
@@ -205,12 +241,19 @@ def get_argparser() -> argparse.ArgumentParser:
                         help='Display additional debug messaging level 1 or higher')
     parser.add_argument('--debug-level', type=int, default=0,
                         help='Set debug level messaging (default: 0)')
-    parser.add_argument('--logfile', type=str, default='',
-                        help='Write eda messaging to logfile (default disabled)')
-    parser.add_argument('--force-logfile', type=str, default='',
+    parser.add_argument('--logfile', type=str, default=None,
+                        help=('Write eda messaging to safe logfile that will not be overwritten'
+                              ' (default disabled)'))
+    parser.add_argument('--force-logfile', type=str, default=None,
                         help='Set to force overwrite the logfile')
+    parser.add_argument('--default-log', **bool_action_kwargs,
+                        default=global_log.default_log_enabled,
+                        help=('Enable/Disable default logging to'
+                              f' {global_log.default_log_filepath}. Default logging is disabled'
+                              ' if --logfile or --force-logfile is set'))
     parser.add_argument('--no-respawn', action='store_true',
-                        help='Legacy mode (default respawn disabled) for respawning eda.py using $OC_ROOT/bin')
+                        help=('Legacy mode (default respawn disabled) for respawning eda.py'
+                              ' using $OC_ROOT/bin'))
     return parser
 
 def get_argparser_short_help(parser=None) -> str:
@@ -251,10 +294,15 @@ def process_tokens(tokens:list) -> (argparse.Namespace, list):
 
     debug(f'util.process_tokens: {parsed=} {unparsed=}  from {tokens=}')
 
-    if parsed.force_logfile != '':
+    if parsed.force_logfile:
         start_log(parsed.force_logfile, force=True)
-    elif parsed.logfile != '':
+    elif parsed.logfile:
         start_log(parsed.logfile, force=False)
+    elif parsed.default_log and \
+         (parsed.force_logfile is None and parsed.logfile is None):
+        # Use a forced logfile in the eda.work/eda.log:
+        start_log(global_log.default_log_filepath, force=True)
+
 
     parsed_as_dict = vars(parsed)
     for key,value in parsed_as_dict.items():
@@ -339,7 +387,7 @@ def print_post(text, end):
             print(fancy_lines_[x],flush=True,end=('' if x==(len(fancy_lines_)-1) else '\n'))
             #time.sleep(1)
         print("\033[1G", end="", flush=True)
-    if logfile: write_log(text, end=end)
+    if global_log.file: write_log(text, end=end)
 
 string_red = f"\x1B[31m"
 string_green = f"\x1B[32m"
@@ -520,6 +568,11 @@ def safe_rmdir(path):
         error(f"An error occurred while removing the directory '{path}': {e}")
 
 def safe_mkdir(path : str):
+    if os.path.exists(path):
+        return
+    left, right = os.path.split(os.path.relpath(path))
+    if left and left not in ['.', '..', os.path.sep]:
+        safe_mkdir(left)
     try:
         os.mkdir(path)
     except FileExistsError:
@@ -534,6 +587,11 @@ def safe_mkdirs(base : str, new_dirs : list):
     for p in new_dirs:
         safe_mkdir( os.path.join(base, p) )
 
+def safe_mkdir_for_file(filepath: str):
+    left, right = os.path.split(filepath)
+    if left:
+        safe_mkdir(left)
+
 
 def import_class_from_string(full_class_name):
     """
@@ -707,9 +765,8 @@ def subprocess_run_background(work_dir, command_list, background=True, fake:bool
 
     debug(f'util.subprocess_run_background: {background=} {tee_fpath=} {shell=}')
 
-    if fake or (not background and not tee_fpath):
-        # If tee_fpath is set, we're going to "background" but with it also
-        # printed out (stdout and tee_fpath).
+    if fake:
+        # let subprocess_run handle it (won't run anything)
         rc = subprocess_run(work_dir, command_list, fake=fake, shell=shell)
         return '', '', rc
 
@@ -734,38 +791,32 @@ def subprocess_run_background(work_dir, command_list, background=True, fake:bool
     debug(f"util.subprocess_run_background: about to call subprocess.Popen({c}, **{proc_kwargs})")
     proc = subprocess.Popen(c, **proc_kwargs)
 
+    stdout = ''
+    stderr = ''
+    tee_fpath_f = None
     if tee_fpath:
-        stdout = ''
-        stderr = ''
-        with open(tee_fpath, 'w') as f:
-            for line in iter(proc.stdout.readline, b''):
-                line = line.rstrip().decode("utf-8", errors="replace")
-                if not background:
-                    print(line)
-                f.write(line + '\n')
-                stdout += line + '\n'
-
-        proc.communicate()
-        rc = proc.returncode
+        try:
+            tee_fpath_f = open(tee_fpath, 'w')
+        except Exception as e:
+            error(f'Unable to open file "{tee_fpath}" for writing, {e}')
+
+    for line in iter(proc.stdout.readline, b''):
+        line = line.rstrip().decode("utf-8", errors="replace")
+        if not background:
+            print(line)
+        if tee_fpath_f:
+            tee_fpath_f.write(line + '\n')
+        if global_log.file:
+            global_log.write(line, '\n')
+        stdout += line + '\n'
+
+    proc.communicate()
+    rc = proc.returncode
+    if tee_fpath_f:
+        tee_fpath_f.write(f'INFO: [{progname}] util.subprocess_run_background: returncode={rc}\n')
+        tee_fpath_f.close()
         info('util.subprocess_run_background: wrote: ' + os.path.abspath(tee_fpath))
 
-
-    else:
-
-        debug(f"util.subprocess_run_background: about to call proc.communicate()")
-        stdout, stderr = proc.communicate()
-        rc = proc.returncode
-
-        stdout = stdout.decode('utf-8', errors="replace") if stdout else ""
-        stderr = stderr.decode('utf-8', errors="replace") if stderr else ""
-        debug(f"shell_run_background: {rc=}")
-        if stdout:
-            for lineno, line in enumerate(stdout.strip().split('\n')):
-                debug(f"stdout:{lineno+1}: {line}")
-        if stderr:
-            for lineno, line in enumerate(stdout.strip().split('\n')):
-                debug(f"stderr:{lineno+1}: {line}")
-
     return stdout, stderr, rc
 
 

{opencos_eda-0.2.46.dist-info → opencos_eda-0.2.48.dist-info}/METADATA

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

{opencos_eda-0.2.46.dist-info → opencos_eda-0.2.48.dist-info}/RECORD

@@ -1,10 +1,10 @@
 opencos/__init__.py,sha256=ZQ7aOCbP0jkIMYGdVrb-mkZX3rnvaK8epBkmp506tXU,85
 opencos/_version.py,sha256=qN7iBoOv-v4tEZz-Pu9sVUJwefshJOsgdaddn8HcHio,510
 opencos/_waves_pkg.sv,sha256=1lbhQOVGc3t_R8czYjP40hssP0I3FlZOpHTkI7yKFbI,1251
-opencos/deps_helpers.py,sha256=Q49Su7cJdkcjC9PufE2EtveHYAuENe2F-Prpmlz7tcI,57245
-opencos/deps_schema.py,sha256=-zXzU_l0mv8abaOgBcxmRiyIelZ9jOUBXI8ahf3ymBU,14860
-opencos/eda.py,sha256=Ky_Uc47TU1N6lRs06eatdpAvtgoSh0iXO0BxhSfEuk0,19420
-opencos/eda_base.py,sha256=utUTieQMv0RC2Mz5n8b7rtneKjSFI3YcgCiJON0T7Ws,84410
+opencos/deps_helpers.py,sha256=iFUMnrh8hiNflRgZWp0hid7x6BKk1P2PegUn_gJS8Z0,59452
+opencos/deps_schema.py,sha256=ECysiiagTGXAtAVp2GnW3N_Iw2ZakYEuSEg-WUWtUKo,15469
+opencos/eda.py,sha256=_gGZmXIsjACImBprg_Zx6oitem0xKVrboNBk6ignDg0,19757
+opencos/eda_base.py,sha256=vOxZrIJs4Y8OZjRbEC4UkYUjznLl96R7AVh5vJOC15Q,85962
 opencos/eda_config.py,sha256=8wwX4PTZ5rmxWogrVxxqAY6adQFPxTsFkkTYbo6H4vU,8853
 opencos/eda_config_defaults.yml,sha256=AteZbwRJ6wviinks47-e5TX0DoU0culJfBw6L3xYOOA,11535
 opencos/eda_config_max_verilator_waivers.yml,sha256=lTAU4IOEbUWVlPzuer1YYhIyxpPINeA4EJqcRIT-Ymk,840
@@ -20,30 +20,30 @@ opencos/oc_cli.py,sha256=kj2OXvgxli2WPj4MQ4zTBb36eFtsP2gsqDdeNeWGL4E,132108
 opencos/pcie.py,sha256=VUJljaZJYgScAAx5yn7F6GoA8K9eTcw24otYZbkMpYs,3035
 opencos/peakrdl_cleanup.py,sha256=vLhSOVs6cEzsi_PwAP4pSXu5_ZMZjDvfK_WmHDLbDac,486
 opencos/seed.py,sha256=8TA2uXhBuT_lOaQdAKqdReYvfBWi_KuyQCFJzA2rOVM,549
-opencos/util.py,sha256=IH6yeazG5VI95I7lGDnn2U58QEYM5ozm3SOHh6rVD_s,29395
+opencos/util.py,sha256=zG2b22EdgR5G2xFUGFjq3sv9DthKtidhPHURnymQ5dk,31242
 opencos/commands/__init__.py,sha256=DtOA56oWJu68l-_1_7Gdv0N-gtXVB3-p9IhGzAYex8U,1014
 opencos/commands/build.py,sha256=jI5ul53qfwn6X-yfSdSQIcLBhGtzZUk7r_wKBBmKJI0,1425
 opencos/commands/elab.py,sha256=m6Gk03wSzX8UkcmReooK7turF7LpqO0IcdOZwJ8XiyI,1596
 opencos/commands/export.py,sha256=juzxJL5-RpEnU5DmwF0fiG5pUrB2BbUbvCp2OasEd88,3494
 opencos/commands/flist.py,sha256=XO0JzNF4cEYlqoO6fJFEH-SjsqQtmIvDO-xRQL7wllY,8531
 opencos/commands/lec.py,sha256=gN6nQ4GURhPC8nu8Zuj08s1fmNzuiuaS9vJgtNZyX28,3647
-opencos/commands/multi.py,sha256=1IH5Bk5xnKsNvtEsYy8a6bFmcyHSfrMVK-lLNdj6vlg,26449
+opencos/commands/multi.py,sha256=Aie9-g5m8yyMAjs-Bzu6ioE2Vm6QFrRAhtEbp-ndeaQ,27271
 opencos/commands/open.py,sha256=unrpGckzg0FE5W3oARq8x0jX7hhV_uM9Oh5FgISHFAg,724
 opencos/commands/proj.py,sha256=MdHTOtQYG93_gT97dWuSyAgUxX2vi9FRhL0dtc-rM98,1096
 opencos/commands/shell.py,sha256=senuqSGOc5nVGU5voZNJO4_hzVAK0ELtu0wmRZgwv3k,7463
 opencos/commands/sim.py,sha256=oZyc4thCWZAk4668bbehRBzbOOVQDhyoDyemlDwYPFg,14059
-opencos/commands/sweep.py,sha256=O0VSpzHHlE_1hM-Edp4d80PAnh2P2HCIwsGLnhkRHWM,9107
+opencos/commands/sweep.py,sha256=EnTLCTEA_3bXc9z9Jb2xT5SN-zwhltHjj_NN1O3vcW8,9296
 opencos/commands/synth.py,sha256=quB-HWS4LKYTiFBHiYarQi4pMnRmt12wQTZpi14VvlE,4355
 opencos/commands/targets.py,sha256=_jRNhm2Fqj0fmMvTw6Ba39DCsRHf_r_uZCy_R064kpA,1472
 opencos/commands/upload.py,sha256=nlb4nlxrDCQPcabEmH3nP19g4PFILDqFDab4LwJ95Z4,796
-opencos/commands/waves.py,sha256=SRfjfsqhuszXHylQrgqYiUT3a5CQs9doxJQzuV4Ae0w,7055
+opencos/commands/waves.py,sha256=dsWwtjpDgH-YsiIjJgqTvteY3OZ48UnEAWc3blV2Fog,7055
 opencos/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opencos/tests/custom_config.yml,sha256=TRoVM9ZFKPOA_8JmlpzaMhnGO1txmaD14N_8P1oqzew,257
-opencos/tests/helpers.py,sha256=r4UYMckYzHY2i2RbSWvysOjerPhty_7i7RB-Z767M-c,8294
+opencos/tests/helpers.py,sha256=MQatotvBIYSOSsA3cZcIDmEc49khXrS9wA5h9wmNSjo,8876
 opencos/tests/test_build.py,sha256=FQAxOpLVQShAHD_L5rqJctPeSAoqoOCNFI0RXflLuY0,387
-opencos/tests/test_deps_helpers.py,sha256=_nJSgLN6WVlMKqu6sCr29gjQyN3Jj-dVk8Ac64ygpJs,5928
+opencos/tests/test_deps_helpers.py,sha256=_C5qH1YuScCCvG3E-Lr8aS_n6C6YKgEl-wIycJEFLRY,7697
 opencos/tests/test_deps_schema.py,sha256=T3P9KjaMyKsk8b7snNVvNSsom2hIJcg6Z9apYiXoH9Y,941
-opencos/tests/test_eda.py,sha256=tplHcx4FiEn8Jmw1mJMlD6tGjpUJ6cxdBGiVRKo7Ykw,38809
+opencos/tests/test_eda.py,sha256=SC008-wibXbnKkmdW9LUhXg0HhPJ1WpYbzi9aPAyqVA,38963
 opencos/tests/test_eda_elab.py,sha256=75bJpOaoO8rn1FXFxiE4KSu5FdjZP1IbW6SyTCjM_ao,2553
 opencos/tests/test_eda_synth.py,sha256=kYfceUB0qQwQmN_lIJvXkHzwoILL3Yb59h3nImg0hLU,5235
 opencos/tests/test_oc_cli.py,sha256=-ZmwVX_CPBXCGT9hXIBEr_XUSIGG2eky89YpSJIbRAg,731
@@ -68,12 +68,12 @@ opencos/tools/slang_yosys.py,sha256=3fyLRRdTXhSppNtUhhUl00oG-cT9TyyPTH6JvasS9ZE,
 opencos/tools/surelog.py,sha256=XhxJCGt8hyligL0LNT1fCWkHF5pkt4WSp3eqVJlQ4uA,4998
 opencos/tools/tabbycad_yosys.py,sha256=2LePPgYXBVdsy7YcffPIWN-I0B7queLQ_f_pme2SCGw,7803
 opencos/tools/verilator.py,sha256=dWnoO8FUvjdMyFmuTjHvC_XYI_zwjApJApYy7iYubf0,18398
-opencos/tools/vivado.py,sha256=_GVqKNIZt9CZeiXS5yZCWTFrhD3BKjcQfzhhxR1qLQM,40017
+opencos/tools/vivado.py,sha256=D0we45_2M5dr7Dp6FBjSaXxYmRpgJWm4rq3dc23Uv1A,40219
 opencos/tools/yosys.py,sha256=FV43RcejyFir4B24WRShnzUoppJMK0sDDNkSlIX8Vew,25579
-opencos_eda-0.2.46.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-opencos_eda-0.2.46.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
-opencos_eda-0.2.46.dist-info/METADATA,sha256=po0uwX8zxK4LmDW80yfBySMF1T2VwUifZPRgcsHB9f4,604
-opencos_eda-0.2.46.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opencos_eda-0.2.46.dist-info/entry_points.txt,sha256=V8OE1lySAFcFQpDNJuVxVZteeSmDH-joLMhGvrxrvmg,164
-opencos_eda-0.2.46.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
-opencos_eda-0.2.46.dist-info/RECORD,,
+opencos_eda-0.2.48.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+opencos_eda-0.2.48.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
+opencos_eda-0.2.48.dist-info/METADATA,sha256=CGrTq0YGaOZ0CEe-x3Lm-BJcoD8S1QyiJsM35P09_qk,604
+opencos_eda-0.2.48.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opencos_eda-0.2.48.dist-info/entry_points.txt,sha256=V8OE1lySAFcFQpDNJuVxVZteeSmDH-joLMhGvrxrvmg,164
+opencos_eda-0.2.48.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
+opencos_eda-0.2.48.dist-info/RECORD,,