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

opencos/deps/deps_processor.py

@@ -103,6 +103,37 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 self.command_design_ref.incdirs.append(abspath)
                 debug(f'Added include dir {abspath} from {self.caller_info}')
 
+
+    def _apply_args_check_tools(self, tokens: list) -> list:
+        '''Helper for apply_args(list), returns list strips --tool args under certain conditions'''
+
+        _orig_tool = self.args.get('tool', '')
+        if not self.command_design_ref.auto_tool_applied and \
+           any(x.startswith('--tool') for x in tokens) and _orig_tool:
+            warn_tool = ''
+            for i, item in enumerate(list(tokens)):
+                if item == '--tool':
+                    if tokens[i + 1] != _orig_tool:
+                        warn_tool = tokens[i + 1]
+                    tokens[i : i+2] = ['', ''] # remove this and next arg
+                elif item.startswith('--tool='):
+                    if item[7:] != _orig_tool:
+                        warn_tool = item
+                    tokens[i] = '' # remove just this arg.
+
+            if warn_tool:
+                warning(
+                    f'Attempting to set --tool {warn_tool} from DEPS',
+                    f'(file={self.deps_file}:{self.target_node})',
+                    f'however the tool was already chosen as: {_orig_tool}. The --tool arg will',
+                    f'not be applied from: {tokens}'
+                )
+
+            tokens = [item for item in tokens if item != ''] # remove blanks
+
+        return tokens
+
+
     def apply_args(self, args_list:list) -> list:
         '''Given args_list, applies them to our self.command_design_ref obj
 
@@ -114,9 +145,20 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             self.error(f"{args_list=} is not type str/list, can't apply args",
                        f"in {self.caller_info}")
         tokens = dep_str2list(args_list)
+
         # We're going to run an ArgumentParser here, which is not the most efficient
         # thing to do b/c it runs on all of self.command_design_ref.args (dict) even
         # if we're applying a single token.
+
+        # We have to special-case anything with --tool[=value] in tokens, otherwise
+        # the user may think they were allowed to set --tool, but in our flow the Command handler
+        # (self.command_design_ref) has already been chosen, so setting the tool can have
+        # strange side-effects.
+        _orig_tool = self.args.get('tool', '')
+        tokens = self._apply_args_check_tools(tokens=tokens)
+        if not tokens:
+            return []
+
         debug(f'deps_processor - custom apply_args with {tokens=}',
               f'from {self.caller_info}')
         _, unparsed = self.command_design_ref.run_argparser_on_list(
@@ -135,6 +177,16 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             # flist from that target.
             warning(f'For {self.command_design_ref.command_name}:' \
                     + f' in {self.caller_info} has unknown args {unparsed=}')
+
+        if self.command_design_ref.auto_tool_applied and _orig_tool != self.args.get('tool', ''):
+            debug(f'deps_processor.apply_args: tool changed, {self.args["tool"]=}, will attempt',
+                  f'to respawn the job using original args: {self.config["eda_original_args"]}')
+            self.command_design_ref.tool_changed_respawn = {
+                'tool': self.args['tool'],
+                'orig_tool': _orig_tool,
+                'from': self.caller_info,
+            }
+
         return unparsed
 
     def apply_reqs(self, reqs_list:list) -> None:
@@ -213,6 +265,10 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             elif key == 'deps':
                 remaining_deps_list += self.process_deps_return_discovered_deps()
 
+            if self.command_design_ref.tool_changed_respawn:
+                # Stop now, and have eda.py respawn the command.
+                return []
+
         # We return the list of deps that still need to be resolved (['full_path/some_target', ...])
         return remaining_deps_list
 
@@ -260,6 +316,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
 
             apply_tag_items_tools = False
+            apply_tag_items_commands = False
             apply_tag_items_with_args = False
 
             tool = self.args.get('tool', None)
@@ -276,6 +333,12 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                     warning(f'{tagname=} in {self.caller_info}:',
                             ' skipped due to with-tools disabled.')
 
+                with_commands = dep_str2list(value.get('with-commands', []))
+                if with_commands and not deps_tags_enables.get('with-commands', None):
+                    with_commands = []
+                    warning(f'{tagname=} in {self.caller_info}:',
+                            ' skipped due to with-commands disabled.')
+
                 with_args = value.get('with-args', {})
                 if not isinstance(with_args, dict):
                     error(f'{tagname=} in {self.caller_info}:',
@@ -299,6 +362,12 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                         if tool_full_version and tool_full_version in with_tools:
                             apply_tag_items_tools = True
 
+                # check with-commands?
+                if not with_commands:
+                    apply_tag_items_commands = True # no with-commands present
+                elif getattr(self.command_design_ref, 'command_name', '') in with_commands:
+                    apply_tag_items_commands = True # with-commands present and we matched.
+
                 # check with-args?
                 with_args_matched_list = []
                 for k,v in with_args.items():
@@ -336,7 +405,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             elif enable_tags_matched:
                 apply_tag_items = True
             else:
-                apply_tag_items = apply_tag_items_tools and apply_tag_items_with_args
+                apply_tag_items = all([apply_tag_items_tools, apply_tag_items_with_args,
+                                       apply_tag_items_commands])
 
             if not apply_tag_items:
                 debug(f'process_tags(): {tagname=} in {self.caller_info}',
@@ -370,7 +440,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                         if args_list:
                             # This will apply knowns args to the target dep:
                             info(f'{tagname=} in {self.caller_info=}:',
-                                 f'applying args b/c {with_tools=} for {args_list=}')
+                                 f'applying args for {args_list=}')
                             self.apply_args(args_list)
 
                     elif key == 'reqs':

opencos/deps_schema.py

@@ -111,6 +111,8 @@ my_target_name:
     <str>:                           <---- string user name for this tag
       with-tools:                    <---- optional array (or string) of tools this tag requires
                                            for the tag to be applied.
+      with-commands:                 <---- optional array (or string) of command this tag requires
+                                           for the tag to be applied.
       with-args:                     <---- optional table of args values that must match for
                                            this tag to be applied.
       args:                          <---- optional array of args to be applied to this target
@@ -217,6 +219,7 @@ TARGET_EDA_COMMAND = {
 TARGET_TAGS_TABLE = {
     Optional(str): {
         Optional('with-tools'): ARRAY_OR_SPACE_SEPARATED_STRING,
+        Optional('with-commands'): ARRAY_OR_SPACE_SEPARATED_STRING,
         Optional('with-args'): dict,
         Optional('args'): ARRAY_OR_SPACE_SEPARATED_STRING,
         Optional('deps'): ARRAY_OR_SPACE_SEPARATED_STRING,

opencos/eda.py

@@ -20,13 +20,19 @@ from pathlib import Path
 
 import opencos
 from opencos import util, eda_config, eda_base
-from opencos.eda_base import Tool, which_tool
+from opencos.eda_base import Tool, which_tool, get_eda_exec
 from opencos.utils import vsim_helper, vscode_helper
+from opencos.utils.subprocess_helpers import subprocess_run_background
+from opencos.utils import status_constants
 
 # Configure util:
 util.progname = "EDA"
 util.global_log.default_log_enabled = True
 util.global_log.default_log_filepath = os.path.join('eda.work', 'eda.log')
+util.global_log.default_log_disable_with_args.extend([
+    # avoid default log on certain eda commands
+    'help', 'waves', 'deps-help', 'targets'
+])
 
 
 # ******************************************************************************
@@ -44,12 +50,12 @@ def init_config(
     # 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():
+    for _cmd, 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")
+            util.error(f"config DEFAULT_HANDLERS command={_cmd} {str_class=} could not import")
         else:
-            config['command_handler'][command] = cls
+            config['command_handler'][_cmd] = cls
 
     config['auto_tools_found'] = {}
     config['tools_loaded'] = set()
@@ -58,6 +64,18 @@ def init_config(
     return config
 
 
+def get_all_commands_help_str(config: dict) -> str:
+    '''Returns a str of help based on what commands eda supports, from config'''
+    all_commands_help = []
+    max_command_str_len = max(len(s) for s in config.get('DEFAULT_HANDLERS_HELP', {}).keys())
+    for key, value in config.get('DEFAULT_HANDLERS_HELP', {}).items():
+        all_commands_help.append(f'    {key:<{max_command_str_len}} - {value.strip()}')
+    if all_commands_help:
+        all_commands_help = [
+            'Where <command> is one of:',
+            '',
+        ] + all_commands_help
+    return '\n'.join(all_commands_help)
 
 
 def usage(tokens: list, config: dict, command="") -> int:
@@ -77,26 +95,11 @@ def usage(tokens: list, config: dict, command="") -> int:
 """
 Usage:
     eda [<options>] <command> [options] <files|targets, ...>
-
-Where <command> is one of:
-
-    sim          - Simulates a DEPS target
-    elab         - Elaborates a DEPS target (sort of sim based LINT)
-    synth        - Synthesizes a DEPS target
-    flist        - Create dependency from a DEPS target
-    proj         - Create a project from a DEPS target for GUI sim/waves/debug
-    multi        - Run multiple DEPS targets, serially or in parallel
-    tools-multi  - Same as 'multi' but run on all available tools, or specfied using --tools
-    sweep        - Sweep one or more arguments across a range, serially or in parallel
-    build        - Build for a board, creating a project and running build flow
-    waves        - Opens waveform from prior simulation
-    upload       - Uploads a finished design into hardware
-    open         - Opens a project
-    export       - Export files related to a target, tool independent
-    shell        - Runs only commands for DEPS target (like sim or elab, but stops prior to tool)
-    targets      - list all possible targets given glob path.
-    help         - This help (without args), or i.e. "eda help sim" for specific help
-
+"""
+        )
+        print(get_all_commands_help_str(config=config))
+        print(
+"""
 And <files|targets, ...> is one or more source file or DEPS markup file target,
     such as .v, .sv, .vhd[l], .cpp files, or a target key in a DEPS.[yml|yaml|toml|json].
     Note that you can prefix source files with `sv@`, `v@`, `vhdl@` or `cpp@` to
@@ -249,7 +252,7 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
             p = shutil.which(exe)
             config['auto_tools_found'][name] = exe # populate key-value pairs w/ first exe in list
             if not quiet:
-                util.info(f"Detected {name} ({p}), auto-setting up tool {name}")
+                util.info(f"Detected {name} ({p})")
             tool_setup(tool=name, quiet=True, auto_setup=True, warnings=warnings, config=config)
 
     return config
@@ -317,7 +320,7 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
     config['tools_loaded'].add(tool)
 
 
-def process_tokens( # pylint: disable=too-many-branches,too-many-statements
+def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-many-locals
         tokens: list, original_args: list, config: dict, is_interactive=False
 ) -> int:
     '''Returns bash/sh style return code int (0 pass, non-zero fail).
