opencos-eda 0.2.48__py3-none-any.whl → 0.2.50__py3-none-any.whl

opencos/eda_config.py

@@ -1,16 +1,25 @@
+''' opencos.eda_config - handles --config-yml arg, and providing a
+'config' dict for use by opencos.eda, opencos.commands, and opencos.tools
+
+Order of precedence for default value of eda arg: --config-yaml:
+1) os.environ.get('EDA_CONFIG_YML', '') -- filepath to an eda_config.yml file
+2) ~/.opencos-eda/EDA_CONFIG.yml
+3) (package pip installed dir for opencos)/eda_config_defaults.yml
+'''
+
+import copy
 import os
-import sys
 import argparse
-import mergedeep
 import shutil
 
+import mergedeep
+
 from opencos import util
+from opencos.utils.markup_helpers import yaml_safe_load, yaml_safe_writer
 
 class Defaults:
-    # Order of precedence for default value of eda arg: --config-yaml:
-    # 1) os.environ.get('EDA_CONFIG_YML', '') -- filepath to an eda_config.yml file
-    # 2) ~/.opencos-eda/EDA_CONFIG.yml
-    # 3) (package pip installed dir for opencos)/eda_config_defaults.yml
+    '''Defaults is a global placeholder for constants and supported features.'''
+
     environ_override_config_yml = os.environ.get('EDA_CONFIG_YML', '')
     home_override_config_yml = os.path.join(
         os.environ.get('HOME', ''), '.opencos-eda', 'EDA_CONFIG.yml'
@@ -56,6 +65,7 @@ class Defaults:
         'coverage-args',
     ])
 
+EDA_OUTPUT_CONFIG_FNAME = 'eda_output_config.yml'
 
 if os.path.exists(Defaults.environ_override_config_yml):
     Defaults.config_yml = Defaults.environ_override_config_yml
@@ -65,9 +75,11 @@ 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:
+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.'''
+    (pip-installed) opencos-eda package paths.'''
 
     # Check fullpath, unless we're only checking the installed pacakge dir.
     if package_search_only:
