opencos-eda 0.2.35__tar.gz → 0.2.38__tar.gz

{opencos_eda-0.2.35/opencos_eda.egg-info → opencos_eda-0.2.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.35
+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.35 → opencos_eda-0.2.38}/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_eda-0.2.38/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-0.2.35 → opencos_eda-0.2.38}/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-0.2.35 → opencos_eda-0.2.38}/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-0.2.35 → opencos_eda-0.2.38}/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-0.2.35 → opencos_eda-0.2.38}/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-0.2.35 → opencos_eda-0.2.38}/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-0.2.35 → opencos_eda-0.2.38}/opencos/eda_deps_bash_completion.bash

@@ -15,7 +15,7 @@
 # what we want to add target completion to:
 SCRIPT_NAME="eda"
 # how we get the completion targets:
-EXTRACTION_SCRIPT_NAME="eda_extract_deps_keys"
+EXTRACTION_SCRIPT_NAME="eda_targets"
 
 _eda_script_completion() {
 
@@ -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-0.2.35/opencos/eda_extract_deps_keys.py → opencos_eda-0.2.38/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__":