opencos-eda 0.2.50__py3-none-any.whl → 0.2.52__py3-none-any.whl

opencos/eda_config_defaults.yml

@@ -280,6 +280,20 @@ tools:
     simulate-waves-args: |
       +trace
 
+  cocotb:
+    defines:
+      OC_TOOL_COCOTB: null
+    log-bad-strings:
+      - "ERROR"
+      - "FAILED"
+      - "AssertionError"
+      - "Exception"
+      - "Traceback"
+      - "COCOTB_TEST_FAILED"
+    log-must-strings:
+      - "passed"
+      - "Cocotb test completed successfully!"
+
 
   vivado:
     sim-libraries:
@@ -345,6 +359,17 @@ auto_tools_order:
       handlers:
         elab:  opencos.tools.invio.CommandElabInvio
 
+    vaporview:
+      exe: code
+      requires_vscode_extension:
+        - lramseyer.vaporview
+      handlers: { }
+
+    surfer:
+      exe: code
+      requires_vscode_extension:
+        - surfer-project.surfer
+      handlers: { }
 
     gtkwave:
       exe: gtkwave
@@ -398,9 +423,7 @@ auto_tools_order:
 
     questa:
       exe: qrun
-      requires_cmd:
-        - qrun -version
-        - vsim -version
+      requires_vsim_helper: True
       handlers:
         elab: opencos.tools.queta.CommandElabQuesta
         sim: opencos.tools.queta.CommandSimQuesta
@@ -408,30 +431,22 @@ auto_tools_order:
     riviera:
       exe: vsim
       requires_cmd:
-        - vsim -version
         - which riviera  # Do not run it, make sure it's in PATH
-      requires_in_exe_path:
-        - riviera
+      requires_vsim_helper: True
       handlers:
         elab: opencos.tools.riviera.CommandElabRiviera
         sim:  opencos.tools.riviera.CommandSimRiviera
 
     modelsim_ase:
       exe: vsim
-      requires_cmd:
-        - vsim -version
-      requires_in_exe_path:
-        - modelsim
+      requires_vsim_helper: True
       handlers:
         elab: opencos.tools.modelsim_ase.CommandElabModelsimAse
         sim:  opencos.tools.modelsim_ase.CommandSimModelsimAse
 
     questa_fse:  # free student edition, works similar to modelsim_ase
       exe: vsim
-      requires_cmd:
-        - vsim -version
-      requires_in_exe_path:
-        - questa_fse
+      requires_vsim_helper: True
       handlers:
         elab: opencos.tools.questa_fse.CommandElabQuestaFse
         sim:  opencos.tools.questa_fse.CommandSimQuestaFse
@@ -441,3 +456,12 @@ auto_tools_order:
       handlers:
         elab: opencos.tools.iverilog.CommandElabIverilog
         sim:  opencos.tools.iverilog.CommandSimIverilog
+
+    cocotb:
+      exe: python
+      requires_cmd:
+        - python -c "import cocotb; print(cocotb.__version__)"
+      requires_py:
+        - cocotb
+      handlers:
+        sim:  opencos.tools.cocotb.CommandSimCocotb

opencos/eda_deps_sanitize.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+
+'''opencos.eda_deps_sanitize is an executable script
+
+Usage:
+    eda_deps_sanitize --dir=<path>
+
+Will print santized JSON data for the DEPS file found in --dir=<path>
+'''
+
+import argparse
+import os
+import sys
+
+from pathlib import Path
+
+from opencos import util
+from opencos.deps import deps_file
+from opencos.utils import status_constants
+
+
+def run(*args) -> (int, str):
+    '''Runs the DEPS sanitizer, prints results to stdout'''
+
+
+    bool_kwargs = util.get_argparse_bool_action_kwargs()
+
+    parser = argparse.ArgumentParser(
+        prog='opencos eda_deps_sanitize', add_help=True, allow_abbrev=False
+    )
+
+    parser.add_argument('--yaml', **bool_kwargs,
+                        help='Print output as YAML text, otherwise default is JSON text')
+    parser.add_argument('dir', type=str, default=str(Path('.')),
+                        help='Directory to look for DEPS.[markup] file')
+
+    try:
+        parsed, unparsed = parser.parse_known_args(list(args) + [''])
+        unparsed = list(filter(None, unparsed))
+    except argparse.ArgumentError:
+        return 1, f'problem attempting to parse_known_args for {args=}'
+
+    deps_path = parsed.dir
+    if os.path.isfile(deps_path):
+        deps_path, _ = os.path.split(deps_path)
+
+    try:
+        my_depsfile_obj = deps_file.DepsFile(None, deps_path, {})
+        if not my_depsfile_obj.deps_file:
+            return status_constants.EDA_DEPS_FILE_NOT_FOUND, f'No DEPS markup file at {parsed.dir}'
+
+        ret_str = my_depsfile_obj.str_sanitized_markup(as_yaml=parsed.yaml)
+        rc = util.get_return_code()
+        return rc, ret_str
+    except Exception as e:
+        rc = 1, str(e)
+
+    return 0, ''
+
+
+def main() -> None:
+    '''calls sys.exit(), main entrypoint'''
+    args = []
+    if len(sys.argv) > 1 and not args:
+        args = sys.argv[1:]
+
+    rc, deps_str = run(*args)
+    print(deps_str)
+    sys.exit(rc)
+
+
+if __name__ == '__main__':
+    main()

