opencos-eda 0.2.57__py3-none-any.whl → 0.3.1__py3-none-any.whl

opencos/deps/deps_processor.py

@@ -4,11 +4,13 @@ a DEPS markup files targets (applying deps, reqs, commands, tags, incdirs, defin
 CommandDesign ref object
 '''
 
+import argparse
 import os
 
 from opencos import files
 from opencos import eda_config
-from opencos.util import debug, info, warning, error
+from opencos.util import debug, info, warning, error, read_tokens_from_dot_f, \
+    patch_args_for_dir
 from opencos.utils.str_helpers import dep_str2list
 from opencos.deps.deps_file import deps_target_get_deps_list
 from opencos.deps.deps_commands import deps_commands_handler
@@ -48,6 +50,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         self.target_path = target_path
         self.target_node = target_node # for debug
         self.deps_file = deps_file # for debug
+        self.deps_dir, _ = os.path.split(deps_file)
         self.caller_info = caller_info
 
         assert isinstance(deps_entry, dict), \
@@ -150,7 +153,9 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         return tokens
 
 
-    def apply_args(self, args_list:list) -> list:
+    def apply_args( # pylint: disable=too-many-locals,too-many-branches
+            self, args_list:list
+    ) -> list:
         '''Given args_list, applies them to our self.command_design_ref obj
 
         This will return unparsed args that weren't in the self.command_design_ref.args keys
@@ -162,10 +167,54 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                        f"in {self.caller_info}")
         tokens = dep_str2list(args_list)
 
+        # patch args relative to the DEPS (if self.deps_dir exists) so things like
+        # --build-tcl=<file> for relative <file> works when calling targets from any directory.
+        tokens = patch_args_for_dir(
+            tokens=tokens, patch_dir=self.deps_dir, caller_info=self.caller_info
+        )
+
         # We're going to run an ArgumentParser here, which is not the most efficient
         # thing to do b/c it runs on all of self.command_design_ref.args (dict) even
         # if we're applying a single token.
 
+        # Since some args (util.py, eda_config.py, eda.py) can only be handled from command
+        # line, it would be nice if -f or --input-file is handled from DEPS, so we'll special
+        # case that now. Recursively resolve -f / --input-file.
+        parser = argparse.ArgumentParser(
+            prog='deps_processor -f/--input-file', add_help=False, allow_abbrev=False
+        )
+        parser.add_argument('-f', '--input-file', default=[], action='append',
+                            help=(
+                                'Input .f file to be expanded as eda args, defines, incdirs,'
+                                ' files, or targets.'
+                            ))
+        try:
+            parsed, unparsed = parser.parse_known_args(tokens + [''])
+            tokens2 = list(filter(None, unparsed))
+        except argparse.ArgumentError:
+            error('deps_processor -f/--input-file, problem attempting to parse_known_args for:',
+                  f'{tokens}')
+            tokens2 = tokens
+
+        if parsed.input_file:
+            dotf_tokens = []
+            for filepath in parsed.input_file:
+                # Since this isn't command line, we have to assume the path is relative
+                # to this DEPS file.
+                if not os.path.isabs(filepath):
+                    filepath = os.path.join(self.deps_dir, filepath)
+                dotf_tokens.extend(read_tokens_from_dot_f(
+                    filepath=filepath, caller_info=self.caller_info, verbose=True
+                ))
+
+            # put the .f files before the unparsed args.
+            tokens2 = dotf_tokens + tokens2
+
+            # recurse until we've resolved nested .f files.
+            return self.apply_args(args_list=tokens2)
+
+        tokens = tokens2 # if no --input-file values, keep parsing the remaining tokens2
+
         # We have to special-case anything with --tool[=value] in tokens, otherwise
         # the user may think they were allowed to set --tool, but in our flow the Command handler
         # (self.command_design_ref) has already been chosen, so setting the tool can have
@@ -180,11 +229,38 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         _, unparsed = self.command_design_ref.run_argparser_on_list(
             tokens=tokens
         )
