opencos-eda 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

opencos/eda_tool_helper.py

@@ -10,8 +10,11 @@ Example uses:
 
 '''
 
+from importlib import import_module
 
-from opencos import eda, eda_config, util
+from opencos import eda_config, util
+from opencos.util import Colors
+from opencos.utils import str_helpers
 
 # Used by pytest, so we can skip tests if tools aren't present.
 
@@ -26,8 +29,13 @@ def get_config_and_tools_loaded( # pylint: disable=dangerous-default-value
     # 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)
+
+    # only import 'eda' here so that other methods in this pymodule can be used
+    # within eda, etc, if you already have a valid config or tools_loaded.
+    eda = import_module("opencos.eda")
     config = eda.init_config(config=config, quiet=quiet)
     tools_loaded = config.get('tools_loaded', set()).copy()
+
     return config, tools_loaded
 
 
@@ -50,22 +58,27 @@ def get_all_handler_commands(config=None, tools_loaded=None) -> 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():
-        if tool not in tools_loaded:
-            continue
-
-        if table.get('disable-tools-multi', False):
-            # Flagged as do-not-add when running eda command: tools-multi
-            util.debug(f'eda_tool_helper.py -- skipping {tool=} it is set with flag',
-                       'disable-tools-multi in config')
-            continue
-
-        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])
-            else:
-                all_handler_commands[command].append(tool)
+    for command, tools_list in config.get('auto_tools_order', {}).items():
+
+        for tool in tools_list:
+            entry = config.get('tools', {}).get(tool, {})
+            assert entry, f'{command=} in auto_tools_order {tool=} not present in tools'
+
+            if tool not in tools_loaded:
+                continue
+
+            if entry.get('disable-tools-multi', False):
+                # Flagged as do-not-add when running eda command: tools-multi
+                util.debug(f'eda_tool_helper.py -- skipping {tool=} it is set with flag',
+                           'disable-tools-multi in config')
+                continue
+
+            if command in entry.get('handlers', {}):
+                if command not in all_handler_commands:
+                    # create ordered list from config.
+                    all_handler_commands[command] = list([tool])
+                else:
+                    all_handler_commands[command].append(tool)
 
     return all_handler_commands
 
@@ -73,7 +86,7 @@ def get_all_handler_commands(config=None, tools_loaded=None) -> dict:
 def get_handler_tool_version(tool: str, eda_command: str, config: dict) -> str:
     '''Attempts to get a Command Handler's version given tool + eda_command'''
 
-    entry = config['auto_tools_order'][0].get(tool, {})
+    entry = config['tools'].get(tool, {})
     if not entry:
         return ''
 
@@ -83,7 +96,163 @@ def get_handler_tool_version(tool: str, eda_command: str, config: dict) -> str:
 
     module = util.import_class_from_string(handler_name)
     obj = module(config=config)
-    if not getattr(obj, 'get_versions', None):
-        return ''
 
