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

opencos/commands/waves.py

@@ -32,6 +32,8 @@ class CommandWaves(CommandDesign):
 
     VSIM_TOOLS = set([
         'questa',
+        'questa_fse',
+        'riviera',
         'modelsim_ase',
     ])
 
@@ -137,13 +139,21 @@ class CommandWaves(CommandDesign):
                 self.error(f"Don't know how to open {wave_file} without one of",
                            f"{self.VSIM_TOOLS} in PATH")
         elif wave_file.endswith('.fst'):
-            if 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
+            if ('vaporview' in self.config['tools_loaded'] or \
+                'surfer' in self.config['tools_loaded']) and shutil.which('code'):
+                command_list = ['code', '-n', '.', wave_file]
+                self.exec(os.path.dirname(wave_file), command_list)
+            elif 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
                 command_list = ['gtkwave', wave_file]
                 self.exec(os.path.dirname(wave_file), command_list)
             else:
                 self.error(f"Don't know how to open {wave_file} without GtkWave in PATH")
         elif wave_file.endswith('.vcd'):
-            if 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
+            if ('vaporview' in self.config['tools_loaded'] or \
+                'surfer' in self.config['tools_loaded']) and shutil.which('code'):
+                command_list = ['code', '-n', '.', wave_file]
+                self.exec(os.path.dirname(wave_file), command_list)
+            elif 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
                 command_list = ['gtkwave', wave_file]
                 self.exec(os.path.dirname(wave_file), command_list)
             elif self._vsim_available(from_tools=self.VSIM_VCD_TOOLS):

opencos/eda.py

@@ -21,7 +21,7 @@ from pathlib import Path
 import opencos
 from opencos import util, eda_config, eda_base
 from opencos.eda_base import Tool, which_tool
-from opencos.utils import vsim_helper
+from opencos.utils import vsim_helper, vscode_helper
 
 # Configure util:
 util.progname = "EDA"
@@ -213,6 +213,19 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
             vsim_helper.init() # only runs checks once internally
             has_vsim_helper = vsim_helper.TOOL_IS.get(name, False)
 
+        has_vscode_helper = True
+        needs_vscode_extensions = value.get('requires_vscode_extension', None)
+        if needs_vscode_extensions:
+            if not isinstance(needs_vscode_extensions, list):
+                util.error(
+                    f'eda config issue, tool {name}: requires_vscode_extension must be a list'
+                )
+            else:
+                vscode_helper.init() # only runs checks once internally
+                has_vscode_helper = all(
+                    x in vscode_helper.EXTENSIONS for x in needs_vscode_extensions
+                )
+
         if has_all_exe:
             requires_cmd_list = value.get('requires_cmd', [])
             for cmd in requires_cmd_list:
@@ -230,8 +243,8 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
                     util.debug(f"... No, exception {e} running {cmd_list}")
 
 
-        if all([has_all_py, has_all_env, has_all_exe, has_all_in_exe_path,
-                has_vsim_helper]):
+        if all((has_all_py, has_all_env, has_all_exe, has_all_in_exe_path,
+                has_vsim_helper, has_vscode_helper)):
             exe = exe_list[0]
             p = shutil.which(exe)
             config['auto_tools_found'][name] = exe # populate key-value pairs w/ first exe in list

opencos/eda_config.py

