siliconcompiler 0.35.2__py3-none-any.whl → 0.35.4__py3-none-any.whl

siliconcompiler/_metadata.py

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

siliconcompiler/apps/sc_issue.py

@@ -72,6 +72,21 @@ To run a testcase, use:
     if not issue.get("cmdarg", "run"):
         project: Project = Project.from_manifest(filepath=issue.get("cmdarg", "cfg"))
 
+        # Determine abs path for build dir
+        builddir = project.option.get_builddir()
+        if isinstance(builddir, str) and not os.path.isabs(builddir):
+            builddirname = os.path.basename(builddir)
+            fullpath = os.path.dirname(os.path.abspath(issue.get("cmdarg", "cfg")))
+            while True:
+                if os.path.basename(fullpath) == builddirname:
+                    project.option.set_builddir(fullpath)
+                    break
+                parent = os.path.dirname(fullpath)
+                if parent == fullpath:
+                    # Reached filesystem root without finding a match
+                    break
+                fullpath = parent
+
         if issue.get("arg", "step"):
             project.set("arg", "step", issue.get("arg", "step"))
         if issue.get("arg", "index"):
@@ -143,8 +158,9 @@ To run a testcase, use:
 
         # Modify run environment to point to extracted files
         builddir_key = ['option', 'builddir']
-        new_builddir = f"{test_dir}/{project.get(*builddir_key)}"
-        project.logger.info(f"Changing {builddir_key} to '{new_builddir}'")
+        new_builddir = os.path.abspath(
+            os.path.join(test_dir, f"{os.path.basename(project.get(*builddir_key))}"))
+        project.logger.info(f"Changing [{','.join(builddir_key)}] to '{new_builddir}'")
         project.set(*builddir_key, new_builddir)
 
         # Run task

siliconcompiler/apps/smake.py

@@ -12,8 +12,8 @@ Python without the need for complex boilerplate code.
 """
 import argparse
 import sys
+import tempfile
 
-import importlib.util
 import os.path
 
 from typing import Union, Tuple, Optional, Dict
@@ -29,7 +29,7 @@ from siliconcompiler.schema import utils
 __default_source_file = "make.py"
 
 
-def __process_file(path: Union[Path, str]) -> Tuple[Dict, Optional[str], Optional[str]]:
+def __process_file(path: Union[Path, str], dir: str) -> Tuple[Dict, Optional[str], Optional[str]]:
     """
     Dynamically loads a Python module and inspects it for runnable targets.
 
