opencos-eda 0.2.56__py3-none-any.whl → 0.3.0__py3-none-any.whl

opencos/eda_base.py

@@ -506,12 +506,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)
 
@@ -970,13 +969,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 +988,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 +1037,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)

opencos/eda_config.py

@@ -47,7 +47,7 @@ class Defaults:
         'exe', 'handlers',
         'requires_env', 'requires_py', 'requires_cmd', 'requires_in_exe_path',
         'requires_vsim_helper', 'requires_vscode_extension',
-        'disable-tools-multi',
+        'disable-tools-multi', 'disable-auto',
     ])
     supported_config_tool_keys = set([
         'defines',
@@ -158,6 +158,9 @@ def update_config_auto_tool_order_for_tool(tool: str, config: dict) -> str:
 
     user_exe = shutil.which(user_exe)
 
+    # try adding to $PATH if in form --tool=/path/to/exe
+    tool_try_add_to_path(tool)
+
     if tool not in config['auto_tools_order'][0]:
         return tool
     if not user_exe:
@@ -322,3 +325,34 @@ def write_eda_config_and_args(
             data['config'][k] = str(v)
 
     yaml_safe_writer(data=data, filepath=fullpath)
+
+
+def tool_try_add_to_path(tool: str) -> None:
+    '''Since we support --tool=<name>=/path/to/bin/exe, attempt to prepend $PATH
+
+    with this information for this tool (which will nicely affect all subprocesses,
+    but not wreck our original shell).'''
+
+    if not tool or '=' not in tool:
+        return
+
+    name, exe = tool.split('=')
+    if os.path.isdir(name):
+        # Someone passes us --tool=<name>=/path/to/bin/ (did not have exe)
+        path = name
+    else:
+        # Someone passes us --tool=<name>=/path/to/bin/exe, remove the exe.
+        path, _ = os.path.split(exe)
+    if not path:
+        return
+
+    path = os.path.abspath(path)
+    if os.path.isdir(path):
+        paths = os.environ['PATH'].split(':')
+        if path not in paths:
+            os.environ['PATH'] = path + ':' + os.environ['PATH']
+            util.info(f'--tool={tool} has path information, prepending PATH with: {path}')
+        else:
+            util.info(f'--tool={tool} has path information, but {path} already in $PATH')
+    if exe and os.path.isfile(exe):
+        util.info(f'--tool={tool} has path information, using exe {shutil.which(exe)}')

opencos/eda_config_defaults.yml

@@ -229,6 +229,7 @@ tools:
   riviera:
     defines:
       OC_TOOL_RIVIERA: 1
+      RIVIERA: 1
     log-bad-strings:
       - "Error:"
     log-must-strings:
@@ -292,7 +293,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:
@@ -516,6 +517,7 @@ auto_tools_order:
         sim:  opencos.tools.iverilog.CommandSimIverilog
 
     cocotb:
+      disable-auto: True # do not allow this to run `eda sim` with --tool not set
       exe: python
       requires_cmd:
         - python -c "import cocotb; print(cocotb.__version__)"

opencos/export_helper.py

@@ -286,7 +286,11 @@ def get_list_sv_included_files(
         # If we have more than N levels of `include hunting, then rethink this.
         # For example, some codebases would do their file dependencies as `include
         # as part of their header guards, which could be ~100 levels of nesting.
-        for fname,traversed in sv_included_files_dict.items():
+
+        # make a copy of keys so we don't alter during traversal of the dict:
+        fnames = list(sv_included_files_dict.keys())
+        for fname in fnames:
+            traversed = sv_included_files_dict[fname]
             if not traversed:
                 included_files_list = find_sv_included_files_within_file(
                     filename=fname,

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:
@@ -39,6 +40,15 @@ def can_run_eda_command(*commands, config: dict) -> bool:
         if handler and getattr(handler, 'CHECK_REQUIRES', []):
             if not all(issubclass(handler, x) for x in getattr(handler, 'CHECK_REQUIRES', [])):
                 return False
+
+        # We cannot run tools that have disable-auto set:
+        tool = getattr(handler, '_TOOL', '')
+        if handler and tool:
+            entry = config['auto_tools_order'][0].get(tool, {})
+            if entry and entry.get('disable-auto', False):
+                # This tool cannot automatically run our command.
+                return False
+
         runnable.append(True)
     return runnable and all(runnable)
 
@@ -148,6 +158,15 @@ 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)
@@ -164,7 +183,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:
@@ -174,6 +197,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
 
@@ -182,13 +209,26 @@ 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):
@@ -207,33 +247,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

opencos/tests/test_deps_helpers.py

@@ -59,26 +59,26 @@ def test_get_all_targets_eda_multi():
 
 def test_parse_deps_shell_str__no_parse():
     line = 'some_file.sv'
-    d = deps_commands.parse_deps_shell_str(line, '', '')
+    d = deps_commands.parse_deps_shell_str(line, '', '', attributes={})
     assert not d, f'{d=}'
 
     line = 'some_target:'
-    d = deps_commands.parse_deps_shell_str(line, '', '')
+    d = deps_commands.parse_deps_shell_str(line, '', '', attributes={})
     assert not d, f'{d=}'
 
     line = '   csr@some_file.sv'
-    d = deps_commands.parse_deps_shell_str(line, '', '')
+    d = deps_commands.parse_deps_shell_str(line, '', '', attributes={})
     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_commands.parse_deps_shell_str(line, '', '')
+    d = deps_commands.parse_deps_shell_str(line, '', '', attributes={})
     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_commands.parse_deps_shell_str(line, '', '')
+    d = deps_commands.parse_deps_shell_str(line, '', '', attributes={})
     assert d, f'{d=}'
     assert d['exec_list'] == ['echo', '"hello', 'world"'], f'{d=}'
 
@@ -88,7 +88,9 @@ def test_parse_deps_shell_str__enable_filepath_replacement():
     module_dir = os.path.dirname(os.path.abspath(__file__))
     os.chdir(module_dir)
     line = 'shell@cp ../deps/deps_commands.py .pytest.copied.py'
-    d = deps_commands.parse_deps_shell_str(line, target_path='./', target_node='foo_target')
+    d = deps_commands.parse_deps_shell_str(
+        line, target_path='./', target_node='foo_target', attributes={}
+    )
     assert d, f'{d=}'
     spath = os.path.abspath(os.path.join('..', 'deps', 'deps_commands.py'))
     assert d['exec_list'] == ['cp', spath, '.pytest.copied.py'], f'{d=}'
@@ -100,8 +102,10 @@ def test_parse_deps_shell_str__disable_filepath_replacement():
     module_dir = os.path.dirname(os.path.abspath(__file__))
     os.chdir(module_dir)
     line = 'shell@cp ../deps/deps_commands.py .pytest.copied.py'
-    d = deps_commands.parse_deps_shell_str(line, target_path='./', target_node='foo_target',
-                                          enable_filepath_subst_target_dir=False)
+    d = deps_commands.parse_deps_shell_str(
+        line, target_path='./', target_node='foo_target',
+        attributes={'filepath-subst-target-dir': False}
+    )
     assert d, f'{d=}'
     assert d['exec_list'] == ['cp', '../deps/deps_commands.py', '.pytest.copied.py'], f'{d=}'
     assert d['target_node'] == 'foo_target'
@@ -112,8 +116,10 @@ def test_parse_deps_shell_str__enable_dirpath_replacement():
     module_dir = os.path.dirname(os.path.abspath(__file__))
     os.chdir(module_dir)
     line = 'shell@ls -ltr ./'
-    d = deps_commands.parse_deps_shell_str(line, target_path='./', target_node='foo_target',
-                                          enable_dirpath_subst_target_dir=True)
+    d = deps_commands.parse_deps_shell_str(
+        line, target_path='./', target_node='foo_target',
+        attributes={'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'
@@ -125,7 +131,10 @@ def test_parse_deps_shell_str__disable_dirpath_replacement():
     module_dir = os.path.dirname(os.path.abspath(__file__))
     os.chdir(module_dir)
     line = 'shell@ls -ltr ./'
-    d = deps_commands.parse_deps_shell_str(line, target_path='./', target_node='foo_target')
+    d = deps_commands.parse_deps_shell_str(
+        line, target_path='./', target_node='foo_target',
+        attributes={}
+    )
     assert d, f'{d=}'
     assert d['exec_list'] == ['ls', '-ltr', './'], f'{d=}'
     assert d['target_node'] == 'foo_target'
@@ -134,26 +143,26 @@ def test_parse_deps_shell_str__disable_dirpath_replacement():
 
 def test_parse_deps_work_dir_add_srcs__no_parse():
     line = 'some_file.sv'
-    d = deps_commands.parse_deps_work_dir_add_srcs(line, '', '')
+    d = deps_commands.parse_deps_work_dir_add_srcs(line, '', '', {})
     assert not d, f'{d=}'
 
     line = 'some_target:'
-    d = deps_commands.parse_deps_work_dir_add_srcs(line, '', '')
+    d = deps_commands.parse_deps_work_dir_add_srcs(line, '', '', {})
     assert not d, f'{d=}'
 
     line = '   csr@some_file.sv'
-    d = deps_commands.parse_deps_work_dir_add_srcs(line, '', '')
+    d = deps_commands.parse_deps_work_dir_add_srcs(line, '', '', {})
     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_commands.parse_deps_work_dir_add_srcs(line, '', '')
+    d = deps_commands.parse_deps_work_dir_add_srcs(line, '', '', {})
     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_commands.parse_deps_work_dir_add_srcs(line, '', '')
+    d = deps_commands.parse_deps_work_dir_add_srcs(line, '', '', {})
     assert d, f'{d=}'
     assert d['file_list'] == [
         'single_file.txt', 'another.sv', 'gen-verilog/mine.v', './gen-vhdl/wordy.vhdl'
@@ -162,34 +171,37 @@ def test_parse_deps_work_dir_add_srcs__several_file():
 
 def test_parse_deps_peakrdl__no_parse():
     line = 'some_file.sv'
-    d = deps_commands.parse_deps_peakrdl(line, '', '')
+    d = deps_commands.parse_deps_peakrdl(line, '', '', {})
     assert not d, f'{d=}'
 
     line = 'some_target:'
-    d = deps_commands.parse_deps_peakrdl(line, '', '')
+    d = deps_commands.parse_deps_peakrdl(line, '', '', {})
     assert not d, f'{d=}'
 
     line = '   csr@some_file.sv'
-    d = deps_commands.parse_deps_peakrdl(line, '', '')
+    d = deps_commands.parse_deps_peakrdl(line, '', '', {})
     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_commands.parse_deps_peakrdl(line, '', '')
+    d = deps_commands.parse_deps_peakrdl(line, '', '', {})
     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']
+    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_commands.parse_deps_peakrdl(line, '', '')
+    d = deps_commands.parse_deps_peakrdl(line, '', '', {})
     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']
+    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_commands.parse_deps_peakrdl(line, '', '')
+    d = deps_commands.parse_deps_peakrdl(line, '', '', {})
     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']
+    assert d['work_dir_add_srcs']['file_list'] == ['peakrdl/my_csrs_pkg.sv',
+                                                   'peakrdl/my_csrs.sv']

opencos/tests/test_eda.py

@@ -20,7 +20,6 @@ and should be more gracefully handled.
 import os
 import shutil
 import subprocess
-from contextlib import redirect_stdout, redirect_stderr
 
 import pytest
 
@@ -107,6 +106,7 @@ class TestsRequiresVerilator( # pylint: disable=too-many-public-methods
         assert rc == 0
 
 
+
     def test_args_sim_tool_with_path(self):
         '''Test for calling a tool as --tool=<tool>=</path/to/tool-exe>'''
         verilator_fullpath = shutil.which('verilator')
@@ -659,6 +659,31 @@ class TestsRequiresIVerilog(Helpers):
         assert rc == 0
 
 
+@pytest.mark.skipif(not can_run_eda_sim(), reason='no tool found to handle command: sim')
+class TestArgs(Helpers):
+    '''Test some args features, needs a sim tool'''
+    DEFAULT_DIR = os.path.join(THISPATH, '..', '..', 'lib', 'tests')
+
+    def test_duplicate_args(self):
+        '''Use oclib_fifo_test to make sure we don't lose (do NOT uniquify) duplicate
+        list-style args'''
+        self.chdir()
+        rc = self.log_it(
+            'sim --stop-before-compile oclib_fifo_test --compile-args=-hi --compile-args=-hi',
+            use_eda_wrap=False
+            )
+        assert rc == 0
+        # Confirm we have two args in self.args['compile-args'] for: -hi
+        eda_config_yml_path = os.path.join(
+            os.getcwd(), 'eda.work', 'oclib_fifo_test.sim', 'eda_output_config.yml'
+        )
+        data = yaml_safe_load(eda_config_yml_path)
+        assert 'args' in data
+        assert 'compile-args' in data['args']
+        assert len(data['args']['compile-args']) == 2
+        assert data['args']['compile-args'] == ['-hi', '-hi']
+
+
 @pytest.mark.skipif(not can_run_eda_sim(), reason='no tool found to handle command: sim')
 class TestDepsReqs:
     '''Tests for 'reqs' in the DEPS files. 'reqs' are requirements, like a .pcap or file
@@ -708,65 +733,6 @@ class TestDepsReqs:
         assert rc > 1
 
 
-@pytest.mark.parametrize("command", ['sim', 'shell'])
-def test_deps_command_order(command):
-    '''Test for various "commands" within a DEPS target. This test checks that command
-    order is preserved in the top-to-bottom deps order, meaning that eda.py has to collect
-    all commands deps order, and then execute them in that order.'''
-
-    chdir_remove_work_dir('deps_files/command_order')
-    if command == 'sim' and not can_run_eda_sim():
-        pytest.skip(f'sim skipped, {can_run_eda_sim()=}')
-        return # skip/pass
-
-    if command == 'shell':
-        cmd_list = 'shell target_test'.split()
-    else:
-        cmd_list = 'sim --stop-before-compile target_test'.split()
-
-    with open('eda.log', 'w', encoding='utf-8') as f:
-        with redirect_stdout(f):
-            with redirect_stderr(f):
-                rc = eda.main(*cmd_list)
-
-    print(f'{rc=}')
-    assert rc == 0
-
-    # We should see "hi" before "bye" to confirm deps + command order is correct.
-    # see ./deps_files/command_order/DEPS.yml - target = target_test
-    found_str_list = [
-        'exec: echo "hi"',
-        'exec: echo "bye"',
-    ]
-    found_lines_list = [None, None]
-
-    with open('eda.log', encoding='utf-8') as f:
-        for lineno, line in enumerate(f.readlines()):
-            line = line.rstrip()
-            for idx,key in enumerate(found_str_list):
-                if key in line:
-                    found_lines_list[idx] = lineno
-
-    assert found_lines_list[0] # found hi
-    assert found_lines_list[1] # found bye
-    assert found_lines_list[0] < found_lines_list[1] # hi before bye
-
-    # Added check, we redirected to create eda.log earlier to confirm the targets worked,
-    # but as a general eda.py check, all shell commands should create their own
-    # {target}__shell_0.log file:
-    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 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 any(text.startswith(x) for x in ['bye', '"bye"', '\\"bye\\"'])
-
 
 @pytest.mark.skipif('verilator' not in tools_loaded, reason="requires verilator")
 class TestDepsOtherMarkup: