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

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)
@@ -102,8 +102,10 @@ class CommandSimRiviera(CommonSimQuesta, ToolRiviera):
                 ' tcl steps are (from tool config in --config-yml):   '
             ) + '; '.join(self.tool_config.get('simulate-coverage-tcl', [])),
             'uvm': (
-                'Attempts to support UVM. Adds to vlog: -l uvm +incdir+PATH for the PATH to'
-                ' uvm_macros.svh for the installed version of Riviera used.'
+                'Attempts to support UVM. For Riviera, this adds "-uvmver NUMBER -dbg" to vlog.f.'
+                ' You can choose your uvmver using eda arg --uvm-version=NUMBER.'
+                ' Also adds +access +r to vopt/vsim. There is no -l or -L library modifications,'
+                ' we rely on Riviera to handle this internally based on running: vlog -uvm'
             ),
             'license-queue': (
                 'Set to enable env vars (if unset) LICENSE_QUEUE=1, ALDEC_LICENSE_QUEUE=1,'

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)