@@ -103,6 +115,11 @@ def find_eda_config_yml_fpath(filename:str, package_search_only=False, package_s
 
 
 def check_config(config:dict, filename='') -> None:
+    '''Returns None, will util.error(..) if there are issues in 'config'
+
+    checks for known dict keys and data types, is NOT exhaustive checking.
+    '''
+
     # sanity checks:
     for key in config:
         if key not in Defaults.supported_config_keys:
@@ -146,7 +163,7 @@ def update_config_auto_tool_order_for_tool(tool: str, config: dict) -> str:
         return tool
 
     old_exe = config['auto_tools_order'][0][tool].get('exe', str())
-    if type(old_exe) is list:
+    if isinstance(old_exe, list):
         config['auto_tools_order'][0][tool]['exe'][0] = user_exe
     else:
         config['auto_tools_order'][0][tool]['exe'] = user_exe
@@ -154,23 +171,33 @@ def update_config_auto_tool_order_for_tool(tool: str, config: dict) -> str:
 
 
 def update_config_auto_tool_order_for_tools(tools: list, config: dict) -> list:
-    ret = list()
+    '''Given a list of tools and eda_config style 'config' dict, update
+
+    the auto_tool_order (consumed by opencos.eda when --tool is not specified).
+    '''
+    ret = []
     for tool in tools:
         ret.append(update_config_auto_tool_order_for_tool(tool, config))
     return ret
 
 
 def update_config_for_eda_safe(config) -> None:
+    '''Set method to update config dict values to run in a "safe" mode'''
     config['dep_command_enables']['shell'] = False
 
 
 def deps_shell_commands_enabled(config) -> bool:
+    '''Get method on config to determine if DEPS.yml shell-style commands are allowed'''
     return config['dep_command_enables']['shell']
 
 
 def get_config(filename) -> dict:
+    '''Given an eda_config_default.yml (or --config-yml=<filename>) return a config
+
+    dict from the filename.'''
+
     fpath = find_eda_config_yml_fpath(filename)
-    user_config = util.yaml_safe_load(fpath)
+    user_config = yaml_safe_load(fpath)
     check_config(user_config, filename=filename)
 
     # The final thing we do is update key 'config-yml' with the full path used.
@@ -181,6 +208,10 @@ def get_config(filename) -> dict:
 
 
 def get_config_handle_defaults(filename) -> dict:
+    '''Given a user provided --config-yml=<filename>, return a merged config with
+
+    the existing default config.'''
+
     user_config = get_config(filename)
     user_config = get_config_merged_with_defaults(user_config)
     return user_config
@@ -197,19 +228,31 @@ def merge_config(dst_config:dict, overrides_config:dict, additive_strategy=False
 
 
 def get_config_merged_with_defaults(config:dict) -> dict:
+    '''Returns a new config that has been merged with the default config.
+
+    The default config location is based on Defaults.config_yml (env, local, or pip
+    installed location)'''
+
     default_fpath = find_eda_config_yml_fpath(Defaults.config_yml, package_search_only=True)
-    default_config = util.yaml_safe_load(default_fpath)
+    default_config = yaml_safe_load(default_fpath)
     merge_config(default_config, overrides_config=config)
     # This technically mutated updated into default_config, so return that one:
     return default_config
 
+
 def get_argparser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog='opencos eda config options', add_help=False, allow_abbrev=False)
+    '''Returns an ArgumentParser, handles --config-yml=<filename> arg'''
+    parser = argparse.ArgumentParser(
+        prog='opencos eda config options', add_help=False, allow_abbrev=False
+    )
     parser.add_argument('--config-yml', type=str, default=Defaults.config_yml,
-                        help=f'YAML filename to use for configuration (default {Defaults.config_yml})')
+                        help=('YAML filename to use for configuration (default'
+                              f' {Defaults.config_yml})'))
     return parser
 
+
 def get_argparser_short_help() -> str:
+    '''Returns a shortened help string given for arg --config-yml.'''
     return util.get_argparser_short_help(parser=get_argparser())
 
 
@@ -249,3 +292,31 @@ def get_eda_config(args:list, quiet=False) -> (dict, list):
         config = get_config_merged_with_defaults(config)
 
     return config, unparsed
+
+
+def write_eda_config_and_args(
+        dirpath : str, filename: str = EDA_OUTPUT_CONFIG_FNAME,
+        command_obj_ref: object = None
+) -> None:
+    '''Writes and eda_config style dict to dirpath/filename'''
+    if command_obj_ref is None:
+        return
+    fullpath = os.path.join(dirpath, filename)
+    data = {}
+    for x in ['command_name', 'config', 'target', 'args', 'modified_args', 'defines',
+              'incdirs', 'files_v', 'files_sv', 'files_vhd']:
+        # 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
+    }
+
+    # 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():
+        if k == 'command_handler':
+            data['config'][k] = str(v)
+
+    yaml_safe_writer(data=data, filepath=fullpath)

opencos/eda_config_defaults.yml

@@ -230,17 +230,39 @@ tools:
     compile-args: |
       -sv -svinputport=net -lint
     compile-waivers:
-      - 2275 # 2275 - Existing package 'foo_pkg' will be overwritten.
-      - 2555 # 2555 - assignment to input port foo
+      - 2275 # 2275 - Existing package 'myname_pkg' will be overwritten.
+      - 2555 # 2555 - assignment to input port myname
       - 2583 # 2583 - [SVCHK] - Extra checking for conflicts with always_comb and
              #        always_latch variables is done at vopt time.
     simulate-waivers:
