opencos-eda 0.3.16__py3-none-any.whl → 0.3.17__py3-none-any.whl

opencos/eda_base.py

@@ -203,7 +203,7 @@ class Tool:
         })
         # update self._EXE if config says to:
         self.set_exe(config)
-        self.get_versions()
+        self.get_versions(quiet=True)
 
         if getattr(self, 'set_tool_config_from_config', None):
             # Hook for classes like CommandSim that have a Tool derived class attached:
@@ -233,7 +233,9 @@ class Tool:
             self.get_versions()
         return str(self._TOOL) + ':' + str(self._VERSION)
 
-    def get_versions(self) -> str:
+    def get_versions( # pylint: disable=unused-argument
+            self, **kwargs
+    ) -> str:
         '''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
@@ -1256,7 +1258,9 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         # cached_deps: key = abspath of DEPS markup file, value is a dict with
         # keys 'data' and 'line_numbers'
         self.cached_deps = {}
-        self.targets_dict = {} # key = targets that we've already processed in DEPS files
+
+        # targets_dict: key = str(Path(target)), value is DepsFile caller_info, or path
+        self.targets_dict = {}
 
         self.has_pre_compile_dep_shell_commands = False
         self.has_post_tool_dep_shell_commands = False
@@ -1717,11 +1721,11 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         self.target_path, self.target = os.path.split(target)
 
-        if target in self.targets_dict:
+        if str(Path(target)) in self.targets_dict:
             # If we're encountered this target before, stop. We're not traversing again.
             return True
 
-        self.targets_dict[target] = None
+        self.targets_dict[str(Path(target))] = f'({self.target_path})'
         file_exists, fpath, forced_extension = files.get_source_file(target)
         if file_exists:
             # If the target is a file (we're at the root here processing CLI arg tokens)
@@ -1748,6 +1752,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         deps, data, deps_file = None, None, None
         found_deps_file = False
+        found_caller_info = ''
 
         if self.config['deps_markup_supported']:
             deps = DepsFile(
@@ -1763,6 +1768,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         if found_deps_file and found_target:
 
+            found_caller_info = deps.gen_caller_info(target_node)
             entry = deps.get_entry(target_node=target_node)
 
             # For convenience, use an external class for this DEPS.yml table/dict
@@ -1799,7 +1805,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                                                    caller_info=caller_info )
 
                 elif x and x not in self.targets_dict:
-                    self.targets_dict[x] = None # add it before processing.
+                    self.targets_dict[str(Path(x))] = None # add it before processing.
                     file_exists, fpath, forced_extension = files.get_source_file(x)
                     if file_exists:
                         self.add_file(filename=fpath, caller_info=caller_info,
@@ -1810,7 +1816,6 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                             x, no_recursion, caller_info=caller_info
                         )
 
-
         # Done with DEPS.yml if it existed.
 
         if not found_target:
@@ -1825,6 +1830,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 if os.path.exists(try_file):
                     self.add_file(try_file, caller_info=f'n/a::{target}::n/a')
                     found_target = True
+                    found_caller_info = os.path.split(try_file)[0]
                     break # move on to the next target
             if not found_target and error_on_not_found: # if STILL not found_this_target...
                 # allow this if --no-error-unknown-args:
@@ -1835,6 +1841,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 )
 
         # if we've found any target since being called, it means we found the one we were called for
+        if found_target:
+            self.targets_dict[str(Path(target))] = f'({found_caller_info})'
         return found_target
 
     def add_file( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
@@ -2107,10 +2115,14 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                     # (not from DEPS.yml) we need to override self.target if that was set. Otherwise
                     # it won't save to the correct work-dir:
                     self.target = self.args['top']
+                    self.targets_dict[str(Path(self.target_path) / self.target)] = (
+                        f'({os.path.split(top_path)[-1]})'
+                    )
                     self.top_details['inferred_from_last_added_source_file'] = top_path
 
-
-        util.info(f'{self.command_name}: top-most target name: {self.target}')
+        caller_info_lookup = str(Path(self.target_path) / self.target)
+        util.info(f'{self.command_name}: top-most target name: {self.target}',
+                  f'{self.targets_dict.get(caller_info_lookup, "")}')
 
         if self.error_on_missing_top and not self.args.get('top', ''):
             self.error("Did not get a --top or DEPS top, required to run command",

opencos/eda_config.py

@@ -55,7 +55,7 @@ class Defaults:
         'auto_tools_order',
     ])
     supported_config_tool_keys = set([
-        'exe', 'handlers',
+        'exe', 'docker_support', 'handlers',
         'requires_env', 'requires_py', 'requires_cmd', 'requires_in_exe_path',
         'requires_vsim_helper',
         'requires_vscode_extension',
@@ -76,6 +76,7 @@ class Defaults:
         'simulate-waivers',
         'simulate-coverage-tcl',
         'coverage-args',
+        'tcl-command-args',
     ])
 
 EDA_OUTPUT_CONFIG_FNAME = 'eda_output_config.yml'

opencos/eda_config_defaults.yml

@@ -47,7 +47,7 @@ DEFAULT_HANDLERS_HELP:
   targets:     List all possible targets given glob path.
   lec:         Run equivalence on two designs.
   deps-help:   Provide help about DEPS markup files, or schema using --verbose or --help.
-  help:        This help (without args), or i.e. "eda help sim" for specific help.
+  help:        This help (without args), or i.e. "eda sim --help [--tool=TOOL]" for specific help.
 
 
 
@@ -270,6 +270,7 @@ tools:
 
   verilator:
     exe: verilator
+    docker_support: true
     handlers:
       lint: opencos.tools.verilator.VerilatorLint
       elab: opencos.tools.verilator.VerilatorElab
@@ -682,9 +683,15 @@ tools:
     requires_cmd:
       - yosys -m slang
     handlers:
+      flist: opencos.tools.slang_yosys.CommandFListSlangYosys
       elab:  opencos.tools.slang_yosys.CommandElabSlangYosys
       synth: opencos.tools.slang_yosys.CommandSynthSlangYosys
       lec:   opencos.tools.slang_yosys.CommandLecSlangYosys
+    tcl-command-args:
+      read_slang:
+        - --ignore-unknown-modules
+        - --best-effort-hierarchy
+        - --ignore-timing
     defines:
       OC_TOOL_YOSYS: null
       OC_TOOL_SLANG: null
@@ -717,5 +724,6 @@ tools:
     requires_cmd:
       - yosys
     handlers:
+      flist: opencos.tools.slang_yosys.CommonFListYosys
       synth: opencos.tools.slang_yosys.CommonSynthYosys
       lec:   opencos.tools.slang_yosys.CommandLecYosys

opencos/eda_tool_helper.py

@@ -14,12 +14,25 @@ from importlib import import_module
 
 from opencos import eda_config, util
 from opencos.util import Colors
-from opencos.utils import str_helpers
+from opencos.utils import str_helpers, docker_checks
+
+# Used by pytest, so we can skip tests if tools aren't present, also used by
+# opencos.eda itself
+
+DOCKER_TOOL_NOTE = ' [via docker] '
+
+def tool_loaded_but_flagged_as_docker_only(tool: str, config: dict) -> bool:
+    '''Checks if a tool was flagged in config as only being able to run
+
+    via docker (and wasn't availble in PATH, shutil.which(..))
+    '''
+    exe = config.get('auto_tools_found', {}).get(tool, '')
+    return exe and exe == DOCKER_TOOL_NOTE
 
-# Used by pytest, so we can skip tests if tools aren't present.
 
 def get_config_and_tools_loaded( # pylint: disable=dangerous-default-value
-        quiet: bool = False, args: list = []
+        quiet: bool = False, args: list = [],
+        remove_tools_with_docker_note: bool = True
 ) -> (dict, set):
     '''Returns config dict and list tools_loaded, given the found config.
 
@@ -36,14 +49,34 @@ def get_config_and_tools_loaded( # pylint: disable=dangerous-default-value
     config = eda.init_config(config=config, quiet=quiet)
     tools_loaded = config.get('tools_loaded', []).copy()
 
+    # Remove any tools from tools_loaded that had their exe flagged with
+    # str DOCKER_TOOL_NOTE. This is also for pytests so that heplers.can_run_eda_sim()
+    # returns False if it were to otherwise appear that we can run verilator
+    # (but only with --docker flag set, that majority of test do not)
+    if remove_tools_with_docker_note:
+        for _tool in list(tools_loaded):
+            if tool_loaded_but_flagged_as_docker_only(tool=_tool, config=config):
+                tools_loaded.remove(_tool)
+
     return config, tools_loaded
 
 
-def get_all_handler_commands(config=None, tools_loaded=None) -> dict:
+def get_all_handler_commands( # pylint: disable=too-many-branches
+        config=None, tools_loaded=None, auto_tools_only: bool = False
+) -> 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] }.
 