+
         # Annoying, but check for plusargs in unparsed, and have referenced CommandDesign
         # or CommandSim class handle it with process_plusarg.
-        for arg in unparsed:
+        for arg in list(unparsed):
             if arg.startswith('+'):
                 self.command_design_ref.process_plusarg(plusarg=arg, pwd=self.target_path)
+                unparsed.remove(arg)
+
+        # For any leftover files, or targets, attempt to process those too:
+        for arg in list(unparsed):
+            # Since this isn't command line, we have to assume for files, the path is relative
+            # to this DEPS file.
+            if os.path.isabs(arg):
+                target = arg
+            else:
+                target = os.path.join(self.deps_dir, arg)
+
+            file_exists, fpath, forced_extension = files.get_source_file(target)
+            if file_exists:
+                _, file_ext = os.path.splitext(fpath)
+                if forced_extension or file_ext:
+                    self.command_design_ref.add_file(fpath, caller_info=self.caller_info,
+                                                     forced_extension=forced_extension)
+                    unparsed.remove(arg)
+
+            else:
+                if not os.path.isdir(target) and \
+                   self.command_design_ref.resolve_target_core(
+                       target=target, no_recursion=False, caller_info=self.caller_info,
+                       error_on_not_found=False
+                   ):
+                    unparsed.remove(arg)
 
         if unparsed:
             # This is only a warning - because things like CommandFlist may not have every

opencos/deps_schema.py

@@ -85,6 +85,8 @@ my_target_name:
                                            directory path substitution relative to target dir
                                            (if substituted directory exists).
         tee:                         <---- string, filename to write logs to
+        run-after-tool:              <---- bool, default false. Set to true to run after any
+                                           EDA tools, or any command handlers have completed.
       - 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
       - peakrdl:                     <---- string peakrdl command for CSR generation
@@ -171,6 +173,7 @@ DEPS_COMMANDS_LIST = [
         Optional('var-subst-args'): bool,
         Optional('var-subst-os-env'): bool,
         Optional('run-from-work-dir'): bool,
+        Optional('run-after-tool'): bool,
         Optional('filepath-subst-target-dir'): bool,
         Optional('dirpath-subst-target-dir'): bool,
         Optional('tee'): Or(str, type(None)),

opencos/eda.py

@@ -520,7 +520,8 @@ def main(*args):
 
     original_args = args.copy() # save before any parsing.
 
-    # Set global --debug, --quiet, --color  early before parsing other args:
+    # Set global --debug, --quiet, --color, -f/--iput-file, --envfile
+    # early before parsing other args:
     util_parsed, unparsed = util.process_tokens(args)
 
     util.debug(f"main: file: {os.path.realpath(__file__)}")

opencos/eda_base.py

@@ -230,6 +230,7 @@ class Command: # pylint: disable=too-many-public-methods
             'enable-tags': [],
             'disable-tags': [],
             'test-mode': False,
+            'error-unknown-args': True,
         })
         self.args_help.update({
             'stop-before-compile': ('stop this run before any compile (if possible for tool) and'
@@ -249,6 +250,7 @@ class Command: # pylint: disable=too-many-public-methods
                             ' --disable-tags has higher precedence than --enable-tags.'),
             'test-mode': ('command and tool dependent, usually stops the command early without'
                           ' executing.'),
+            'error-unknown-args': 'Enable errors on unknown/unparsable args',
         })
         self.modified_args = {}
         self.config = copy.deepcopy(config) # avoid external modifications.
@@ -495,9 +497,10 @@ class Command: # pylint: disable=too-many-public-methods
 
         # Do some minimal type handling, preserving the type(self.args[key])
         if key not in self.args:
-            self.error(f'set_arg, {key=} not in self.args {value=}',
-                       f'({self.command_name=}, {self.__class__.__name__=})',
-                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+            self.error_unknown_arg(
+                f'set_arg, {key=} not in self.args {value=}',
+                f'({self.command_name=}, {self.__class__.__name__=})'
+            )
 
         cur_value = self.args[key]
 
@@ -506,12 +509,11 @@ class Command: # pylint: disable=too-many-public-methods
             self.args[key].update(value)
 
         elif isinstance(cur_value, list):
-            # if list, append (no duplicates)
+            # if list, append (allow duplicates)
             if isinstance(value, list):
                 # new value also a list
                 for x in value:
-                    if x not in self.args[key]:
-                        self.args[key].append(x)
+                    self.args[key].append(x)
             elif value not in cur_value:
                 self.args[key].append(value)
 
@@ -693,9 +695,10 @@ class Command: # pylint: disable=too-many-public-methods
         _, unparsed = self.run_argparser_on_list(tokens)
         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)
+            self.error_unknown_arg(
+                f"Didn't understand argument: '{unparsed=}' in",
+                f"{self.command_name=} context, {pwd=}"
+            )
 
         return unparsed
 
@@ -911,6 +914,16 @@ class Command: # pylint: disable=too-many-public-methods
         lines.append(self.pretty_str_known_args(command=commands[-1])) # use last command if > 1
         util.warning("\n".join(lines))
 
+    def error_unknown_arg(self, *msg) -> None:
+        '''For errors involving an unknown --arg, they can be optionally disabled
+
+        using --no-error-unknown-args
+        '''
+        if self.args['error-unknown-args']:
+            self.error(*msg, error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+        else:
+            util.warning(*msg)
+
 
 class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
     '''CommandDesign is the eda base class for command handlers that need to track files.
@@ -970,13 +983,16 @@ 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
+        self.has_pre_compile_dep_shell_commands = False
+        self.has_post_tool_dep_shell_commands = False
 
 
     def run_dep_commands(self) -> None:
-        '''Run shell/peakrdl style commands from DEPS files
+        '''Run shell/peakrdl style commands from DEPS files, this is peformed before
 
-        These are deferred to maintain the deps ordering, and run in that order.
+        any tool compile step. These are deferred to maintain the deps ordering, and
+        run in that order. Note this will NOT run any DEPS command marked with
+        run-after-tool=True.
         '''
         self.run_dep_shell_commands()
         # Update any work_dir_add_srcs@ in our self.files, self.files_v, etc, b/c
@@ -986,17 +1002,41 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         self.update_non_source_files_in_work_dir()
 
 
-    def run_dep_shell_commands(self) -> None:
-        '''Specifically runs shell command from DEPS files'''
+    def run_post_tool_dep_commands(self) -> None:
+        '''Run shell style commands from DEPS files that have been marked with
+
+        run-after-tool=True. Note these are skipped if any args like
+        stop-before- or stop-after- are set.
+        '''
+
+        self.run_dep_shell_commands(filter_run_after_tool=True)
+
+
+    def run_dep_shell_commands( # pylint: disable=too-many-branches,too-many-locals
+            self, filter_run_after_tool: bool = False
+    ) -> None:
+        '''Runs collected shell command from DEPS files.
+
+        There are two flavors of shell commands: with or without 'run-after-tool'
+        set. The default is to run shell command before the compile step of any tool,
+        by calling this method with default pre_compile=True before any tool runs
+        (for generating code, etc). However, it may be useful to run shell commands
+        after a tool is complete (check timing, coverage, etc).
+        '''
 
         # Runs from self.args['work-dir']
         all_cmds_lists = []
 
         log_fnames_count = {} # count per target_node.
 
-        for i, d in enumerate(self.dep_shell_commands):
+        filtered_dep_shell_commands = []
+        for value in self.dep_shell_commands:
+            if value['attributes']['run-after-tool'] == filter_run_after_tool:
+                filtered_dep_shell_commands.append(value)
+
+
+        for i, d in enumerate(filtered_dep_shell_commands):
             clist = util.ShellCommandList(d['exec_list'])
-            run_from_work_dir = d['run_from_work_dir'] # default True
             log = clist.tee_fpath
             target_node = d["target_node"]
             if clist.tee_fpath is None:
@@ -1011,29 +1051,48 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 # (or tee name from DEPS.yml)
                 [f'# command {i}: target: {d["target_path"]} : {target_node} --> {log}'],
             ]
