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

opencos/eda_tool_helper.py

@@ -10,15 +10,18 @@ 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.
 
 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.
+    '''Returns config dict and list tools_loaded, given the found config.
 
     Can BYO args such as --config-yml=MY_OWN_EDA_CONFIG.yml
     '''
@@ -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()
+    tools_loaded = config.get('tools_loaded', []).copy()
+
     return config, tools_loaded
 
 
@@ -47,25 +55,30 @@ def get_all_handler_commands(config=None, tools_loaded=None) -> dict:
         config, tools_loaded = get_config_and_tools_loaded()
 
     assert isinstance(config, dict)
-    assert isinstance(tools_loaded, set)
+    assert isinstance(tools_loaded, list)
 
     # 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', []))
+
+    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/tools/cocotb.py

@@ -4,7 +4,7 @@ Contains classes for ToolCocotb, CommandSimCocotb.
 '''
 
 import os
-import subprocess
+from importlib import metadata
 
 from opencos import util
 from opencos.commands import CommandSim
@@ -38,33 +38,19 @@ 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 ''
 
-    def set_tool_defines(self):
-        super().set_tool_defines()
-        self.defines.update({
-            'SIMULATION': 1,
-            'COCOTB': 1,
-            'OC_TOOL_COCOTB': None,
-        })
-
 
 class CommandSimCocotb(CommandSim, ToolCocotb):
     '''CommandSimCocotb is a command handler for: eda sim --tool=cocotb'''
@@ -109,9 +95,6 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
         self.cocotb_test_files = []
 
 
-    def set_tool_defines(self):
-        ToolCocotb.set_tool_defines(self)
-
     def help( # pylint: disable=dangerous-default-value
             self, tokens: list = [], no_targets: bool = False
     ) -> None:
@@ -331,12 +314,6 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
         '''Generate the content for the Python runner script'''
 
         if safe_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.
             tmp_verilator_obj = verilator.VerilatorSim(config=self.config)
             verilator_waivers = tmp_verilator_obj.get_verilator_tool_config_waivers()
         else:

opencos/tools/invio.py

@@ -26,14 +26,8 @@ class ToolInvio(Tool):
         if not spec:
             self.error('"invio" package not in python env')
 
-
         return super().get_versions()
 
-    def set_tool_defines(self):
-        super().set_tool_defines()
-        self.defines.update({
-            'OC_TOOL_INVIO': None,
-        })
 
 class CommandElabInvio(CommandElab, ToolInvio):
     '''Command handler for: eda elab --tool=invio'''

opencos/tools/iverilog.py

@@ -44,14 +44,6 @@ class ToolIverilog(Tool):
         self._VERSION = version
         return self._VERSION
 
-    def set_tool_defines(self):
-        # TODO(drew): come back to this, Tool doesn't have self.defines. Command does.
-        self.defines.update({
-            'SIMULATION': 1,
-            'IVERILOG': 1,
-            'OC_ASSERT_PROPERTY_NOT_SUPPORTED': 1,
-        })
-
 
 class CommandSimIverilog(CommandSim, ToolIverilog):
     '''CommandSimIverilog is a command handler for: eda sim --tool=iverilog'''
@@ -128,17 +120,25 @@ class CommandSimIverilog(CommandSim, ToolIverilog):
         for value in self.incdirs:
             command_list += [ '-I', value ]
 
-        for k,v in self.defines.items():
-            if v is None:
-                command_list += [ '-D', k ]
-            else:
-                # Generally we should only support int and str python types passed as
-                # +define+{k}={v}, but also for SystemVerilog plusargs
-                command_list += [ '-D', f'{k}={sanitize_defines_for_sh(v)}' ]
+        if self.args['ext-defines-sv-fname']:
+            self.create_ext_defines_sv()
+        else:
+            for k,v in self.defines.items():
+                if v is None:
+                    command_list += [ '-D', k ]
+                else:
+                    # Generally we should only support int and str python types passed as
+                    # +define+{k}={v}, but also for SystemVerilog plusargs
+                    command_list += [ '-D', f'{k}={sanitize_defines_for_sh(v)}' ]
 
         # parameters
+        # If you do -PName=Value, all parameters in the hierachy with Name will be set,
+        # so to only do top level parameters, if hierarchy isn't mentioned in the Name,
+        # would need to do -P{self.args['top'].Name=Value
         command_list.extend(
-            self.process_parameters_get_list(arg_prefix=f'-P{self.args["top"]}.')
+            self.process_parameters_get_list(
+                arg_prefix='-P', hier_delimiter='.', top_hier_str=f'{self.args["top"]}.'
+            )
         )
 
         if not self.files_sv and not self.files_v:

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.
 '''
@@ -40,18 +40,6 @@ class CommandSimModelsimAse(CommonSimQuesta):
             )
         })
 
-    def set_tool_defines(self):
-        # Update any defines from config.tools.modelsim_ase:
-        self.defines.update(
-            self.tool_config.get(
-                'defines',
-                # defaults, if not set:
-                {'OC_ASSERT_PROPERTY_NOT_SUPPORTED': 1,
-                 'OC_TOOL_MODELSIM_ASE': 1}
-            )
-        )
-
-
 
 class CommandElabModelsimAse(CommandSimModelsimAse):
     '''CommandElabModelsimAse is a command handler for: eda elab --tool=modelsim_ase'''

opencos/tools/quartus.py

@@ -42,6 +42,55 @@ class ToolQuartus(Tool):
             'family': 'FPGA family for Quartus (e.g., Stratix IV, Arria 10, etc.)',
         })
 