opencos/tests/test_tools.py

@@ -10,6 +10,7 @@ from opencos import eda, eda_tool_helper, eda_base
 
 from opencos.tools.verilator import ToolVerilator
 from opencos.tools.vivado import ToolVivado
+from opencos.tools.cocotb import ToolCocotb
 from opencos.tests import helpers
 from opencos.tests.helpers import eda_wrap
 from opencos.utils.markup_helpers import yaml_safe_load
@@ -48,7 +49,18 @@ def test_tools_loaded():
         full_ver = obj.get_full_tool_and_versions()
         assert chk_str in full_ver, f'{chk_str=} not in {full_ver=}'
         ver_num = full_ver.rsplit(':', maxsplit=1)[-1]
-        assert float(ver_num), f'{ver_num=} is not a float, from {full_ver=}'
+        if 'b' in ver_num:
+            ver_num = ver_num.split('b')[0] # TODO(chaitanya): remove once cocotb 2.0 is released
+        if '.' in ver_num:
+            major_ver = ver_num.split('.')[0]
+            assert major_ver.isdigit(), (
+                f'Major version {major_ver=} is not a digit, from {full_ver=}'
+            )
+            assert float(major_ver) >= 0, (
+                f'{major_ver=} is not a valid version number, from {full_ver=}'
+            )
+        else:
+            assert float(ver_num), f'{ver_num=} is not a float, from {full_ver=}'
 
 
     # Do some very crude checks on the eda.Tool methods, and make
@@ -61,6 +73,9 @@ def test_tools_loaded():
         my_tool = ToolVivado(config={})
         version_checker(obj=my_tool, chk_str='vivado:')
 
