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

opencos/tools/riviera.py

@@ -13,6 +13,7 @@ import subprocess
 from opencos import util
 from opencos.tools.modelsim_ase import ToolModelsimAse, CommandSimModelsimAse
 from opencos.utils.str_helpers import sanitize_defines_for_sh
+from opencos.utils import status_constants
 
 class ToolRiviera(ToolModelsimAse):
     '''ToolRiviera used by opencos.eda for --tool=riviera'''
@@ -61,6 +62,7 @@ class CommandSimRiviera(CommandSimModelsimAse, ToolRiviera):
             'gui': False,
             'waves-fst': True,
             'waves-vcd': False,
+            'coverage-tcl': '',
         })
         self.args_help.update({
             'waves-fst': (
@@ -70,6 +72,10 @@ class CommandSimRiviera(CommandSimModelsimAse, ToolRiviera):
             ),
             'waves-vcd': 'If using --waves, apply simulation runtime arg +trace=vcd',
             'waves': 'Save a .asdb offline wavefile, can be used with --waves-fst or --waves-vcd',
+            'coverage-tcl': (
+                'bring your own .tcl file to run in Riviera (vsim) for coverage. The default'
+                ' tcl steps are (from tool config in --config-yml):   '
+            ) + '; '.join(self.tool_config.get('simulate-coverage-tcl', [])),
         })
 
     def set_tool_defines(self):
@@ -183,7 +189,9 @@ class CommandSimRiviera(CommandSimModelsimAse, ToolRiviera):
 
 
 
-    def write_vsim_dot_do(self, dot_do_to_write: list) -> None:
+    def write_vsim_dot_do( # pylint: disable=too-many-branches
+            self, dot_do_to_write: list
+    ) -> None:
         '''Writes files(s) based on dot_do_to_write(list of str)
 
         list arg values can be empty (all) or have items 'all', 'sim', 'lint', 'vlog'.'''
@@ -278,18 +286,21 @@ class CommandSimRiviera(CommandSimModelsimAse, ToolRiviera):
             "}",
         ]
 
+        vsim_dot_do_lines += [
+            "run -all;",
+        ]
         if self.args['coverage']:
-            vsim_dot_do_lines += [
-                "run -all;",
-                "acdb save",
-                "acdb report -db work.acdb -txt -o cov.txt",
-                # Note - could try:
-                ##"cover report -o cov.report.txt -fullverbose -all_columns",
-            ]
-        else:
-            vsim_dot_do_lines += [
-                "run -all;",
-            ]
+            if self.args['coverage-tcl']:
+                tclfile = os.path.abspath(self.args['coverage-tcl'])
+                if not os.path.isfile(tclfile):
+                    self.error(f'--coverage-tcl file not found: {tclfile}',
+                               error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+                vsim_dot_do_lines += [
+                    f'source {tclfile}'
+                ]
+            else:
+                # default TCL for coverage:
+                vsim_dot_do_lines += self.tool_config.get('simulate-coverage-tcl', [])
 
 
         vsim_dot_do_lines += [

opencos/tools/slang.py

@@ -128,6 +128,7 @@ class CommandElabSlang(CommandElab, ToolSlang):
         command_list += self.tool_config.get('compile-args', '--single-unit').split()
         command_list += self.args['slang-args'] # add user args.
         command_list += self._get_slang_json_args(command_exe=command_list[0])
+        command_list += self._get_slang_tool_config_waivers()
 
         # incdirs
         for value in self.incdirs:
@@ -214,6 +215,11 @@ class CommandElabSlang(CommandElab, ToolSlang):
 
         return command_list
 
+    def _get_slang_tool_config_waivers(self) -> list:
+        # Add compile waivers from config and command-line args
+        return [f'-Wno-{waiver}' for waiver in
+                self.tool_config.get('compile-waivers', []) + self.args['compile-waivers']]
+
 
 class CommandLintSlang(CommandElabSlang):
     '''CommandLintSlang is a command handler for: eda lint --tool=slang.'''

opencos/tools/verilator.py

@@ -5,10 +5,12 @@ Contains classes for ToolVerilator and VerilatorSim, VerilatorElab.
 
 # pylint: disable=R0801 # (calling functions with same arguments)
 
+import multiprocessing
 import os
 import shutil
 import subprocess
 
+
 from opencos import util
 from opencos.eda_base import Tool
 from opencos.commands import CommandSim
@@ -81,6 +83,7 @@ class VerilatorSim(CommandSim, ToolVerilator):
             'lint-only': False,
             'cc-mode': False,
             'verilator-coverage-args': [],
+            'uvm': False,
             'x-assign': '',
             'x-initial': '',
         })