+    If you use auto_tools_only=True, then you will only get command: tools that exist in
+    config['auto_tools_order'] (and are loaded tools). This would be what you'd get if you
+    ran `eda [command]` and did not set the --tool=TOOL arg, for what can run that command.
+
+    If you use auto_tools_only=False (default), you will get the auto tool order +
+    tool handlers (loaded tools only) that can service the command. For example, eda waves,
+    eda upload, and others may not be in the auto tool list for an `eda [command]`, because
+    those command have to self determine their tool.
+
     For example:
        { "sim": ["verilator", "vivado"],
          "elab": ["slang", "verilator", ...], ...
@@ -51,9 +84,14 @@ def get_all_handler_commands(config=None, tools_loaded=None) -> dict:
     '''
     all_handler_commands = {}
 
-    if config is None or tools_loaded is None:
+
+    if config and tools_loaded is None:
+        tools_loaded = config.get('tools_loaded', [])
+    elif config is None or tools_loaded is None:
+        # This will re-run eda.init_config(..), b/c you didn't bring a config.
         config, tools_loaded = get_config_and_tools_loaded()
 
+
     assert isinstance(config, dict)
     assert isinstance(tools_loaded, list)
 
@@ -80,6 +118,19 @@ def get_all_handler_commands(config=None, tools_loaded=None) -> dict:
                 else:
                     all_handler_commands[command].append(tool)
 
+    if auto_tools_only:
+        # skip the next step and return what we've got.
+        return all_handler_commands
+
+    # Note that the above will miss commands (waves, upload) that are not in auto_tools_order
+    for tool in tools_loaded:
+        handlers = config.get('tools', {}).get(tool, {}).get('handlers', {})
+        for command, _ in handlers.items():
+            if command not in all_handler_commands:
+                all_handler_commands[command] = list([tool])
+            elif tool not in all_handler_commands.get(command, []):
+                all_handler_commands[command].append(tool)
+
     return all_handler_commands
 
 
@@ -90,6 +141,9 @@ def get_handler_tool_version(tool: str, eda_command: str, config: dict) -> str:
     if not entry:
         return ''
 
+    # TODO(drew): maybe if there are no handlers, then do something to get version?
+    # like, offer tool_class?
+
     handler_name = entry.get('handlers', {}).get(eda_command, '')
     if not handler_name:
         return ''
@@ -246,13 +300,34 @@ def pretty_info_handler_tools( # pylint: disable=dangerous-default-value
         else:
             tools_rows.append([_tool, path])
 
+    # Since Docker isn't technically a tool, and only lives in opencos.utils.docker_checks,
+    # we would like to still list it here (as "other") to at least show path/version information.
+    # This also makes it less surprising if an actual tool has their PATH set with ' [via docker] '
+    # (DOCKER_TOOL_NOTE str)
+    other_rows = [
+        ['--Detected other--', '--Path--']
+    ]
+    if show_versions:
+        other_rows[0].append('--Version--')
+    if docker_checks.DOCKER_EXE:
+        other_rows.append([
+                'docker',
+                docker_checks.DOCKER_EXE,
+                docker_checks.get_docker_version()
+        ])
+
+    # Finally, print everything
+    pretty_info_tool_rows(tools_rows + other_rows)
+
+
+def pretty_info_tool_rows(rows: list) -> None:
+    '''Pretty print a 2-d list, called by pretty_info_handler_tools'''
 
-    # Finally, print detected tools:
     for rownum, row in enumerate(str_helpers.pretty_2dlist_columns(
-            tools_rows, return_as_2d_list=True, header_row_centered=False)):
-        if rownum == 0:
+            rows, return_as_2d_list=True, header_row_centered=False)):
+        if rownum == 0 or row[0].startswith('--'):
             util.info(f'{Colors.bgreen}{"".join(row)}')
         else:
-            # get the results in a padded 2D list so we can colorize the tool (index 0)
+            # get the results in a padded 2D list so we can colorize the name (index 0)
             util.info(f'{Colors.bgreen}{row[0]}{Colors.normal}{Colors.cyan}' \
                       + ''.join(row[1:]))

opencos/files.py

@@ -13,6 +13,7 @@ as part of a verilog $readmemh, etc)
 '''
 
 import os
+from pathlib import Path
 import shutil
 
 # Ways to force files not ending in .sv to be systemverilog (for tools
@@ -68,6 +69,46 @@ def safe_shutil_which(path: str) -> str:
             return found
     return ''
 
+
+def get_source_files_paths(
+        cmd_des_obj, minimal_root_paths: bool = False
+) -> list:
+    '''Given a CommandDesign object, returns list of Path objs for all source files
+
+    If minimal_root_paths=True, attempts to return the minimal set of root paths for
+    docker read-only volume mapping
+
+    will look at members for all source files that (any member list type in cmd_des_obj.files_)
+    '''
+
+    # Iterate over lists and add to our set, we'll include cmd_des_obj.incdirs (list)
+    # here as well.
+    file_dirs = set()
+    for name in [x for x in dir(cmd_des_obj) if x.startswith('files_')]:
+        member = getattr(cmd_des_obj, name, None)
+        if callable(member) or not isinstance(member, list):
+            continue
+        _ = [file_dirs.add(Path(x).resolve().parent) for x in member]
+
+    # also incdirs, a path not a file, so don't use .parent
+    _ = [file_dirs.add(Path(incdir).resolve()) for incdir in getattr(cmd_des_obj, 'incdirs', [])]
+
+    if not minimal_root_paths:
+        # return them all:
+        return list(file_dirs)
+
+    for x in list(file_dirs):
+        # - Using list(file_dirs) as iterator as cheap copy b/c we're altering set file_dirs
+        # - We don't want to add '/' as a root path, so make sure dirs have at least
+        #   2 parts if we're going to trim items from file_dirs.
+        # - Also this is a n^2 traversal, make sure we aren't matching ourselves (x != y)
+        #   in check. Using childPath.is_relative_to(parentPath).
+        if any(x != y and x.is_relative_to(y) and len(y.parts) >= 2 for y in file_dirs):
+            file_dirs.remove(x)
+
+    return list(file_dirs)
+
+
 # Note that in Windows, 'python' will return the venv or uv version, 'python3' will
 # return the installed version (which may not be what you want), so we'll prefer
 # 'python':

opencos/tools/cocotb.py

@@ -25,7 +25,7 @@ class ToolCocotb(Tool):
     cocotb_version = ''
     python_exe = ''
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
 

opencos/tools/invio.py

@@ -17,7 +17,7 @@ class ToolInvio(Tool):
     _TOOL = 'invio'
     _URL = 'https://www.verific.com/products/invio/'
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
 

opencos/tools/invio_yosys.py

@@ -19,7 +19,7 @@ class ToolInvioYosys(ToolYosys):
     _URL = 'https://www.verific.com/products/invio/'
     _EXE = 'yosys'
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
 

opencos/tools/iverilog.py

@@ -23,7 +23,7 @@ class ToolIverilog(Tool):
         self.iverilog_exe = ''
         super().__init__(config=config) # calls self.get_versions()
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         self.iverilog_exe = ''
         if self._VERSION:
             return self._VERSION

opencos/tools/quartus.py

@@ -91,7 +91,7 @@ class ToolQuartus(Tool):
             util.debug("Could not determine Quartus version from: quartus_sh --version")
 
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
 

opencos/tools/questa_common.py

@@ -53,14 +53,16 @@ class ToolQuesta(Tool):
                 if line.strip().startswith('Release Notes For'):
                     m = re.search(r'(\d+)\.(\d+)', line)
                     if m:
+                        _maj, _min = int(m.group(1)), int(m.group(2))
+                        self._VERSION = f'{_maj}.{_min}'
                         if self._TOOL.startswith('questa'):
                             # don't set these for ModelsimASE:
-                            self.questa_major = int(m.group(1))
+                            self.questa_major = int(m.group(2))
                             self.questa_minor = int(m.group(2))
-                        self._VERSION = str(self.questa_major) + '.' + str(self.questa_minor)
                         util.debug(f'version {self._VERSION} ({release_notes_txt_filepath})')
                         break
 
+
     def _try_set_version_from_path(self) -> None:
         '''Attempts to use portions of exe path to get version info
 
@@ -75,7 +77,7 @@ class ToolQuesta(Tool):
             util.warning("Questa path doesn't specificy version, expecting (d+.d+)")
 
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
         path = safe_shutil_which(self._EXE)
@@ -103,6 +105,7 @@ class ToolQuesta(Tool):
 
         return self._VERSION
 
+
     def set_tool_defines(self) -> None:
         '''Override from class Tool, which handles picking up config['tools'][self._TOOL]
 

opencos/tools/riviera.py

@@ -27,7 +27,7 @@ class ToolRiviera(ToolQuesta):
     use_vopt = False
     uvm_versions = set()
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
         path = safe_shutil_which(self._EXE)

opencos/tools/slang.py

@@ -27,7 +27,7 @@ class ToolSlang(Tool):
     slang_tidy_exe = ''
     slang_hier_exe = ''
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
         path = safe_shutil_which(self._EXE)

opencos/tools/slang_yosys.py

@@ -8,10 +8,10 @@ Contains classes for ToolSlangYosys, CommandSynthSlangYosys
 import os
 
 from opencos import util
-from opencos.tools.yosys import ToolYosys, CommonSynthYosys, CommandLecYosys
-
+from opencos.tools.yosys import ToolYosys, CommonSynthYosys, CommandLecYosys, CommonFListYosys
 from opencos.commands.sim import parameters_dict_get_command_list
 
+
 class ToolSlangYosys(ToolYosys):
     '''Uses slang.so in yosys plugins directory, called via yosys > plugin -i slang'''
     _TOOL = 'slang_yosys'
@@ -30,6 +30,15 @@ class CommandSynthSlangYosys(CommonSynthYosys, ToolSlangYosys):
         CommonSynthYosys.__init__(self, config)
         ToolSlangYosys.__init__(self, config=self.config)
 
+        self.args.update({
+            'yosys-read-slang-args': []
+        })
+        self.args_help.update({
+            'yosys-read-slang-args': (
+                'list-style arg, these are applied to the "read_slang" command'
+                )
+        })
+
         self.slang_out_dir = ''
         self.slang_v_path = ''
 
@@ -98,11 +107,10 @@ class CommandSynthSlangYosys(CommonSynthYosys, ToolSlangYosys):
 
     def _get_read_slang_cmd_str(self) -> str:
 
-        read_slang_cmd = [
-            'read_slang',
-            '--ignore-unknown-modules',
-            '--best-effort-hierarchy',
-        ]
+        read_slang_cmd = ['read_slang'] + \
+            self.args.get('yosys-read-slang-args', []) + \
+            self.config.get('tools', {}).get(self._TOOL, {}).get(
+                'tcl-command-args', {}).get('read_slang', [])
 
         read_slang_cmd += self.get_yosys_read_verilog_defines_incdirs_files()
 
@@ -113,7 +121,6 @@ class CommandSynthSlangYosys(CommonSynthYosys, ToolSlangYosys):
         )
 
         # In case --top was not set:
