siliconcompiler 0.35.0__py3-none-any.whl → 0.35.1__py3-none-any.whl

siliconcompiler/_metadata.py

@@ -1,5 +1,5 @@
 # Version number following semver standard.
-version = '0.35.0'
+version = '0.35.1'
 
 # Default server address for remote runs, if unspecified.
 default_server = 'https://server.siliconcompiler.com'

siliconcompiler/apps/_common.py

@@ -90,7 +90,8 @@ def _get_manifests(cwd: str) -> Dict:
     return organized_manifest
 
 
-def pick_manifest_from_file(cliproject: Project, src_file: str, all_manifests: Dict):
+def pick_manifest_from_file(cliproject: Project, src_file: Optional[str], all_manifests: Dict) \
+        -> Optional[str]:
     """
     Tries to find a manifest located in the same directory as a given source file.
 
@@ -125,7 +126,7 @@ def pick_manifest_from_file(cliproject: Project, src_file: str, all_manifests: D
     return None
 
 
-def pick_manifest(cliproject: Project, src_file: Optional[str] = None):
+def pick_manifest(cliproject: Project, src_file: Optional[str] = None) -> Optional[str]:
     """
     Selects the most appropriate manifest based on the project's configuration.
 

siliconcompiler/apps/sc_dashboard.py

@@ -4,6 +4,8 @@ import shlex
 
 import os.path
 
+from typing import Union
+
 from siliconcompiler import Project
 from siliconcompiler.apps._common import pick_manifest
 from siliconcompiler.report.dashboard.web import WebDashboard
@@ -56,7 +58,7 @@ To include another project object to compare to:
             '-graph_cfg'],
         use_sources=False)
 
-    manifest = cli.get("cmdarg", "cfg")
+    manifest: Union[None, str] = cli.get("cmdarg", "cfg")
 
     # Attempt to load a manifest
     if not manifest:

siliconcompiler/apps/sc_install.py

@@ -8,12 +8,53 @@ import sys
 
 import os.path
 
+from typing import Dict, List, Optional, Set
+
 from collections.abc import Container
 from pathlib import Path
 
 import siliconcompiler
 
 from siliconcompiler.schema_support.record import RecordSchema
+from siliconcompiler.utils import get_plugins
+
+
+def get_install_groups() -> Dict[str, List[str]]:
+    """
+    Provide recommended install tool groups for common workflows.
+
+    Each mapping key is a high-level group name and each value is an ordered list of tool
+    identifiers suitable for that group.
+
+    Returns:
+        dict: Mapping from group name (str) to a list of tool identifiers (List[str]).
+    """
+    return {
+        "asic": ["sv2v", "yosys", "yosys-slang", "openroad", "klayout"],
+        "asic-hls": ["bambu", "yosys", "yosys-slang", "openroad", "klayout"],
+        "fpga": ["sv2v", "yosys", "yosys-slang", "vpr", "yosys-wildebeest"],
+        "digital-simulation": ["verilator", "icarus", "surfer"],
+        "analog-simulation": ["xyce"]
+    }
+
+
+def get_install_tools(osname: str) -> Dict[str, str]:
+    tools_root = _get_tool_script_dir()
+
+    script_dir = None
+    if osname:
+        script_dir = tools_root / osname
+        if not script_dir.exists():
+            script_dir = None
+
+    tools = {}
+    if script_dir:
+        for script in glob.glob(str(script_dir / "install-*.sh")):
+            tool = re.match(r"install-(.*)\.sh", os.path.basename(script).lower())
+            if tool:
+                tools[tool.group(1)] = script
+
+    return tools
 
 
 class ChoiceOptional(Container):
@@ -29,18 +70,45 @@ class ChoiceOptional(Container):
         return item in self.__choices
 
     def __iter__(self):
+        """
+        Iterate over the stored choices.
+
+        Returns:
+            iterator: An iterator over the stored choice strings.
+        """
         return self.__choices.__iter__()
 
-    def get_items(self, choices):
+    def get_items(self, choices: List[str]) -> List[str]:
+        """
+        Return a sorted list of unique choice strings.
+
+        Parameters:
+            choices (List[str]): Iterable of choice strings which may contain duplicates.
+
+        Returns:
+            List[str]: Sorted list containing each unique choice from `choices`.
+        """
         items = set(choices)
         return sorted(items)
 
 