-            if not run_from_work_dir:
+            if not d['attributes']['run-from-work-dir']:
                 all_cmds_lists.append([f'cd {d["target_path"]}'])
 
             # actual command (list or util.ShellCommandList)
             all_cmds_lists.append(clist)
 
-            if not run_from_work_dir:
+            if not d['attributes']['run-from-work-dir']:
                 all_cmds_lists.append([f'cd {os.path.abspath(self.args["work-dir"])}'])
 
             d['exec_list'] = clist # update to tee_fpath is set.
 
         if all_cmds_lists:
+            if filter_run_after_tool:
+                filename='post_tool_dep_shell_commands.sh'
+                self.has_post_tool_dep_shell_commands = True
+            else:
+                filename='pre_compile_dep_shell_commands.sh'
+                self.has_pre_compile_dep_shell_commands = True
+
             util.write_shell_command_file(
-                dirpath=self.args['work-dir'], filename='pre_compile_dep_shell_commands.sh',
+                dirpath=self.args['work-dir'], filename=filename,
                 command_lists=all_cmds_lists
             )
-            self.has_dep_shell_commands = True
 
-        for i, d in enumerate(self.dep_shell_commands):
+
+        if all_cmds_lists and filter_run_after_tool and \
+           any(self.args.get(x, False) for x in (
+                "stop-before-compile",
+                "stop-after-compile",
+                "stop-after-elaborate"
+                )):
+            args_set = [key for key,value in self.args.items() if \
+                        key.startswith('stop-') and value]
+            util.info(f'Skipping DEPS run-after-tool commands due to args {args_set}')
+            util.debug(f'Skipped commands: {filtered_dep_shell_commands=}')
+            return
+
+        for i, d in enumerate(filtered_dep_shell_commands):
             util.info(f'run_dep_shell_commands {i=}: {d=}')
             clist = util.ShellCommandList(d['exec_list'])
             tee_fpath=clist.tee_fpath
-            if d['run_from_work_dir']:
+            if d['attributes']['run-from-work-dir']:
                 run_from_dir = self.args['work-dir']
             else:
                 # Run from the target's directory (not the `eda` caller $PWD)
@@ -1347,7 +1406,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         return self.resolve_target_core(target, no_recursion, caller_info)
 
     def resolve_target_core( # pylint: disable=too-many-locals,too-many-branches
-            self, target: str, no_recursion: bool, caller_info: str = ''
+            self, target: str, no_recursion: bool, caller_info: str = '',
+            error_on_not_found: bool = True
     ) -> bool:
         '''Returns True if target is found. recursive point for resolving path or DEPS markup
         target names.'''
@@ -1436,14 +1496,14 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                     self.add_file(try_file, caller_info=f'n/a::{target}::n/a')
                     found_target = True
                     break # move on to the next target
-            if not found_target: # if STILL not found_this_target...
+            if not found_target and error_on_not_found: # if STILL not found_this_target...
                 self.error(f"Unable to resolve {target=}",
                            error_code=status_constants.EDA_DEPS_TARGET_NOT_FOUND)
 
         # if we've found any target since being called, it means we found the one we were called for
         return found_target
 
-    def add_file(
+    def add_file( # pylint: disable=too-many-locals,too-many-branches
             self, filename: str, use_abspath: bool = True, add_to_non_sources: bool = False,
             caller_info: str = '', forced_extension: str = ''
     ) -> str:
@@ -1467,6 +1527,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         vhdl_file_ext_list = known_file_ext_dict.get('vhdl', [])
         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', [])
 
         if forced_extension:
             # If forced_extension='systemverilog', then use the first known extension for
@@ -1499,6 +1560,13 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         elif file_ext in sdc_file_ext_list:
             self.files_sdc.append(file_abspath)
             util.debug(f"Added SDC file {filename} as {file_abspath}")
+        elif file_ext in dotf_file_ext_list:
+            # a stray .f file as a source file, sure why not support it:
+            dp = DepsProcessor(command_design_ref=self, deps_entry={}, target='',
+                               target_path='', target_node='', deps_file='',
+                               caller_info=caller_info)
+            dp.apply_args(args_list=[f'-f={file_abspath}'])
+            del dp
         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
@@ -1592,9 +1660,10 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         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)
+            self.error_unknown_arg(
+                f"Didn't understand unparsed args: {possible_unparsed_args}, for command",
+                f"'{self.command_name}', tool '{_tool}'"
+            )
 
         remove_list = []
         last_potential_top_file = ('', '')   # (top, fpath)