-      - 3009 # 3009: [TSCALE] - Module 'foo' does not have a timeunit/timeprecision
+      - 3009 # 3009: [TSCALE] - Module 'myname' does not have a timeunit/timeprecision
              #       specification in effect, but other modules do.
     simulate-waves-args: |
       +acc
 
 
+  questa_fse:
+    defines:
+      OC_TOOL_QUESTA_FSE: 1
+    log-bad-strings:
+      - "Error:"
+    log-must-strings:
+      - " vsim "
+      - "Errors: 0"
+    compile-args: |
+      -sv -svinputport=net -lint
+    compile-waivers:
+      - 2275 # 2275 - Existing package 'myname_pkg' will be overwritten.
+      - 2555 # 2555 - assignment to input port myname
+      - 2583 # 2583 - [SVCHK] - Extra checking for conflicts with always_comb and
+             #        always_latch variables is done at vopt time.
+    simulate-waivers:
+      - 3009 # 3009: [TSCALE] - Module 'myname' does not have a timeunit/timeprecision
+             #       specification in effect, but other modules do.
+    simulate-waves-args: |
+      -voptargs=+acc=bcgnprst
+
+
   iverilog:
     log-bad-strings:
       - "Error:"
@@ -303,7 +325,7 @@ auto_tools_order:
     # TODO(drew): surelog is disabled from `eda tools-multi`. It is still
     # enabled for `eda [multi] elab --tool surelog`. It does not support
     # type comparisons:
-    #   if type(foo) == type(bar)
+    #   if type(myname) == type(othername)
     # [ERR:UH0700] ... Unsupported expression
     # modelsim_ase also doesn't, but it won't fail elab, whereas surelog does.
     surelog:
@@ -404,6 +426,16 @@ auto_tools_order:
         elab: opencos.tools.modelsim_ase.CommandElabModelsimAse
         sim:  opencos.tools.modelsim_ase.CommandSimModelsimAse
 
+    questa_fse:  # free student edition, works similar to modelsim_ase
+      exe: vsim
+      requires_cmd:
+        - vsim -version
+      requires_in_exe_path:
+        - questa_fse
+      handlers:
+        elab: opencos.tools.questa_fse.CommandElabQuestaFse
+        sim:  opencos.tools.questa_fse.CommandSimQuestaFse
+
     iverilog:
       exe: iverilog
       handlers:

opencos/eda_extract_targets.py

@@ -8,12 +8,8 @@ targets from DEPS files
 import sys
 import os
 from pathlib import Path
-import json
 
-import yaml
-import toml
-
-from opencos.deps_helpers import get_all_targets
+from opencos.deps.deps_file import get_all_targets
 
 PATH_LPREFIX = str(Path('.')) + os.path.sep
 
@@ -32,12 +28,13 @@ def get_terminal_columns():
     except OSError:
         # Handle cases where the terminal size cannot be determined (e.g., not in a TTY)
         return 80  # Default to 80 columns
-    else:
-        return 80
+
+    return 80 # else default to 80.
 
 
 def print_columns_manual(data: list, num_columns: int = 4, auto_columns: bool = True) -> None:
     """Prints a list of strings in columns, manually aligning them."""
+
     if not data:
         print()
         return