-    return obj.get_versions()
+    # Some command classes like CommandWaves, don't have get_versions(), but
+    # have get_versions_of_tool():
+    if getattr(obj, 'get_versions_of_tool', None):
+        return obj.get_versions_of_tool(tool)
+
+    # Note that Tool.get_versions() is supposed to be 'fast', we don't always
+    # run the tool if the 'exe -version' takes too long.
+    if getattr(obj, 'get_versions', None):
+        return obj.get_versions()
+
+    return ''
+
+
+
+def get_handler_info_with_versions( # pylint: disable=too-many-branches
+        config: dict | None = None,
+        include_commands: bool = True,
+        sort: bool = True
+) -> str:
+    '''Creates and returns a dict of
+
+    {'commands': (what tools/versions can run them),
+     'tools': (what version and what commands they can run)
+    }
+
+    for arg 'config' you may use:
+
+    config, tools_loaded = get_config_and_tools_loaded()
+    '''
+
+    if not config:
+        config, tools_loaded = get_config_and_tools_loaded()
+    else:
+        tools_loaded = list(config.get('tools_loaded', set()))
+
+    eda_commands = list(config.get('DEFAULT_HANDLERS', {}).keys())
+    show_versions = config.get('show_tool_versions', False)
+
+    info = {
+        'tools': {},
+    }
+
+
+    if not show_versions:
+        for tool, path in config.get('auto_tools_found', {}).items():
+            info['tools'][tool] = {
+                'path': path
+            }
+        return info
+
+
+    if include_commands:
+        info.update({
+            'commands': {}
+        })
+        for eda_command in eda_commands:
+            info['commands'][eda_command] = {} # init
+
+    for tool in tools_loaded:
+
+        if include_commands:
+            info['tools'][tool] = {
+                'version': '',
+                'commands': [],
+            }
+        else:
+            info['tools'][tool] = {
+                'version': '',
+            }
+
+        for eda_command in eda_commands:
+
+            if not include_commands and info['tools'][tool]['version']:
+                # version is already set, and we're not doing for all commands:
+                break
+
+            # Note that if you have a generic handler, or a tool that has
+            # several handlers with more than one Tool class, that all can return a
+            # non blank-str version, you may have problems.
+            ver = get_handler_tool_version(
+                tool=tool, eda_command=eda_command, config=config
+            )
+
+            if not ver:
+                continue
+
+            info['tools'][tool]['version'] = ver
+
+            if include_commands:
+                info['commands'][eda_command][tool] = ver
+                info['tools'][tool]['commands'].append(eda_command)
+
+    for tool, _ in info['tools'].items():
+        if tool in config.get('auto_tools_found', {}):
+            info['tools'][tool]['path'] = config['auto_tools_found'][tool]
+
+    # return the info dict with 'tools' and 'commands' entries sorted:
+    if sort:
+        for key in list(info.keys()):
+            if info[key]:
+                info[key] = dict(sorted(info[key].items()))
+
+    return info
+
+
+def pretty_info_handler_tools(
+        info: dict | None = None, config: dict | None = None, command: str | None = ''
+) -> None:
+    '''Pretty print (via util.info) the result from get_handler_info_with_versions()
+
+    if info is None or empty, will use config to run get_handler_info_with_versions(..)
+
+    Does not include commands
+    '''
+
+    if not info:
+        info = get_handler_info_with_versions(config=config, include_commands=False, sort=True)
+
+    if not info.get('tools', {}):
+        # No tools detected
+        if command and command in config.get('command_tool_is_optional', []):
+            # but this command doesn't need tools
+            return
+
+        # if command omitted, or command may need tools, print that we don't have any
+        util.info('No tools detected!', color=Colors.yellow)
+        return
+
+    show_versions = any('version' in dvalue for dvalue in info['tools'].values())
+
+    tools_rows = [
+        ['--Detected tool--', '--Path--'] # Header row.
+    ]
+
+    if show_versions:
+        tools_rows[0].append('--Version--')
+
+    for _tool, dvalue in info['tools'].items():
+        path = dvalue.get("path", "")
+        if path:
+            path = f'({path})'
+
+        if show_versions:
+            version = dvalue.get("version", "")
+            # will defer printing again, so we can put them into aligned columns:
+            tools_rows.append([_tool, path, version])
+        else:
+            tools_rows.append([_tool, path])
+
+
+    # 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:
+            util.info(f'{Colors.bgreen}{"".join(row)}')
+        else:
+            # get the results in a padded 2D list so we can colorize the tool (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
+import shutil
 
 # Ways to force files not ending in .sv to be systemverilog (for tools
 # that require -sv vs Verilog-2001'''
@@ -31,8 +32,12 @@ FORCE_PREFIX_DICT = {
 
 ALL_FORCED_PREFIXES = set(list(FORCE_PREFIX_DICT.keys()))
 
-def get_source_file(target:str) -> (bool, str, str):
+def get_source_file(target: str) -> (bool, str, str):
     '''Returns tuple: bool if file exists, filepath str, and optional forced file type str'''
+
+    if '$' in target:
+        target = os.path.expandvars(target)
+
     if os.path.isfile(target):
         # target exists as a file, return True w/ original target:
         return True, target, ''
@@ -47,3 +52,23 @@ def get_source_file(target:str) -> (bool, str, str):
 
     # target or fpath didn't exist, return False with the original target:
     return False, target, ''
+
+
+def safe_shutil_which(path: str) -> str:
+    '''Windows/WSL compatible Wrapper for shutil.which that checks for 'path':
+
+    - path
+    - path.exe
+    - path.bat
+
+    Returns full path str returned by shutil.which
+    '''
+    for ext in ('', '.exe', 'bat'):
+        if found := shutil.which(f'{path}{ext}'):
+            return found
+    return ''
+
+# 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':
+PY_EXE = safe_shutil_which('python') or safe_shutil_which('python3')

opencos/tools/cocotb.py

@@ -4,12 +4,12 @@ Contains classes for ToolCocotb, CommandSimCocotb.
 '''
 
 import os
-import shutil
-import subprocess
+from importlib import metadata
 
 from opencos import util
-from opencos.eda_base import Tool
 from opencos.commands import CommandSim
+from opencos.eda_base import Tool
+from opencos.files import safe_shutil_which, PY_EXE
 from opencos.utils import status_constants
 from opencos.utils.str_helpers import sanitize_defines_for_sh
 from opencos.tools import verilator # For default waivers.
@@ -30,7 +30,7 @@ class ToolCocotb(Tool):
             return self._VERSION
 
         # Check if python is available
-        python_path = shutil.which('python') or shutil.which('python3')
+        python_path = PY_EXE
         if not python_path:
             self.error('"python" or "python3" not in path, required for cocotb')
         else:
@@ -38,22 +38,16 @@ class ToolCocotb(Tool):
 
         # Check if cocotb is installed
         try:
-            version_ret = subprocess.run(
-                [self.python_exe, '-c', 'import cocotb; print(cocotb.__version__)'],
-                capture_output=True,
-                check=True,
-                text=True
-            )
-            version = version_ret.stdout.strip()
+            version = metadata.version('cocotb')
             self.cocotb_version = version
             self._VERSION = version
             util.debug(f'Found cocotb version: {version}')
             return self._VERSION
-        except subprocess.CalledProcessError:
-            self.error('cocotb package not installed in python environment. '
-                      'Install with: pip install cocotb')
+        except metadata.PackageNotFoundError:
+            util.warning('cocotb package not installed in python environment. '
+                       'Install with: pip install cocotb; or pypackage: opencos-eda[cocotb]')
         except Exception as e:
-            self.error(f'Failed to check cocotb version: {e}')
+            util.warning(f'Failed to check cocotb version: {e}')
 
         return ''
 
@@ -128,7 +122,7 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
             util.warning('--cocotb-simulator is not set, a simulation cannot be run with'
                          'this arg value')
             return
-        exe = shutil.which(simulator)
+        exe = safe_shutil_which(simulator)
         if not exe:
             util.warning(f'--cocotb-simulator={simulator}, {simulator} is not present in PATH',
                          'a simulation cannot be run with this arg value')
@@ -330,13 +324,7 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
     def _generate_runner_script_content(self, test_module: str, hdl_sources: list) -> str:
         '''Generate the content for the Python runner script'''
 
-        if shutil.which('verilator'):
-            # TODO(drew): this shortcuts if verilator is truly usable,
-            # consider using eda_tool_helper to get "tools_loaded", which
-            # is not set in self.config['tools_loaded'] when --tool=cocotb.
-            # Would need minor refactor for eda.py methods auto_tools_order,
-            # tool_setup to go into eda_tool_helper.py, and those methods would
-            # need hooks to be non-destructive to config.
+        if safe_shutil_which('verilator'):
             tmp_verilator_obj = verilator.VerilatorSim(config=self.config)
             verilator_waivers = tmp_verilator_obj.get_verilator_tool_config_waivers()
         else:

opencos/tools/invio.py

@@ -5,9 +5,9 @@
 import importlib.util
 
 from opencos import util
-from opencos.tools import invio_helpers
-from opencos.eda_base import Tool
 from opencos.commands import CommandElab
+from opencos.eda_base import Tool
+from opencos.tools import invio_helpers
 
 
 

opencos/tools/invio_yosys.py

@@ -8,6 +8,7 @@ import os
 import importlib.util
 
 from opencos import util
+from opencos.files import PY_EXE
 from opencos.tools import invio_helpers
 from opencos.tools.yosys import ToolYosys, CommonSynthYosys
 
@@ -100,7 +101,7 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
 
 
         invio_command_list = util.ShellCommandList(
-            ['python3', invio_dict['full_py_filename']], tee_fpath=invio_dict['full_py_filename']
+            [PY_EXE, invio_dict['full_py_filename']], tee_fpath=invio_dict['full_py_filename']
         )
 
         # Optinally create and run a sta.f:

opencos/tools/iverilog.py

@@ -3,12 +3,12 @@
 Contains classes for ToolIverilog CommandSimIverilog, CommandElabIverilog.
 '''
 
-import shutil
 import subprocess
 
 from opencos import util
-from opencos.eda_base import Tool
 from opencos.commands import CommandSim
+from opencos.eda_base import Tool
+from opencos.files import safe_shutil_which
 from opencos.utils.str_helpers import sanitize_defines_for_sh
 
 
@@ -28,7 +28,7 @@ class ToolIverilog(Tool):
         if self._VERSION:
             return self._VERSION
 
-        iverilog_path = shutil.which(self._EXE)
+        iverilog_path = safe_shutil_which(self._EXE)
         if iverilog_path is None:
             self.error(f'"{self._EXE}" not in path, need to get it ({self._URL})')
         else:

opencos/tools/modelsim_ase.py

@@ -1,6 +1,6 @@
 ''' opencos.tools.modelsim_ase - Used by opencos.eda for sim/elab commands w/ --tool=modelsim_ase.
 
-Contains classes for ToolModelsimAse, CommandSimModelsimAse, CommandElabModelsimAse.
+Contains classes for CommandSimModelsimAse, CommandElabModelsimAse.
 
 Note that this is for 32-bit Modelsim Student Edition. Consider using --tool=questa_fse instead.
 '''