+    if 'cocotb' in tools_loaded:
+        my_tool = ToolCocotb(config={})
+        version_checker(obj=my_tool, chk_str='cocotb:')
 
 # Run these on simulation tools.
 list_of_commands = [
@@ -82,6 +97,11 @@ list_of_deps_targets = [
     ('tb_dollar_err', False),
 ]
 
+cannot_use_cocotb = 'cocotb' not in tools_loaded or \
+    ('iverilog' not in tools_loaded and \
+     'verilator' not in tools_loaded)
+CANNOT_USE_COCOTB_REASON = 'requires cocotb in tools_loaded, and one of (iverilog, verilator) too'
+
 @pytest.mark.parametrize("command", list_of_commands)
 @pytest.mark.parametrize("tool", list_of_tools)
 @pytest.mark.parametrize("target,sim_expect_pass", list_of_deps_targets)
@@ -154,3 +174,177 @@ def test_vivado_tool_defines():
 
     assert data['defines']['OC_LIBRARY'] == '1'
     assert data['defines']['OC_LIBRARY_ULTRASCALE_PLUS'] is None # key present, no value
+
+
+@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+def test_cocotb_tool_defines():
+    '''Test cocotb tool defines, configs, and integration.'''
+
+    chdir_remove_work_dir('../../examples/cocotb')
+
+    # Test 0: Using eda multi:
+    rc = eda_wrap('multi', 'sim', '--tool=cocotb', '*test')
+    assert rc == 0
+
+    # Test 1: basic cocotb sim command with Python runner (default)
+    rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_counter_test')
+    assert rc == 0
+
+    # Test 2: cocotb works with different simulators/configurations
+    rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_counter_waves_test')
+    assert rc == 0
+
+    # Test 3: Makefile approach
+    rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_counter_makefile_test')
+    assert rc == 0
+
+    # Test 4: cocotb-specific defines are set correctly
+    eda_config_yml_path = os.path.join(
+        os.getcwd(), 'eda.work', 'cocotb_counter_test.sim', 'eda_output_config.yml'
+    )
+
+    data = yaml_safe_load(eda_config_yml_path)
+    assert 'args' in data
+    assert data['args'].get('top', '') == 'counter'
+    assert 'config' in data
+    assert 'eda_original_args' in data['config']
+    assert 'cocotb_counter_test' in data['config']['eda_original_args'] or \
+        './cocotb_counter_test' in data['config']['eda_original_args']
+    assert data.get('target', '') == 'cocotb_counter_test'
+
+    assert 'defines' in data
+    assert 'OC_TOOL_COCOTB' in data['defines']
+    assert 'SIMULATION' in data['defines']
+    assert 'COCOTB' in data['defines']
+
+    assert data['defines']['SIMULATION'] == 1
+    assert data['defines']['COCOTB'] == 1
+    assert data['defines']['OC_TOOL_COCOTB'] is None  # key present, no value
+
+    assert 'VERILATOR' not in data['defines']
+    assert 'SYNTHESIS' not in data['defines']
+
+
+
+@pytest.mark.parametrize("cocotb_simulator", ['verilator', 'iverilog'])
+@pytest.mark.parametrize("waves_arg", ["", "--waves"])
+@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+def test_cocotb_different_simulators(cocotb_simulator, waves_arg):
+    '''Test cocotb with different simulator configurations.'''
+
+    if cocotb_simulator not in tools_loaded:
+        pytest.skip(f"{cocotb_simulator=} skipped, {tools_loaded=}")
+        return #skip/bypass
+
+    chdir_remove_work_dir('../../examples/cocotb')
+
+    rc = eda_wrap(
+        'sim', '--tool', 'cocotb',
+        f'--cocotb-simulator={cocotb_simulator}',
+        waves_arg,
+        'cocotb_counter_test',
+    )
+    assert rc == 0
+
+
+
+@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+def test_cocotb_tool_instantiation():
+    '''Test that ToolCocotb can be instantiated and has correct properties.'''
+
+    tool = ToolCocotb(config={})
+
+    # version detection works
+    version = tool.get_versions()
+    assert version, "Should return a non-empty version string"
+    assert isinstance(version, str)
+
+    # tool defines
+    tool.set_tool_defines()
+    defines = tool.defines
+    assert 'SIMULATION' in defines
+    assert 'COCOTB' in defines
+    assert 'OC_TOOL_COCOTB' in defines
+    assert defines['SIMULATION'] == 1
+    assert defines['COCOTB'] == 1
+
+
+
+@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+def test_cocotb_failure_cases():
+    '''Test cocotb failure scenarios to ensure proper error handling.'''
+
+    chdir_remove_work_dir('../../examples/cocotb')
+
+    # Test 1: missing test files should fail gracefully
+    rc = eda_wrap('sim', '--tool', 'cocotb', 'counter')  # Just HDL, no test files
+    assert rc > 1, "Should fail when no cocotb test files are found"
+
+    # Test 2: non-existent target should fail
+    rc = eda_wrap('sim', '--tool', 'cocotb', 'nonexistent_target')
+    assert rc > 1, "Should fail for non-existent target"
+
+    # Test 3: invalid cocotb test module should fail
+    rc = eda_wrap(
+        'sim', '--tool', 'cocotb',
+        '--cocotb-test-module=nonexistent_test',
+        'cocotb_counter_test',
+    )
+    assert rc > 1, "Should fail with invalid test module"
+
+
+@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+def test_cocotb_missing_dependencies():
+    '''Test cocotb behavior when dependencies are missing.'''
+
+    # Test missing cocotb installation (simulate by checking error handling)
+    tool = ToolCocotb(config={})
+    version = tool.get_versions()
+    assert version, "Should return version when cocotb is properly installed"
+
+    # Test tool defines are properly set even with minimal config
+    tool.set_tool_defines()
+    defines = tool.defines
+    assert 'SIMULATION' in defines
+    assert 'COCOTB' in defines
+    assert 'OC_TOOL_COCOTB' in defines
+
+
+@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+def test_cocotb_invalid_simulator():
+    '''Test cocotb with invalid simulator configuration.'''
+
+    chdir_remove_work_dir('../../examples/cocotb')
+
+    rc = eda_wrap(
+        'sim', '--tool', 'cocotb',
+        '--cocotb-simulator=invalid_sim',
+        'cocotb_counter_test',
+    )
+    assert rc > 1, "Should fail with invalid simulator"
+
+@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+def test_cocotb_malformed_hdl():
+    '''Test cocotb with malformed HDL files.'''
+
+    chdir_remove_work_dir('../../lib/tests')
+
+    # Test with a target that has syntax errors - should fail during compilation
+    rc = eda_wrap(
+        'sim', '--tool', 'cocotb',
+        '--cocotb-test-module=test_counter',
+        'tb_dollar_fatal',
+    )
+
+    assert rc > 1, "Should fail with malformed HDL or failing test assertions"
+
+
+@pytest.mark.skipif(cannot_use_cocotb, reason=CANNOT_USE_COCOTB_REASON)
+def test_cocotb_test_failures():
+    '''Test that cocotb properly reports test failures.'''
+
+    chdir_remove_work_dir('../../examples/cocotb')
+
+    # Intentionally failing cocotb tests
+    rc = eda_wrap('sim', '--tool', 'cocotb', 'cocotb_failure_test')
+    assert rc > 1, "Should fail when cocotb tests contain assertion failures"