-def install_tool(tool, script, build_dir, prefix):
-    # Ensure build dir is available
-    build_dir = Path(build_dir) / tool
-    shutil.rmtree(str(build_dir), ignore_errors=True)
-    build_dir.mkdir(parents=True, exist_ok=True)
+def install_tool(tool: str, script: str, build_dir: str, prefix: str) -> bool:
+    """
+    Prepare a build directory, configure the environment, and execute an install script for a tool.
+
+    Parameters:
+        tool (str): Tool identifier used to create a per-tool build subdirectory under `build_dir`.
+        script (str): Path to the install script to execute.
+        build_dir (str): Base directory where a per-tool build directory will be created.
+        prefix (str): Installation prefix; added to PATH and used to determine whether
+                      sudo is required.
+
+    Returns:
+        bool: `True` if the install script exited with status 0, `False` otherwise.
+    """
+    build_path = Path(build_dir) / tool
+    shutil.rmtree(str(build_path), ignore_errors=True)
+    build_path.mkdir(parents=True, exist_ok=True)
 
     # setup environment
     env = os.environ.copy()
@@ -57,14 +125,22 @@ def install_tool(tool, script, build_dir, prefix):
         env["USE_SUDO_INSTALL"] = "yes"
 
     # run
-    ret = subprocess.call(script, env=env, cwd=build_dir)
+    ret = subprocess.call(script, env=env, cwd=build_path)
     if ret != 0:
         print(f"Error occurred while building/installing {tool}")
         return False
     return True
 
 
-def show_tool(tool, script):
+def show_tool(tool: str, script: str) -> None:
+    """
+    Print a bordered header, the contents of the given install script, and a
+    closing bordered footer.
+
+    Parameters:
+        tool (str): Tool identifier used in the printed header.
+        script (str): Path to the install script file whose contents will be displayed.
+    """
     def print_header(head):
         border_len = max(80, len(script) + 2)
         border = border_len*"#"
@@ -83,7 +159,19 @@ def show_tool(tool, script):
     print_header("end")
 
 
-def _get_os_name():
+def _get_os_name() -> Optional[str]:
+    """
+    Map recorded machine information to a short OS identifier used by the installer.
+
+    This inspects the machine information provided by RecordSchema and, for supported
+    Linux distributions, returns a compact identifier composed of the distro and
+    major version (for example, "ubuntu20" or "rhel8"). Returns None for
+    non-Linux systems or unrecognized distributions.
+
+    Returns:
+        os_name (Optional[str]): Mapped OS identifier (e.g., "ubuntu20", "rhel8") or
+        `None` if the OS cannot be mapped.
+    """
     machine_info = RecordSchema.get_machine_information()
     system = machine_info.get('system', "").lower()
     if system == 'linux':
@@ -103,7 +191,14 @@ def _get_os_name():
     return None
 
 
-def print_machine_info():
+def print_machine_info() -> None:
+    """
+    Prints detected machine and mapped OS information.
+
+    Prints the system name, distribution name, OS version, mapped OS identifier, and the path to
+    the install tools scripts directory as obtained from RecordSchema.get_machine_information()
+    and internal helpers.
+    """
     machine_info = RecordSchema.get_machine_information()
     mapped_os = _get_os_name()
 
@@ -114,7 +209,20 @@ def print_machine_info():
     print("Scripts:  ", _get_tool_script_dir())
 
 
-def __print_summary(successful, failed):
+def __print_summary(successful: Optional[Set[str]],
+                    failed: Optional[str],
+                    notstarted: Optional[Set[str]]) -> None:
+    """
+    Prints a fixed-width summary banner listing installed, failed, and pending tools.
+
+    Parameters:
+        successful (Optional[Set[str]]): Set of tool names that were installed; when provided,
+                                         they are shown under "Installed".
+        failed (Optional[str]): Name of a tool that failed to install; when provided, it is shown
+                                under "Failed to install".
+        notstarted (Optional[Set[str]]): Set of tool names that were not started or are pending;
+                                         when provided, they are shown under "Pending".
+    """
     max_len = 64
     print("#"*max_len)
     if successful:
@@ -124,40 +232,31 @@ def __print_summary(successful, failed):
     if failed:
         msg = f"Failed to install: {failed}"
         print(f"# {msg}")
-    print("#"*max_len)
 
+    if notstarted:
+        msg = f"Pending: {', '.join(sorted(notstarted))}"
+        print(f"# {msg}")
 
-def _get_tool_script_dir():
-    return Path(siliconcompiler.__file__).parent / "toolscripts"
+    print("#"*max_len)
 
 
-def _get_tools_list():
-    tools_root = _get_tool_script_dir()
+def _get_tool_script_dir() -> Path:
+    return Path(siliconcompiler.__file__).parent / "toolscripts"
 
-    script_dir = None
-    os_dir = _get_os_name()
-    if os_dir:
-        script_dir = tools_root / os_dir
-        if not script_dir.exists():
-            script_dir = None
 
+def _get_tools_list() -> Dict[str, str]:
     tools = {}
-    if script_dir:
-        for script in glob.glob(str(script_dir / "install-*.sh")):
-            tool = re.match(r"install-(.*)\.sh", os.path.basename(script).lower())
-            tools[tool.group(1)] = script
+    os = _get_os_name()
+    for plugin in get_plugins("install", name="tools"):
+        tools.update(plugin(os))
 
     return tools
 
 
-def _recommended_tool_groups(tools):
-    groups = {
-        "asic": {"sv2v", "yosys", "yosys-slang", "openroad", "klayout"},
-        "asic-hls": {"bambu", "yosys", "yosys-slang", "openroad", "klayout"},
-        "fpga": {"sv2v", "yosys", "yosys-slang", "vpr"},
-        "digital-simulation": {"verilator", "icarus", "surfer"},
-        "analog-simulation": {"xyce"}
-    }
+def _recommended_tool_groups(tools) -> Dict[str, List[str]]:
+    groups = {}
+    for plugin in get_plugins("install", name="groups"):
+        groups.update(plugin())
 
     filter_groups = {}
     for group, group_tools in groups.items():
@@ -174,7 +273,19 @@ class HelpFormatter(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescript
     pass
 
 
-def main():
+def main() -> int:
+    """
+    CLI entry point for installing tools, showing install scripts, or printing machine
+    debug information.
+
+    Parses command-line arguments, validates the host OS, expands tool groups, and either
+    displays install scripts (-show), prints machine info (-debug_machine), or runs install
+    scripts for the requested tools, then prints a summary and optional shell-path guidance.
+
+    Returns:
+        `0` on successful completion, `1` on failure (e.g., unsupported OS or
+        any tool installation failure).
+    """
     progname = "sc-install"
 
     tools = _get_tools_list()
@@ -286,13 +397,14 @@ Tool groups:
             show_tool(tool, tools[tool])
         else:
             if not install_tool(tool, tools[tool], args.build_dir, args.prefix):
-                __print_summary(tools_completed, tool)
+                notstarted = set(args.tool) - tools_completed - tools_handled
+                __print_summary(tools_completed, tool, notstarted)
                 return 1
             else:
                 tools_completed.add(tool)
 
     if not args.show:
-        __print_summary(tools_completed, None)
+        __print_summary(tools_completed, None, None)
 
         msgs = []
         for env, path in (

siliconcompiler/apps/smake.py

@@ -11,9 +11,15 @@ This allows for creating simple, self-documenting build or task scripts in
 Python without the need for complex boilerplate code.
 """
 import argparse
-import importlib
 import sys
+
+import importlib.util
 import os.path
+
+from typing import Union, Tuple, Optional, Dict
+
+from pathlib import Path
+
 from inspect import getmembers, isfunction, getfullargspec
 
 from siliconcompiler._metadata import version
@@ -23,7 +29,7 @@ from siliconcompiler.schema import utils
 __default_source_file = "make.py"
 
 
-def __process_file(path):
+def __process_file(path: Union[Path, str]) -> Tuple[Dict, Optional[str], Optional[str]]:
     """
     Dynamically loads a Python module and inspects it for runnable targets.
 
@@ -99,7 +105,7 @@ def __process_file(path):
     return args, default_arg, module_help
 
 
-def main(source_file=None):
+def main(source_file: Optional[Union[str, Path]] = None) -> int:
     """
     The main entry point for the smake command-line application.
 

siliconcompiler/checklist.py

@@ -2,7 +2,7 @@ import re
 
 import os.path
 
-from typing import Tuple
+from typing import Tuple, Optional
 
 from siliconcompiler.schema import NamedSchema
 from siliconcompiler.schema import EditableSchema, Parameter, Scope, BaseSchema
@@ -231,13 +231,13 @@ class Checklist(NamedSchema):
 
     def _generate_doc(self, doc,
                       ref_root: str = "",
-                      key_offset: Tuple[str] = None,
+                      key_offset: Optional[Tuple[str, ...]] = None,
                       detailed: bool = True):
         from .schema.docs.utils import build_section
         settings = build_section('Configuration', f"{ref_root}-config")
 
         if not key_offset:
-            key_offset = []
+            key_offset = tuple()
 
         for key in self.getkeys():
             criteria = build_section(key, f"{ref_root}-config-{key}")

siliconcompiler/data/demo_fpga/z1000_yosys_config.json

@@ -0,0 +1,24 @@
+{
+    "version": 1,
+    "partname": "z1000",
+    "lut_size": 4,
+    "flipflops": {
+        "features": [
+            "async_reset",
+            "flop_enable"
+        ],
+        "models": {
+            "dffer": "cad/techlib_custom_plugin/dffer.v",
+            "dffr": "cad/techlib_custom_plugin/dffr.v",
+            "dffe": "cad/techlib_custom_plugin/dffe.v",
+            "dff": "cad/techlib_custom_plugin/dff.v"
+        },
+        "legalize_list": [
+            "$_DFF_PN0_",
+            "$_DFF_P_",
+            "$_DFFE_PP_",
+            "$_DFFE_PN0P_"
+        ],
+        "techmap": "tech_flops.v"
+    }
+}