@@ -1652,9 +1721,10 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         # we were unable to figure out what this command line token is for...
         if process_all and 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)
+            self.error_unknown_arg(
+                f"Didn't understand remaining args or targets {unparsed=} for command",
+                f"'{self.command_name}'"
+            )
 
         # handle a missing self.args['top'] with last filepath or last target:
         if not self.args.get('top', ''):
@@ -2199,9 +2269,10 @@ class CommandParallel(Command):
         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)
+            self.error_unknown_arg(
+                f'for {self.command_name} {command=} the following args are unknown',
+                f'{bad_remaining_args}'
+            )
 
         # Remove unparsed args starting with '+', since those are commonly sent downstream to
         # single job (example, CommandSim plusargs).

opencos/eda_config_defaults.yml

@@ -91,6 +91,9 @@ file_extensions:
   synth_constraints:
     - .sdc
     - .xdc
+  dotf:
+    - .f
+    - .vc
 
   inferred_top:
     # file extensions that we can infer "top" module from, if --top omitted.
@@ -229,6 +232,7 @@ tools:
   riviera:
     defines:
       OC_TOOL_RIVIERA: 1
+      RIVIERA: 1
     log-bad-strings:
       - "Error:"
     log-must-strings:
@@ -292,7 +296,7 @@ tools:
       - 3009 # 3009: [TSCALE] - Module 'myname' does not have a timeunit/timeprecision
              #       specification in effect, but other modules do.
     simulate-waves-args: |
-      -voptargs=+acc=bcgnprst
+      -voptargs=+acc=bcnprst
 
 
   iverilog:

opencos/files.py

@@ -24,6 +24,7 @@ FORCE_PREFIX_DICT = {
     'vhdl@': 'vhdl',
     'cpp@': 'cpp',
     'sdc@': 'synth_constraints',
+    'f@': 'dotf'
 }
 
 ALL_FORCED_PREFIXES = set(list(FORCE_PREFIX_DICT.keys()))

opencos/tests/deps_files/command_order/DEPS.yml

@@ -18,3 +18,14 @@ target_echo_hi_bye:
 target_test:
   deps: target_echo_hi_bye
   top: foo
+
+target_test_with_post_tool_commands:
+  deps:
+    # In this test, we want to put a new command in the front of the ordered "deps" list,
+    # but with run-after-tool=true, so it should run after any of the normal pre-compile
+    # shell commands.
+    - commands:
+        - shell: echo "final goodbye"
+          run-after-tool: true
+    - target_echo_hi_bye
+  top: foo

opencos/tests/helpers.py

@@ -13,6 +13,7 @@ from opencos import eda
 from opencos import deps_schema
 from opencos.utils.markup_helpers import yaml_safe_load
 from opencos.utils import status_constants
+from opencos.utils.subprocess_helpers import subprocess_run_background
 
 
 def eda_wrap_is_sim_fail(rc: int, quiet: bool = False) -> bool:
@@ -157,10 +158,20 @@ class Helpers:
     DEFAULT_DIR = ''
     DEFAULT_LOG_DIR = os.getcwd()
     DEFAULT_LOG = os.path.join(DEFAULT_LOG_DIR, '.pytest.eda.log')
+
+    # How should the job run? subprocess? eda_wrap? eda.main?
+    # Note - if using eda.main, args like --debug will persist in opencos.util.args,
+    #  so if you need those to be re-loaded, set RUN_IN_SUBPROCESS=True.
+    # Note - if you mess with os.enviorn, it may persist through subprocess.
+    RUN_IN_SUBPROCESS = True
+    USE_EDA_WRAP = True
+    PRESERVE_ENV = False
+
     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