@@ -114,6 +117,15 @@ class VerilatorSim(CommandSim, ToolVerilator):
                          ' 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'),
+            'uvm': (
+                'Warns on Verilator < 5.042, or missing $UVM_HOME environment var set (or in'
+                ' .env, $UVM_HOME/uvm_pkg.sv should exist), and will run verilator with args:'
+                ' -Wno-fatal +define+UVM_NO_DPI'
+            ),
+            'verilator-coverage-args': (
+                'Requires --coverage, args to be applied to verilator_coverage, which runs'
+                ' after running the compiled executable simulation'
+            ),
         })
 
         self.verilate_command_lists = []
@@ -210,18 +222,19 @@ class VerilatorSim(CommandSim, ToolVerilator):
 
         verilate_command_list = self._get_start_verilator_command_list(lint_only=lint_only)
 
-        # Add compile args from our self.config (tools.verilator.compile-args str)
-        config_compile_args = self.tool_config.get(
-            'compile-args',
-            '--timing --assert --autoflush -sv').split()
-        verilate_command_list += config_compile_args
+        # Handle UVM things (return args), but also handles uvm_pkg.sv in self.files_sv:
+        # since we run this 2x (lint-only and normal) only do warnings for one of them:
+        verilate_command_list += self._verilator_args_uvm(
+            warnings=(not lint_only), add_uvm_pkg_if_found=True
+        )
 
         verilate_command_list += self._get_verilator_tool_config_waivers()
 
-        verilate_command_list += self._verilator_args_deal_with_cflags()
+        verilate_command_list += self._verilator_args_defaults_cflags_nproc()
 
         verilate_command_list += self._get_verilator_waves_args(lint_only=lint_only)
 
+
         if self.args.get('coverage', True):
             verilate_command_list += self.tool_config.get(
                 'compile-coverage-args', '--coverage').split()
@@ -425,45 +438,51 @@ class VerilatorSim(CommandSim, ToolVerilator):
         return ret
 
 
-    def _verilator_args_deal_with_cflags(self) -> list:
+    def _verilator_args_defaults_cflags_nproc(self) -> list:
         '''Returns list of args to be added to verilator (compile) step
 
-        Uses self.args['verilate-args'] and self.args['compile-args']
+        Uses self.args['verilate-args'], self.args['compile-args'], and self.tool_config
+
+        Sets -j <value> and -CFLAGS -O<value> if not present in --config-yml, --compile-args,
+        or --verilate-args. If present, chooses the first instance (does not present duplicates
+        to verilator call).
         '''
 
-        # We can only support one -CFLAGS followed by one -O[0-9] arg in self.args['verilate-args']:
-        verilate_cflags_args_dict = {}
-        verilate_args = [] # will be combined verilate_args + compile-args
-        prev_arg_is_cflags = False
+        # We can only support one -CFLAGS followed by one -O[0-9] arg in
+        # --verilate-args or --compile-args.
+
+        # Add compile args from our self.config (tools.verilator.compile-args str)
+        verilate_args = self.args['verilate-args'] + \
+            self.args['compile-args'] + \
+            self.tool_config.get(
+                'compile-args',
+                '--timing --assert --autoflush -sv').split()
+
         util.debug(f"{self.args['verilate-args']=}")
         util.debug(f"{self.args['compile-args']=}")