+    def _try_set_version_from_version_txt(self) -> None:
+        '''Attempts to use VSIM_PATH/../version.txt to get version info
+
+        Return None, may set self._VERSION
+        '''
+        util.debug(f"quartus path = {self.quartus_exe}")
+        version_txt_filepath = os.path.join(self.quartus_base_path, '..', 'version.txt')
+        if os.path.isfile(version_txt_filepath):
+            with open(version_txt_filepath, encoding='utf-8') as f:
+                for line in f.readlines():
+                    if line.startswith('Version='):
+                        _, version = line.strip().split('=')
+                        self._VERSION = version
+                        break
+
+    def _try_set_version_from_path(self) -> None:
+        '''Attempts to use portions of VSIM_PATH to get version info
+
+        Return None, may set self._VERSION
+        '''
+        m = re.search(r'(\d+)\.(\d+)', self.quartus_exe)
+        if m:
+            version = m.group(1) + '.' + m.group(2)
+            self._VERSION = version
+
+    def _try_set_version_from_exe(self) -> None:
+        '''Attempts to run: vsim --version; (max timeout 3 sec) to get version info
+
+        Return None, may set self._VERSION
+
+        Since this may fail if we don't have a valid license, we will not error if the version
+        is not determined.
+        '''
+        try:
+            result = subprocess.run(
+                [self.quartus_exe, '--version'],
+                capture_output=True, text=True, timeout=3, check=False
+            )
+            version_match = re.search(r'Version (\d+\.\d+)', result.stdout)
+            if version_match:
+                self._VERSION = version_match.group(1)
+            else:
+                util.debug("Could not determine Quartus version from: quartus_sh --version")
+        except (
+            subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError
+        ):
+            util.debug("Could not determine Quartus version from: quartus_sh --version")
+
+
     def get_versions(self) -> str:
         if self._VERSION:
             return self._VERSION
@@ -58,35 +107,23 @@ class ToolQuartus(Tool):
             os.path.join(self.quartus_base_path, 'quartus') # vs quartus_sh
         )
 
-        # Get version based on install path name or by running quartus_sh --version
-        util.debug(f"quartus path = {self.quartus_exe}")
-        m = re.search(r'(\d+)\.(\d+)', self.quartus_exe)
-        if m:
-            version = m.group(1) + '.' + m.group(2)
-            self._VERSION = version
-        else:
-            # Try to get version by running quartus_sh --version
-            try:
-                result = subprocess.run(
-                    [self.quartus_exe, '--version'],
-                    capture_output=True, text=True, timeout=10, check=False
-                )
-                version_match = re.search(r'Version (\d+\.\d+)', result.stdout)
-                if version_match:
-                    self._VERSION = version_match.group(1)
-                else:
-                    self.error("Could not determine Quartus version")
-            except (
-                subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError
-            ):
-                self.error("Could not determine Quartus version")
+        # Get version based on install path name:
+        # 1. if ../version.txt exists, use that
+        # 2. Use the path name if it has version information
+        # 3. or by running quartus_sh --version (max timeout=3)
+        # If we cannot find the version return '' and warn, do not error.
+        self._try_set_version_from_version_txt()
+        if not self._VERSION:
+            self._try_set_version_from_path()
+        if not self._VERSION:
+            self._try_set_version_from_exe()
 
         if self._VERSION:
             numbers_list = self._VERSION.split('.')
             self.quartus_year = int(numbers_list[0])
             self.quartus_release = int(numbers_list[1])
         else:
-            self.error(f"Quartus version not found, quartus path = {self.quartus_exe}")
+            util.warning(f"Quartus version not found, quartus path = {self.quartus_exe}")
         return self._VERSION
 
     def set_tool_defines(self) -> None:
@@ -513,9 +550,29 @@ class CommandFListQuartus(CommandFList, ToolQuartus):
         CommandFList.__init__(self, config=config)
         ToolQuartus.__init__(self, config=self.config)
         self.args.update({
-            'emit-parameter': False
+            # synth/project style Flist, can't emit these:
+            'emit-parameter': False,
+            'emit-plusargs': False,
         })
 
+    def get_flist_plusargs_list(self) -> list:
+        '''Overriden from CommandFList.'''
+        if self.args['unprocessed-plusargs']:
+            util.warning('Command "flist" for --tool=quartus is not intended for simulation',
+                         'and plusargs were present. They will NOT be included in the flist:',
+                         f'{self.args["unprocessed-plusargs"]}')
+
+        return []
+
+    def get_flist_parameter_list(self) -> list:
+        '''Overriden from CommandFList.'''
+        if self.parameters:
+            util.warning('Command "flist" for --tool=quartus is not intended for simulation',
+                         'and parameters were present. They will NOT be included in the flist:',
+                         f'{self.parameters}')
+
+        return []
+
 
 class CommandProjQuartus(CommandProj, ToolQuartus):
     '''CommandProjQuartus is a command handler for: eda proj --tool=quartus'''

opencos/tools/questa.py

@@ -39,20 +39,6 @@ class CommandSimQuesta(CommonSimQuesta):
         })
 
 
-    def set_tool_defines(self):
-        '''Override from questa.ToolQuesta'''
-        # Update any defines from config.tools.questa_fse:
-        self.defines.update(
-            self.tool_config.get(
-                'defines',
-                # defaults, if not set:
-                {
-                 'OC_TOOL_QUESTA': 1
-                }
-            )
-        )
-
-
 class CommandElabQuesta(CommandSimQuesta):
     '''CommandElabQuesta is a command handler for: eda elab --tool=questa'''