@@ -173,7 +184,11 @@ class Helpers:
                 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:
+    def log_it(
+            self, command_str: str, logfile=None, use_eda_wrap: bool = True,
+            run_in_subprocess: bool = False,
+            preserve_env: bool = False
+    ) -> int:
         '''Replacement for calling eda.main or eda_wrap, when you want an internal logfile
 
         Usage:
@@ -183,6 +198,10 @@ class Helpers:
         Note this will run with --no-default-log to avoid a Windows problem with stomping
         on a log file.
         '''
+
+        if self.PRESERVE_ENV or preserve_env:
+            saved_env = os.environ.copy()
+
         logfile = self._resolve_logfile(logfile)
         rc = 50
 
@@ -191,17 +210,30 @@ class Helpers:
         # look at eda.work/{target}.sim/sim.log or xsim.log.
         print(f'{os.getcwd()=}')
         print(f'{command_str=}')
-        with open(logfile, 'w', encoding='utf-8') as f:
-            with redirect_stdout(f), redirect_stderr(f):
-                if use_eda_wrap:
-                    rc = eda_wrap('--no-default-log', *(command_str.split()))
-                else:
-                    rc = eda.main('--no-default-log', *(command_str.split()))
-            print(f'Wrote: {os.path.abspath(logfile)=}')
+        if run_in_subprocess or self.RUN_IN_SUBPROCESS:
+            command_list = ['eda', '--no-default-log'] + command_str.split()
+            _, _, rc = subprocess_run_background(
+                work_dir=self.DEFAULT_DIR,
+                command_list=command_list,
+                background=True,
+                tee_fpath=logfile
+            )
+        else:
+            with open(logfile, 'w', encoding='utf-8') as f:
+                with redirect_stdout(f), redirect_stderr(f):
+                    if use_eda_wrap or self.USE_EDA_WRAP:
+                        rc = eda_wrap('--no-default-log', *(command_str.split()))
+                    else:
+                        rc = eda.main('--no-default-log', *(command_str.split()))
+                print(f'Wrote: {os.path.abspath(logfile)=}')
+
+        if self.PRESERVE_ENV or preserve_env:
+            os.environ = saved_env
+
         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'''
+        '''Check if want_str (joined) is in the logfile, or self.DEFAULT_LOG'''
         logfile = self._resolve_logfile(logfile)
         want_str0 = ' '.join(list(want_str))
         want_str1 = want_str0.replace('/', '\\')
@@ -216,33 +248,31 @@ class Helpers:
         '''gets all log lines with any of want_str args are in the logfile, or self.DEFAULT_LOG'''
         logfile = self._resolve_logfile(logfile)
         ret_list = []
-        want_str0 = ' '.join(list(want_str))
-        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str0 in line:
+                if any(x in line for x in list(want_str)):
                     ret_list.append(line)
-                elif windows_path_support and want_str1 in line:
+                elif windows_path_support and \
+                     any(x.replace('/', '\\') in line for x in list(want_str)):
                     ret_list.append(line)
         return ret_list
 
     def get_log_words_with(self, *want_str, logfile=None, windows_path_support=False):
-        '''gets all log lines with any of *want_str within a single word
+        '''gets all log words with any of *want_str within a single word
         in the logfile or self.DEFAULT_LOG
         '''
         logfile = self._resolve_logfile(logfile)
         ret_list = []
-        want_str0 = ' '.join(list(want_str))
-        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str0 in line:
+                if any(x in line for x in list(want_str)):
                     for word in line.split():
-                        if want_str0 in word:
+                        if any(x in word for x in list(want_str)):
                             ret_list.append(word)
-                elif windows_path_support and want_str1 in line:
+                elif windows_path_support and \
+                     any(x.replace('/', '\\') in line for x in list(want_str)):
                     for word in line.split():
-                        if want_str1 in word:
+                        if any(x.replace('/', '\\') in word for x in list(want_str)):
                             ret_list.append(word)
 
         return ret_list