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

opencos/export_helper.py

@@ -42,12 +42,18 @@ def json_paths_to_jsonl(
     with open(output_json_path, 'w', encoding='utf-8') as outf:
 
         # jsonl is every line of the file is a json.
+        # We would expect the JSON to have "tests": [ ... ] with >= 1 test.
         for json_file_path in json_file_paths:
             with open(json_file_path, encoding='utf-8') as f:
                 data = json.load(f)
                 if len(assert_json_types) > 0 and type(data) not in assert_json_types:
                     error(f'{json_file_path=} JSON data is not a Table (py dict) {type(data)=}')
-                json.dump(data, outf)
+                if 'tests' in data and isinstance(data['tests'], list):
+                    for test in data['tests']:
+                        json.dump(test, outf)
+                else:
+                    json.dump(data, outf)
+
                 outf.write('\n')
         info(f'Wrote {len(json_file_paths)} tests to {output_json_path=}')
 
@@ -78,7 +84,12 @@ def json_paths_to_single_json(
                 data = json.load(f)
                 if len(assert_json_types) > 0 and type(data) not in assert_json_types:
                     error(f'{json_file_path=} JSON data is not a Table (py dict) {type(data)=}')
-                out_json_data['tests'].append(data)
+                if 'tests' in data and isinstance(data['tests'], list):
+                    for test in data['tests']:
+                        out_json_data['tests'].append(test)
+                else:
+                    out_json_data['tests'].append(data)
+
         json.dump(out_json_data, outf)
         outf.write('\n')
         info(f'Wrote {len(json_file_paths)} tests {output_json_path=}')
@@ -471,7 +482,52 @@ class ExportHelper:
         yaml_safe_writer(data=data, filepath=dst)
 
 
-    def create_export_json_in_out_dir( # pylint: disable=unused-argument
+    def create_combined_env_file_in_out_dir(self) -> list:
+        ''' Returns list of all .env lines to be put in output directory
+
+        Creates single exported .env file if any --env-file(s)
+        were loaded by CLI or DEPS targets. --input-file/-f was handled as args
+        already, but --env-files need to be special cased. We do not add this
+        combined ".env" file to the all_files list, just build it on the fly if needed.
+        '''
+        env_lines = []
+        for filepath in util.env_files_loaded:
+            with open(filepath, encoding='utf-8') as f:
+                env_lines.extend(f.readlines() + ['\n'])
+
+        if env_lines:
+            dst = os.path.join(self.out_dir, '.env')
+
+            # Write this to the export directory too:
+            with open(dst, 'w', encoding='utf-8') as f:
+                for lineno, line in enumerate(env_lines):
+
+                    # modify VERILOG_SOURCES line if present, although it is known via DEPS.yml,
+                    # we can set it according to files_v and files_sv:
+                    if line.strip().startswith('VERILOG_SOURCES'):
+                        base_verilog_filenames = [
+                            os.path.split(x)[1] for x in \
+                            self.cmd_design_obj.files_v + self.cmd_design_obj.files_sv
+                        ]
+                        env_lines[lineno] = (
+                            f'VERILOG_SOURCES = {" ".join(base_verilog_filenames)}'
+                        )
+                        continue
+
+                    # remove PYTHONPATH from .env
+                    if line.strip().startswith('PYTHONPATH'):
+                        env_lines[lineno] = ''
+                        continue
+
+                    f.write(line)
+
+
+            info(f'export_helper: Wrote {dst}')
+
+        return env_lines
+
+
+    def create_export_json_in_out_dir( # pylint: disable=unused-argument,too-many-locals,too-many-branches
             self, eda_config:dict={}, **kwargs
     ) -> None:
         '''Optionally creates an exported JSON file in the output directory'''
@@ -482,40 +538,43 @@ class ExportHelper:
         # assumes we've run self.create_deps_yml_in_out_dir():
         assert self.target
         assert self.out_deps_file
+        full_eda_cmd_list = ['eda', self.eda_command]
+        if self.args.get('waves', False):
+            full_eda_cmd_list.append('--waves')
+        if self.args.get('tool', ''):
+            full_eda_cmd_list.append(f'--tool={self.args["tool"]}')
+        full_eda_cmd_list.append(self.target)
 
         data = {
-            'name': self.target,
-            'eda': {
-                'enable': True,
-                'multi': False, # Not yet implemented.
-                'command': self.eda_command,
-                'targets': [self.target],
-                'args': [],
-                'waves': self.args.get('waves', False),
-                # tool - eda.CommandSimVerilator has this set in self.args:
-                'tool': self.args.get('tool', None),
-            },
-            'files': [],
+            'correlationId': self.target,
+            'jobType': 'edaCmd',
+            'cmd': ' '.join(full_eda_cmd_list),
+            'timeout': 600,
+            'filesList': [], # filename (str), content (str)
         }
 
-        # allow caller to override eda - tool, or eda - args, etc.
-        for k,v in eda_config.items():
-            if k in data['eda'] and v is not None:
-                data['eda'][k] = v
-
         # Note that args may already be set via:
         #   create_deps_yml_in_out_dir(deps_file_args=some_list)
         # For example, eda.CommandSim.do_export() will set certain allow-listed
         # args if present with non-default values.
 
-
         all_files = [self.out_deps_file] + self.included_files \
             + self.cmd_design_obj.files_sv + self.cmd_design_obj.files_v \
             + self.cmd_design_obj.files_vhd + self.cmd_design_obj.files_cpp \
+            + self.cmd_design_obj.files_sdc + self.cmd_design_obj.files_py \
+            + self.cmd_design_obj.files_makefile + self.cmd_design_obj.files_non_source
+
+        all_files = list(dict.fromkeys(all_files)) # uniqify list.
+
+        # The last file we handle is a single exported .env file if any --env-file(s)
+        env_lines = self.create_combined_env_file_in_out_dir()
+        if env_lines:
+            # write the updated env_lines to the export.json file.
+            data['filesList'].append({
+                'filename': '.env',
+                'content': ''.join(env_lines), # already has \n per line
+            })
 
-        for x in self.cmd_design_obj.files_non_source:
-            if x not in all_files:
-                all_files.append(x)
 
         for somefile in all_files:
 
@@ -532,18 +591,17 @@ class ExportHelper:
 
             assert os.path.exists(somefile)
             with open(somefile, encoding='utf-8') as f:
-                filestr = ''.join(f.readlines())
-                data['files'].append({
-                    'name': os.path.split(somefile)[1],
-                    'content': filestr,
+                data['filesList'].append({
+                    'filename': os.path.split(somefile)[1],
+                    'content': ''.join(f.readlines()),
                 })
 
-
+        test_runner_data = {'tests': [data]} # single test for test runner.
         dst = os.path.join(self.out_dir, 'export.json')
         with open(dst, 'w', encoding='utf-8') as f:
-            json.dump(data, f)
+            json.dump(test_runner_data, f)
             f.write('\n')
-        info(f'export_helper: Wrote {dst=}')
+        info(f'export_helper: Wrote {dst}')
 
         # If this was from an `export` command, and the self.out_dir != self.args['work-dir'], then
         # copy the export.json to the work-dir:

opencos/files.py

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

opencos/tests/deps_files/command_order/DEPS.yml

@@ -29,3 +29,16 @@ target_test_with_post_tool_commands:
           run-after-tool: true
     - target_echo_hi_bye
   top: foo
+
+
+test_run_from_work_dir:
+  deps:
+    - commands:
+        - shell: echo "pwd=$PWD"
+          run-from-work-dir: true
+
+test_run_from_work_dir_false:
+  deps:
+    - commands:
+        - shell: echo "pwd=$PWD"
+          run-from-work-dir: false

opencos/tests/helpers.py

@@ -10,8 +10,8 @@ from pathlib import Path
 from contextlib import redirect_stdout, redirect_stderr
 
 from opencos import eda, eda_tool_helper, deps_schema
-from opencos.utils.markup_helpers import yaml_safe_load
 from opencos.utils import status_constants
+from opencos.utils.markup_helpers import yaml_safe_load
 from opencos.utils.subprocess_helpers import subprocess_run_background
 
 # Figure out what tools the system has available, without calling eda.main(..)
@@ -164,38 +164,43 @@ def assert_gen_deps_yml_good(filepath:str, want_target:str='') -> dict:
 
 def assert_export_json_good(filepath:str) -> dict:
     '''Checks that an exported JSON (from eda export, or eda <command> --export) has known keys'''
-    assert os.path.exists(filepath), f'{filepath=} does not exist'
+    assert os.path.isfile(filepath), f'{filepath=} does not exist'
     with open(filepath, encoding='utf-8') as f:
         data = json.load(f)
-    assert 'name' in data
-    assert 'eda' in data
-    assert any(x in data for x in ['files', 'tb'])
+    assert 'tests' in data
+    assert len(data.get('tests', [])) >= 1
+    for test in data.get('tests', []):
+        check_test_runner_schema(test)
     return data
 
+def check_test_runner_schema(test: dict) -> None:
+    '''Confirm that a single test's JSON/JSONL schema is OK.'''
+    assert 'correlationId' in test
+    assert 'jobType' in test
+    assert 'cmd' in test
+    assert 'filesList' in test # 0 files is OK.
+
 
 def assert_export_jsonl_good(filepath:str, jsonl:bool=True) -> list:
     '''Checks that an exported JSONL (from eda multi --export) has known keys'''
-    assert os.path.exists(filepath), f'{filepath=} does not exist'
+    assert os.path.isfile(filepath), f'{filepath=} does not exist'
     ret = []
     with open(filepath, encoding='utf-8') as f:
         if jsonl:
+            print(f'Using JSONL for {filepath=}')
             for line in f.readlines():
                 line = line.strip()
-                data = json.loads(line)
-                assert 'name' in data
-                assert 'eda' in data
-                assert any(x in data for x in ['files', 'tb'])
-                ret.append(data)
+                test = json.loads(line)
+                check_test_runner_schema(test)
+                ret.append(test)
         else:
+            print(f'Using JSON for {filepath=}')
             data = json.load(f)
             assert 'tests' in data
-            assert isinstance(data['tests'], list)
-            for entry in data['tests']:
-                assert 'name' in entry
-                assert 'eda' in entry
-                assert any(x in entry for x in ['files', 'tb'])
-                ret.append(entry)
-
+            assert len(data.get('tests', [])) >= 1
+            for test in data.get('tests', []):
+                check_test_runner_schema(test)
+                ret.append(test)
 
     return ret
 
@@ -233,7 +238,7 @@ class Helpers:
 
     def log_it(
             self, command_str: str, logfile=None, use_eda_wrap: bool = True,
-            run_in_subprocess: bool = False,
+            run_in_subprocess: bool = False, include_default_log: bool = False,
             preserve_env: bool = False
     ) -> int:
         '''Replacement for calling eda.main or eda_wrap, when you want an internal logfile
@@ -252,26 +257,31 @@ class Helpers:
         logfile = self._resolve_logfile(logfile)
         rc = 50
 
+        eda_log_arg = '--no-default-log'
+        if include_default_log:
+            eda_log_arg = ''
+
         # TODO(drew): There are some issues with log_it redirecting stdout from vivado
         # and modelsim_ase. So this may not work for all tools, you may have to directly
         # look at eda.work/{target}.sim/sim.log or xsim.log.
         print(f'{os.getcwd()=}')
         print(f'{command_str=}')
         if run_in_subprocess or self.RUN_IN_SUBPROCESS:
-            command_list = ['eda', '--no-default-log'] + command_str.split()
+            command_list = ['eda', eda_log_arg] + command_str.split()
             _, _, rc = subprocess_run_background(
                 work_dir=self.DEFAULT_DIR,
                 command_list=command_list,
                 background=True,
                 tee_fpath=logfile
             )
+            print(f'Wrote: {os.path.abspath(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()))
+                        rc = eda_wrap(eda_log_arg, *(command_str.split()))
                     else:
-                        rc = eda.main('--no-default-log', *(command_str.split()))
+                        rc = eda.main(eda_log_arg, *(command_str.split()))
                 print(f'Wrote: {os.path.abspath(logfile)=}')
 
         if self.PRESERVE_ENV or preserve_env:

opencos/tests/test_eda.py

@@ -648,7 +648,7 @@ class TestsRequiresIVerilog(Helpers):
         print(f'{rc=}')
         assert rc == 0
         assert self.is_in_log('Detected iverilog')
-        assert self.is_in_log("Generic help for command='sim' (using 'CommandSimIverilog')")
+        assert self.is_in_log("Generic help for command=sim tool=iverilog")
 
     def test_iverilog_sim(self):
         '''Test for command sim'''

opencos/tests/test_tools.py

@@ -3,6 +3,7 @@
 # pylint: disable=R0801 # (similar lines in 2+ files)
 
 import os
+import shutil
 import sys
 import pytest
 
@@ -32,14 +33,19 @@ def test_tools_loaded():
     assert config
     assert len(config.keys()) > 0
 
+
     # It's possible we're running in some container or install that has no tools, for example,
     # Windows.
     if sys.platform.startswith('win') and \
        not helpers.can_run_eda_command('elab', 'sim', cfg=config):
-        # Windows, not handlers for elab or sim:
+        # Windows, no handlers for elab or sim:
         pass
     else:
-        assert len(tools_loaded) > 0
+        basic_tools_available_via_path = any(shutil.which(x) for x in (
+            'verilator', 'iverilog', 'xsim', 'vsim', 'slang', 'yosys'
+        ))
+        if basic_tools_available_via_path:
+            assert len(tools_loaded) > 0
 
     def version_checker(
             obj: eda_base.Tool, chk_str: str
@@ -49,7 +55,7 @@ def test_tools_loaded():
         assert chk_str in full_ver, f'{chk_str=} not in {full_ver=}'
         ver_num = full_ver.rsplit(':', maxsplit=1)[-1]
         if 'b' in ver_num:
-            ver_num = ver_num.split('b')[0] # TODO(chaitanya): remove once cocotb 2.0 is released
+            ver_num = ver_num.split('b')[0]
         if '.' in ver_num:
             major_ver = ver_num.split('.')[0]
             assert major_ver.isdigit(), (

opencos/tools/cocotb.py

@@ -10,7 +10,9 @@ import subprocess
 from opencos import util
 from opencos.eda_base import Tool
 from opencos.commands import CommandSim
+from opencos.utils import status_constants
 from opencos.utils.str_helpers import sanitize_defines_for_sh
+from opencos.tools import verilator # For default waivers.
 
 
 class ToolCocotb(Tool):
@@ -76,6 +78,8 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
             'tcl-file': None,
             'cocotb-test-module': None,
             'cocotb-test-runner': 'python',
+            'cocotb-test-runner-file': '',
+            'cocotb-test-run-dir': None, # If None, use self.args['work-dir']
             'cocotb-simulator': 'verilator',
             'cocotb-makefile': False,
             'cocotb-python-runner': True,
@@ -86,17 +90,25 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
             'waves': 'Include waveforms by setting COCOTB_ENABLE_WAVES=1',
             'cocotb-test-module': 'Python test module name (e.g., test_my_design)',
             'cocotb-test-runner': 'Test runner to use: python (default) or pytest',
-            'cocotb-simulator': ('Simulator backend: verilator (default), icarus, etc.'
-                                 ' Note that iverilog will convert to icarus here'),
+            'cocotb-test-runner-file': 'Bring your own test_runner.py file',
+            'cocotb-test-run-dir': (
+                'Directory where cocotb-test-runner will run, if unset uses default eda.work/(name)'
+            ),
+            'cocotb-simulator': (
+                'Simulator backend: verilator (default), icarus, etc.'
+                ' Note that iverilog will convert to icarus here'
+            ),
             'cocotb-makefile': 'Use traditional Makefile system instead of Python runner',
             'cocotb-python-runner': 'Use Python-based runner system (default, cocotb 1.8+)',
-            'cocotb-standalone-makefile': ('Use provided Makefile as-is, '
-                                          'run make in source directory'),
+            'cocotb-standalone-makefile': (
+                'Use provided Makefile as-is, run make in source directory'
+            ),
         })
 
         self.cocotb_command_lists = []
         self.cocotb_test_files = []
 
+
     def set_tool_defines(self):
         ToolCocotb.set_tool_defines(self)
 
@@ -155,12 +167,13 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
             simulate_sh_fname='cocotb_test.sh'
         )
 
+
     def _find_cocotb_test_files(self):
         '''Find Python test files that contain cocotb tests'''
         self.cocotb_test_files = []
 
         # Look for test files in the current directory and deps
-        for file_path in self.files_non_source:
+        for file_path in self.files_non_source + self.files_py:
             if (file_path.endswith('.py') and
                 ('test' in file_path.lower() or 'tb' in file_path.lower())):
                 # Check if it's a cocotb test file
@@ -193,8 +206,19 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
     def _prepare_python_runner_system(self):
         '''Prepare cocotb using the Python-based runner system (cocotb 1.8+)'''
 
-        # Create a Python runner script
-        runner_script = self._create_python_runner_script()
+        # Create a Python runner script, or use from --cocotb-test-runner-file
+        if self.args['cocotb-test-runner-file']:
+
+            runner_script = self.args['cocotb-test-runner-file']
+            if not os.path.isfile(self.args['cocotb-test-runner-file']):
+                self.error(
+                    "File does not exist, for: --cocotb-test-runner-file=",
+                    f"{self.args['cocotb-test-runner-file']}",
+                    error_code=status_constants.EDA_GENERAL_FILE_NOT_FOUND
+                )
+                return
+        else:
+            runner_script = self._create_python_runner_script()
 
         if self.args['cocotb-test-runner'] == 'pytest':
             # Use pytest to run the tests
@@ -212,28 +236,41 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
         # Set environment variables
         env_vars = self._get_cocotb_env_vars()
 
-        # Create command with environment variables
-        command_list = self._create_env_command(env_vars) + cmd_list
-        self.cocotb_command_lists = [util.ShellCommandList(command_list,
-                                                          tee_fpath='cocotb_test.log')]
+        # Create command with environment variables, needs to be list-of-(cmd_list)
+        self.cocotb_command_lists = [
+            util.ShellCommandList(
+                self._create_env_command(env_vars) + cmd_list,
+                tee_fpath='cocotb_test.log',
+                # If someone wanted to run this from a specific dir, then
+                # run it from there.
+                work_dir=self.args['cocotb-test-run-dir']
+            )
+        ]
 
     def _prepare_makefile_system(self):
         '''Prepare cocotb using the traditional Makefile system'''
 
         makefile_path = os.path.join(self.args['work-dir'], 'Makefile')
+        self.files_makefile.append(makefile_path)
         with open(makefile_path, 'w', encoding='utf-8') as f:
             f.write(self._create_makefile_content())
 
         cmd_list = self._create_shell_command_with_success('make -f Makefile')
-        self.cocotb_command_lists = [util.ShellCommandList(cmd_list,
-                                                          tee_fpath='cocotb_makefile.log')]
+        self.cocotb_command_lists = [
+            util.ShellCommandList(
+                cmd_list, tee_fpath='cocotb_makefile.log',
+                # If someone wanted to run this from a specific dir, then
+                # run it from there.
+                work_dir=self.args['cocotb-test-run-dir']
+            )
+        ]
 
     def _prepare_standalone_makefile_system(self):
         '''Use provided Makefile as-is, run make in source directory'''
 
         # Find the Makefile in our dependencies
         makefile_path = None
-        for file_path in self.files_non_source:
+        for file_path in self.files_non_source + self.files_makefile:
             if os.path.basename(file_path).lower() == 'makefile':
                 makefile_path = file_path
                 break
@@ -241,10 +278,19 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
         if not makefile_path:
             self.error('No Makefile found in deps for --cocotb-standalone-makefile')
 
+        if any(value for key,value in self.args.items() if key.startswith('export')):
+            util.warning(f'Using an --export arg with Cocotb standalong Makefile {makefile_path}',
+                         'is not fully supported')
+
         makefile_dir = os.path.dirname(os.path.abspath(makefile_path))
-        cmd_list = self._create_shell_command_with_success(f'cd {makefile_dir} && make')
-        self.cocotb_command_lists = [util.ShellCommandList(
-            cmd_list, tee_fpath='cocotb_standalone.log')]
+        cmd_list = self._create_shell_command_with_success('make')
+        self.cocotb_command_lists = [
+            util.ShellCommandList(
+                cmd_list,
+                tee_fpath='cocotb_standalone.log',
+                work_dir=makefile_dir
+            )
+        ]
 
     def _get_test_module_name(self) -> str:
         '''Get the test module name from args or detected files'''
@@ -280,8 +326,22 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
 
         return script_path
 
+
     def _generate_runner_script_content(self, test_module: str, hdl_sources: list) -> str:
         '''Generate the content for the Python runner script'''
+
+        if shutil.which('verilator'):
+            # TODO(drew): this shortcuts if verilator is truly usable,
+            # consider using eda_tool_helper to get "tools_loaded", which
+            # is not set in self.config['tools_loaded'] when --tool=cocotb.
+            # Would need minor refactor for eda.py methods auto_tools_order,
+            # tool_setup to go into eda_tool_helper.py, and those methods would
+            # need hooks to be non-destructive to config.
+            tmp_verilator_obj = verilator.VerilatorSim(config=self.config)
+            verilator_waivers = tmp_verilator_obj.get_verilator_tool_config_waivers()
+        else:
+            verilator_waivers = []
+
         return f'''#!/usr/bin/env python3
 """
 Cocotb test runner script generated by opencos
@@ -337,6 +397,8 @@ def run_cocotb_test():
 
         if simulator == "verilator":
             build_args.extend({list(self.args.get('verilate-args', []))!r})
+            build_args.extend({list(self.args.get('compile-args', []))!r})
+            build_args.extend({list(verilator_waivers)!r})
 
         # Build the design
         runner.build(
@@ -449,9 +511,20 @@ include $(shell cocotb-config --makefiles)/Makefile.sim
         '''Get environment variables for cocotb execution'''
         env_vars = {}
 
+        top = self.args.get('top', 'top')
+
         # Basic cocotb configuration
-        env_vars['SIM'] = self.args['cocotb-simulator']
-        env_vars['TOPLEVEL'] = self.args.get('top', 'top')
+        env_vars.update({
+            'SIM': self.args['cocotb-simulator'],
+            'TOPLEVEL': top,
+            'COCOTB_TOPLEVEL': top,
+        })
+
+        if test_module := self.args['cocotb-test-module']:
+            env_vars.update({
+                'MODULE': test_module,
+                'COCOTB_TEST_MODULES': test_module,
+            })
 
         # Enable waves if requested
         if self.args.get('waves', False):
@@ -464,8 +537,8 @@ include $(shell cocotb-config --makefiles)/Makefile.sim
             env_vars['COCOTB_LOG_LEVEL'] = 'INFO'
 
         # Random seed
-        if self.args.get('seed'):
-            env_vars['COCOTB_RANDOM_SEED'] = str(self.args['seed'])
+        if seed := self.args.get('seed'):
+            env_vars['COCOTB_RANDOM_SEED'] = str(seed)
 
         return env_vars
 

opencos/tools/verilator.py

@@ -76,7 +76,6 @@ class VerilatorSim(CommandSim, ToolVerilator):
         ToolVerilator.__init__(self, config=self.config)
         self.args.update({
             'gui': False,
-            'tcl-file': None,
             'dump-vcd': False,
             'waves-fst': True,
             'waves-vcd': False,
@@ -95,7 +94,7 @@ class VerilatorSim(CommandSim, ToolVerilator):
                 ' plusarg and apply $dumpfile("dump.fst").'
             ),
             'waves-fst': (
-                '(Default True) If using --waves, apply simulation runtime arg +trace.'
+                'If using --waves, apply simulation runtime arg +trace.'
                 ' Note that if you do not have SV code using $dumpfile, eda will add'
                 ' _waves_pkg.sv to handle this for you with +trace runtime plusarg.'
             ),
@@ -228,7 +227,7 @@ class VerilatorSim(CommandSim, ToolVerilator):
             warnings=(not lint_only), add_uvm_pkg_if_found=True
         )
 
-        verilate_command_list += self._get_verilator_tool_config_waivers()
+        verilate_command_list += self.get_verilator_tool_config_waivers()
 
         verilate_command_list += self._verilator_args_defaults_cflags_nproc()
 
@@ -408,7 +407,10 @@ class VerilatorSim(CommandSim, ToolVerilator):
 
         return verilate_command_list
 
-    def _get_verilator_tool_config_waivers(self) -> list:
+    def get_verilator_tool_config_waivers(self) -> list:
+        '''Returns list of args to verilator for waviers, from --compile-waivers and
+
+        --config-yml for tool: (config)'''
 
         # Add compile waivers from self.config (tools.verilator.compile-waivers list):
         # list(set(mylist)) to get unique.

opencos/tools/yosys.py

@@ -70,9 +70,9 @@ class ToolYosys(Tool):
                 [self.sta_exe, '-version'], capture_output=True, check=False
             )
             util.debug(f'{self.yosys_exe} {sta_version_ret=}')
-            sta_ver = sta_version_ret.stdout.decode('utf-8', errors='replace').split()[0]
-            if sta_ver:
-                self.sta_version = sta_ver
+            sta_ver = sta_version_ret.stdout.decode('utf-8', errors='replace').split()
+            if sta_ver and isinstance(sta_ver, list):
+                self.sta_version = sta_ver[0]
 
         version_ret = subprocess.run(
             [self.yosys_exe, '--version'], capture_output=True, check=False