opencos-eda 0.2.36__py3-none-any.whl → 0.2.38__py3-none-any.whl

opencos/commands/__init__.py

@@ -17,6 +17,7 @@ from .sweep import CommandSweep
 from .synth import CommandSynth
 from .upload import CommandUpload
 from .waves import CommandWaves
+from .targets import CommandTargets
 
 __all__ = [
     'CommandBuild',
@@ -32,4 +33,5 @@ __all__ = [
     'CommandToolsMulti',
     'CommandUpload',
     'CommandWaves',
+    'CommandTargets',
 ]

opencos/commands/targets.py

@@ -0,0 +1,49 @@
+'''opencos.commands.targets - command handler for: eda targets [args]
+
+Note this command is handled differently than others (such as CommandSim),
+it is generally run as simply
+
+    > eda targets
+    > eda targets <directory>
+    > eda targets [directory/]<pattern> [directory2/]<pattern2> ...
+
+uses no tools and will print a pretty list of targets to stdout.
+'''
+
+# Note - similar code waiver, tricky to eliminate it with inheritance when
+# calling reusable methods.
+# pylint: disable=R0801
+
+import os
+
+from opencos import eda_extract_targets
+from opencos.eda_base import Command
+
+
+class CommandTargets:
+    '''command handler for: eda targets'''
+
+    command_name = 'targets'
+
+    def __init__(self, config: dict):
+        # We don't inherit opencos.eda_base.Command, so we have to set a few
+        # member vars for Command.help to work.
+        self.args = {}
+        self.args_help = {}
+        self.config = config
+        self.status = 0
+
+    def process_tokens( # pylint: disable=unused-argument
+        self, tokens: list, process_all: bool = True,
+        pwd: str = os.getcwd()
+    ) -> list:
+        '''This is effectively our 'run' method, entrypoint from opencos.eda.main'''
+
+        eda_extract_targets.run(partial_paths=tokens, base_path=pwd)
+        return []
+
+    def help(self, tokens: list) -> None:
+        '''Since we don't inherit from opencos.eda_base.Command, need our own help
+        method
+        '''
+        Command.help(self, tokens=tokens)

opencos/eda.py

@@ -10,6 +10,7 @@ import re
 import signal
 import argparse
 import shlex
+import importlib.util
 
 import opencos
 from opencos import util, files
@@ -19,7 +20,6 @@ from opencos.eda_base import Tool, which_tool
 
 # Globals
 
-debug_respawn = False
 util.progname = "EDA"
 
 
@@ -30,37 +30,25 @@ util.progname = "EDA"
 # eda command (such as, command: eda sim) is handled by which class (such as class: CommandSim)
 # These are also overriden depending on the tool, for example --tool verilator sets
 # "sim": CommandSimVerilator.
-def init_config(config: dict,  quiet=False, tool=None) -> dict:
+def init_config(
+        config: dict,  quiet: bool = False, tool=None, run_auto_tool_setup: bool = True
+) -> dict:
     '''Sets or clears entries in config (dict) so tools can be re-loaded.'''
 
-    from opencos.commands import CommandSim, CommandElab, CommandSynth, \
-        CommandFList, CommandProj, CommandMulti, CommandToolsMulti, \
-        CommandSweep, CommandBuild, CommandWaves, CommandUpload, CommandOpen, \
-        CommandExport
-
-    # If config didn't set the auto_tools_order, then use a fully populated default
-    # dict:
-    config = eda_config.get_config_merged_with_defaults(config)
-
-    config['command_handler'] = {
-        "sim"         : CommandSim,
-        "elab"        : CommandElab,
-        "synth"       : CommandSynth,
-        "flist"       : CommandFList,
-        "proj"        : CommandProj,
-        "multi"       : CommandMulti,
-        "tools-multi" : CommandToolsMulti,
-        "sweep"       : CommandSweep,
-        "build"       : CommandBuild,
-        "waves"       : CommandWaves,
-        "upload"      : CommandUpload,
-        "open"        : CommandOpen,
-        "export"      : CommandExport,
-    }
+    # For key DEFAULT_HANDLERS, we'll update config['command_handler'] with
+    # the actual class using importlib (via opencos.util)
+    config['command_handler'] = {}
+    for command, str_class in config['DEFAULT_HANDLERS'].items():
+        cls = util.import_class_from_string(str_class)
+        if not cls:
+            util.error(f"config DEFAULT_HANDLERS {command=} {str_class=} could not import")
+        else:
+            config['command_handler'][command] = cls
 
     config['auto_tools_found'] = dict()
     config['tools_loaded'] = set()
-    config = auto_tool_setup(config=config, quiet=quiet, tool=tool)
+    if run_auto_tool_setup:
+        config = auto_tool_setup(config=config, quiet=quiet, tool=tool)
     return config
 
 
@@ -154,7 +142,6 @@ def auto_tool_setup(warnings:bool=True, config=None, quiet=False, tool=None) ->
       tool='verlator', tool='verilator=/path/to/verilator.exe'
       If so, updates config['auto_tools_order'][tool]['exe']
     '''
-    import importlib.util
 
     tool = eda_config.update_config_auto_tool_order_for_tool(
         tool=tool, config=config
@@ -237,7 +224,6 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
       tool='verlator', tool='verilator=/path/to/verilator.exe'
 
     '''
-    import importlib
 
     tool = eda_config.update_config_auto_tool_order_for_tool(
         tool=tool, config=config
@@ -281,10 +267,7 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
             # skip, already has a tool associated with it, and we're in auto_setup=True
             continue
 
-        if str_class_name not in globals():
-            cls = util.import_class_from_string(str_class_name)
-        else:
-            cls = globals().get(str_class_name, None)
+        cls = util.import_class_from_string(str_class_name)
 
         assert issubclass(cls, Tool), f'{str_class_name=} is does not have Tool class associated with it'
         util.debug(f'Setting {cls=} for {command=} in config.command_handler')
@@ -302,6 +285,7 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
 
     deferred_tokens = []
     command = ""
+    run_auto_tool_setup = True
 
     parser = eda_base.get_argparser()
     try:
@@ -324,22 +308,29 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     if parsed.eda_safe:
         eda_config.update_config_for_eda_safe(config)
 
+    util.debug(f'eda process_tokens: {parsed=} {unparsed=}')
+
+    # Attempt to get the 'command' in the unparsed args before we've even
+    # set the command handlers (some commands don't use tools).
+    for value in unparsed:
+        if value in config['DEFAULT_HANDLERS'].keys():
+            command = value
+            if value in config['command_uses_no_tools']:
+                run_auto_tool_setup = False
+            unparsed.remove(value)
+            break
+
     if not interactive:
         # Run init_config() now, we deferred it in main(), but only run it
         # for this tool (or tool=None to figure it out)
-        config = init_config(config, tool=parsed.tool)
+        config = init_config(
+            config, tool=parsed.tool,
+            run_auto_tool_setup=run_auto_tool_setup
+        )
         if not config:
             util.error(f'eda.py main: problem loading config, {args=}')
             return 3
 
-
-    util.debug(f'eda process_tokens: {parsed=} {unparsed=}')
-    for value in unparsed:
-        if value in config['command_handler'].keys():
-            command = value
-            unparsed.remove(value)
-            break
-
     # Deal with help, now that we have the command (if it was set).
     if parsed.help:
         if not command:
@@ -363,7 +354,9 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     util.debug(f'{command=}')
     util.debug(f'{sco.config=}')
     util.debug(f'{type(sco)=}')
-    if not parsed.tool and command not in config.get('command_determines_tool', []):
+    if not parsed.tool and \
+       command not in config.get('command_determines_tool', []) and \
+       command not in config.get('command_uses_no_tools', []):
         use_tool = which_tool(command, config)
         util.info(f"--tool not specified, using default for {command=}: {use_tool}")
 
@@ -377,7 +370,7 @@ def process_tokens(tokens: list, original_args: list, config: dict, interactive=
     sco.config['eda_original_args'] = original_args
 
     setattr(sco, 'command_name', command) # as a safeguard, b/c 'command' is not always passed to 'sco'
-    unparsed = sco.process_tokens(deferred_tokens)
+    unparsed = sco.process_tokens(tokens=deferred_tokens, pwd=os.getcwd())
 
     # query the status from the Command object (0 is pass, > 0 is fail)
     rc = getattr(sco, 'status', 1)
@@ -439,7 +432,6 @@ def main(*args):
     # Handle --config-yml= arg
     config, unparsed = eda_config.get_eda_config(unparsed)
 
-
     # Note - we used to call: config = init_config(config=config)
     # However, we now defer calling init_config(..) until eda.process_tokens(..)
 
@@ -459,22 +451,8 @@ def main(*args):
                               config=config)
 
 
-def main_cli(support_respawn=False):
+def main_cli() -> None:
     ''' Returns None, will exit with return code. Entry point for package script or __main__.'''
-
-    if support_respawn and '--no-respawn' not in sys.argv:
-        # If someone called eda.py directly (aka, __name__ == '__main__'),
-        # then we still support a legacy mode of operation - where we check
-        # for OC_ROOT (in env, or git repo) to make sure this is the right
-        # location of eda.py by calling main_cli(support_respawn=True).
-        # Otherwise, we do not respawn $OC_ROOT/bin/eda.py
-        # Can also be avoided with --no-respawn.
-
-        # Note - respawn will never work if calling as a package executable script,
-        # which is why our package entrypoint will be main_cli() w/out support_respawn.
-        main_maybe_respawn()
-
-
     signal.signal(signal.SIGINT, signal_handler)
     util.global_exit_allowed = True
     # Strip eda or eda.py from sys.argv, we know who we are if called from __main__:
@@ -482,46 +460,8 @@ def main_cli(support_respawn=False):
     util.exit(rc)
 
 
-def main_maybe_respawn():
-    ''' Returns None, will respawn - run - exit, or will return and the command
-
-    is expected to run in main_cli()'''
-
-    # First we check if we are respawning
-    this_path = os.path.realpath(__file__)
-    if debug_respawn: util.info(f"RESPAWN: this_path : '{this_path}'")
-    oc_root = util.get_oc_root()
-    if debug_respawn: util.info(f"RESPAWN: oc_root   : '{oc_root}'")
-    cwd = util.getcwd()
-    if debug_respawn: util.info(f"RESPAWN: cwd       : '{cwd}'")
-    if oc_root:
-        new_paths = [
-            os.path.join(oc_root, 'opencos', 'eda.py'),
-            os.path.join(oc_root, 'bin', 'eda'),
-        ]
-        if debug_respawn: util.info(f"RESPAWN: {new_paths=} {this_path=}")
-        if this_path not in new_paths and os.path.exists(new_paths[0]):
-            # we are not the correct version of EDA for this Git repo, we should respawn
-            util.info(f"{this_path} respawning {new_paths[0]} in {cwd} with --no-respawn")
-            sys.argv[0] = new_paths[0]
-            sys.argv.insert(1, '--no-respawn')
-            proc = subprocess.Popen(sys.argv, shell=0, cwd=cwd, universal_newlines=True)
-            while True:
-                try:
-                    proc.communicate()
-                    break
-                except KeyboardInterrupt:
-                    continue
-            # get exit status from proc and return it
-            util.exit(proc.returncode, quiet=True)
-        else:
-            if debug_respawn: util.info(f"RESPAWN: {oc_root=} respawn not necessary")
-    else:
-        if debug_respawn: util.info("RESPAWN: respawn not necessary")
-
-
 if __name__ == '__main__':
-    main_cli(support_respawn=True)
+    main_cli()
 
 # IDEAS:
 # * options with no default (i.e. if user doesn't override, THEN we set it, like "seed" or "work-dir") can be given a

opencos/eda_base.py

@@ -550,7 +550,7 @@ class Command:
             self.set_tool_defines()
 
 
-    def help(self, tokens: list = []):
+    def help(self, tokens: list = []) -> None:
         '''Since we don't quite follow standard argparger help()/usage(), we'll format our own
 
         if self.args_help has additional help information.
@@ -569,8 +569,13 @@ class Command:
 
         print_base_help()
         lines = []
+        if not self.args:
+            print(f'Unparsed args: {tokens}')
+            return
+
         if self.command_name:
-            lines.append(f"Generic help for command='{self.command_name}' (using '{self.__class__.__name__}')")
+            lines.append(f"Generic help for command='{self.command_name}'"
+                         f" (using '{self.__class__.__name__}')")
         else:
             lines.append(f"Generic help (from class Command):")
 
@@ -752,7 +757,7 @@ class CommandDesign(Command):
         #   token = '\'+define+OC_ROOT="/foo/bar/opencos"\''
         # So we strip all outer ' or " on the plusarg:
         plusarg = util.strip_outer_quotes(plusarg)
-        if pwd is None:
+        if not pwd:
             pwd = ''
 
         if plusarg.startswith('+define+'):

opencos/eda_config.py

@@ -15,9 +15,11 @@ class Defaults:
     home_override_config_yml = os.path.join(
         os.environ.get('HOME', ''), '.opencos-eda', 'EDA_CONFIG.yml'
     )
-    config_yml = 'eda_config_defaults.yml'
+    opencos_config_yml = 'eda_config_defaults.yml'
+    config_yml = ''
 
     supported_config_keys = set([
+        'DEFAULT_HANDLERS',
         'defines',
         'dep_command_enables',
         'dep_tags_enables',
@@ -26,10 +28,11 @@ class Defaults:
         'bare_plusarg_supported',
         'dep_sub',
         'vars',
-        'tools',
-        'auto_tools_order',
         'file_extensions',
         'command_determines_tool',
+        'command_uses_no_tools',
+        'tools',
+        'auto_tools_order',
     ])
     supported_config_auto_tools_order_keys = set([
         'exe', 'handlers', 'requires_env', 'requires_py', 'requires_cmd',
@@ -53,6 +56,14 @@ class Defaults:
     ])
 
 
+if os.path.exists(Defaults.environ_override_config_yml):
+    Defaults.config_yml = Defaults.environ_override_config_yml
+elif os.path.exists(Defaults.home_override_config_yml):
+    Defaults.config_yml = Defaults.home_override_config_yml
+else:
+    Defaults.config_yml = Defaults.opencos_config_yml
+
+
 def find_eda_config_yml_fpath(filename:str, package_search_only=False, package_search_enabled=True) -> str:
     '''Locates the filename (.yml) either from fullpath provided or from the sys.path
     opencos package paths.'''
@@ -192,15 +203,9 @@ def get_config_merged_with_defaults(config:dict) -> dict:
     return default_config
 
 def get_argparser() -> argparse.ArgumentParser:
-    if os.path.exists(Defaults.environ_override_config_yml):
-        default_config_yml = Defaults.environ_override_config_yml
-    elif os.path.exists(Defaults.home_override_config_yml):
-        default_config_yml = Defaults.home_override_config_yml
-    else:
-        default_config_yml = Defaults.config_yml
     parser = argparse.ArgumentParser(prog='opencos eda config options', add_help=False, allow_abbrev=False)
-    parser.add_argument('--config-yml', type=str, default=default_config_yml,
-                        help=f'YAML filename to use for configuration (default {default_config_yml})')
+    parser.add_argument('--config-yml', type=str, default=Defaults.config_yml,
+                        help=f'YAML filename to use for configuration (default {Defaults.config_yml})')
     return parser
 
 def get_argparser_short_help() -> str:
@@ -213,6 +218,8 @@ def get_eda_config(args:list, quiet=False) -> (dict, list):
 
     Handles args for:
       --config-yml=<YAMLFILE>
+
+    This will merge the result with the default config (if overriden)
     '''
 
     parser = get_argparser()
@@ -237,5 +244,7 @@ def get_eda_config(args:list, quiet=False) -> (dict, list):
     else:
         config = None
 
+    if parsed.config_yml != Defaults.config_yml:
+        config = get_config_merged_with_defaults(config)
 
     return config, unparsed

opencos/eda_config_defaults.yml

@@ -3,6 +3,28 @@
 # python mergedeep with Strategy.TYPESAFE_REPLACE. I considered doing TYPESAFE_ADDITIVE but then
 # the user would lose full control over existing list values.
 
+DEFAULT_HANDLERS:
+  # These commands (sim, elab, etc) require a tool, but have a default handler
+  # base class:
+  sim         : opencos.commands.CommandSim
+  elab        : opencos.commands.CommandElab
+  synth       : opencos.commands.CommandSynth
+  flist       : opencos.commands.CommandFList
+  proj        : opencos.commands.CommandProj
+  build       : opencos.commands.CommandBuild
+  upload      : opencos.commands.CommandUpload
+  open        : opencos.commands.CommandOpen
+  # These commands don't necessarily require a tool
+  multi       : opencos.commands.CommandMulti
+  tools-multi : opencos.commands.CommandToolsMulti
+  sweep       : opencos.commands.CommandSweep
+  # These commands (waves, export, targets) do not require a tool, or
+  # will self determine the tool:
+  waves       : opencos.commands.CommandWaves
+  export      : opencos.commands.CommandExport
+  targets     : opencos.commands.CommandTargets
+
+
 defines: { } # Add these defines to every eda call
 
 dep_command_enables:
@@ -47,9 +69,14 @@ file_extensions:
     - .vhdl
 
 command_determines_tool:
-  # eda commands that will self-determine the tool to use.
+  # eda commands that will self-determine the tool to use
   - waves
 
+command_uses_no_tools:
+  # eda commands that do not use a tool at all, will skip auto_tools_order
+  - export
+  - targets
+
 
 tools:
 

opencos/eda_config_reduced.yml

@@ -9,7 +9,6 @@ dep_command_enables:
   var_subst_os_env: false
 
 # Values overriden to false:
-deps_legacy_supported: false
 deps_subprocess_shell: false
 
 

opencos/eda_deps_bash_completion.bash

@@ -35,7 +35,7 @@ _eda_script_completion() {
     if [ -z "${completions}" ]; then
         # If we didn't find anything in a DEPS.[yml|yaml|toml|json], then use:
         # 1. a bunch of known eda words or args.
-        eda_words="multi sim elab flist build synth waves proj waves \
+        eda_words="multi sim elab flist build synth waves proj waves targets \
                     +define+ +incdirs+ \
                     --help --quiet --verbose --debug \
                     --tool --seed --top --keep --force --fake --lint --work-dir \

opencos/eda_extract_targets.py

@@ -72,12 +72,8 @@ def print_columns_manual(data: list, num_columns: int = 4, auto_columns: bool =
         if col_index == num_columns - 1 or i == len(data) - 1:
             print() # New line at the end of a row or end of data
 
-
-def run(partial_path: str = '', base_path=str(Path('.'))) -> None:
-    '''Returns None, prints DEPS keys into pretty columns, using arg
-
-    partial_path as a string filter for target completions.
-    '''
+def get_path_and_pattern(partial_path: str = '', base_path=str(Path('.'))) -> (str, str):
+    '''Returns tuple of (partial_path, partial_target or filter)'''
     partial_target = ''
     if not partial_path or partial_path == str(Path('.')):
         partial_path = PATH_LPREFIX
@@ -86,18 +82,40 @@ def run(partial_path: str = '', base_path=str(Path('.'))) -> None:
     if not partial_path:
         partial_path = PATH_LPREFIX
 
-    try:
-        keys = get_all_targets(
-            dirs=[partial_path],
-            base_path=base_path,
-            filter_str=partial_target,
-            error_on_empty_return=False,
-            lstrip_path=True
-        )
-    except:
-        keys = []
+    return partial_path, partial_target
 
-    print_columns_manual(data=keys, num_columns=4, auto_columns=True)
+
+
+def run(partial_paths: list, base_path=str(Path('.'))) -> None:
+    '''Returns None, prints DEPS keys into pretty columns, using arg
+
+    partial_path as a string filter for target completions.
+    '''
+
+    targets_set = set()
+    if not partial_paths:
+        partial_paths = [PATH_LPREFIX] # run on current directory.
+
+    for partial_path in partial_paths:
+        partial_path, partial_target = get_path_and_pattern(
+            partial_path=partial_path, base_path=base_path
+        )
+        try:
+            keys = get_all_targets(
+                dirs=[partial_path],
+                base_path=base_path,
+                filter_str=partial_target,
+                error_on_empty_return=False,
+                lstrip_path=True
+            )
+        except:
+            keys = []
+        for key in keys:
+            targets_set.add(key)
+
+    data = list(targets_set)
+    data.sort()
+    print_columns_manual(data=data, num_columns=4, auto_columns=True)
 
 
 def main() -> None:
@@ -109,8 +127,8 @@ def main() -> None:
     if len(sys.argv) > 1:
         partial_path = sys.argv[1]
     else:
-        partial_path = PATH_LPREFIX
-    run(partial_path)
+        partial_path = ''
+    run(partial_paths=[partial_path])
 
 
 if __name__ == "__main__":

opencos/files.py

@@ -29,7 +29,7 @@ ALL_FORCED_PREFIXES = set(list(FORCE_PREFIX_DICT.keys()))
 
 def get_source_file(target:str) -> (bool, str, str):
     '''Returns tuple: bool if file exists, filepath str, and optional forced file type str'''
-    if os.path.exists(target):
+    if os.path.isfile(target):
         # target exists as a file, return True w/ original target:
         return True, target, ''
 
@@ -37,7 +37,7 @@ def get_source_file(target:str) -> (bool, str, str):
         for p in ALL_FORCED_PREFIXES:
             if p in target:
                 fpath = ''.join(target.split(p)) # essentially just removing the "sv@" or whatever it is
-                if os.path.exists(fpath):
+                if os.path.isfile(fpath):
                     return True, fpath, FORCE_PREFIX_DICT.get(p)
 
     # target or fpath didn't exist, return False with the original target:

opencos/tests/helpers.py

@@ -142,13 +142,14 @@ class Helpers:
         # TODO(drew): There are some issues with log_it redirecting stdout from vivado
         # and modelsim_ase. So this may not work for all tools, you may have to directly
         # look at eda.work/{target}.sim/sim.log or xsim.log.
+        print(f'{os.getcwd()=}')
+        print(f'{command_str=}')
         with open(logfile, 'w', encoding='utf-8') as f:
-            with redirect_stdout(f):
-                with redirect_stderr(f):
-                    if use_eda_wrap:
-                        rc = eda_wrap(*(command_str.split()))
-                    else:
-                        rc = eda.main(*(command_str.split()))
+            with redirect_stdout(f), redirect_stderr(f):
+                if use_eda_wrap:
+                    rc = eda_wrap(*(command_str.split()))
+                else:
+                    rc = eda.main(*(command_str.split()))
             print(f'Wrote: {os.path.abspath(logfile)=}')
         return rc
 

opencos/tests/test_eda.py

@@ -53,6 +53,28 @@ def test_args_sim_default_tool():
     assert rc == 0
 
 
+class TestTargets(Helpers):
+    '''Tests for: eda targets'''
+
+    DEFAULT_DIR = os.path.join(THISPATH, '..', '..', 'lib', 'tests')
+
+    def test_lib_tests__no_pattern(self):
+        '''Test that this works: eda targets'''
+        self.chdir()
+        rc = self.log_it('targets --debug', use_eda_wrap=False)
+        assert rc == 0
+        assert self.is_in_log('oclib_fifo_test')
+        assert self.is_in_log('oclib_rrarb_test')
+
+    def test_lib_tests__with_pattern(self):
+        '''Test that this works: eda targets oclib_fifo*test'''
+        self.chdir()
+        rc = self.log_it('targets oclib_fifo*test', use_eda_wrap=False)
+        assert rc == 0
+        assert self.is_in_log('oclib_fifo_test')
+        assert not self.is_in_log('oclib_rrarb_test')
+
+
 @pytest.mark.skipif(
     'verilator' not in tools_loaded, reason="requires verilator"
 )

opencos/tools/invio.py

@@ -2,7 +2,6 @@
 
 # pylint: disable=R0801 # (duplicate code in derived classes, such as if-condition return.)
 
-import shutil
 import importlib.util
 
 from opencos import util
@@ -22,11 +21,11 @@ class ToolInvio(Tool):
         if self._VERSION:
             return self._VERSION
 
-        # We also have to make sure invio-py exists, or that we can import invio within python.
-        invio_py_path = shutil.which('invio-py')
+        # We also have to make sure we can import invio within python.
         spec = importlib.util.find_spec('invio')
-        if not spec or not invio_py_path:
-            self.error('"invio-py" not in path, or invio package not in python env')
+        if not spec:
+            self.error('"invio" package not in python env')
+
 
         return super().get_versions()
 

opencos/tools/invio_yosys.py

@@ -5,7 +5,6 @@
 # pylint: disable=too-many-locals     # TODO(drew): fix this later.
 
 import os
-import shutil
 import importlib.util
 
 from opencos import util
@@ -23,11 +22,10 @@ class ToolInvioYosys(ToolYosys):
         if self._VERSION:
             return self._VERSION
 
-        # We also have to make sure invio-py exists, or that we can import invio within python.
-        invio_py_path = shutil.which('invio-py')
+        # We also have to make sure we can import invio within python.
         spec = importlib.util.find_spec('invio')
-        if not spec or not invio_py_path:
-            self.error('"invio-py" not in path, or invio package not in python env')
+        if not spec:
+            self.error('"invio" package not in python env')
 
         # run ToolYosys.get_versions() to set up self.yosys_exe, and return the version
         # str:
@@ -49,6 +47,9 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
         self.args.update({
             'invio-blackbox': [],                # list of modules that invio/verific will blackbox.
         })
+        self.args_help.update({
+            'invio-blackbox': 'List of modules that invio will blackbox prior to yosys',
+        })
 
     def write_and_run_yosys_f_files(self, **kwargs) -> None:
 
@@ -74,13 +75,13 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
             os.mkdir(fullp)
 
         # create yosys.f so we can run a few commands within yosys.
-        yosys_f_path = os.path.join(work_dir, 'yosys.f')
-        yosys_v_path = os.path.join(work_dir, 'yosys', invio_dict['v_filename'])
-
-        synth_command = self.args.get('yosys-synth', 'synth')
+        yosys_f_path = os.path.join(self.full_work_dir, 'yosys.f')
+        self.yosys_v_path = os.path.join(self.yosys_out_dir, invio_dict['v_filename'])
 
         with open(yosys_f_path, 'w', encoding='utf-8') as f:
             lines = []
+            if self.args['liberty-file']:
+                lines.append('read_liberty -lib ' + self.args['liberty-file'])
             for path in invio_dict.get('blackbox_files_list', []):
                 # We have to read the verilog files from the invio blackbox_files_list:
                 lines.append(f'read_verilog {path}')
@@ -88,12 +89,9 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
                 # But we may blackbox different cells for yosys synthesis.
                 lines.append(f'blackbox {module}')
 
+
             lines.append(f'read_verilog {invio_dict["full_v_filename"]}')
-            lines += self.args.get('yosys-pre-synth', [])
-            lines += [
-                synth_command,
-                f'write_verilog {yosys_v_path}'
-            ]
+            lines += self.get_synth_command_lines()
             f.write('\n'.join(lines))
 
         synth_command_list = util.ShellCommandList(
@@ -105,6 +103,9 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
             ['python3', invio_dict['full_py_filename']], tee_fpath=invio_dict['full_py_filename']
         )
 
+        # Optinally create and run a sta.f:
+        sta_command_list = self.create_sta_f() # [] or util.ShellCommandList
+
         # We create a run_yosys.sh wrapping these scripts, but we do not run this one.
         util.write_shell_command_file(
             dirpath=self.args['work-dir'],
@@ -121,18 +122,25 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
                 # Gives us bash commands with tee and pipstatus:
                 invio_command_list,
                 synth_command_list,
+                sta_command_list,
             ],
         )
 
         # Do not run this if args['stop-before-compile'] is True
         if self.args.get('stop-before-compile', False) or \
            self.args.get('stop-after-compile', False):
-            pass # skip it.
-        else:
-            self.exec( work_dir=work_dir, command_list=synth_command_list,
-                       tee_fpath=synth_command_list.tee_fpath )
-            util.info(f'yosys: wrote verilog to {yosys_v_path}')
-        return self.status
+            return
+
+        # Run the synth commands standalone:
+        self.exec( work_dir=work_dir, command_list=synth_command_list,
+                   tee_fpath=synth_command_list.tee_fpath )
+
+        if self.args['sta']:
+            self.exec(work_dir=self.full_work_dir, command_list=sta_command_list,
+                      tee_fpath=sta_command_list.tee_fpath)
+
+        if self.status == 0:
+            util.info(f'yosys: wrote verilog to {self.yosys_v_path}')
 
 
 class CommandElabInvioYosys(CommandSynthInvioYosys):

opencos/tools/slang_yosys.py

@@ -8,8 +8,7 @@ Contains classes for ToolSlangYosys, CommandSynthSlangYosys
 import os
 
 from opencos import util
-from opencos.commands import CommandSynth
-from opencos.tools.yosys import ToolYosys
+from opencos.tools.yosys import ToolYosys, CommonSynthYosys
 
 class ToolSlangYosys(ToolYosys):
     '''Uses slang.so in yosys plugins directory, called via yosys > plugin -i slang'''
@@ -28,49 +27,17 @@ class ToolSlangYosys(ToolYosys):
         })
 
 
-class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
+class CommandSynthSlangYosys(CommonSynthYosys, ToolSlangYosys):
     '''CommandSynthSlangYosys is a command handler for: eda synth --tool=slang_yosys'''
 
     def __init__(self, config: dict):
-        CommandSynth.__init__(self, config)
+        CommonSynthYosys.__init__(self, config)
         ToolSlangYosys.__init__(self, config=self.config)
-        self.args.update({
-            'sta': False,
-            'liberty-file': '',
-            'sdc-file': '',
-            'yosys-synth': 'synth',       # synth_xilinx, synth_altera, etc (see: yosys help)
-            'yosys-pre-synth': ['prep', 'proc'], # command run in yosys prior to yosys-synth.
-            'yosys-blackbox': [],                # list of modules that yosys will blackbox.
-        })
-        self.args_help.update({
-            'sta': 'After running Yosys, run "sta" with --liberty-file.' \
-            + ' sta can be installed via: https://github.com/The-OpenROAD-Project/OpenSTA',
-            'sdc-file': '.sdc file to use with --sta, if not present will use auto constraints',
-            'liberty-file': 'Single liberty file for synthesis and sta,' \
-            + ' for example: github/OpenSTA/examples/nangate45_slow.lib.gz',
-            'yosys-synth': 'The synth command provided to Yosys, see: yosys help.',
-            'yosys-pre-synth': 'Yosys commands performed prior to running "synth"' \
-            + ' (or eda arg value for --yosys-synth)',
-            'yosys-blackbox': 'List of modules that yosys will blackbox, likely will need these' \
-            + ' in Verilog-2001 for yosys to read outside of slang and synth',
-        })
 
         self.slang_out_dir = ''
-        self.yosys_out_dir = ''
         self.slang_v_path = ''
-        self.yosys_v_path = ''
-        self.full_work_dir = ''
-        self.blackbox_list = []
 
-    def do_it(self) -> None:
-        CommandSynth.do_it(self)
-
-        if self.is_export_enabled():
-            return
-
-        self._write_and_run_yosys_f_files()
-
-    def _write_and_run_yosys_f_files(self):
+    def write_and_run_yosys_f_files(self, **kwargs) -> None:
         '''
         1. Creates and runs: yosys.slang.f
            -- should create post_slang_ls.txt
@@ -88,28 +55,20 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
         util.debug(f'slang_yosys: {self.blackbox_list=}')
 
         # create {work_dir} / yosys
-        self.full_work_dir = self.args.get('work-dir', '')
-        if not self.full_work_dir:
-            self.error(f'work_dir={self.full_work_dir} is not set')
-        self.full_work_dir = os.path.abspath(self.full_work_dir)
         self.slang_out_dir = os.path.join(self.full_work_dir, 'slang')
-        self.yosys_out_dir = os.path.join(self.full_work_dir, 'yosys')
-        for p in [self.slang_out_dir, self.yosys_out_dir]:
-            util.safe_mkdir(p)
+        util.safe_mkdir(self.slang_out_dir)
 
         self.slang_v_path = os.path.join(self.slang_out_dir, f'{self.args["top"]}.v')
-        self.yosys_v_path = os.path.join(self.yosys_out_dir, f'{self.args["top"]}.v')
-
 
         # Run our created yosys.slang.f script
         # Note - this will always run, even if --stop-before-compile is set.
         slang_command_list = self._create_yosys_slang_f() # util.ShellCommandList
 
         # Create and run yosys.synth.f
-        synth_command_list = self._create_yosys_synth_f() # util.ShellCommandList
+        synth_command_list = self.create_yosys_synth_f() # util.ShellCommandList
 
         # Optinally create and run a sta.f:
-        sta_command_list = self._create_sta_f() # [] or util.ShellCommandList
+        sta_command_list = self.create_sta_f() # [] or util.ShellCommandList
 
         # We create a run_yosys.sh wrapping these scripts, but we do not run this one.
         util.write_shell_command_file(
@@ -246,7 +205,7 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
                             yosys_blackbox_list.append(line)
         return yosys_blackbox_list
 
-    def _create_yosys_synth_f(self) -> util.ShellCommandList:
+    def create_yosys_synth_f(self) -> util.ShellCommandList:
         # Create yosys.synth.f
         yosys_synth_f_path = os.path.join(self.full_work_dir, 'yosys.synth.f')
 
@@ -254,10 +213,6 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
         # yosys.synth.f script.
         yosys_blackbox_list = self._get_yosys_blackbox_list()
 
-        synth_command = self.args.get('yosys-synth', 'synth')
-        if self.args['flatten-all']:
-            synth_command += ' -flatten'
-
         if self.args['liberty-file'] and not os.path.exists(self.args['liberty-file']):
             self.error(f'--liberty-file={self.args["liberty-file"]} file does not exist')
 
@@ -273,20 +228,7 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
             for inst in yosys_blackbox_list:
                 lines.append('blackbox ' + inst)
 
-            lines += self.args.get('yosys-pre-synth', [])
-            lines.append(synth_command)
-
-            # TODO(drew): I need a blackbox flow here? Or a memory_libmap?
-            #   --> https://yosyshq.readthedocs.io/projects/yosys/en/latest/cmd/memory_libmap.html
-            # TODO(drew): can I run multiple liberty files?
-            if self.args['liberty-file']:
-                lines += [
-                    'dfflibmap -liberty ' + self.args['liberty-file'],
-                    #'memory_libmap -lib ' + self.args['liberty-file'], # Has to be unzipped?
-                    'abc -liberty  ' + self.args['liberty-file'],
-                ]
-
-            lines.append(f'write_verilog {self.yosys_v_path}')
+            lines += self.get_synth_command_lines()
             f.write('\n'.join(lines))
 
         synth_command_list = util.ShellCommandList(
@@ -296,74 +238,7 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
         return synth_command_list
 
 
-    def _create_sta_f(self) -> list:
-
-        if not self.args['sta']:
-            return []
-
-        if not self.args['liberty-file']:
-            self.error('--sta is set, but need to also set --liberty-file=<file>')
-
-        if self.args['sdc-file']:
-            if not os.path.exists(self.args['sdc-file']):
-                self.error(f'--sdc-file={self.args["sdc-file"]} file does not exist')
-
-        if not self.sta_exe:
-            self.error(f'--sta is set, but "sta" was not found in PATH, see: {self._URL}')
-
-        sta_command_list = util.ShellCommandList(
-            [ self.sta_exe, '-no_init', '-exit', 'sta.f' ],
-            tee_fpath = 'sta.log'
-        )
-
-        # Need to create sta.f:
-        if self.args['sdc-file']:
-            sdc_path = self.args['sdc-file']
-        else:
-            # Need to create sdc.f:
-            sdc_path = 'sdc.f'
-            self._create_sdc_f()
-
-        with open(os.path.join(self.args['work-dir'], 'sta.f'), 'w',
-                  encoding='utf-8') as f:
-            lines = [
-                'read_liberty ' + self.args['liberty-file'],
-                'read_verilog ' + self.yosys_v_path,
-                'link_design ' + self.args['top'],
-                'read_sdc ' + sdc_path,
-                'report_checks',
-            ]
-            f.write('\n'.join(lines))
-
-        return util.ShellCommandList(
-            sta_command_list,
-            tee_fpath = 'sta.log'
-        )
-
-
-    def _create_sdc_f(self) -> None:
-        if self.args['sdc-file']:
-            # already exists from args, return b/c nothing to create.
-            return
-
-        with open(os.path.join(self.args['work-dir'], 'sdc.f'), 'w',
-                  encoding='utf-8') as f:
-            clock_name = self.args['clock-name']
-            period = self.args['clock-ns']
-            name_not_equal_clocks_str = f'NAME !~ "{clock_name}"'
-            lines = [
-                f'create_clock -add -name {clock_name} -period {period} [get_ports ' \
-                + '{' + clock_name + '}];',
-                f'set_input_delay -max {self.args["idelay-ns"]} -clock {clock_name}' \
-                + ' [get_ports * -filter {DIRECTION == IN && ' \
-                + name_not_equal_clocks_str + '}];',
-                f'set_output_delay -max {self.args["odelay-ns"]} -clock {clock_name}' \
-                + ' [get_ports * -filter {DIRECTION == OUT}];',
-            ]
-            f.write('\n'.join(lines))
-
-
-class CommandElabSlangYosys(CommandSynthSlangYosys):
+class CommandElabSlangYosys(CommandSynthSlangYosys): # pylint: disable=too-many-ancestors
     '''CommandSynthSlangYosys is a command handler for: eda synth --tool=slang_yosys
 
     Runs slang-yosys as elab only (does not run the synthesis portion), but is

opencos/tools/yosys.py

@@ -5,6 +5,7 @@ Contains classes for ToolYosys
 
 # pylint: disable=R0801 # (calling functions with same arguments)
 
+import os
 import shutil
 import subprocess
 
@@ -84,15 +85,44 @@ class CommonSynthYosys(CommandSynth, ToolYosys):
         ToolYosys.__init__(self, config=self.config)
 
         self.args.update({
+            'sta': False,
+            'liberty-file': '',
+            'sdc-file': '',
             'yosys-synth': 'synth',              # synth_xilinx, synth_altera, etc (see: yosys help)
             'yosys-pre-synth': ['prep', 'proc'], # command run in yosys prior to yosys-synth.
             'yosys-blackbox': [],                # list of modules that yosys will blackbox.
         })
+        self.args_help.update({
+            'sta': 'After running Yosys, run "sta" with --liberty-file.' \
+            + ' sta can be installed via: https://github.com/The-OpenROAD-Project/OpenSTA',
+            'sdc-file': '.sdc file to use with --sta, if not present will use auto constraints',
+            'liberty-file': 'Single liberty file for synthesis and sta,' \
+            + ' for example: github/OpenSTA/examples/nangate45_slow.lib.gz',
+            'yosys-synth': 'The synth command provided to Yosys, see: yosys help.',
+            'yosys-pre-synth': 'Yosys commands performed prior to running "synth"' \
+            + ' (or eda arg value for --yosys-synth)',
+            'yosys-blackbox': 'List of modules that yosys will blackbox, likely will need these' \
+            + ' in Verilog-2001 for yosys to read outside of slang and synth',
+        })
+
+        self.yosys_out_dir = ''
+        self.yosys_v_path = ''
+        self.full_work_dir = ''
+        self.blackbox_list = []
 
     def do_it(self) -> None:
         self.set_tool_defines()
         self.write_eda_config_and_args()
 
+        # Set up some dirs and filenames.
+        self.full_work_dir = self.args.get('work-dir', '')
+        if not self.full_work_dir:
+            self.error(f'work_dir={self.full_work_dir} is not set')
+        self.full_work_dir = os.path.abspath(self.full_work_dir)
+        self.yosys_out_dir = os.path.join(self.full_work_dir, 'yosys')
+        util.safe_mkdir(self.yosys_out_dir)
+        self.yosys_v_path = os.path.join(self.yosys_out_dir, f'{self.args["top"]}.v')
+
         if self.is_export_enabled():
             self.do_export()
             return
@@ -102,3 +132,108 @@ class CommonSynthYosys(CommandSynth, ToolYosys):
     def write_and_run_yosys_f_files(self, **kwargs) -> None:
         '''Derived classes must define, to run remainder of do_it() steps'''
         raise NotImplementedError
+
+
+    def create_yosys_synth_f(self) -> util.ShellCommandList:
+        '''Derived classes may define, if they wish to get a list of yosys commands'''
+        return util.ShellCommandList([])
+
+
+    def get_synth_command_lines(self) -> list:
+        '''Common yosys tcl after all blackbox and read_verilog commands'''
+
+        lines = []
+        lines += self.args.get('yosys-pre-synth', [])
+
+        synth_command = self.args.get('yosys-synth', 'synth')
+        if self.args['flatten-all']:
+            synth_command += ' -flatten'
+
+        lines.append(synth_command)
+
+
+        # TODO(drew): I need a blackbox flow here? Or a memory_libmap?
+        #   --> https://yosyshq.readthedocs.io/projects/yosys/en/latest/cmd/memory_libmap.html
+        # TODO(drew): can I run multiple liberty files?
+        if self.args['liberty-file']:
+            lines += [
+                'dfflibmap -liberty ' + self.args['liberty-file'],
+                #'memory_libmap -lib ' + self.args['liberty-file'], # Has to be unzipped?
+                'abc -liberty  ' + self.args['liberty-file'],
+            ]
+        lines += [
+            'opt_clean',
+            f'write_verilog {self.yosys_v_path}',
+            f'write_json {self.yosys_v_path}.json',
+        ]
+        return lines
+
+
+    def create_sta_f(self) -> util.ShellCommandList:
+        '''Returns command list, for running 'sta' on sta.f'''
+
+        if not self.args['sta']:
+            return []
+
+        if not self.args['liberty-file']:
+            self.error('--sta is set, but need to also set --liberty-file=<file>')
+
+        if self.args['sdc-file']:
+            if not os.path.exists(self.args['sdc-file']):
+                self.error(f'--sdc-file={self.args["sdc-file"]} file does not exist')
+
+        if not self.sta_exe:
+            self.error(f'--sta is set, but "sta" was not found in PATH, see: {self._URL}')
+
+        sta_command_list = util.ShellCommandList(
+            [ self.sta_exe, '-no_init', '-exit', 'sta.f' ],
+            tee_fpath = 'sta.log'
+        )
+
+        # Need to create sta.f:
+        if self.args['sdc-file']:
+            sdc_path = self.args['sdc-file']
+        else:
+            # Need to create sdc.f:
+            sdc_path = 'sdc.f'
+            self.create_sdc_f()
+
+        with open(os.path.join(self.args['work-dir'], 'sta.f'), 'w',
+                  encoding='utf-8') as f:
+            lines = [
+                'read_liberty ' + self.args['liberty-file'],
+                'read_verilog ' + self.yosys_v_path,
+                'link_design ' + self.args['top'],
+                'read_sdc ' + sdc_path,
+                'report_checks',
+            ]
+            f.write('\n'.join(lines))
+
+        return util.ShellCommandList(
+            sta_command_list,
+            tee_fpath = 'sta.log'
+        )
+
+
+    def create_sdc_f(self) -> None:
+        '''Returns None, creates sdc.f'''
+
+        if self.args['sdc-file']:
+            # already exists from args, return b/c nothing to create.
+            return
+
+        with open(os.path.join(self.args['work-dir'], 'sdc.f'), 'w',
+                  encoding='utf-8') as f:
+            clock_name = self.args['clock-name']
+            period = self.args['clock-ns']
+            name_not_equal_clocks_str = f'NAME !~ "{clock_name}"'
+            lines = [
+                f'create_clock -add -name {clock_name} -period {period} [get_ports ' \
+                + '{' + clock_name + '}];',
+                f'set_input_delay -max {self.args["idelay-ns"]} -clock {clock_name}' \
+                + ' [get_ports * -filter {DIRECTION == IN && ' \
+                + name_not_equal_clocks_str + '}];',
+                f'set_output_delay -max {self.args["odelay-ns"]} -clock {clock_name}' \
+                + ' [get_ports * -filter {DIRECTION == OUT}];',
+            ]
+            f.write('\n'.join(lines))

{opencos_eda-0.2.36.dist-info → opencos_eda-0.2.38.dist-info}/METADATA

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

{opencos_eda-0.2.36.dist-info → opencos_eda-0.2.38.dist-info}/RECORD

@@ -3,25 +3,25 @@ opencos/_version.py,sha256=qN7iBoOv-v4tEZz-Pu9sVUJwefshJOsgdaddn8HcHio,510
 opencos/_waves_pkg.sv,sha256=1lbhQOVGc3t_R8czYjP40hssP0I3FlZOpHTkI7yKFbI,1251
 opencos/deps_helpers.py,sha256=Pgo3dO_QBHzGB0lE2B0uf2vWWDy3dSDN0pvW-eA6ocs,56939
 opencos/deps_schema.py,sha256=MhytzXwp071F14RwxqHt78ak8Qruoe4FeK5XSzkO2f0,14658
-opencos/eda.py,sha256=NCsSAnWANumzP2EzlsT-TvGUEuY8ONpHo-cvTcWC2wM,21261
-opencos/eda_base.py,sha256=Fi21IIKvYIzyj_vQtaqPwrUXDaszfIixoB80-TQMM2k,77455
-opencos/eda_config.py,sha256=CXfFVW4QOtP1gpMcX8JhCe93_aibcdbGoS7RAiYQnOs,8561
-opencos/eda_config_defaults.yml,sha256=4ryY9THfaeL2kclo5KLkC7F1_g7FbjVzDMQFdAsvTl0,9195
+opencos/eda.py,sha256=k0_7ppBBPFsQ8Jd0mJGOnc6llUNo2hryHwx8DZ_B_jU,18832
+opencos/eda_base.py,sha256=8kDrKM5YpwSmSqnSIItiV6R9FDr5QjraiEF3PeXe7Lw,77580
+opencos/eda_config.py,sha256=FVp-dg9IVq78LZoh43kFYo9WXKfFxsMQMo6JGulEbEM,8818
+opencos/eda_config_defaults.yml,sha256=0tqs4paxCYZJshb2WW2GfaZyeh_l9ZUKWMh8hh17AWk,10235
 opencos/eda_config_max_verilator_waivers.yml,sha256=lTAU4IOEbUWVlPzuer1YYhIyxpPINeA4EJqcRIT-Ymk,840
-opencos/eda_config_reduced.yml,sha256=2mV9CiUEj_tyJnQsC9_k0RlxuBrky0zW1HX2xlDVEjU,1469
-opencos/eda_deps_bash_completion.bash,sha256=BmCZNnRBioiPf93qwjtOmIPdDeHes0ojS_s_k4jhMoo,1950
-opencos/eda_extract_targets.py,sha256=Qc4IEx82ZNY2bLNYY0htpB4XLT-Mr2JQfPriyRigWkI,3467
+opencos/eda_config_reduced.yml,sha256=cQ9jY4J7EvAbeHTiP6bvpDSVJAYiitjLZPSxxLKIEbk,1440
+opencos/eda_deps_bash_completion.bash,sha256=jMkQKY82HBgOnQeMdA1hMrXguRFtB52SMBxUemKovL4,1958
+opencos/eda_extract_targets.py,sha256=LLf8pGia0HxqXQFRck0E990EchbEdiFTC1fQyA8FZqs,4101
 opencos/eda_tool_helper.py,sha256=MxNd_ImyA13DZbzMol1R5H8tJZddJfqyDgFVR2ad374,1666
 opencos/export_helper.py,sha256=2SfzHM3m6b5Wh-OMgRWv5I_A95MHIYBn8-H_P3YC7ZQ,19680
 opencos/export_json_convert.py,sha256=KsP1ESmSWs8ouecDC5ikuwOFZNJtLjmiYOvYLeN5UZU,3768
-opencos/files.py,sha256=IB-hTRrVQx884GNqdJX1V1ikSRUS1Vwu-B3yX0AN6FI,1495
+opencos/files.py,sha256=z7HYk5j7cMyjK8e25xzCyyUzOnj9iZt9IpGJibbbh-U,1495
 opencos/names.py,sha256=LMhAE5UH5LEy4zqHp3rOe6tP26i_Dka6JOJzKMo_bkg,1201
 opencos/oc_cli.py,sha256=kj2OXvgxli2WPj4MQ4zTBb36eFtsP2gsqDdeNeWGL4E,132108
 opencos/pcie.py,sha256=VUJljaZJYgScAAx5yn7F6GoA8K9eTcw24otYZbkMpYs,3035
 opencos/peakrdl_cleanup.py,sha256=vLhSOVs6cEzsi_PwAP4pSXu5_ZMZjDvfK_WmHDLbDac,486
 opencos/seed.py,sha256=8TA2uXhBuT_lOaQdAKqdReYvfBWi_KuyQCFJzA2rOVM,549
 opencos/util.py,sha256=3rADW0tUzq69wdHsa2GB060N1jCAK2Dk0NLx6N6BMcc,27861
-opencos/commands/__init__.py,sha256=cHermtb27ZOUurW1UIGarQIJihH1oJvpFWwUbk6q2i0,858
+opencos/commands/__init__.py,sha256=d-8heMkBjjm6_yeduZgUv34lPfHVpj9MWP1ifpdjJws,916
 opencos/commands/build.py,sha256=jI5ul53qfwn6X-yfSdSQIcLBhGtzZUk7r_wKBBmKJI0,1425
 opencos/commands/elab.py,sha256=m6Gk03wSzX8UkcmReooK7turF7LpqO0IcdOZwJ8XiyI,1596
 opencos/commands/export.py,sha256=uGDI5_lUhyNB54gFjm9cWv9g_3waEOJN4wOC01oFlCY,3535
@@ -32,15 +32,16 @@ opencos/commands/proj.py,sha256=MdHTOtQYG93_gT97dWuSyAgUxX2vi9FRhL0dtc-rM98,1096
 opencos/commands/sim.py,sha256=phATz_wR0BAH6B_IJ4zyzg_Hptp5hSEOe_-9NLaL_bY,14058
 opencos/commands/sweep.py,sha256=L4AYF3vQHR-fi0871f1CwrD0y4tydrsNpWSDjVf1xIA,8719
 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=SRfjfsqhuszXHylQrgqYiUT3a5CQs9doxJQzuV4Ae0w,7055
 opencos/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opencos/tests/custom_config.yml,sha256=TRoVM9ZFKPOA_8JmlpzaMhnGO1txmaD14N_8P1oqzew,257
-opencos/tests/helpers.py,sha256=M_XwM1vQmcrVEgfvpL7C23VPjiFhPpsCqhAH5ZZqAT4,8211
+opencos/tests/helpers.py,sha256=zzQQP8ZeNUwrvJRQVlpTnvz9yxFG0Jfuss50ZPjxa-c,8240
 opencos/tests/test_build.py,sha256=FQAxOpLVQShAHD_L5rqJctPeSAoqoOCNFI0RXflLuY0,387
 opencos/tests/test_deps_helpers.py,sha256=_nJSgLN6WVlMKqu6sCr29gjQyN3Jj-dVk8Ac64ygpJs,5928
 opencos/tests/test_deps_schema.py,sha256=mWTWI4wriGXC8UAnaeq_MIvWJOvf08-fPUqUgELptQ4,896
-opencos/tests/test_eda.py,sha256=HCUGCg9yVILIIyyey2XArllgtBV5XHeVVnL5AGglO7I,37786
+opencos/tests/test_eda.py,sha256=eraWvyJJHrlq4CVoeWakYckRG8RRUYtecJRzlcXX45Q,38545
 opencos/tests/test_eda_elab.py,sha256=75bJpOaoO8rn1FXFxiE4KSu5FdjZP1IbW6SyTCjM_ao,2553
 opencos/tests/test_eda_synth.py,sha256=C_1LzblTuK_lHFv_Hh8v3DKUN4hGfxoChYR77GricX4,2871
 opencos/tests/test_oc_cli.py,sha256=-ZmwVX_CPBXCGT9hXIBEr_XUSIGG2eky89YpSJIbRAg,731
@@ -53,23 +54,23 @@ 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/invio.py,sha256=xAkYkMFKIUZDU1PkHeydDuPFjpEF_TN-1uYv7ErH4hY,3296
+opencos/tools/invio.py,sha256=q9E9n6xsozDfar-1rLvJEZbCpPb_bQEy6WKEI3KS3dk,3163
 opencos/tools/invio_helpers.py,sha256=1au4CYmV5aC7DHjaZBNemydH6Eq0i-Yt5L3HyKfQOfY,7638
-opencos/tools/invio_yosys.py,sha256=a7GGuPgxyilves_EjE1DSZqetPr7n0fcQC-xxrzjqag,5714
+opencos/tools/invio_yosys.py,sha256=4zWBeFKXHSyb5WSnf6ZpVG2UwoKF0SC-00I1_VqgXZM,6016
 opencos/tools/iverilog.py,sha256=1SmkJAtG096ozIY6N19UtpD-YT1UKJAcMLJ9blfraP0,6413
 opencos/tools/modelsim_ase.py,sha256=x5xFWBNaln2lVLixN0Od0uNaLKN_Bt1q6a91QmhKoNA,13162
 opencos/tools/questa.py,sha256=AX_3USyf6eMcssH4b-8WLbCzz-cXYnQzlHvCyL9C7Og,7505
 opencos/tools/slang.py,sha256=74EDAAnN7mrrYxgxaPDaoRJZK7Se9B_HsW8Ioi2Nw44,7425
-opencos/tools/slang_yosys.py,sha256=8zLwScd3PjouuLQpLvpX837kGqYQiJ9bnButCwrmSqI,15047
+opencos/tools/slang_yosys.py,sha256=mw4AfutGjKyCj7NLrHDy2j3p0XC2H7uuBf9RkVQJYoQ,9856
 opencos/tools/surelog.py,sha256=JOMs8SqnzJ_ZL5mEdyyn3Z1r1Kc8hfbV3Pnen1YzxWA,4980
 opencos/tools/tabbycad_yosys.py,sha256=h9kkAi479cZzYfb4R9WBNY_JmR6BgVFj4s3VShnGpoA,7813
 opencos/tools/verilator.py,sha256=0ZHAkkUqnsM1A4B8-u6tff3lhl-cgfDUx-Dq7DaRwkI,18080
 opencos/tools/vivado.py,sha256=cL5IZdudqquddvZqHQGDVmaHSxgBZsMUmAq18q8AgoM,39134
-opencos/tools/yosys.py,sha256=Nov3zKyliZ6rHwMbH4f8XEkoo9H66T2-MN-KNQTjWFk,3530
-opencos_eda-0.2.36.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-opencos_eda-0.2.36.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
-opencos_eda-0.2.36.dist-info/METADATA,sha256=bcp36pjsJ-jZgB8xXIiaYRKT86yOHYl_cBgKHaMVDDI,604
-opencos_eda-0.2.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opencos_eda-0.2.36.dist-info/entry_points.txt,sha256=V8OE1lySAFcFQpDNJuVxVZteeSmDH-joLMhGvrxrvmg,164
-opencos_eda-0.2.36.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
-opencos_eda-0.2.36.dist-info/RECORD,,
+opencos/tools/yosys.py,sha256=aZnRFbsODYRe4BHbfxl6vfWeEP7WJYJk50gCZcn8Fu0,8902
+opencos_eda-0.2.38.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+opencos_eda-0.2.38.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
+opencos_eda-0.2.38.dist-info/METADATA,sha256=kKhYeLRFFBsjoHaLMNW-xyGGbQejy0hEnW00rsC6puQ,604
+opencos_eda-0.2.38.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opencos_eda-0.2.38.dist-info/entry_points.txt,sha256=V8OE1lySAFcFQpDNJuVxVZteeSmDH-joLMhGvrxrvmg,164
+opencos_eda-0.2.38.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
+opencos_eda-0.2.38.dist-info/RECORD,,