opencos-eda 0.3.11__py3-none-any.whl → 0.3.13__py3-none-any.whl

opencos/eda_base.py

@@ -26,7 +26,8 @@ from opencos import eda_config
 
 from opencos.util import Colors, safe_emoji
 from opencos.utils.str_helpers import sprint_time, strip_outer_quotes, string_or_space, \
-    indent_wrap_long_text, pretty_list_columns_manual, get_terminal_columns
+    indent_wrap_long_text, pretty_list_columns_manual, get_terminal_columns, \
+    PARAMETER_NAME_RSTR
 from opencos.utils.subprocess_helpers import subprocess_run_background
 from opencos.utils import status_constants
 
@@ -192,6 +193,8 @@ class Tool:
             self.args_help = {}
         if getattr(self, 'defines', None) is None:
             self.defines = {}
+        if getattr(self, 'config', None) is None:
+            self.config = config
         self.args.update({
             'tool':   self._TOOL, # Set for all derived classes.
         })
@@ -211,7 +214,7 @@ class Tool:
 
     def set_exe(self, config: dict) -> None:
         '''Sets self._EXE based on config'''
-        if self._TOOL and self._TOOL in config.get('auto_tools_order', [{}])[0]:
+        if self._TOOL and self._TOOL in config.get('auto_tools_found', {}):
             # config['auto_tools_found'] has the first exe full path:
             exe = config.get('auto_tools_found', {}).get(self._TOOL)
             if exe and exe != self._EXE:
@@ -231,7 +234,11 @@ class Tool:
         return str(self._TOOL) + ':' + str(self._VERSION)
 
     def get_versions(self) -> str:
-        '''Sets and returns self._VERSION'''
+        '''Sets and returns self._VERSION. Note that this is overriden by nearly all
+
+        child Tool classes, and should limit info/warning messaging since it is part
+        of opencos.eda.init_config(..)
+        '''
         return self._VERSION
 
     def report_tool_warn_error_counts(self) -> None:
@@ -247,7 +254,7 @@ class Tool:
             info_color = Colors.yellow
         if self.tool_error_count:
             info_color = Colors.yellow
-            error_color = Colors.byellow
+            error_color = Colors.bred
             start = safe_emoji('🔶 ')
         util.info(
             f"{start}Tool - {Colors.bold}{tool_name}{Colors.normal}{info_color}, total counts:",
@@ -257,8 +264,20 @@ class Tool:
         )
 
     def set_tool_defines(self) -> None:
-        '''Derived classes may override, sets any additional defines based on tool.'''
-        return
+        '''Derived classes may override, sets any additional defines based on tool.
+
+        If overriding, you likely want to call:
+            super().set_tool_defines()
+        to pick up anything from self.config['tools'] (from the eda_config YAML)
+        '''
+        if not self._TOOL:
+            return
+
+        _tool_config = self.config.get('tools', {}).get(self._TOOL, {})
+        self.defines.update(
+            _tool_config.get('defines', {})
+        )
+
 
 
 class Command: # pylint: disable=too-many-public-methods,too-many-instance-attributes
@@ -878,23 +897,20 @@ class Command: # pylint: disable=too-many-public-methods,too-many-instance-attri
 
         return unparsed
 