-        for arg in self.args['verilate-args'] + self.args['compile-args']:
-            # pick the first ones we see of these:
-            if arg == '-CFLAGS':
-                prev_arg_is_cflags = True
-                if arg not in verilate_cflags_args_dict:
-                    # We can only have 1
-                    verilate_cflags_args_dict[arg] = True
-                    verilate_args.append(arg)
-                else:
-                    util.debug(f'Previous saw -CFLAGS args {verilate_cflags_args_dict=},',
-                               f'skipping new {arg=}')
-
-            elif arg.startswith('-O') and len(arg) == 3:
-                if '-O' not in verilate_cflags_args_dict and prev_arg_is_cflags:
-                    # We can only have 1
-                    verilate_cflags_args_dict['-O'] = arg[-1]
-                    verilate_args.append(arg)
-                else:
-                    util.debug(f'Previous saw -CFLAGS args {verilate_cflags_args_dict=},',
-                               f'skipping new {arg=}')
-                prev_arg_is_cflags = False
-
-            else:
-                prev_arg_is_cflags = False
-                verilate_args.append(arg)
 
-        if '-CFLAGS' in verilate_args:
+        dash_j_arg_indices = []
+        cflags_dasho_args_indices = []
+        for i, arg in enumerate(list(verilate_args)):
+            # There can only be one of these: -j <value>, similarly can only be one of
+            # -CFLAGS -O<value>
+            if (i + 1) < len(verilate_args):
+                if arg == '-j':
+                    dash_j_arg_indices.extend([i, i + 1])
+                if arg == '-CFLAGS':
+                    next_arg = verilate_args[i + 1]
+                    if next_arg.startswith('-O') and len(next_arg) == 3:
+                        cflags_dasho_args_indices.extend([i, i + 1])
+
+        # For -j <value> we'll pick the first one, remove the rest.
+        # Same goes for -CFLAGS -O<value>
+        for index in dash_j_arg_indices[2:] + cflags_dasho_args_indices[2:]:
+            verilate_args[index] = ''
+
+        verilate_args = [x for x in verilate_args if x != ''] # strip empty str.
+
+        # Support for --optimize which will use -CFLAGS -O3, if -CFLAGS is not present at all.
+        if cflags_dasho_args_indices:
             # add whatever args were passed via 'compile-args' or 'verilate_args'. Note these will
             # take precedence over the --optimize arg.
             pass
@@ -472,11 +491,87 @@ class VerilatorSim(CommandSim, ToolVerilator):
             # (slower compile, better runtime)
             verilate_args += '-CFLAGS', '-O3'
         else:
+            # Default to -O1:
             verilate_args += '-CFLAGS', '-O1'
 
+        # If there was no -j setting, then use max(2, $(nproc) - 1)
+        if not dash_j_arg_indices:
+            nproc = max(2, multiprocessing.cpu_count() - 1)
+            verilate_args += '-j', f'{nproc}'
+
+
         return verilate_args
 
 
