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

opencos/tools/questa.py

@@ -14,7 +14,7 @@ import shutil
 
 from opencos import util
 from opencos.eda_base import Tool
-from opencos.commands import CommandSim
+from opencos.commands import CommandSim, CommandFList
 
 class ToolQuesta(Tool):
     '''Base class for CommandSimQuesta, collects version information about qrun'''
@@ -23,6 +23,7 @@ class ToolQuesta(Tool):
     _EXE = 'qrun'
 
     starter_edition = False # Aka, modelsim_ase
+    use_vopt = shutil.which('vopt') # vopt exists in qrun/vsim framework, and we'll use it.
     sim_exe = '' # vsim or qrun
     sim_exe_base_path = ''
     questa_major = None
@@ -74,126 +75,204 @@ class CommandSimQuesta(CommandSim, ToolQuesta):
         CommandSim.__init__(self, config)
         ToolQuesta.__init__(self, config=self.config)
         # add args specific to this simulator
-        self.args['gui'] = False
-        self.args['tcl-file'] = "sim.tcl"
+        self.args.update({
+            'gui': False,
+            'tcl-file': 'sim.tcl',
+            'work-lib': 'work',
+        })
+        self.args_help.update({
+            'gui': 'Run Questa in GUI mode',
+            'tcl-file': 'name of TCL file to be created for Questa simulation',
+            'work-lib': 'Questa work library name',
+        })
+
         self.shell_command = self.sim_exe # set by ToolQuesta.get_versions(self)
+        self.vlog_commands = []
+        self.vopt_commands = []
+        self.vsim_commands = []
 
     def set_tool_defines(self):
         ToolQuesta.set_tool_defines(self)
 
-    def do_it(self):
-        # add defines for this job
+    # We do not override CommandSim.do_it(), CommandSim.check_logs_for_errors(...)
+
+    def prepare_compile(self):
         self.set_tool_defines()
+        self.vlog_commands = self.get_compile_command_lists()
+        self.vopt_commands = self.get_elaborate_command_lists()
+        self.vsim_commands = self.get_simulate_command_lists()
+
+        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='compile.sh',
+                                      command_lists=self.vlog_commands)
+        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='elaborate.sh',
+                                      command_lists=self.vopt_commands)
+        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='simulate.sh',
+                                      command_lists=self.vsim_commands)
+        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='all.sh',
+                                      command_lists = [
+                                          ['./pre_compile_dep_shell_commands.sh'],
+                                          ['./compile.sh'],
+                                          ['./elaborate.sh'],
+                                          ['./simulate.sh'],
+                                      ])
+
         self.write_eda_config_and_args()
 