@@ -59,10 +56,12 @@ def print_columns_manual(data: list, num_columns: int = 4, auto_columns: bool =
             max_line_len += x + _spacing
         if max_line_len > window_cols:
             # subtract a column (already >= 2):
-            return print_columns_manual(data=data, num_columns=num_columns-1, auto_columns=True)
+            print_columns_manual(data=data, num_columns=num_columns-1, auto_columns=True)
+            return
         if max_line_len + max_item_len + _spacing < window_cols:
             # add 1 more column if we're guaranteed to have room.
-            return print_columns_manual(data=data, num_columns=num_columns+1, auto_columns=True)
+            print_columns_manual(data=data, num_columns=num_columns+1, auto_columns=True)
+            return
         # else continue
 
     # Print data in columns
@@ -72,21 +71,30 @@ 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 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
-    if not os.path.exists(partial_path):
-        partial_path, partial_target = os.path.split(partial_path)
+
+    # if the partial path is not an existing file or dir, then treat it as
+    # a partial and split it so partial_path/partial_target can be used later.
+    if not base_path or base_path == str(Path('.')):
+        if not os.path.exists(partial_path):
+            partial_path, partial_target = os.path.split(partial_path)
+    else:
+        if not os.path.exists(os.path.join(base_path, partial_path)):
+            partial_path, partial_target = os.path.split(partial_path)
+
+    # if we have no partial path, use compatible ./
     if not partial_path:
         partial_path = PATH_LPREFIX
 
     return partial_path, partial_target
 
 
-
-
 def get_targets(partial_paths: list, base_path=str(Path('.'))) -> list:
     '''Returns a list of DEPS keys into pretty columns, using arg
 
@@ -109,7 +117,7 @@ def get_targets(partial_paths: list, base_path=str(Path('.'))) -> list:
                 error_on_empty_return=False,
                 lstrip_path=True
             )
-        except:
+        except Exception:
             keys = []
         for key in keys:
             targets_set.add(key)

opencos/eda_tool_helper.py

@@ -1,12 +1,28 @@
+''' opencos.eda_tool_helper -- used by pytests and other checks to see if tools are loaded
+
+which helps determine if a pytest is runnable for a given tool, or should be skipped.
+Does this without calling `eda` or eda.main(..)
+
+Example uses:
+    from opencos import eda_tool_helper
+    cfg, tools_loaded = eda_tool_helper.get_config_and_tools_loaded()
+    assert 'verilator' in tools_loaded
+
+'''
 
-import os
-import sys
 
 from opencos import eda, eda_config, util
 
 # Used by pytest, so we can skip tests if tools aren't present.
 
-def get_config_and_tools_loaded(quiet=False, args=[]):
+def get_config_and_tools_loaded( # pylint: disable=dangerous-default-value
+        quiet: bool = False, args: list = []
+) -> (dict, set):
+    '''Returns config dict and set tools_loaded, given the found config.
+
+    Can BYO args such as --config-yml=MY_OWN_EDA_CONFIG.yml
+    '''
+
     # We have to figure out what tools are avaiable w/out calling eda.main,
     # so we can get some of these using eda_config.get_eda_config()
     config, _ = eda_config.get_eda_config(args=args, quiet=quiet)
@@ -14,14 +30,24 @@ def get_config_and_tools_loaded(quiet=False, args=[]):
     tools_loaded = config.get('tools_loaded', set()).copy()
     return config, tools_loaded
 
+
 def get_all_handler_commands(config=None, tools_loaded=None) -> dict:
-    all_handler_commands = dict()
+    '''Given a config and tools_loaded (or if not supplied uses defaults) returns a dict
+
+    of { <command>: [list of tools that run that command, in auto-tool-order] }.
+
+    For example:
+       { "sim": ["verilator", "vivado"],
+         "elab": ["slang", "verilator", ...], ...
+       }
+    '''
+    all_handler_commands = {}
 
     if config is None or tools_loaded is None:
         config, tools_loaded = get_config_and_tools_loaded()
 
-    assert type(config) is dict
-    assert type(tools_loaded) is set
+    assert isinstance(config, dict)
+    assert isinstance(tools_loaded, set)
 
     # Let's re-walk auto_tools_order to get this ordered per eda command:
     for tool, table in config.get('auto_tools_order', [{}])[0].items():
@@ -34,7 +60,7 @@ def get_all_handler_commands(config=None, tools_loaded=None) -> dict:
                        'disable-tools-multi in config')
             continue
 
-        for command, handler in table.get('handlers', {}).items():
+        for command in table.get('handlers', {}).keys():
             if command not in all_handler_commands:
                 # create ordered list from config.
                 all_handler_commands[command] = list([tool])