+    def _verilator_support_uvm_pkg_fpath(self, add_if_found: bool = True) -> bool:
+        '''Returns False if we could not find a suitable uvm_pkg.sv to use, or if --no-uvm.
+
+        This will also auto-add uvm_pkg.sv from $UVM_HOME/uvm_pkg.sv if not present in
+        self.files already (adds to front of self.files_sv)
+        '''
+
+        if not self.args['uvm']:
+            return False
+
+        for fname, exists in self.files.items():
+            if exists and os.path.split(fname)[1] == 'uvm_pkg.sv':
+                # already present in our source files (assume someone doing it manually
+                # or via DEPS)
+                return True
+
+        uvm_home = os.environ.get('UVM_HOME', '')
+        if not uvm_home:
+            return False
+
+        uvm_pkg_fpath = os.path.join(uvm_home, 'uvm_pkg.sv')
+        if add_if_found and os.path.isfile(uvm_pkg_fpath):
+            uvm_pkg_fpath = os.path.abspath(uvm_pkg_fpath)
+            util.info(f'For --uvm, adding to source files: {uvm_pkg_fpath}')
+            self.files[uvm_pkg_fpath] = True
+            self.files_sv.insert(0, uvm_pkg_fpath)
+            self.files_caller_info[uvm_pkg_fpath] = 'verilator.py'
+            util.info(f'For --uvm, adding +incdir+: {uvm_home}')
+            self.incdirs.append(os.path.abspath(uvm_home))
+            return True
+
+        return False
+
+
+    def _verilator_args_uvm(
+            self, warnings: bool = True, add_uvm_pkg_if_found: bool = True
+    ) -> list:
+        '''Returns list of args to be added to verilator (compile) step if --uvm present
+
+        Warnings on potential issues (Veriltor version, missing uvm_pkg.sv).
+        Optionally adds uvm_pkg.sv to source files.
+        '''
+
+        # Handle --uvm args:
+        if not self.args['uvm']:
+            return []
+
+        if warnings:
+
+            # prefers Verilator >= v5.042, $UVM_HOME to be set, or warning.
+            version_list = self._VERSION.split('.')
+            if int(version_list[0]) < 5 or \
+               (int(version_list[0]) == 5 and int(version_list[1]) < 42):
+                util.warning(f'Verilator version is {self._VERSION}, --uvm set prefers Verilator',
+                             'version > v5.042')
+
+            if not os.environ.get('UVM_HOME', ''):
+                util.warning('--uvm set, however env (or .env or --env-file) $UVM_HOME is not set')
+
+        uvm_pkg_found = self._verilator_support_uvm_pkg_fpath(add_if_found=add_uvm_pkg_if_found)
+        if warnings and not uvm_pkg_found:
+            util.warning(
+                '--uvm set, however no suitable uvm_pkg.sv is source files,',
+                f'nor in $UVM_HOME/uvm_pkg.sv. $UVM_HOME={os.environ.get("UVM_HOME", "")}'
+            )
+
+        return ['-Wno-fatal', '+define+UVM_NO_DPI']
+
+
     def artifacts_add(self, name: str, typ: str, description: str) -> None:
         '''Override from Command.artifacts_add, so we can catch known file
 

opencos/tools/vivado.py

@@ -272,6 +272,7 @@ class CommandSimVivado(CommandSim, ToolVivado):
             xsim_plusargs_list.append('--testplusarg')
             if x[0] == '+':
                 x = x[1:]
+            x = x.replace('"', '\\\"') # we have to preserve " in the value.
             xsim_plusargs_list.append(f'\"{x}\"')
 
         # execute snapshot

opencos/util.py

@@ -18,8 +18,10 @@ from enum import Enum
 from pathlib import Path
 from importlib import import_module
 from dotenv import load_dotenv
+from supports_color import supportsColor
 
 from opencos.utils import status_constants
+from opencos.utils.str_helpers import strip_ansi_color
 
 global_exit_allowed = False # pylint: disable=invalid-name
 progname = "UNKNOWN"        # pylint: disable=invalid-name
@@ -29,7 +31,7 @@ dot_f_files_expanded = set() # pylint: disable=invalid-name
 env_files_loaded = set()     # pylint: disable=invalid-name
 
 args = {                    # pylint: disable=invalid-name
-    'color' : False,
+    'color' : bool(supportsColor.stdout),
     'quiet' : False,
     'verbose' : False,
     'debug' : False,
@@ -351,13 +353,14 @@ def get_argparser() -> argparse.ArgumentParser:
     bool_action_kwargs = get_argparse_bool_action_kwargs()
 
     parser.add_argument('--version', default=False, action='store_true')
-    parser.add_argument('--color', **bool_action_kwargs, default=True,
+    parser.add_argument('--color', **bool_action_kwargs, default=bool(supportsColor.stdout),
                         help='Use shell colors for info/warning/error messaging')
-    parser.add_argument('--quiet', **bool_action_kwargs, help='Do not display info messaging')
-    parser.add_argument('--verbose', **bool_action_kwargs,
+    parser.add_argument('--quiet', **bool_action_kwargs, default=args['quiet'],
+                        help='Do not display info messaging')
+    parser.add_argument('--verbose', **bool_action_kwargs, default=args['verbose'],
                         help='Display additional messaging level 2 or higher')
-    parser.add_argument('--fancy', **bool_action_kwargs)
-    parser.add_argument('--debug', **bool_action_kwargs,
+    parser.add_argument('--fancy', **bool_action_kwargs, default=args['fancy'])
+    parser.add_argument('--debug', **bool_action_kwargs, default=args['debug'],
                         help='Display additional debug messaging level 1 or higher')
     parser.add_argument('--debug-level', type=int, default=0,
                         help='Set debug level messaging (default: 0)')
@@ -381,8 +384,10 @@ def get_argparser() -> argparse.ArgumentParser:
                             'Input .f file to be expanded as eda'
                             ' args/defines/incdirs/files/targets'))
     parser.add_argument('--env-file', default=[], action='append',
-                        help='dotenv file(s) to pass ENV vars, (default: .env, loaded last)'
-                        )
+                        help=(
+                            "dotenv file(s) to pass ENV vars, (default: .env loaded first,"
+                            " subsequent files' vars override .env"
+                        ))
     return parser
 
 
@@ -405,10 +410,10 @@ def get_argparser_short_help(parser: object = None) -> str:
     '''Returns short help for our ArgumentParser'''
     if not parser:
         parser = get_argparser()
-    full_lines = parser.format_help().split('\n')
+    full_lines = strip_ansi_color(parser.format_help()).split('\n')
     lineno = 0
     for lineno, line in enumerate(full_lines):
-        if line.startswith('options:'):
+        if any(line.startswith(x) for x in ('options:', 'optional arguments:')):
             break
     # skip the line that says 'options:', repalce with the progname:
     return f'{parser.prog}:\n' + '\n'.join(full_lines[lineno + 1:])
@@ -430,11 +435,12 @@ def process_token(arg: list) -> bool:
 def load_env_file(env_file: str) -> None:
     '''Handles .env file (from util CLI args --env-file)'''
     if os.path.isfile(env_file):
-        load_dotenv(env_file)
+        load_dotenv(env_file, override=True)
         env_files_loaded.add(os.path.abspath(env_file))
     else:
         warning(f'--env-file {env_file} does not exist and is not loaded.')
 
+
 def patch_args_for_dir(tokens: list, patch_dir: str, caller_info: str) -> list:
     '''Given list of args, attempt to correct for relative dir'''
 
@@ -534,8 +540,10 @@ def process_tokens( # pylint: disable=too-many-branches
     parser.add_argument('--debug-level', type=int, default=0,
                         help='Set debug level messaging (default: 0)')
     parser.add_argument('--env-file', default=[], action='append',
-                        help='dotenv file(s) to pass ENV vars, (default: .env, loaded last)'
-                        )
+                        help=(
+                            "dotenv file(s) to pass ENV vars, (default: .env loaded first,"
+                            " subsequent files' vars override .env"
+                        ))
     parser.add_argument('-f', '--input-file', default=[], action='append',
                         help=(
                             'Input .f file to be expanded as eda args, defines, incdirs,'
@@ -551,7 +559,7 @@ def process_tokens( # pylint: disable=too-many-branches
     debug(f'util.process_tokens: {parsed=} {unparsed=} from: {tokens}')
 
     if os.path.isfile(str(Path('.env'))):
-        parsed.env_file.append('.env')
+        parsed.env_file.insert(0, '.env')
     if parsed.env_file:
         for env_file in parsed.env_file:
             load_env_file(env_file)

opencos/utils/str_helpers.py

@@ -172,7 +172,7 @@ def pretty_list_columns_manual(data: list, num_columns: int = 4, auto_columns: b
                 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:
+        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)
@@ -198,3 +198,8 @@ def print_columns_manual(data: list, num_columns: int = 4, auto_columns: bool =
         data=data, num_columns=num_columns, auto_columns=auto_columns
     )
     print('\n'.join(lines))
+
+def strip_ansi_color(text: str) -> str:
+    '''Strip ANSI color characters from str'''
+    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+    return ansi_escape.sub('', text)

opencos/utils/subprocess_helpers.py

@@ -5,10 +5,18 @@ import shutil
 import subprocess
 import sys
 
-from opencos.util import debug, error, info, progname, global_log
+import psutil
+from opencos.util import debug, error, info, warning, progname, global_log
 
 IS_WINDOWS = sys.platform.startswith('win')
 
+# For non-Windows, we track the background parent PIDs, because some tools (vivado XSim,
+# most Modelsim/Questa variants) tend to spawn children PIDs that don't always respond
+# nicely to a friendly *nix SIGTERM. So we'll remember what our parent PIDs are, and
+# eda.py's (or other CLI opencos script) can use signal to cleanup any remaining
+# parents + children using subprocess_helpers.cleanup_all()
+ALL_PARENT_PIDS = set()
+
 def subprocess_run(
         work_dir: str, command_list: list, fake: bool = False, shell: bool = False
 ) -> int:
@@ -35,10 +43,11 @@ def subprocess_run(
 
     debug(f"subprocess_run: About to call subprocess.run({c}, **{proc_kwargs}")
     proc = subprocess.run(c, check=True, **proc_kwargs)
+    # Note - we do not get PID management for subprocess_run(...)
     return proc.returncode
 
 
-def subprocess_run_background(
+def subprocess_run_background( # pylint: disable=too-many-branches
         work_dir: str, command_list: list, background: bool = True, fake : bool = False,
         shell: bool = False, tee_fpath: str = ''
 ) -> (str, str, int):
@@ -76,6 +85,9 @@ def subprocess_run_background(
 
     debug(f"subprocess_run_background: about to call subprocess.Popen({c}, **{proc_kwargs})")
     proc = subprocess.Popen(c, **proc_kwargs) # pylint: disable=consider-using-with
+    if not background:
+        info(f'PID {proc.pid} for {command_list[0]}')
+    add_running_parent_pid(proc.pid)
 
     stdout = ''
     tee_fpath_f = None
@@ -99,10 +111,61 @@ def subprocess_run_background(
         stdout += line + '\n'
 
     proc.communicate()
+    remove_completed_parent_pid(proc.pid)
+
     rc = proc.returncode
     if tee_fpath_f:
         tee_fpath_f.write(f'INFO: [{progname}] subprocess_run_background: returncode={rc}\n')
         tee_fpath_f.close()
-        info('subprocess_run_background: wrote: ' + os.path.abspath(tee_fpath))
+        if not background:
+            info('subprocess_run_background: wrote: ' + os.path.abspath(tee_fpath))
 
     return stdout, '', rc
+
+
+def add_running_parent_pid(pid: int) -> None:
+    '''Adds pid (if still alive) to ALL_PARENT_PIDS'''
+    try:
+        p = psutil.Process(pid)
+        ALL_PARENT_PIDS.add(p.pid)
+    except psutil.NoSuchProcess:
+        pass
+    except Exception as e:
+        error(f'{pid=} exception {e}')
+
+def remove_completed_parent_pid(pid: int) -> None:
+    '''Removes pid (if no longer alive) from ALL_PARENT_PIDS.'''
+    try:
+        p = psutil.Process(pid)
+        warning(f'PID {p.pid} still running')
+    except psutil.NoSuchProcess:
+        ALL_PARENT_PIDS.remove(pid)
+    except Exception as e:
+        error(f'{pid=} exception {e}')
+
+
+def cleanup_all() -> None:
+    '''Kills everything from ALL_PARENT_PIDS.'''
+    for parent in ALL_PARENT_PIDS:
+        kill_proc_tree(parent)
+
+
+def kill_proc_tree(pid: int, including_parent: bool = True) -> None:
+    '''Kills a process and its entire descendant tree'''
+    try:
+        parent = psutil.Process(pid)
+        children = parent.children(recursive=True)
+        info(f'{pid=} {parent=} {children=}')
+        for child in children:
+            if psutil.Process(child.pid):
+                info(f'parent {pid=} killing {child=}')
+                child.kill()
+        _, still_alive = psutil.wait_procs(children, timeout=5)
+        if still_alive:
+            warning(f'parent {pid=} {still_alive=}')
+        if including_parent:
+            info(f'parent {pid=} killing {parent=}')
+            parent.kill()
+            parent.wait(5)
+    except psutil.NoSuchProcess:
+        pass # Process already terminated

{opencos_eda-0.3.2.dist-info → opencos_eda-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.3.2
+Version: 0.3.5
 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
@@ -9,12 +9,21 @@ License-File: LICENSE
 License-File: LICENSE.spdx
 Requires-Dist: mergedeep>=1.3.4
 Requires-Dist: peakrdl>=1.1.0
+Requires-Dist: psutil>=7.0.0
 Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: pytest>=8.3.5
 Requires-Dist: python-dotenv>=1.0.1
 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
+Requires-Dist: supports_color>=0.2.0
+Provides-Extra: dev
+Requires-Dist: pylint>=3.0.0; extra == "dev"
+Requires-Dist: pytest>=8.3.5; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocs-wavedrom-plugin; extra == "docs"
+Requires-Dist: mkdocs-plantuml; extra == "docs"
 Dynamic: license-file