@@ -335,6 +338,7 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements
     deferred_tokens = []
     command = ""
     run_auto_tool_setup = True
+    process_tokens_cwd = os.getcwd()
 
     parser = eda_base.get_argparser()
     try:
@@ -409,6 +413,7 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements
        command not in config.get('command_tool_is_optional', []):
         use_tool = which_tool(command, config)
         util.info(f"--tool not specified, using default for {command=}: {use_tool}")
+        setattr(sco, 'auto_tool_applied', True)
 
     rc = check_command_handler_cls(command_obj=sco, command=command, parsed_args=parsed)
     if rc > 0:
@@ -426,6 +431,25 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements
     # rc=1 because that's the python exception rc)
     rc = getattr(sco, 'status', 2)
     util.debug(f'Return from main process_tokens({tokens=}), {rc=}, {type(sco)=}, {unparsed=}')
+
+    if rc == 0 and not parsed.tool and getattr(sco, 'tool_changed_respawn', False):
+        use_tool = sco.args.get('tool', '')
+        if not use_tool:
+            util.error(f'Unable to change tool from {parsed.tool}, internal eda problem.')
+            return status_constants.EDA_DEFAULT_ERROR
+
+        # close the util.log:
+        util.stop_log()
+        # respawn the original job, but with --tool=<use_tool> applied:
+        _command_list = [get_eda_exec(command), f"--tool={use_tool}"] + original_args
+        util.info(f'eda: respawn for tool change: {" ".join(_command_list)};',
+                  f' (running from: {process_tokens_cwd})')
+        subprocess_run_background(
+            work_dir=process_tokens_cwd,
+            command_list=_command_list,
+            background=util.args.get('quiet', False)
+        )
+
     return rc