@@ -54,16 +54,18 @@ def __process_file(path: Union[Path, str]) -> Tuple[Dict, Optional[str], Optiona
     if not os.path.exists(path):
         return {}, None, None
 
+    mod_name, _ = os.path.splitext(os.path.basename(path))
+
     # Dynamically load the specified file as a Python module.
-    mod_name = 'scmake'
-    spec = importlib.util.spec_from_file_location(mod_name, path)
-    make = importlib.util.module_from_spec(spec)
-    sys.modules[mod_name] = make
-    # Temporarily add CWD to path to allow the makefile to import local modules.
-    syspath = sys.path.copy()
+    with open(os.path.join(dir, "sc_module_load.py"), "w") as f:
+        f.write(f"import {mod_name} as make\n")
+
     sys.path.insert(0, os.getcwd())
-    spec.loader.exec_module(make)
-    sys.path = syspath
+    sys.path.insert(0, os.path.dirname(path))
+
+    # Load newly created file
+    import sc_module_load
+    make = sc_module_load.make
 
     # Inspect the module for public functions to treat as targets.
     args = {}
@@ -172,100 +174,104 @@ To run a target with arguments, use:
         print(f"Error: Unable to change directory to {source_dir}")
         return 1
 
-    # --- Process the source file to discover targets ---
-    make_args, default_arg, module_help = __process_file(source_file) \
-        if source_file else ({}, None, None)
-
-    if module_help:
-        description += f"\n\n{module_help}\n\n"
-        description += "-----------------------------------------------------------"
-
-    # --- Set up the main argument parser ---
-    parser = argparse.ArgumentParser(
-        progname,
-        description=description,
-        formatter_class=argparse.RawDescriptionHelpFormatter)
-
-    parser.add_argument(
-        '--file', '-f',
-        metavar='<file>',
-        help=f'Use file as makefile, default is {__default_source_file}')
-    parser.add_argument(
-        '--directory', '-C',
-        metavar='<directory>',
-        help='Change to directory <directory> before reading the makefile.')
-    parser.add_argument(
-        '--version', '-v',
-        action='version',
-        version=f"%(prog)s {version}")
-
-    # --- Create subparsers for each discovered target ---
-    targetparsers = parser.add_subparsers(
-        dest='target',
-        metavar='<target>',
-        help='Target to execute')
-
-    for arg, info in make_args.items():
-        subparse = targetparsers.add_parser(
-            arg,
-            description=info['full_help'],
-            help=info['help'],
-            formatter_class=argparse.RawDescriptionHelpFormatter)
+    with tempfile.TemporaryDirectory(prefix="smake") as dir:
+        # Add temp dir to path
+        sys.path.insert(0, dir)
 
-        # Add arguments for each parameter of the target function.
-        for subarg, subarg_info in info['args'].items():
-            add_args = {}
-            if "default" not in subarg_info:
-                add_args["required"] = True
-            else:
-                add_args["default"] = subarg_info["default"]
-
-            # Handle boolean arguments correctly.
-            arg_type = subarg_info["type"]
-            if arg_type is bool:
-                # Use a custom string-to-boolean converter.
-                def str2bool(v):
-                    val = str(v).lower()
-                    if val in ('y', 'yes', 't', 'true', 'on', '1'):
-                        return True
-                    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
-                        return False
-                    raise ValueError(f"invalid truth value {val!r}")
-                arg_type = str2bool
-
-            subparse.add_argument(
-                f'--{subarg}',
-                dest=f'sub_{subarg}',
-                metavar=f'<{subarg}>',
-                type=arg_type,
-                **add_args)
-
-    # --- Parse arguments and execute the target ---
-    args = parser.parse_args()
-    target = args.target or default_arg
-
-    if not target:
-        if make_args:
-            print("Error: No target specified and no default target found.")
-            parser.print_help()
-        else:
-            print(f"Error: Unable to load makefile '{source_file}'.")
-        return 1
+        # --- Process the source file to discover targets ---
+        make_args, default_arg, module_help = __process_file(source_file, dir) \
+            if source_file else ({}, None, None)
 
-    if target not in make_args:
-        print(f"Error: Target '{target}' not found in '{source_file}'.")
-        return 1
+        if module_help:
+            description += f"\n\n{module_help}\n\n"
+            description += "-----------------------------------------------------------"
 
-    # Prepare arguments to pass to the target function.
-    call_args = {}
-    args_vars = vars(args)
-    for arg in make_args[target]["args"]:
-        arg_key = f'sub_{arg}'
-        if arg_key in args_vars and args_vars[arg_key] is not None:
-            call_args[arg] = args_vars[arg_key]
+        # --- Set up the main argument parser ---
+        parser = argparse.ArgumentParser(
+            progname,
+            description=description,
+            formatter_class=argparse.RawDescriptionHelpFormatter)
 
-    # Call the selected function with its arguments.
-    make_args[target]["function"](**call_args)
+        parser.add_argument(
+            '--file', '-f',
+            metavar='<file>',
+            help=f'Use file as makefile, default is {__default_source_file}')
+        parser.add_argument(
+            '--directory', '-C',
+            metavar='<directory>',
+            help='Change to directory <directory> before reading the makefile.')
+        parser.add_argument(
+            '--version', '-v',
+            action='version',
+            version=f"%(prog)s {version}")
+
+        # --- Create subparsers for each discovered target ---
+        targetparsers = parser.add_subparsers(
+            dest='target',
+            metavar='<target>',
+            help='Target to execute')
+
+        for arg, info in make_args.items():
+            subparse = targetparsers.add_parser(
+                arg,
+                description=info['full_help'],
+                help=info['help'],
+                formatter_class=argparse.RawDescriptionHelpFormatter)
+
+            # Add arguments for each parameter of the target function.
+            for subarg, subarg_info in info['args'].items():
+                add_args = {}
+                if "default" not in subarg_info:
+                    add_args["required"] = True
+                else:
+                    add_args["default"] = subarg_info["default"]
+
+                # Handle boolean arguments correctly.
+                arg_type = subarg_info["type"]
+                if arg_type is bool:
+                    # Use a custom string-to-boolean converter.
+                    def str2bool(v):
+                        val = str(v).lower()
+                        if val in ('y', 'yes', 't', 'true', 'on', '1'):
+                            return True
+                        elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+                            return False
+                        raise ValueError(f"invalid truth value {val!r}")
+                    arg_type = str2bool
+
+                subparse.add_argument(
+                    f'--{subarg}',
+                    dest=f'sub_{subarg}',
+                    metavar=f'<{subarg}>',
+                    type=arg_type,
+                    **add_args)
+
+        # --- Parse arguments and execute the target ---
+        args = parser.parse_args()
+        target = args.target or default_arg
+
+        if not target:
+            if make_args:
+                print("Error: No target specified and no default target found.")
+                parser.print_help()
+            else:
+                print(f"Error: Unable to load makefile '{source_file}'.")
+            return 1
+
+        if target not in make_args:
+            print(f"Error: Target '{target}' not found in '{source_file}'.")
+            return 1
+
+        # Prepare arguments to pass to the target function.
+        call_args = {}
+        args_vars = vars(args)
+        for arg in make_args[target]["args"]:
+            arg_key = f'sub_{arg}'
+            if arg_key in args_vars and args_vars[arg_key] is not None:
+                call_args[arg] = args_vars[arg_key]
+
+        # Call the selected function with its arguments.
+        make_args[target]["function"](**call_args)
 
     return 0
 

siliconcompiler/checklist.py

@@ -6,6 +6,7 @@ from typing import Tuple, List, Optional, Union, Dict, Iterable
 from siliconcompiler.schema import NamedSchema, EditableSchema, Parameter, Scope, BaseSchema
 from siliconcompiler.schema.utils import trim
 from siliconcompiler import NodeStatus, utils
+from siliconcompiler.utils.paths import cwdirsafe
 
 
 class Criteria(NamedSchema):
@@ -328,7 +329,7 @@ class Checklist(NamedSchema):
 
         schema_root = self._parent(root=True)
         logger = getattr(schema_root, "logger", None)
-        cwd = getattr(schema_root, "_Project__cwd", os.getcwd())
+        cwd = cwdirsafe(schema_root)
 
         assert hasattr(schema_root, "history"), f"{schema_root}"
 

siliconcompiler/constraints/asic_component.py

@@ -1,4 +1,4 @@
-from typing import Tuple, Union
+from typing import Tuple, Union, Optional
 
 from siliconcompiler.schema import BaseSchema, NamedSchema, EditableSchema, Parameter, \
     PerNode, Scope
@@ -13,7 +13,7 @@ class ASICComponentConstraint(NamedSchema):
     keepout halo, and rotation.
     """
 
-    def __init__(self, name: str = None):
+    def __init__(self, name: Optional[str] = None):
         super().__init__()
         self.set_name(name)
 
@@ -113,7 +113,8 @@ class ASICComponentConstraint(NamedSchema):
                     270 deg ccw
                     """))
 