@@ -46,7 +46,7 @@ class Defaults:
     supported_config_auto_tools_order_keys = set([
         'exe', 'handlers',
         'requires_env', 'requires_py', 'requires_cmd', 'requires_in_exe_path',
-        'requires_vsim_helper',
+        'requires_vsim_helper', 'requires_vscode_extension',
         'disable-tools-multi',
     ])
     supported_config_tool_keys = set([

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
@@ -431,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/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"

opencos/tools/cocotb.py

@@ -0,0 +1,483 @@
+''' opencos.tools.cocotb - Used by opencos.eda for sim commands with --tool=cocotb.
+
+Contains classes for ToolCocotb, CommandSimCocotb.
+'''
+
+import os
+import shutil
+import subprocess
+
+from opencos import util
+from opencos.eda_base import Tool
+from opencos.commands import CommandSim
+from opencos.utils.str_helpers import sanitize_defines_for_sh
+
+
+class ToolCocotb(Tool):
+    '''ToolCocotb used by opencos.eda for --tool=cocotb'''
+
+    _TOOL = 'cocotb'
+    _EXE = 'python'
+    _URL = 'https://github.com/cocotb/cocotb'
+
+    cocotb_version = ''
+    python_exe = ''
+
+    def get_versions(self) -> str:
+        if self._VERSION:
+            return self._VERSION
+
+        # Check if python is available
+        python_path = shutil.which('python') or shutil.which('python3')
+        if not python_path:
+            self.error('"python" or "python3" not in path, required for cocotb')
+        else:
+            self.python_exe = python_path
+
+        # Check if cocotb is installed
+        try:
+            version_ret = subprocess.run(
+                [self.python_exe, '-c', 'import cocotb; print(cocotb.__version__)'],
+                capture_output=True,
+                check=True,
+                text=True
+            )
+            version = version_ret.stdout.strip()
+            self.cocotb_version = version
+            self._VERSION = version
+            util.debug(f'Found cocotb version: {version}')
+            return self._VERSION
+        except subprocess.CalledProcessError:
+            self.error('cocotb package not installed in python environment. '
+                      'Install with: pip install cocotb')
+        except Exception as e:
+            self.error(f'Failed to check cocotb version: {e}')
+
+        return ''
+
+    def set_tool_defines(self):
+        super().set_tool_defines()
+        self.defines.update({
+            'SIMULATION': 1,
+            'COCOTB': 1,
+            'OC_TOOL_COCOTB': None,
+        })
+
+
+class CommandSimCocotb(CommandSim, ToolCocotb):
+    '''CommandSimCocotb is a command handler for: eda sim --tool=cocotb'''
+
+    def __init__(self, config: dict):
+        CommandSim.__init__(self, config)
+        ToolCocotb.__init__(self, config=self.config)
+
+        self.args.update({
+            'gui': False,
+            'tcl-file': None,
+            'cocotb-test-module': None,
+            'cocotb-test-runner': 'python',
+            'cocotb-simulator': 'verilator',
+            'cocotb-makefile': False,
+            'cocotb-python-runner': True,
+            'cocotb-standalone-makefile': False,
+        })
+
+        self.args_help.update({
+            '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-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'),
+        })
+
+        self.cocotb_command_lists = []
+        self.cocotb_test_files = []
+
+    def set_tool_defines(self):
+        ToolCocotb.set_tool_defines(self)
+
+    def prepare_compile(self):
+        self.set_tool_defines()
+
+        # Fix iverilog -> icarus
+        if self.args['cocotb-simulator'] == 'iverilog':
+            self.args['cocotb-simulator'] = 'icarus'
+
+        # Find cocotb test files
+        self._find_cocotb_test_files()
+
+        if self.args['cocotb-standalone-makefile']:
+            self._prepare_standalone_makefile_system()
+        elif self.args['cocotb-makefile']:
+            self._prepare_makefile_system()
+        else:
+            self._prepare_python_runner_system()
+
+        # Create directories
+        paths = ['logs', 'sim_build']
+        util.safe_mkdirs(base=self.args['work-dir'], new_dirs=paths)
+
+        # Write shell scripts
+        util.write_shell_command_file(
+            dirpath=self.args['work-dir'],
+            filename='cocotb_test.sh',
+            command_lists=self.cocotb_command_lists,
+            line_breaks=True
+        )
+
+        util.write_shell_command_file(
+            dirpath=self.args['work-dir'],
+            filename='all.sh',
+            command_lists=[
+                ['./pre_compile_dep_shell_commands.sh'],
+                ['./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:
+            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
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                        if 'import cocotb' in content or 'from cocotb' in content:
+                            self.cocotb_test_files.append(file_path)
+                            util.debug(f'Found cocotb test file: {file_path}')
+                except Exception as e:
+                    util.debug(f'Could not read {file_path}: {e}')
+
+        # If no test files found, look for explicit test module
+        if not self.cocotb_test_files and self.args.get('cocotb-test-module'):
+            test_module = self.args['cocotb-test-module']
+            if not test_module.endswith('.py'):
+                test_module += '.py'
+
+            # Look in work directory and target directory
+            for search_dir in [self.args['work-dir'], os.path.dirname(self.target or '.')]:
+                test_path = os.path.join(search_dir, test_module)
+                if os.path.exists(test_path):
+                    self.cocotb_test_files.append(test_path)
+                    break
+
+        if not self.cocotb_test_files:
+            self.error('No cocotb test files found. Either include .py files with '
+                      'cocotb imports in your deps, or specify --cocotb-test-module')
+
+    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()
+
+        if self.args['cocotb-test-runner'] == 'pytest':
+            # Use pytest to run the tests
+            runner_script_name = os.path.basename(runner_script)
+            cmd_list = [
+                self.python_exe, '-m', 'pytest',
+                runner_script_name,
+                '-v', '-s'
+            ]
+        else:
+            # Run the Python script directly
+            runner_script_name = os.path.basename(runner_script)
+            cmd_list = [self.python_exe, runner_script_name]
+
+        # 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')]
+
+    def _prepare_makefile_system(self):
+        '''Prepare cocotb using the traditional Makefile system'''
+
+        makefile_path = os.path.join(self.args['work-dir'], 'Makefile')
+        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')]
+
+    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:
+            if os.path.basename(file_path).lower() == 'makefile':
+                makefile_path = file_path
+                break
+
+        if not makefile_path:
+            self.error('No Makefile found in deps for --cocotb-standalone-makefile')
+
+        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')]
+
+    def _get_test_module_name(self) -> str:
+        '''Get the test module name from args or detected files'''
+        if self.args.get('cocotb-test-module'):
+            return self.args['cocotb-test-module']
+        if self.cocotb_test_files:
+            # Use the first test file found, strip .py extension
+            test_file = os.path.basename(self.cocotb_test_files[0])
+            return test_file.replace('.py', '')
+        return 'test_design'
+
+
+    def _get_hdl_sources(self) -> dict:
+        '''Get HDL source files organized by type'''
+        return {
+            'verilog': (self.files_sv or []) + (self.files_v or []),
+            'vhdl': self.files_vhd or [],
+            'all': (self.files_sv or []) + (self.files_v or []) + (self.files_vhd or [])
+        }
+
+    def _create_python_runner_script(self) -> str:
+        '''Create the Python runner script and return its path'''
+        test_module = self._get_test_module_name()
+        hdl_sources = self._get_hdl_sources()['all']
+
+        script_content = self._generate_runner_script_content(test_module, hdl_sources)
+        script_path = os.path.join(self.args['work-dir'], 'cocotb_runner.py')
+
+        with open(script_path, 'w', encoding='utf-8') as f:
+            f.write(script_content)
+
+        os.chmod(script_path, 0o755)
+
+        return script_path
+
+    def _generate_runner_script_content(self, test_module: str, hdl_sources: list) -> str:
+        '''Generate the content for the Python runner script'''
+        return f'''#!/usr/bin/env python3
+"""
+Cocotb test runner script generated by opencos
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add current directory to Python path for test imports
+sys.path.insert(0, os.getcwd())
+
+try:
+    from cocotb_tools.runner import get_runner
+except ImportError:
+    print("ERROR: cocotb not found. Install with: pip install cocotb")
+    sys.exit(1)
+
+def run_cocotb_test():
+    """Run cocotb test using the Python runner system"""
+
+    # Configuration
+    simulator = "{self.args['cocotb-simulator']}"
+    hdl_toplevel = "{self.args.get('top', 'top')}"
+    test_module = "{test_module}"
+
+    # HDL source files
+    hdl_sources = {hdl_sources!r}
+
+    # Convert to Path objects and make absolute
+    sources = []
+    for src in hdl_sources:
+        src_path = Path(src)
+        if not src_path.is_absolute():
+            src_path = Path.cwd() / src_path
+        sources.append(src_path)
+
+    # Include directories
+    include_dirs = {list(self.incdirs)!r}
+
+    # Defines (filter out None values for cocotb compatibility)
+    all_defines = {dict(self.defines)!r}
+    defines = {{k: v for k, v in all_defines.items() if v is not None}}
+
+    # Parameters (empty for simple modules without parameters)
+    parameters = {{}}
+
+    try:
+        # Get the runner for the specified simulator
+        runner = get_runner(simulator)
+
+        # Build the design
+        runner.build(
+            sources=sources,
+            hdl_toplevel=hdl_toplevel,
+            includes=include_dirs,
+            defines=defines,
+            parameters=parameters,
+            build_dir="sim_build",
+        )
+
+        # Run the test
+        runner.test(
+            hdl_toplevel=hdl_toplevel,
+            test_module=test_module,
+            test_dir=".",
+        )
+
+        print("{self._get_success_message()}")
+
+    except Exception as e:
+        print(f"ERROR: Cocotb test failed: {{e}}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    run_cocotb_test()
+'''
+
+    def _create_makefile_content(self) -> str:
+        '''Create Makefile content for cocotb traditional system'''
+
+        # Determine test module
+        test_module = self._get_test_module_name()
+
+        # Get HDL sources and determine language
+        hdl_sources = self._get_hdl_sources()
+        verilog_sources = hdl_sources['verilog']
+        vhdl_sources = hdl_sources['vhdl']
+
+        # Determine HDL language
+        if vhdl_sources and not verilog_sources:
+            hdl_lang = 'vhdl'
+            sources_var = 'VHDL_SOURCES'
+            sources_list = ' '.join(vhdl_sources)
+        else:
+            hdl_lang = 'verilog'
+            sources_var = 'VERILOG_SOURCES'
+            sources_list = ' '.join(verilog_sources)
+
+        makefile_content = f'''# Cocotb Makefile generated by opencos
+
+# Simulator selection
+SIM ?= {self.args['cocotb-simulator']}
+
+# HDL language
+TOPLEVEL_LANG = {hdl_lang}
+
+# HDL sources
+{sources_var} = {sources_list}
+
+# Top level module
+TOPLEVEL = {self.args.get('top', 'top')}
+
+# Test module
+MODULE = {test_module}
+
+# Include directories
+'''
+
+        if self.incdirs:
+            makefile_content += ('COMPILE_ARGS += ' +
+                               ' '.join(f'-I{inc}' for inc in self.incdirs) + '\n')
+
+        # Add defines
+        if self.defines:
+            define_args = []
+            for k, v in self.defines.items():
+                if v is None:
+                    define_args.append(f'-D{k}')
+                else:
+                    define_args.append(f'-D{k}={sanitize_defines_for_sh(v)}')
+            makefile_content += 'COMPILE_ARGS += ' + ' '.join(define_args) + '\n'
+
+        makefile_content += '''
+# Waves support
+ifeq ($(WAVES),1)
+    COCOTB_ENABLE_WAVES = 1
+    export COCOTB_ENABLE_WAVES
+endif
+
+# Include cocotb's Makefile
+include $(shell cocotb-config --makefiles)/Makefile.sim
+'''
+
+        return makefile_content
+
+    def _get_success_message(self) -> str:
+        '''Get standardized success message'''
+        return "Cocotb test completed successfully!"
+
+    def _create_shell_command_with_success(self, base_command: str) -> list:
+        '''Create a shell command list with success message'''
+        return ['sh', '-c', f'{base_command} && echo "{self._get_success_message()}"']
+
+    def _get_cocotb_env_vars(self) -> dict:
+        '''Get environment variables for cocotb execution'''
+        env_vars = {}
+
+        # Basic cocotb configuration
+        env_vars['SIM'] = self.args['cocotb-simulator']
+        env_vars['TOPLEVEL'] = self.args.get('top', 'top')
+
+        # Enable waves if requested
+        if self.args.get('waves', False):
+            env_vars['COCOTB_ENABLE_WAVES'] = '1'
+
+        # Set log level based on verbosity
+        if util.args.get('verbose', False):
+            env_vars['COCOTB_LOG_LEVEL'] = 'DEBUG'
+        else:
+            env_vars['COCOTB_LOG_LEVEL'] = 'INFO'
+
+        # Random seed
+        if self.args.get('seed'):
+            env_vars['COCOTB_RANDOM_SEED'] = str(self.args['seed'])
+
+        return env_vars
+
+    def _create_env_command(self, env_vars: dict) -> list:
+        '''Create environment variable command prefix'''
+        env_cmd = []
+        for key, value in env_vars.items():
+            env_cmd.extend(['env', f'{key}={value}'])
+        return env_cmd
+
+    def compile(self):
+        # For cocotb, compilation happens as part of the test run
+        if self.args['stop-before-compile']:
+            return
+        util.info('Cocotb: compilation will happen during test execution')
+
+    def elaborate(self):
+        # For cocotb, elaboration happens as part of the test run
+        pass
+
+    def simulate(self):
+        if self.args['stop-before-compile'] or self.args['stop-after-compile'] or \
+           self.args['stop-after-elaborate']:
+            return
+
+        # Run the cocotb tests
+        self.run_commands_check_logs(self.cocotb_command_lists)
+
+    def get_compile_command_lists(self, **kwargs) -> list:
+        # Cocotb handles compilation internally
+        return []
+
+    def get_elaborate_command_lists(self, **kwargs) -> list:
+        # Cocotb handles elaboration internally
+        return []
+
+    def get_simulate_command_lists(self, **kwargs) -> list:
+        return self.cocotb_command_lists
+
+    def get_post_simulate_command_lists(self, **kwargs) -> list:
+        return []

opencos/tools/verilator.py

@@ -79,6 +79,8 @@ class VerilatorSim(CommandSim, ToolVerilator):
             'lint-only': False,
             'cc-mode': False,
             'verilator-coverage-args': [],
+            'x-assign': '',
+            'x-initial': '',
         })
 
         self.args_help.update({
@@ -92,6 +94,14 @@ class VerilatorSim(CommandSim, ToolVerilator):
             'gui':       'Not supported for Verilator',
             'cc-mode':   'Run verilator with --cc, requires a sim_main.cpp or similar sources',
             'optimize':  'Run verilator with: -CLAGS -O3, if no other CFLAGS args are presented',
+            'x-assign': ('String value to added to verilator call: --x-assign <string>;'
+                         ' where valid string values are: 0, 1, unique, fast.'
+                         ' Also conditinally adds to verilated exe call:'
+                         ' +verilator+rand+reset+[0,1,2] for arg values 0, 1, unique|fast'),
+            'x-initial': ('String value to added to verilator call: --x-initial <string>;'
+                         ' where valid string values are: 0, unique, fast.'
+                         ' Also conditinally adds to verilated exe call:'
+                         ' +verilator+rand+reset+[0,2] for arg values 0, unique|fast'),
         })
 
         self.verilate_command_lists = []
@@ -219,6 +229,14 @@ class VerilatorSim(CommandSim, ToolVerilator):
                 '-o', 'sim.exe',
             ]
 
+        for arg in ('x-assign', 'x-initial'):
+            if self.args[arg] and f'--{arg}' not in verilate_command_list:
+                # Only add this if arg is set, and not present in verilator call
+                # this takes care of it being in our self.tool_config for compile-args.
+                verilate_command_list += [
+                    f'--{arg}', self.args[arg]
+                ]
+
         # incdirs
         for value in self.incdirs:
             verilate_command_list += [ f"+incdir+{value}" ]
@@ -295,6 +313,19 @@ class VerilatorSim(CommandSim, ToolVerilator):
         if not any(x.startswith('+verilator+seed+') for x in verilated_exec_command_list):
             verilated_exec_command_list.append(f'+verilator+seed+{verilator_seed}')
 
+        if any(self.args[arg] in ('unique', 'fast') for arg in ('x-assign', 'x-initial')) and \
+           not any(x.startswith('+verilator+rand+reset') for x in verilated_exec_command_list):
+            # Only add this if arg is one of x-assign/x-initial is set to "unique" or "fast",
+            # we use the encoded value "2" for +verilator+rand+reset+2
+            verilated_exec_command_list.append('+verilator+rand+reset+2')
+
+        if self.args['x-assign'] == '1' and \
+           not any(x.startswith('+verilator+rand+reset') for x in verilated_exec_command_list):
+            # Only add this if --x-assign=1 (not valid for --x-initial),
+            # we use the encoded value "1" for +verilator+rand+reset+1
+            verilated_exec_command_list.append('+verilator+rand+reset+1')
+
+
         return [
             util.ShellCommandList(verilated_exec_command_list, tee_fpath='sim.log')
         ] # single entry list

opencos/util.py

@@ -425,10 +425,12 @@ def process_tokens(tokens:list) -> (argparse.Namespace, list):
     elif parsed.logfile:
         start_log(parsed.logfile, force=False)
     elif parsed.default_log and \
+         not parsed.version and \
          not any(x in unparsed for x in ('help', '-h', '--help')) and \
          (parsed.force_logfile is None and parsed.logfile is None):
         # Use a forced logfile in the eda.work/eda.log:
         # avoid this if someone has --help arg not yet parsed.
+        # avoid this if someone called --version, b/c that will print and exit.
         start_log(global_log.default_log_filepath, force=True)
 
     parsed_as_dict = vars(parsed)

opencos/utils/vscode_helper.py

@@ -0,0 +1,47 @@
+'''Because > 1 tools use the exe 'code', I don't want to run
+
+`code --list-extensions --show-versionsvsim -version` for every tool that needs
+to check if they exist in VScode land.
+
+Instead, eda.py can call this once, and then query if the VScode extension exists when
+running opencos.eda.auto_tool_setup(..)
+'''
+
+import shutil
+import subprocess
+
+from opencos.util import debug
+
+vscode_path = shutil.which('code')
+
+INIT_HAS_RUN = False
+EXTENSIONS = {} # dict of {name: version} for VScode extensions of name
+
+
+def init() -> None:
+    '''Sets INIT_HAS_RUN=True (only runs once) and one of TOOL_IS[tool] = True'''
+    global INIT_HAS_RUN # pylint: disable=global-statement
+
+    if INIT_HAS_RUN:
+        return
+
+    INIT_HAS_RUN = True
+
+    if not vscode_path:
+        return
+
+    proc = None
+    try:
+        proc = subprocess.run([vscode_path, '--list-extensions', '--show-versions'],
+                              capture_output=True, check=False)
+    except Exception as e:
+        debug(f'vscode --list-extensions --show-versions: exception {e}')
+
+    if proc is None or proc.returncode != 0:
+        return
+
+    for line in proc.stdout.decode('utf-8', errors='replace').split('\n'):
+        if '@' in line:
+            parts = line.split('@')
+            if parts[0] and parts[1]:
+                EXTENSIONS[parts[0]] = parts[1]

{opencos_eda-0.2.51.dist-info → opencos_eda-0.2.52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.51
+Version: 0.2.52
 Summary: A simple Python package for wrapping RTL simuliatons and synthesis
 Author-email: Simon Sabato <simon@cognichip.ai>, Drew Ranck <drew@cognichip.ai>
 Project-URL: Homepage, https://github.com/cognichip/opencos
@@ -15,4 +15,5 @@ Requires-Dist: schema>=0.7.7
 Requires-Dist: toml>=0.10.2
 Requires-Dist: yamllint>=1.35.1
 Requires-Dist: PySerial>=3.5
+Requires-Dist: cocotb>=2.0.0b1
 Dynamic: license-file

{opencos_eda-0.2.51.dist-info → opencos_eda-0.2.52.dist-info}/RECORD

@@ -2,10 +2,10 @@ opencos/__init__.py,sha256=RwJA9oc1uUlvNX7v5zoqwjnSRNq2NZwRlHqtS-ICJkI,122
 opencos/_version.py,sha256=XiHFZjCofkkZvI9befTFKsRt5zLouUo1CIwhW4srWU0,582
 opencos/_waves_pkg.sv,sha256=1lbhQOVGc3t_R8czYjP40hssP0I3FlZOpHTkI7yKFbI,1251
 opencos/deps_schema.py,sha256=pdJpKmfXxCYZsfXTxsnACw-s6Mzk55QH06ZSA5uqPV0,15454
-opencos/eda.py,sha256=rYBt4Qu2y45zdwD4jDx_p3l2u5LMS1nsaGQCP2ZYdwY,20883
+opencos/eda.py,sha256=bK5wX9EUib7UkIR0LcM_kGBjv_eGxjBBYjYkutYLTgI,21501
 opencos/eda_base.py,sha256=q0uKEzAMzLmqb4jMBcGv7rTpdKnfrhnMZo7MyB8YN8Y,95706
-opencos/eda_config.py,sha256=Xma8w7kBLCNPCSrCKpceieU7GUBv4i54XZlHjnZ95X4,11353
-opencos/eda_config_defaults.yml,sha256=PdR3xHWQIdGeIyCTr2c3W9Vfq9RC1E9HbqiSydyDYZE,12417
+opencos/eda_config.py,sha256=R6tbcuBJWA0vv1s9K_L928EVbjhv-lqDFLZqk_UGe9w,11382
+opencos/eda_config_defaults.yml,sha256=dy5MKm5wbam8aT39frSLbJJm6LPJpoeI7PO_XOpt27A,13147
 opencos/eda_config_max_verilator_waivers.yml,sha256=lTAU4IOEbUWVlPzuer1YYhIyxpPINeA4EJqcRIT-Ymk,840
 opencos/eda_config_reduced.yml,sha256=cQ9jY4J7EvAbeHTiP6bvpDSVJAYiitjLZPSxxLKIEbk,1440
 opencos/eda_deps_bash_completion.bash,sha256=jMkQKY82HBgOnQeMdA1hMrXguRFtB52SMBxUemKovL4,1958
@@ -18,7 +18,7 @@ opencos/files.py,sha256=aoq0O2KfISzZb-Vi_q_0TTGBER9xJc--FkVZf0ga7pA,1549
 opencos/names.py,sha256=iC37PV7Pz0PicTDg09vbQ9NXAj-5m6RKrWHkkcHB8As,1145
 opencos/peakrdl_cleanup.py,sha256=vHNGtalTrIVP335PhRjPt9RhoccgpK1HJAi-E4M8Kc8,736
 opencos/seed.py,sha256=IL9Yg-r9SLSRseMVWaEHmuw2_DNi_eyut11EafoNTsU,942
-opencos/util.py,sha256=hnE66Mu7Uu-OGdAE5gkJ8nsKc_zUNMptXcuBFkm30wU,33975
+opencos/util.py,sha256=L36MM2cqR0xWbs617AJN52JvrTkrgggELHG3Y3s2jPI,34089
 opencos/commands/__init__.py,sha256=DtOA56oWJu68l-_1_7Gdv0N-gtXVB3-p9IhGzAYex8U,1014
 opencos/commands/build.py,sha256=jI5ul53qfwn6X-yfSdSQIcLBhGtzZUk7r_wKBBmKJI0,1425
 opencos/commands/elab.py,sha256=m6Gk03wSzX8UkcmReooK7turF7LpqO0IcdOZwJ8XiyI,1596
@@ -34,7 +34,7 @@ opencos/commands/sweep.py,sha256=ni4XFgnFF8HLXtwPhETyLWfvc2kgtm4bcxFcKzUhkf0,934
 opencos/commands/synth.py,sha256=quB-HWS4LKYTiFBHiYarQi4pMnRmt12wQTZpi14VvlE,4355
 opencos/commands/targets.py,sha256=_jRNhm2Fqj0fmMvTw6Ba39DCsRHf_r_uZCy_R064kpA,1472
 opencos/commands/upload.py,sha256=nlb4nlxrDCQPcabEmH3nP19g4PFILDqFDab4LwJ95Z4,796
-opencos/commands/waves.py,sha256=dsWwtjpDgH-YsiIjJgqTvteY3OZ48UnEAWc3blV2Fog,7055
+opencos/commands/waves.py,sha256=s8xYyNFBDqUtGdpioVIHWDKE4ZSnY6e1gdZNIm7yXBE,7654
 opencos/deps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opencos/deps/defaults.py,sha256=4VgTRXf0hSJrj4tMk0t-mmvgEaaQQFDIYrxWrcKfYWk,1241
 opencos/deps/deps_commands.py,sha256=OlqueYFK8U83loasok3xJGzUDpNcj2DPk37332DfmRo,17039
@@ -53,7 +53,7 @@ opencos/tests/test_eda.py,sha256=bg7SjSVCJSJ2lk51ddfjuVckMOps6_HU-3tCwAIRO7c,391
 opencos/tests/test_eda_elab.py,sha256=VyYiaLLyfJi26FkoN9p_Kb9cMHfY-0u_0Mx1iVpsg-I,2657
 opencos/tests/test_eda_synth.py,sha256=LOM8CKpNyjka_sKS2c00YObOAQeVgpRmuM12Bn-PHqU,5234
 opencos/tests/test_oc_cli.py,sha256=w-F-LjSSWVql3D2WG8tcV4_C52i-hL_2WT3oDpKQn9s,734
-opencos/tests/test_tools.py,sha256=HEjKm86OMcrZznJMiiDFsDBN8FlBf4LR9egGO1pOh5c,5285
+opencos/tests/test_tools.py,sha256=1x6zaDhhkkzcKpZjCdWqzYJPzrK_pnqBeUWiuy8cqAg,12128
 opencos/tests/deps_files/command_order/DEPS.yml,sha256=vloOzWZ5qU3yGNFaDlrAJdEzYxK6qf8gfac3zqF-0FI,438
 opencos/tests/deps_files/error_msgs/DEPS.yml,sha256=fYvHouIscOlr8V28bqx9SoxRBpDBLX4AG-AkVXh8qbo,717
 opencos/tests/deps_files/iverilog_test/DEPS.yml,sha256=vDylEuLt642lhRSvOr3F5ziB5lhPSwkaUGN4_mWJw-c,40
@@ -62,6 +62,7 @@ opencos/tests/deps_files/non_sv_reqs/DEPS.yml,sha256=VZkahO1AKhD9GUV5lK8VwUONEi5
 opencos/tests/deps_files/tags_with_tools/DEPS.yml,sha256=-5U1qfJElgpVhmkLEu3lYuvDYva8kDlt6JOdB9jidmc,1377
 opencos/tests/deps_files/test_err_fatal/DEPS.yml,sha256=GnXIUJvshQWR9PlYxX67T53ejf5KhDbtD8sUJB4Rwd0,95
 opencos/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opencos/tools/cocotb.py,sha256=0AzT2pJWKwepZMT_hlgYYMV_Fr3Qr4gH7BgMDtNuLK0,16614
 opencos/tools/invio.py,sha256=q9E9n6xsozDfar-1rLvJEZbCpPb_bQEy6WKEI3KS3dk,3163
 opencos/tools/invio_helpers.py,sha256=1au4CYmV5aC7DHjaZBNemydH6Eq0i-Yt5L3HyKfQOfY,7638
 opencos/tools/invio_yosys.py,sha256=asSjbdPjBXB76KxNZIhoDRn2DoXKsZEQ1YDX_WBzKiA,6019
@@ -74,7 +75,7 @@ opencos/tools/slang.py,sha256=mFw58vhnCTRR9yaQ2zHPlNB5HKSf3Y078XcaVnpLaAc,7798
 opencos/tools/slang_yosys.py,sha256=3fyLRRdTXhSppNtUhhUl00oG-cT9TyyPTH6JvasS9ZE,9804
 opencos/tools/surelog.py,sha256=dtj3ApAKoQasnGdg42n9DPgeqoJ5nCuurIkIO3G5ZCY,5011
 opencos/tools/tabbycad_yosys.py,sha256=2LePPgYXBVdsy7YcffPIWN-I0B7queLQ_f_pme2SCGw,7803
-opencos/tools/verilator.py,sha256=h5VScZyJYxk2cXDRrTTD47C_yAVHuyXv9_p7UL1o5mk,19486
+opencos/tools/verilator.py,sha256=dIhrvLH9hHiTV_DWQbMNlAjolKctCbBMO9u9V7yAHuE,21400
 opencos/tools/vivado.py,sha256=roM0MxrHoNIT_DsUiql1vQFlez2ql4qhwAfB-rGH4Qg,40485
 opencos/tools/yosys.py,sha256=UKWzvc2rSi3J9U2TROqRbmePdBmjskap664giumeRBk,26323
 opencos/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -82,11 +83,12 @@ opencos/utils/markup_helpers.py,sha256=A8Ev5UJ4EVKjdcF2g85SQbjdPZR4jGpNqCLaBy_4v
 opencos/utils/status_constants.py,sha256=aQui30ohPCEaWNDh2iujJQ_KQa3plry_rk7uDzS3vWk,603
 opencos/utils/str_helpers.py,sha256=DOkwfKJR6aENM3U2BkJ41ELDU5Uj_zyhEfxuaQEcpEY,3352
 opencos/utils/subprocess_helpers.py,sha256=xemAGPey6M0sWY_FElvr-Z0phCfdjaC-znP8FKihPaE,3535
+opencos/utils/vscode_helper.py,sha256=2YPjcDH_vTlwJvcITyMfvx8dLzPSRKzAvFRJz7BaJk8,1332
 opencos/utils/vsim_helper.py,sha256=2voGRZI2iAQ2Pv2ZI5g2why6xpgig-To8im-LVXtuDU,1517
-opencos_eda-0.2.51.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-opencos_eda-0.2.51.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
-opencos_eda-0.2.51.dist-info/METADATA,sha256=XAX9j35DEWh0nLU7Gt8unosqGzK9dGeqHtGcj8IgK-8,604
-opencos_eda-0.2.51.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opencos_eda-0.2.51.dist-info/entry_points.txt,sha256=6n1T5NwVYDhN5l1h5zmyT197G4pE0SySDreB0QJzJR0,218
-opencos_eda-0.2.51.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
-opencos_eda-0.2.51.dist-info/RECORD,,
+opencos_eda-0.2.52.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+opencos_eda-0.2.52.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
+opencos_eda-0.2.52.dist-info/METADATA,sha256=NLxBxJ0aSl6Vfizn3tZqnskXn6VuWpDSdZQdKb4BGig,635
+opencos_eda-0.2.52.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opencos_eda-0.2.52.dist-info/entry_points.txt,sha256=6n1T5NwVYDhN5l1h5zmyT197G4pE0SySDreB0QJzJR0,218
+opencos_eda-0.2.52.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
+opencos_eda-0.2.52.dist-info/RECORD,,