-        # TODO(drew): Can we skip this if it was an inferred top???
         if not any(x.startswith('--top') for x in read_slang_cmd):
             read_slang_cmd.append(f'--top {self.args["top"]}')
 
@@ -249,3 +256,24 @@ class CommandLecSlangYosys(CommandLecYosys, ToolSlangYosys): # pylint: disable=t
     def __init__(self, config: dict):
         CommandLecYosys.__init__(self, config)
         ToolSlangYosys.__init__(self, config=self.config)
+
+
+class CommandFListSlangYosys(CommonFListYosys, ToolSlangYosys):
+    '''
+    Handler for: eda flist --tool=slang_yosys
+
+    This will create a eda.yosys_slang.f flist (or to std-out if --print-to-stdout),
+    suitable for args passed to a "read_slang" command in yosys, such as:
+
+        yosys -i slang
+        read_slang -f FILE_CREATED_BY_THIS_HANDLER [other args]
+
+    '''
+    def __init__(self, config: dict):
+        CommonFListYosys.__init__(self, config=config)
+        ToolSlangYosys.__init__(self, config=self.config)
+
+        self.args.update({
+            'force': True, # always overwrite the output
+            'out': 'eda_flist.yosys.read_slang.f',
+        })

opencos/tools/surelog.py

@@ -22,7 +22,7 @@ class ToolSurelog(Tool):
 
     surelog_exe = ''
 
-    def get_versions(self) -> str:
+    def get_versions(self, **kwargs) -> str:
         if self._VERSION:
             return self._VERSION
         path = safe_shutil_which(self._EXE)