-    def set_placement(self, x: float, y: float, step: str = None, index: Union[str, int] = None):
+    def set_placement(self, x: float, y: float,
+                      step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the placement constraint for the component.
 
@@ -134,7 +135,8 @@ class ASICComponentConstraint(NamedSchema):
             raise TypeError("y must be a number")
         return self.set("placement", (x, y), step=step, index=index)
 
-    def get_placement(self, step: str = None, index: Union[str, int] = None) -> Tuple[float, float]:
+    def get_placement(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> Tuple[float, float]:
         """
         Retrieves the current placement constraint of the component.
 
@@ -148,7 +150,8 @@ class ASICComponentConstraint(NamedSchema):
         """
         return self.get("placement", step=step, index=index)
 
-    def set_partname(self, name: str, step: str = None, index: Union[str, int] = None):
+    def set_partname(self, name: str,
+                     step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the part name (cell name) constraint for the component.
 
@@ -165,7 +168,8 @@ class ASICComponentConstraint(NamedSchema):
             raise ValueError("a partname is required")
         return self.set("partname", name, step=step, index=index)
 
-    def get_partname(self, step: str = None, index: Union[str, int] = None) -> str:
+    def get_partname(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> str:
         """
         Retrieves the current part name (cell name) constraint of the component.
 
@@ -178,7 +182,8 @@ class ASICComponentConstraint(NamedSchema):
         """
         return self.get("partname", step=step, index=index)
 
-    def set_halo(self, x: float, y: float, step: str = None, index: Union[str, int] = None):
+    def set_halo(self, x: float, y: float,
+                 step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the placement keepout halo constraint around the component.
 
@@ -204,7 +209,8 @@ class ASICComponentConstraint(NamedSchema):
             raise ValueError("y must be a positive number")
         return self.set("halo", (x, y), step=step, index=index)
 
-    def get_halo(self, step: str = None, index: Union[str, int] = None) -> Tuple[float, float]:
+    def get_halo(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> Tuple[float, float]:
         """
         Retrieves the current placement keepout halo constraint of the component.
 
@@ -218,7 +224,8 @@ class ASICComponentConstraint(NamedSchema):
         """
         return self.get("halo", step=step, index=index)
 
-    def set_rotation(self, rotation: str, step: str = None, index: Union[str, int] = None):
+    def set_rotation(self, rotation: str,
+                     step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the rotation constraint for the component.
 
@@ -231,7 +238,8 @@ class ASICComponentConstraint(NamedSchema):
         """
         return self.set("rotation", rotation, step=step, index=index)
 
-    def get_rotation(self, step: str = None, index: Union[str, int] = None) -> str:
+    def get_rotation(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> str:
         """
         Retrieves the current rotation constraint of the component.
 
@@ -286,7 +294,7 @@ class ASICComponentConstraints(BaseSchema):
 
         EditableSchema(self).insert(component.name, component, clobber=True)
 
-    def get_component(self, component: str = None):
+    def get_component(self, component: Optional[str] = None):
         """
         Retrieves one or all component constraints from the configuration.
 
@@ -350,6 +358,36 @@ class ASICComponentConstraints(BaseSchema):
         self.add_component(constraint)
         return constraint
 
+    def copy_component(self, component: str, name: str, insert: bool = True) \
+            -> ASICComponentConstraint:
+        """
+        Copies an existing component constraint, renames it, and optionally adds it to the design.
+
+        This method retrieves the component constraint identified by ``component``, creates a
+        deep copy of it, and renames the copy to ``name``. If ``insert`` is True,
+        the new constraint is immediately added to the configuration.
+
+        Args:
+            component (str): The name of the existing component constraint to be copied.
+            name (str): The name to assign to the new copied constraint.
+            insert (bool, optional): Whether to add the newly created constraint
+                to the configuration. Defaults to True.
+
+        Returns:
+            ASICComponentConstraint: The newly created copy of the component constraint.
+
+        Raises:
+            LookupError: If the source component constraint specified by ``component`` does not
+                         exist.
+        """
+        constraint = EditableSchema(self.get_component(component)).copy()
+        EditableSchema(constraint).rename(name)
+        if insert:
+            if self.valid(name):
+                raise ValueError(f"{name} already exists")
+            self.add_component(constraint)
+        return constraint
+
     def remove_component(self, component: str) -> bool:
         """
         Removes a component constraint from the design configuration.

siliconcompiler/constraints/asic_floorplan.py

@@ -1,4 +1,4 @@
-from typing import Union, List, Tuple
+from typing import Union, List, Tuple, Optional
 
 from siliconcompiler.schema import BaseSchema, EditableSchema, Parameter, PerNode, Scope
 
@@ -99,9 +99,9 @@ class ASICAreaConstraint(BaseSchema):
 
     def set_density(self,
                     density: float,
-                    aspectratio: float = None,
-                    coremargin: float = None,
-                    step: str = None, index: Union[str, int] = None):
+                    aspectratio: Optional[float] = None,
+                    coremargin: Optional[float] = None,
+                    step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the target layout density.
 
@@ -145,7 +145,8 @@ class ASICAreaConstraint(BaseSchema):
             params.append(self.set_coremargin(coremargin, step=step, index=index))
         return params
 
-    def get_density(self, step: str = None, index: Union[str, int] = None) -> float:
+    def get_density(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> float:
         """
         Retrieves the current target layout density.
 
@@ -162,7 +163,7 @@ class ASICAreaConstraint(BaseSchema):
 
     def set_aspectratio(self,
                         aspectratio: float,
-                        step: str = None, index: Union[str, int] = None):
+                        step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the layout aspect ratio.
 
@@ -192,8 +193,8 @@ class ASICAreaConstraint(BaseSchema):
 
         return self.set("aspectratio", aspectratio, step=step, index=index)
 
-    def get_aspectratio(self,
-                        step: str = None, index: Union[str, int] = None) -> float:
+    def get_aspectratio(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> float:
         """
         Retrieves the current layout aspect ratio.
 
@@ -210,7 +211,7 @@ class ASICAreaConstraint(BaseSchema):
 
     def set_coremargin(self,
                        coremargin: float,
-                       step: str = None, index: Union[str, int] = None):
+                       step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the core margin.
 
@@ -240,8 +241,8 @@ class ASICAreaConstraint(BaseSchema):
 
         return self.set("coremargin", coremargin, step=step, index=index)
 
-    def get_coremargin(self,
-                       step: str = None, index: Union[str, int] = None) -> float:
+    def get_coremargin(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> float:
         """
         Retrieves the current core margin.
 
@@ -259,8 +260,8 @@ class ASICAreaConstraint(BaseSchema):
     def set_diearea_rectangle(self,
                               height: float,
                               width: float,
-                              coremargin: Union[float, Tuple[float, float]] = None,
-                              step: str = None, index: Union[str, int] = None):
+                              coremargin: Optional[Union[float, Tuple[float, float]]] = None,
+                              step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the die area as a rectangle with its bottom-left corner at (0,0).
 
@@ -311,7 +312,7 @@ class ASICAreaConstraint(BaseSchema):
                                dieheight: float,
                                diewidth: float,
                                coremargin: Union[float, Tuple[float, float]],
-                               step: str = None, index: Union[str, int] = None):
+                               step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the core area as a rectangle within a die area, based on margins.
 
@@ -378,7 +379,7 @@ class ASICAreaConstraint(BaseSchema):
 
     def set_diearea(self,
                     points: List[Tuple[float, float]],
-                    step: str = None, index: Union[str, int] = None):
+                    step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the die area using a list of points defining its boundary.
 
@@ -396,8 +397,8 @@ class ASICAreaConstraint(BaseSchema):
         """
         return self.set("diearea", points, step=step, index=index)
 
-    def get_diearea(self,
-                    step: str = None, index: Union[str, int] = None) -> List[Tuple[float, float]]:
+    def get_diearea(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> List[Tuple[float, float]]:
         """
         Retrieves the current die area definition.
 
@@ -415,7 +416,7 @@ class ASICAreaConstraint(BaseSchema):
 
     def set_corearea(self,
                      points: List[Tuple[float, float]],
-                     step: str = None, index: Union[str, int] = None):
+                     step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the core area using a list of points defining its boundary.
 
@@ -432,8 +433,8 @@ class ASICAreaConstraint(BaseSchema):
         """
         return self.set("corearea", points, step=step, index=index)
 
-    def get_corearea(self,
-                     step: str = None, index: Union[str, int] = None) -> List[Tuple[float, float]]:
+    def get_corearea(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> List[Tuple[float, float]]:
         """
         Retrieves the current core area definition.
 
@@ -449,7 +450,8 @@ class ASICAreaConstraint(BaseSchema):
         """
         return self.get("corearea", step=step, index=index)
 
-    def calc_diearea(self, step: str = None, index: str = None) -> float:
+    def calc_diearea(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> float:
         '''Calculates the area of a rectilinear die.
 
         Uses the shoelace formula to calculate the design area from the (x,y)