-        # it all gets done with one command
-        command_list = [ self.shell_command, "-64", "-sv" ]
-
-        # incdirs
-        for value in self.incdirs:
-            command_list += [ f"+incdir+{value}" ]
-
-        # defines
-        for key, value in self.defines.items():
-            if value is None:
-                command_list += [ f"+define+{key}" ]
-            elif isinstance(value, str) and "\'" in value:
-                command_list += [ f"\"+define+{key}={value}\"" ]
-            else:
-                command_list += [ f"\'+define+{key}={value}\'" ]
-
-        # compile verilog
-        for f in self.files_v:
-            command_list += [ f ]
-
-        # compile systemverilog
-        for f in self.files_sv:
-            command_list += [ f ]
-
-        # TODO(drew): We don't natively support Xilinx Ultrascale+ glbl.v in questa yet.
-        # To do so, would need to do something along the lines of:
-        # if using_queta_and_xilinx_libs:
-        #     vivado_base_path = getattr(self, 'vivado_base_path', '')
-        #     glbl_v = vivado_base_path.replace('bin', 'data/verilog/src/glbl.v')
-        #     if not os.path.exists(glbl_v):
-        #         self.error(f"Vivado is not setup, could not find file {glbl_v=}")
-        #     command_list.append(glbl_v)
-
-        # misc options
-        command_list += [ '-top', self.args['top'], '-timescale', '1ns/1ps', '-work', 'work.lib']
-        # TODO(drew): most of these should move to eda_config_defaults.yml
-        command_list += [
-            # avoid warnings about defaulting to "var" which isn't LRM behavior
-            '-svinputport=net',
-            #  Existing package 'xxxx_pkg' at line 9 will be overwritten.
-            '-suppress', 'vlog-2275',
-            #  Extra checking for conflict in always_comb and always_latch variables at vopt time
-            '-suppress', 'vlog-2583',
-            #  Missing connection for port 'xxxx' (The default port value will be used)
+    def compile(self):
+        if self.args['stop-before-compile']:
+            return
+        self.run_commands_check_logs(
+            self.vlog_commands, check_logs=True, log_filename='vlog.log'
+        )
+
+    def elaborate(self):
+        if self.args['stop-before-compile'] or self.args['stop-after-compile']:
+            return
+        self.run_commands_check_logs(
+            self.vopt_commands, check_logs=True, log_filename='vopt.log'
+        )
+
+    def simulate(self):
+        if self.args['stop-before-compile'] or self.args['stop-after-compile'] or \
+           self.args['stop-after-elaborate']:
+            return
+        self.run_commands_check_logs(
+            self.vsim_commands, check_logs=True, log_filename='vsim.log'
+        )
+
+    def get_compile_command_lists(self, **kwargs) -> list:
+        self.set_tool_defines()
+        ret = []
+
+        # Create work library
+        vlib_cmd = [os.path.join(self.sim_exe_base_path, 'vlib'), self.args['work-lib']]
+        ret.append(vlib_cmd)
+
+        # Map work library
+        vmap_cmd = [os.path.join(self.sim_exe_base_path, 'vmap'), 'work', self.args['work-lib']]
+        ret.append(vmap_cmd)
+
+        # Compile files
+        if self.files_v or self.files_sv:
+            vlog_cmd = [os.path.join(self.sim_exe_base_path, 'vlog'), '-64', '-sv']
+
+            # Add include directories
+            for incdir in self.incdirs:
+                vlog_cmd += [f'+incdir+{incdir}']
+
+            # Add defines
+            for key, value in self.defines.items():
+                if value is None:
+                    vlog_cmd += [f'+define+{key}']
+                else:
+                    vlog_cmd += [f'+define+{key}={value}']
+
+            # Add suppression flags
+            vlog_cmd += [
+                '-svinputport=net',
+                '-suppress', 'vlog-2275',
+                '-suppress', 'vlog-2583',
+            ]
+
+            # Add source files
+            vlog_cmd += self.files_v + self.files_sv
+
+            ret.append(vlog_cmd)
+
+        # Compile VHDL files if any
+        if self.files_vhd:
+            vcom_cmd = [os.path.join(self.sim_exe_base_path, 'vcom'), '-64']
+            vcom_cmd += self.files_vhd
+            ret.append(vcom_cmd)
+
+        return ret
+
+    def get_elaborate_command_lists(self, **kwargs) -> list:
+        if self.args['stop-after-compile']:
+            return []
+
+        vopt_cmd = [os.path.join(self.sim_exe_base_path, 'vopt'), '-64']
+
+        # Add optimization flags
+        vopt_cmd += [
             '-suppress', 'vopt-13159',
-            #  Too few port connections for 'uAW_FIFO'.  Expected 10, found 8
             '-suppress', 'vopt-2685',
-            #  Missing connection for port 'almostEmpty' ... same message for inputs and outputs.
             '-note', 'vopt-2718',
         ]
-        if self.args['gui']:
-            command_list += ['-gui=interactive', '+acc', '-i']
-        elif self.args['waves']:
-            command_list += ['+acc', '-c']
-        else:
-            command_list += ['-c']
 
-        if util.args['verbose']:
-            command_list += ['-verbose']
+        if self.args['gui'] or self.args['waves']:
+            vopt_cmd += ['+acc']
 
-        # TODO(drew): We don't natively support Xilinx Ultrascale+ libraries in --tool=questa
-        # with an easy hook (like --xilinx) but we could?
-        # To get this to work, need to add this, among other items:
-        # --> command_list += '''-L xil_defaultlib -L unisims_ver -L unimacro_ver
-        #                        -L xpm -L secureip -L xilinx_vip'''.split(" ")
+        # Add top module and output
+        vopt_cmd += [self.args['top'], '-o', 'opt_design']
 
-        # check if we're bailing out early
-        if self.args['stop-after-elaborate']:
-            command_list += ['-elab', 'elab.output', '-do', '"quit"' ]
+        return [vopt_cmd]
 
-        # create TCL
+    def get_simulate_command_lists(self, **kwargs) -> list:
+        # Create TCL file
         tcl_name = os.path.abspath(os.path.join(self.args['work-dir'], self.args['tcl-file']))
-        with open( tcl_name, 'w', encoding='utf-8' ) as fo:
+
+        if self.args['waves']:
+            util.artifacts.add_extension(
+                search_paths=self.args['work-dir'], file_extension='wlf',
+                typ='waveform', description='Questa Waveform WLF file'
+            )
+
+        with open(tcl_name, 'w', encoding='utf-8') as fo:
             if self.args['waves']:
                 if self.args['waves-start']:
                     print(f"run {self.args['waves-start']} ns", file=fo)
                 print("add wave -r /*", file=fo)
             print("run -all", file=fo)
-            if not self.args['gui']:
+            if self.run_in_batch_mode():
                 print("quit", file=fo)
-        command_list += ['-do', tcl_name ]
 
-        # execute snapshot
-        self.exec(self.args['work-dir'], command_list)
+        # Create vsim command
+        vsim_cmd = [os.path.join(self.sim_exe_base_path, 'vsim'), '-64']
 
-    # Note that CommandSimQuesta doesn't yet follow the framework from CommandSim.do_it()
-    # so we have to define all helper methods for pylint:
+        if not self.run_in_batch_mode():
+            vsim_cmd += ['-gui']
+        else:
+            vsim_cmd += ['-c']
 
-    def compile(self) -> None:
-        pass
+        if util.args['verbose']:
+            vsim_cmd += ['-verbose']
 
-    def elaborate(self) -> None:
-        pass
+        # Add simulation arguments
+        vsim_cmd += ['-do', tcl_name, 'opt_design']
 
-    def simulate(self) -> None:
-        pass
+        return [vsim_cmd]
 
-    def get_compile_command_lists(self, **kwargs) -> list:
+    def get_post_simulate_command_lists(self, **kwargs) -> list:
         return []
 
-    def get_elaborate_command_lists(self, **kwargs) -> list:
-        return []
+    def run_in_batch_mode(self) -> bool:
+        '''Returns bool if we should run in batch mode (-c) from command line'''
+        if self.args['test-mode']:
+            return True
+        if self.args['gui']:
+            return False
+        return True
 
-    def get_simulate_command_lists(self, **kwargs) -> list:
-        return []
+    def artifacts_add(self, name: str, typ: str, description: str) -> None:
+        '''Override from Command.artifacts_add for better descriptions'''
+        _, leafname = os.path.split(name)
+        if leafname == 'vsim.log':
+            description = 'Questa simulation step (3/3) log from stdout/stderr'
+        elif leafname == 'vopt.log':
+            description = 'Questa elaboration step (2/3) log from stdout/stderr'
+        elif leafname == 'vlog.log':
+            description = 'Questa compile step (1/3) log from stdout/stderr'
 
-    def get_post_simulate_command_lists(self, **kwargs) -> list:
-        return []
+        super().artifacts_add(name=name, typ=typ, description=description)
+
+
+class CommandFListQuesta(CommandFList, ToolQuesta):
+    '''CommandFListQuesta is a command handler for: eda flist --tool=questa'''
+
+    def __init__(self, config: dict):
+        CommandFList.__init__(self, config=config)
+        ToolQuesta.__init__(self, config=self.config)
 
 
 class CommandElabQuesta(CommandSimQuesta):

opencos/tools/questa_fse.py

@@ -11,6 +11,7 @@ For: Questa Intel Starter FPGA Edition-64 vsim 20XX.X Simulator
 import os
 
 from opencos.tools.modelsim_ase import CommandSimModelsimAse
+from opencos.tools.questa import CommandFListQuesta
 
 
 class CommandSimQuestaFse(CommandSimModelsimAse):
@@ -20,6 +21,7 @@ class CommandSimQuestaFse(CommandSimModelsimAse):
     '''
     _TOOL = 'questa_fse'
     _EXE = 'vsim'
+    use_vopt = True
 
     def __init__(self, config: dict):
         # this will setup with self._TOOL = modelsim_ase, which is not ideal so
@@ -57,3 +59,11 @@ class CommandElabQuestaFse(CommandSimQuestaFse):
     def __init__(self, config:dict):
         super().__init__(config)
         self.args['stop-after-elaborate'] = True
+
+
+class CommandFListQuestaFse(CommandFListQuesta):
+    '''CommandFListQuestaFse is a command handler for: eda flist --tool=questa_fse'''
+
+    def __init__(self, config: dict):
+        CommandFListQuesta.__init__(self, config=config)
+        self._TOOL = 'questa_fse'

opencos/tools/riviera.py

@@ -19,6 +19,7 @@ class ToolRiviera(ToolModelsimAse):
 
     _TOOL = 'riviera'
     _EXE = 'vsim'
+    use_vopt = False
 
     def get_versions(self) -> str:
         if self._VERSION:

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/tools/vivado.py

@@ -259,7 +259,7 @@ class CommandSimVivado(CommandSim, ToolVivado):
                     print(f"run {self.args['waves-start']} ns", file=fo)
                 print("log_wave -recursive *", file=fo)
             print("run -all", file=fo)
-            if not self.args['gui']:
+            if not self.args['gui'] or self.args['test-mode']:
                 print("exit", file=fo)
 
         sv_seed = str(self.args['seed'])
@@ -280,7 +280,7 @@ class CommandSimVivado(CommandSim, ToolVivado):
         if sys.platform == "win32":
             command_list[0] += ".bat"
         command_list += self.tool_config.get('simulate-args', 'snapshot --stats').split()
-        if self.args['gui']:
+        if self.args['gui'] and not self.args['test-mode']:
             command_list += ['-gui']
         command_list += [
             '--tclbatch', tcl_name.replace('\\','\\\\'),  # needed for windows paths
@@ -701,7 +701,7 @@ class CommandBuildVivado(CommandBuild, ToolVivado):
         command_list = [self.vivado_exe]
         command_list += [
             '-mode',
-            'gui' if self.args['gui'] else 'batch',
+            'gui' if self.args['gui'] and not self.args['test-mode'] else 'batch',
             '-log', os.path.join(self.args['work-dir'], self.args['top'] + '.build.log')
         ]
         if not util.args['verbose']:

opencos/util.py

@@ -224,16 +224,17 @@ class UtilLogger:
     # util's argparser: --no-default-log, --logfile=<name>, or --force-logfile=<name>
     default_log_enabled = False
     default_log_filepath = os.path.join('eda.work', 'eda.log')
+    default_log_disable_with_args = ['-h', '--help'] # common argparse help
     enable = True
 
     def clear(self) -> None:
-        '''Resets internals'''
+        '''Resets some internals for logging, but preserve others'''
         self.file = None
         self.filepath = ''
         self.time_last = 0
 
     def stop(self) -> None:
-        '''Closes open log, resets internals'''
+        '''Closes open log, resets some internals'''
         if self.file:
             self.write_timestamp(f'stop - {self.filepath}')
             info(f"Closing logfile: {self.filepath}")
@@ -367,6 +368,21 @@ def get_argparser() -> argparse.ArgumentParser:
     return parser
 
 
+def get_argparser_args_list(parser: object = None) -> list:
+    '''Returns list of all args, all items will include the -- prefix (--help, etc)'''
+    if not isinstance(parser, argparse.ArgumentParser):
+        return []
+    return list(vars(parser).get('_option_string_actions', {}).keys())
+
+
+def get_argparsers_args_list(parsers: list) -> list:
+    '''Returns list of all args from list of parsers, all items have -- prefix (--help, etc)'''
+    _args_list = []
+    for parser in parsers:
+        _args_list.extend(get_argparser_args_list(parser))
+    return list(dict.fromkeys(_args_list)) # uniqify, preserve order
+
+
 def get_argparser_short_help(parser: object = None) -> str:
     '''Returns short help for our ArgumentParser'''
     if not parser:
@@ -420,15 +436,18 @@ def process_tokens(tokens:list) -> (argparse.Namespace, list):
     # set artifacts.enabled based on args['artifacts-json']
     artifacts.reset(enable=parsed.artifacts_json)
 
+
     if parsed.force_logfile:
         start_log(parsed.force_logfile, force=True)
     elif parsed.logfile:
         start_log(parsed.logfile, force=False)
     elif parsed.default_log and \
-         not any(x in unparsed for x in ('help', '-h', '--help')) and \
+         not parsed.version and \
+         not any(x in unparsed for x in global_log.default_log_disable_with_args) 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/str_helpers.py

@@ -1,10 +1,21 @@
 '''opencos.utils.str_helpers -- Various str helpers for printing, indenting'''
 
 import fnmatch
+import os
 import re
 import shlex
 import textwrap
 
+VALID_TARGET_INFO_STR = (
+    "should start with an underscore/letter, rest should be alpha-numeric, dashes, or underscores."
+)
+
+def is_valid_target_name(s: str) -> bool:
+    '''Returns True if str starts with underscore/letter, rest  alphanum, dash, or underscores'''
+    if not s or not (s[0].isalpha() or s[0] == '_'):
+        return False
+    return s.replace('_', '').replace('-', '').isalnum()
+
 def strip_all_quotes(s: str) -> str:
     '''Returns str with all ' and " removed'''
     return s.replace("'", '').replace('"', '')
@@ -109,3 +120,77 @@ def fnmatch_or_re(pattern: str, string: str) -> bool:
         # could have been an illegal/unsupported regex, so don't match.
         pass
     return any(matches)
+
+
+def get_terminal_columns():
+    """
+    Retrieves the number of columns (width) of the terminal window.
+
+    Returns:
+        int: The number of columns in the terminal, or a default value (e.g., 80)
+             if the terminal size cannot be determined.
+    """
+    try:
+        size = os.get_terminal_size()
+        return size.columns
+    except OSError:
+        # Handle cases where the terminal size cannot be determined (e.g., not in a TTY)
+        return 80  # Default to 80 columns
+
+    return 80 # else default to 80.
+
+
+def pretty_list_columns_manual(data: list, num_columns: int = 4, auto_columns: bool = True) -> list:
+    """Returns list, from list of str, organized into columns, manually aligning them."""
+
+    ret_lines = []
+    if not data:
+        return ret_lines
+
+    _spacing = 2
+
+    # Calculate maximum width for each column
+    max_lengths = [0] * num_columns
+    max_item_len = 0
+    for i, item in enumerate(data):
+        col_index = i % num_columns
+        max_lengths[col_index] = max(max_lengths[col_index], len(item))
+        max_item_len = max(max_item_len, len(item))
+
+    if auto_columns and num_columns > 1:
+        window_cols = get_terminal_columns()
+        max_line_len = 0
+        for x in max_lengths:
+            max_line_len += x + _spacing
+        if max_line_len > window_cols:
+            # subtract a column (already >= 2):
+            ret_lines.extend(
+                pretty_list_columns_manual(data=data, num_columns=num_columns-1, auto_columns=True)
+            )
+            return ret_lines
+        if max_line_len + max_item_len + _spacing < window_cols:
+            # add 1 more column if we're guaranteed to have room.
+            ret_lines.extend(
+                pretty_list_columns_manual(data=data, num_columns=num_columns+1, auto_columns=True)
+            )
+            return ret_lines
+        # else continue
+
+    # Print data in columns
+    ret_lines.append('')
+    for i, item in enumerate(data):
+        col_index = i % num_columns
+        ret_lines[-1] += str(item).ljust(max_lengths[col_index] + _spacing)
+        if col_index == num_columns - 1 or i == len(data) - 1:
+            ret_lines.append('')
+
+    return ret_lines
+
+
+def print_columns_manual(data: list, num_columns: int = 4, auto_columns: bool = True) -> None:
+    """Prints a list of strings in columns, manually aligning them."""
+
+    lines = pretty_list_columns_manual(
+        data=data, num_columns=num_columns, auto_columns=auto_columns
+    )
+    print('\n'.join(lines))

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.53.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.51
+Version: 0.2.53
 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