-    def get_command_from_unparsed_args(
-            self, tokens: list, error_if_no_command: bool = True
+    def get_sub_command_from_config(
+            self, error_if_no_command: bool = True,
     ) -> str:
-        '''Given a list of unparsed args, try to fish out the eda COMMAND value.
+        '''If this is a command with a sub-command (multi, sweep), then opencos.eda would
 
-        This will remove the value from the tokens list.
+        have already parsed in an place it in config['sub_command']. Get this value and return
+        it.
         '''
-        ret = ''
-        for value in tokens:
-            if value in self.config['command_handler'].keys():
-                ret = value
-                tokens.remove(value)
-                break
+        ret = self.config.get('sub_command', '')
 
         if not ret and error_if_no_command:
+            util.debug(f'get_sub_command_from_config: see: {self.config=}')
             self.error(f"Looking for a valid eda {self.command_name} COMMAND",
-                       f"but didn't find one in {tokens=}",
+                       "but didn't find one in config",
                        error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
         return ret
 
@@ -1500,7 +1516,14 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
     def process_parameter_arg(
             self, text: str, pwd: str = os.getcwd()
     ) -> None:
-        '''Retuns None, parses -G<Name>=<Value> adds to internal self.parameters.'''
+        '''Retuns None, parses -G<Name>=<Value> adds to internal self.parameters.
+
+        Note that not all tools will allow hierarchy path information when setting
+        parameters. The Queta/Modelsim family can handle -G/Path/To/Name=Value,
+        but other tools may crash.
+
+        Also note - we do not currently accept [0] in the /Path/To/generate[1]/Name=Value
+        '''
 
         # Deal with raw CLI/bash/powershell argparser, strip all outer quotes.
         text = strip_outer_quotes(text)
@@ -1513,14 +1536,14 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
             return
 
         text = text[2:] # strip leading -G
-        m = re.match(r'^(\w+)$', text)
+        m = re.match(rf'^({PARAMETER_NAME_RSTR})$', text)
         if m:
             k = m.group(1)
             util.warning(f"Parameter {k} has no value and will not be applied")
             return
-        m = re.match(r'^(\w+)\=(\S+)$', text)
+        m = re.match(rf'^({PARAMETER_NAME_RSTR})\=(\S+)$', text)
         if not m:
-            m = re.match(r'^(\w+)\=(\"[^\"]*\")$', text)
+            m = re.match(rf'^({PARAMETER_NAME_RSTR})\=(\"[^\"]*\")$', text)
         if m:
             k = m.group(1)
             v = m.group(2)
@@ -1535,7 +1558,11 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 v = int(v)
             except ValueError:
                 pass
+            util.debug('set parameter Name={k} Value={v}')
             self.set_parameter(k, v)
+        else:
+            util.warning(f'Unable to set parameter from token (-G removed): {text}')
+
 
 
     def process_plusarg( # pylint: disable=too-many-branches
@@ -1923,19 +1950,24 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
             m = re.match(r"^\'?\+\w+", token)
             if m:
                 # Copy and strip all outer ' or " on the plusarg:
+                util.debug(f'plusarg found at {token=}')
                 plusarg = strip_outer_quotes(token)
                 self.process_plusarg(plusarg, pwd=pwd)
                 remove_list.append(token)
                 continue
 
             # Parameters in -G<word>=<something>
-            m = re.match(r"^\'?\-G\w+\=.+", token)
+            # Parameters in -Gpath.to.<word>=<something>
+            # Parameters in -G/path/to/<word>=<something>
+            m = re.match(rf"^\'?\-G{PARAMETER_NAME_RSTR}\=.+", token)
             if m:
                 # Copy and strip all outer ' or " on the text:
+                util.debug(f'found parameter at {token=}')
                 param = strip_outer_quotes(token)
                 self.process_parameter_arg(param, pwd=pwd)
                 remove_list.append(token)
 
+
         for x in remove_list:
             unparsed.remove(x)
 

opencos/eda_config.py

@@ -22,6 +22,10 @@ class Defaults:
     '''Defaults is a global namespace for constants and supported features.
 
     Defaults.config_yml is set depending on search order for default eda_config[_defaults].yml
+
+    Note that opencos.eda and other packages are free to set and add additonal keys to the
+    "config", but the "supported_config_keys" are only what's allowed in the initial
+    --config-yml=YAML_FILE
     '''
 
     environ_override_config_yml = ''
@@ -29,6 +33,7 @@ class Defaults:
     opencos_config_yml = 'eda_config_defaults.yml'
     config_yml = ''
     config_yml_set_from = ''
+    non_default_config_yml_arg_used = ''
 
     supported_config_keys = set([
         'DEFAULT_HANDLERS', 'DEFAULT_HANDLERS_HELP',
@@ -39,6 +44,7 @@ class Defaults:
         'deps_subprocess_shell',
         'bare_plusarg_supported',
         'deps_expandvars_enable',
+        'show_tool_versions',
         'dep_sub',
         'vars',
         'file_extensions',
@@ -48,13 +54,12 @@ class Defaults:
         'tools',
         'auto_tools_order',
     ])
-    supported_config_auto_tools_order_keys = set([
+    supported_config_tool_keys = set([
         'exe', 'handlers',
         'requires_env', 'requires_py', 'requires_cmd', 'requires_in_exe_path',
-        'requires_vsim_helper', 'requires_vscode_extension',
+        'requires_vsim_helper',
+        'requires_vscode_extension',
         'disable-tools-multi', 'disable-auto',
-    ])
-    supported_config_tool_keys = set([
         'defines',
         'log-bad-strings',
         'log-must-strings',
@@ -158,14 +163,6 @@ def check_config(config:dict, filename='') -> None:
             util.error(f'eda_config.get_config({filename=}): has unsupported {key=}' \
                        + f' {Defaults.supported_config_keys=}')
 
-    for row in config.get('auto_tools_order', []):
-        for tool, table in row.items():
-            for key in table:
-                if key not in Defaults.supported_config_auto_tools_order_keys:
-                    util.error(f'eda_config.get_config({filename=}): has unsupported {key=}' \
-                               + f' in auto_tools_order, {tool=},' \
-                               + f' {Defaults.supported_config_auto_tools_order_keys=}')
-
     for tool,table in config.get('tools', {}).items():
         for key in table:
             if key not in Defaults.supported_config_tool_keys:
@@ -318,11 +315,35 @@ def get_eda_config(args:list, quiet=False) -> (dict, list):
         config = None
 
     if parsed.config_yml != Defaults.config_yml:
+        Defaults.non_default_config_yml_arg_used = parsed.config_yml
         config = get_config_merged_with_defaults(config)
 
     return config, unparsed
 
 
+def get_config_yml_args_for_flist() -> list:
+    '''Returns list of args, or empty list. Used by CommandFList when we want to get the args
+
+    to reproduce a target to be run again in `eda`'''
+    ret = []
+
+    if Defaults.non_default_config_yml_arg_used:
+        ret.append(f'--config-yml={Defaults.non_default_config_yml_arg_used}')
+
+        if Defaults.config_yml_set_from:
+            # a default config-yml was used, but it wasn't from eda, was from
+            # ENV or HOME dir. This is not included in the flist, so warn about it.
+            # Since we don't support > 1 config-yml args, need to warn about this.
+            util.warning('Note: for command "flist", picked up',
+                         f'--config-yml={Defaults.config_yml},',
+                         f'from: {Defaults.config_yml_set_from}')
+
+    elif Defaults.config_yml_set_from:
+        ret.append(f'--config-yml={Defaults.config_yml}')
+
+    return ret
+
+
 def write_eda_config_and_args(
         dirpath : str, filename: str = EDA_OUTPUT_CONFIG_FNAME,
         command_obj_ref: object = None
@@ -338,16 +359,22 @@ def write_eda_config_and_args(
         # Use deep copy b/c otherwise these are references to opencos.eda.
         data[x] = copy.deepcopy(getattr(command_obj_ref, x, ''))
 
-    # copy util.args
-    data['util'] = {
-        'args': util.args
-    }
+    # copy util.args, and other util globals:
+    data['util'] = {}
+    for x in ['INITIAL_CWD', 'args', 'dot_f_files_expanded', 'env_files_loaded', 'max_error_code']:
+        data['util'][x] = getattr(util, x, '')
+
+    # copy some information about which eda_config YAML was used:
+    for member in ['config_yml', 'config_yml_set_from', 'non_default_config_yml_arg_used']:
+        data[member] = getattr(Defaults, member, '')
 
     # fix some burried class references in command_obj_ref.config,
     # otherwise we won't be able to safe load this yaml, so cast as str repr.
-    for k, v in getattr(command_obj_ref, 'config', {}).items():
+    config = getattr(command_obj_ref, 'config', {})
+    for k, v in config.items():
         if k == 'command_handler':
-            data['config'][k] = str(v)
+            data['config']['command_handler'] = str(v)
+
 
     yaml_safe_writer(data=data, filepath=fullpath)
 
@@ -393,10 +420,10 @@ def tool_try_add_to_path( # pylint: disable=too-many-branches
 
     name, path_arg = name_path_parts[0:2]
 
-    if name not in config['auto_tools_order'][0]:
+    if name not in config['tools']:
         return name
 
-    config_exe = config['auto_tools_order'][0][name].get('exe', str())
+    config_exe = config['tools'][name].get('exe', str())
     if isinstance(config_exe, list):
         orig_exe = config_exe[0]
     else:
@@ -433,17 +460,17 @@ def tool_try_add_to_path( # pylint: disable=too-many-branches
 
     if update_config:
         if isinstance(config_exe, list):
-            config['auto_tools_order'][0][name]['exe'][0] = user_exe
+            config['tools'][name]['exe'][0] = user_exe
             for index,value in enumerate(config_exe[1:]):
                 # update all entries, if we can, if the value is also in 'path'
                 # from our set --tool=Name=path/exe
                 new_value = os.path.join(path, os.path.split(value)[1])
                 if os.path.exists(new_value) and safe_shutil_which(new_value) and \
                    os.access(new_value, os.X_OK):
-                    config['auto_tools_order'][0][name]['exe'][index] = new_value
+                    config['tools'][name]['exe'][index] = new_value
         else:
-            config['auto_tools_order'][0][name]['exe'] = user_exe
-        util.debug(f'For {tool=}, auto_tools_order config updated')
+            config['tools'][name]['exe'] = user_exe
+        util.debug(f'For {tool=}, tools config entry updated')
 
     util.debug(f'For {tool=}, final {user_exe=}')