librelane 2.4.0.dev11__py3-none-any.whl → 2.4.1__py3-none-any.whl

librelane/env_info.py

@@ -23,17 +23,16 @@ import os
 import re
 import sys
 import json
+import shutil
 import tempfile
 import platform
 import subprocess
 
 try:
-    from typing import Optional, Dict, List  # noqa: F401
+    from typing import Union, Optional, Dict, List  # noqa: F401
 except ImportError:
     pass
 
-CONTAINER_ENGINE = os.getenv("OPENLANE_CONTAINER_ENGINE", "docker")
-
 
 class StringRepresentable(object):
     def __str__(self):
@@ -44,6 +43,7 @@ class StringRepresentable(object):
 
 
 class ContainerInfo(StringRepresentable):
+    path = None  # type: Optional[str]
     engine = "UNKNOWN"  # type: str
     version = "UNKNOWN"  # type: str
     conmon = False  # type: bool
@@ -54,63 +54,84 @@ class ContainerInfo(StringRepresentable):
         self.version = "UNKNOWN"
         self.conmon = False
         self.rootless = False
+        self.seccomp = False
+        self.selinux = False
+        self.apparmor = False
 
     @staticmethod
     def get():
-        # type: () -> Optional['ContainerInfo']
+        # type: () -> Union[ContainerInfo, str]
+        cinfo = ContainerInfo()
+        # Here are the rules:
+        # 1. If LIBRELANE_CONTAINER_ENGINE exists, use that uncritically.
+        # 2. Else, if OPENLANE_CONTAINER_ENGINE exists, use that uncritically.
+        # 3. Else, if "docker" is in PATH, always use it.
+        # 4. Else, see if "podman" is in PATH, and use THAT.
+        # 5. If none exist, halt and return early.
+
+        container_engine = os.getenv(
+            "LIBRELANE_CONTAINER_ENGINE", os.getenv("OPENLANE_CONTAINER_ENGINE")
+        )
+        if container_engine is None or container_engine == "":
+            container_engine = shutil.which("docker")
+            if container_engine is None:
+                container_engine = shutil.which("podman")
+                if container_engine is None:
+                    return "no compatible container engine found in PATH (tried docker, podman)"
         try:
-            cinfo = ContainerInfo()
+            info_str = subprocess.check_output(
+                [container_engine, "info", "--format", "{{json .}}"]
+            ).decode("utf8")
+        except Exception as e:
+            return "failed to get container engine info: %s" % str(e)
+        cinfo.path = container_engine
 
+        try:
+            info = json.loads(info_str)
+        except Exception as e:
+            return "result from '%s info' was not valid JSON: %s" % (
+                container_engine,
+                str(e),
+            )
+
+        if (
+            info.get("Docker Root Dir") is not None
+            or info.get("DockerRootDir") is not None
+        ):
+            cinfo.engine = "docker"
+
+            # Get Version
             try:
-                info_str = subprocess.check_output(
-                    [CONTAINER_ENGINE, "info", "--format", "{{json .}}"]
-                ).decode("utf8")
-            except Exception as e:
-                raise Exception("Failed to get Docker info: %s" % str(e)) from None
+                version_output = (
+                    subprocess.check_output([container_engine, "--version"])
+                    .decode("utf8")
+                    .strip()
+                )
+                cinfo.version = re.split(r"\s", version_output)[2].strip(",")
+            except Exception:
+                pass
 
-            try:
-                info = json.loads(info_str)
-            except Exception as e:
-                raise Exception(
-                    "Result from 'docker info' was not valid JSON: %s" % str(e)
-                ) from None
-
-            if info.get("host") is not None:
-                if info["host"].get("conmon") is not None:
-                    cinfo.conmon = True
-                    if (
-                        info["host"].get("remoteSocket") is not None
-                        and "podman" in info["host"]["remoteSocket"]["path"]
-                    ):
-                        cinfo.engine = "podman"
-
-                        cinfo.version = info["version"]["Version"]
-            elif (
-                info.get("Docker Root Dir") is not None
-                or info.get("DockerRootDir") is not None
-            ):
-                cinfo.engine = "docker"
-
-                # Get Version
-                try:
-                    version_output = (
-                        subprocess.check_output([CONTAINER_ENGINE, "--version"])
-                        .decode("utf8")
-                        .strip()
-                    )
-                    cinfo.version = re.split(r"\s", version_output)[2].strip(",")
-                except Exception:
-                    print("Could not extract Docker version.", file=sys.stderr)
-
-                security_options = info.get("SecurityOptions")
-                for option in security_options:
-                    if "rootless" in option:
-                        cinfo.rootless = True
-
-            return cinfo
-        except Exception as e:
-            print(e, file=sys.stderr)
-            return None
+            security_options = info.get("SecurityOptions")
+            for option in security_options:
+                if "rootless" in option:
+                    cinfo.rootless = True
+        elif info.get("host") is not None:
+            host = info["host"]
+            conmon = host.get("conmon")
+            remote_socket = host.get("remoteSocket")
+            security = host.get("security")
+            if conmon is not None:
+                cinfo.conmon = True
+            if remote_socket is not None and "podman" in remote_socket["path"]:
+                cinfo.engine = "podman"
+                cinfo.version = info["version"]["Version"]
+            if security is not None:
+                cinfo.rootless = security.get("rootless", False)
+                cinfo.apparmor = security.get("apparmorEnabled", False)
+                cinfo.seccomp = security.get("seccompEnabled", False)
+                cinfo.selinux = security.get("selinuxEnabled", False)
+
+        return cinfo
 
 
 class NixInfo(StringRepresentable):
@@ -127,73 +148,65 @@ class NixInfo(StringRepresentable):
 
     @staticmethod
     def get():
-        # type: () -> Optional['NixInfo']
+        # type: () -> Union[NixInfo, str]
         ninfo = NixInfo()
+        if shutil.which("nix") is None:
+            return "nix not found in PATH"
         try:
-            try:
-                version_str = subprocess.check_output(
-                    ["nix", "--version"], encoding="utf8"
-                )
-                ninfo.version_string = version_str.strip()
-            except Exception as e:
-                raise Exception("Failed to get Nix info: %s" % str(e)) from None
+            version_str = subprocess.check_output(["nix", "--version"], encoding="utf8")
+            ninfo.version_string = version_str.strip()
+        except Exception as e:
+            return "could not get nix version: %s" % str(e)
 
-            try:
-                channels = {}
-                channels_raw = subprocess.check_output(
-                    ["nix-channel", "--list"], encoding="utf8"
-                )
-                for channel in channels_raw.splitlines():
-                    name, url = channel.split(maxsplit=1)
-                    channels[name] = url
-                ninfo.channels = channels
-            except Exception as e:
+        try:
+            channels = {}
+            channels_raw = subprocess.check_output(
+                ["nix-channel", "--list"], encoding="utf8"
+            )
+            for channel in channels_raw.splitlines():
+                name, url = channel.split(maxsplit=1)
+                channels[name] = url
+            ninfo.channels = channels
+        except Exception:
+            pass
+
+        with tempfile.TemporaryDirectory(prefix="librelane_env_report_") as d:
+            with open(os.path.join(d, "flake.nix"), "w") as f:
+                f.write("{}")
+            nix_command = subprocess.run(
+                ["nix", "eval"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                cwd=d,
+                encoding="utf8",
+            )
+            nix_command_result = nix_command.stdout
+            if "'nix-command'" in nix_command_result:
+                pass
+            elif "'flakes'" in nix_command_result:
+                ninfo.nix_command = True
+            elif "lacks attribute" in nix_command_result:
+                ninfo.nix_command = True
+                ninfo.flakes = True
+            else:
                 print(
-                    "Failed to get nix channels: %s" % str(e),
+                    "'nix flake' returned unexpected output: %s" % nix_command_result,
                     file=sys.stderr,
                 )
 
-            with tempfile.TemporaryDirectory(prefix="librelane_env_report_") as d:
-                with open(os.path.join(d, "flake.nix"), "w") as f:
-                    f.write("{}")
-                nix_command = subprocess.run(
-                    ["nix", "eval"],
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.STDOUT,
-                    cwd=d,
-                    encoding="utf8",
-                )
-                nix_command_result = nix_command.stdout
-                if "'nix-command'" in nix_command_result:
-                    pass
-                elif "'flakes'" in nix_command_result:
-                    ninfo.nix_command = True
-                elif "lacks attribute" in nix_command_result:
-                    ninfo.nix_command = True
-                    ninfo.flakes = True
-                else:
-                    print(
-                        "'nix flake' returned unexpected output: %s"
-                        % nix_command_result,
-                        file=sys.stderr,
-                    )
-
-            return ninfo
-        except Exception as e:
-            print(e, file=sys.stderr)
-            return None
+        return ninfo
 
 
 class OSInfo(StringRepresentable):
     kernel = ""  # type: str
     kernel_version = ""  # type: str
     supported = False  # type: bool
-    distro = None  # type: Optional[str]
-    distro_version = None  # type: Optional[str]
+    distro = "UNKNOWN"  # type: str
+    distro_version = "UNKNOWN"  # type: str
     python_version = ""  # type: str
     python_path = []  # type: List[str]
-    container_info = None  # type: Optional[ContainerInfo]
-    nix_info = None  # type: Optional[NixInfo]
+    container_info = None  # type: Union[ContainerInfo, str]
+    nix_info = None  # type: Union[NixInfo, str]
 
     def __init__(self):
         self.kernel = platform.system()
@@ -201,8 +214,8 @@ class OSInfo(StringRepresentable):
             platform.release()
         )  # Unintuitively enough, it's the kernel's release
         self.supported = self.kernel in ["Darwin", "Linux"]
-        self.distro = None
-        self.distro_version = None
+        self.distro = "UNKNOWN"
+        self.distro_version = "UNKNOWN"
         self.python_version = platform.python_version()
         self.python_path = sys.path.copy()
         self.tkinter = False
@@ -212,8 +225,8 @@ class OSInfo(StringRepresentable):
             self.tkinter = True
         except ImportError:
             pass
-        self.container_info = None
-        self.nix_info = None
+        self.container_info = ""
+        self.nix_info = ""
 
     @staticmethod
     def get():
@@ -253,13 +266,14 @@ class OSInfo(StringRepresentable):
 
                     config[key] = value
 
-                osinfo.distro = config.get("ID") or config.get("DISTRIB_ID")
-                osinfo.distro_version = config.get("VERSION_ID") or config.get(
-                    "DISTRIB_RELEASE"
+                osinfo.distro = (
+                    config.get("ID") or config.get("DISTRIB_ID") or "UNKNOWN"
+                )
+                osinfo.distro_version = (
+                    config.get("VERSION_ID")
+                    or config.get("DISTRIB_RELEASE")
+                    or "UNKNOWN"
                 )
-
-            else:
-                print("Failed to get distribution info.", file=sys.stderr)
 
         osinfo.container_info = ContainerInfo.get()
         osinfo.nix_info = NixInfo.get()

librelane/flows/flow.py

@@ -375,7 +375,7 @@ class Flow(ABC):
         self.progress_bar = FlowProgressBar(self.name)
 
     @classmethod
-    def get_help_md(Self, myst_anchors: bool = True) -> str:  # pragma: no cover
+    def get_help_md(Self, myst_anchors: bool = False) -> str:  # pragma: no cover
         """
         :returns: rendered Markdown help for this Flow
         """
@@ -415,10 +415,10 @@ class Flow(ABC):
         flow_config_vars = Self.config_vars
 
         if len(flow_config_vars):
+            config_var_anchors = f"({slugify(Self.__name__, lower=True)}-config-vars)="
             result += textwrap.dedent(
                 f"""
-                ({slugify(Self.__name__, lower=True)}-config-vars)=
-
+                {config_var_anchors * myst_anchors}
                 #### Flow-specific Configuration Variables
 
                 | Variable Name | Type | Description | Default | Units |
@@ -435,18 +435,14 @@ class Flow(ABC):
         if len(Self.Steps):
             result += "#### Included Steps\n"
             for step in Self.Steps:
-                if hasattr(step, "long_name"):
-                    name = step.long_name
-                elif hasattr(step, "name"):
-                    name = step.name
-                else:
-                    name = step.id
+                imp_id = step.get_implementation_id()
                 if myst_anchors:
-                    result += (
-                        f"* [`{step.id}`](./step_config_vars.md#{slugify(name)})\n"
-                    )
+                    result += f"* [`{step.id}`](./step_config_vars.md#step-{slugify(imp_id, lower=True)})\n"
                 else:
-                    result += f"* {step.id}"
+                    variant_str = ""
+                    if imp_id != step.id:
+                        variant_str = f" (implementation: `{imp_id}`)"
+                    result += f"* `{step.id}`{variant_str}\n"
 
         return result
 
@@ -824,7 +820,6 @@ class Flow(ABC):
             DesignFormat.POWERED_NETLIST: (os.path.join("verilog", "gl"), "v"),
             DesignFormat.DEF: ("def", "def"),
             DesignFormat.LEF: ("lef", "lef"),
-            DesignFormat.SDF: (os.path.join("sdf", "multicorner"), "sdf"),
             DesignFormat.SPEF: (os.path.join("spef", "multicorner"), "spef"),
             DesignFormat.LIB: (os.path.join("lib", "multicorner"), "lib"),
             DesignFormat.GDS: ("gds", "gds"),
@@ -883,38 +878,67 @@ class Flow(ABC):
                         file_path, os.path.join(to_dir, file), follow_symlinks=True
                     )
 
-        signoff_folder = os.path.join(
-            path, "signoff", self.config["DESIGN_NAME"], "librelane-signoff"
-        )
-        mkdirp(signoff_folder)
+        def find_one(pattern):
+            result = glob.glob(pattern)
+            if len(result) == 0:
+                return None
+            return result[0]
 
-        # resolved.json
+        signoff_dir = os.path.join(path, "signoff", self.config["DESIGN_NAME"])
+        openlane_signoff_dir = os.path.join(signoff_dir, "openlane-signoff")
+        mkdirp(openlane_signoff_dir)
+
+        ## resolved.json
         shutil.copyfile(
             self.config_resolved_path,
-            os.path.join(signoff_folder, "resolved.json"),
+            os.path.join(openlane_signoff_dir, "resolved.json"),
             follow_symlinks=True,
         )
 
-        # Logs
-        mkdirp(signoff_folder)
-        copy_dir_contents(self.run_dir, signoff_folder, "*.log")
+        ## metrics
+        with open(os.path.join(signoff_dir, "metrics.csv"), "w", encoding="utf8") as f:
+            last_state.metrics_to_csv(f)
+
+        ## flow logs
+        mkdirp(openlane_signoff_dir)
+        copy_dir_contents(self.run_dir, openlane_signoff_dir, "*.log")
 
-        # Step-specific
+        ### step-specific signoff logs and reports
         for step in self.step_objects:
             reports_dir = os.path.join(step.step_dir, "reports")
             step_imp_id = step.get_implementation_id()
+            if step_imp_id == "Magic.DRC":
+                if drc_rpt := find_one(os.path.join(reports_dir, "*.rpt")):
+                    shutil.copyfile(
+                        drc_rpt, os.path.join(openlane_signoff_dir, "drc.rpt")
+                    )
+                if drc_xml := find_one(os.path.join(reports_dir, "*.xml")):
+                    # Despite the name, this is the Magic DRC report simply
+                    # converted into a KLayout-compatible format. Confusing!
+                    drc_xml_out = os.path.join(openlane_signoff_dir, "drc.klayout.xml")
+                    with open(drc_xml, encoding="utf8") as i, open(
+                        drc_xml_out, "w", encoding="utf8"
+                    ) as o:
+                        o.write(
+                            "<!-- Despite the name, this is the Magic DRC report in KLayout format. -->\n"
+                        )
+                        shutil.copyfileobj(i, o)
+            if step_imp_id == "Netgen.LVS":
+                if lvs_rpt := find_one(os.path.join(reports_dir, "*.rpt")):
+                    shutil.copyfile(
+                        lvs_rpt, os.path.join(openlane_signoff_dir, "lvs.rpt")
+                    )
             if step_imp_id.endswith("DRC") or step_imp_id.endswith("LVS"):
-                if os.path.exists(reports_dir):
-                    copy_dir_contents(reports_dir, signoff_folder)
-            if step_imp_id.endswith("LVS"):
-                copy_dir_contents(step.step_dir, signoff_folder, "*.log")
+                copy_dir_contents(step.step_dir, openlane_signoff_dir, "*.log")
             if step_imp_id.endswith("CheckAntennas"):
                 if os.path.exists(reports_dir):
                     copy_dir_contents(
-                        reports_dir, signoff_folder, "antenna_summary.rpt"
+                        reports_dir, openlane_signoff_dir, "antenna_summary.rpt"
                     )
             if step_imp_id.endswith("STAPostPNR"):
-                timing_report_folder = os.path.join(signoff_folder, "timing-reports")
+                timing_report_folder = os.path.join(
+                    openlane_signoff_dir, "timing-reports"
+                )
                 mkdirp(timing_report_folder)
                 copy_dir_contents(step.step_dir, timing_report_folder, "*summary.rpt")
                 for dir in os.listdir(step.step_dir):
@@ -925,6 +949,18 @@ class Flow(ABC):
                     mkdirp(target)
                     copy_dir_contents(dir_path, target, "*.rpt")
 
+        # 3. SDF
+        #   (This one, as with many things in the Efabless format, is special)
+        if sdf := last_state[DesignFormat.SDF]:
+            assert isinstance(sdf, dict), "SDF is not a dictionary"
+            for corner, view in sdf.items():
+                assert isinstance(view, Path), "SDF state out returned multiple paths"
+                target_dir = os.path.join(signoff_dir, "sdf", corner)
+                mkdirp(target_dir)
+                shutil.copyfile(
+                    view, os.path.join(target_dir, f"{self.config['DESIGN_NAME']}.sdf")
+                )
+
     @deprecated(
         version="2.0.0a46",
         reason="Use .progress_bar.set_max_stage_count",

librelane/help/__main__.py

@@ -0,0 +1,39 @@
+# Copyright 2025 LibreLane Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from ..common.cli import formatter_settings
+from ..flows import Flow
+from ..steps import Step
+from ..logging import console
+
+import cloup
+
+
+@cloup.command(formatter_settings=formatter_settings)
+@cloup.argument("step_or_flow")
+@cloup.pass_context
+def cli(ctx, step_or_flow):
+    """
+    Displays rich help for the step or flow in question.
+    """
+    if TargetFlow := Flow.factory.get(step_or_flow):
+        TargetFlow.display_help()
+    elif TargetStep := Step.factory.get(step_or_flow):
+        TargetStep.display_help()
+    else:
+        console.log(f"Unknown Flow or Step '{step_or_flow}'.")
+        ctx.exit(-1)
+
+
+if __name__ == "__main__":
+    cli()

librelane/scripts/magic/def/mag_gds.tcl

@@ -77,5 +77,3 @@ if { $::env(MAGIC_GDS_POLYGON_SUBCELLS) } {
 
 gds write $::env(SAVE_MAG_GDS)
 puts "\[INFO\] GDS Write Complete"
-
-exit 0

librelane/scripts/magic/drc.tcl

@@ -76,4 +76,3 @@ puts stdout "\[INFO\] Saving mag view with DRC errors ($mag_view)"
 # WARNING: changes the name of the cell; keep as last step
 save $mag_view
 puts stdout "\[INFO\] Saved"
-exit 0

librelane/scripts/magic/gds/extras_mag.tcl

@@ -43,5 +43,3 @@ if {  [info exist ::env(EXTRA_GDS_FILES)] } {
 		puts "\[INFO\] Saved mag view from $gds_file under $::env(STEP_DIR)"
 	}
 }
-
-exit 0

librelane/scripts/magic/gds/mag_with_pointers.tcl

@@ -29,4 +29,3 @@ set final_filepath $::env(signoff_tmpfiles)/gds_ptrs.mag
 file rename -force $::env(signoff_tmpfiles)/$::env(DESIGN_NAME).mag $final_filepath
 
 puts "\[INFO\] Wrote $final_filepath including GDS pointers."
-exit 0

librelane/scripts/magic/lef/extras_maglef.tcl

@@ -59,5 +59,3 @@ foreach design_name [cellname list allcells] {
 	puts $fp [join $new_mag_lines "\n"]
 	close $fp
 }
-
-exit 0

librelane/scripts/magic/lef/maglef.tcl

@@ -24,4 +24,3 @@ cellname filepath $::env(DESIGN_NAME).lef $::env(signoff_results)
 save
 
 puts "\[INFO\] DONE GENERATING MAGLEF VIEW"
-exit 0

librelane/scripts/magic/wrapper.tcl

@@ -17,3 +17,5 @@ if {[catch {source $::env(_MAGIC_SCRIPT)} err]} {
     puts "Error: $err"
     exit 1
 }
+
+exit 0

librelane/scripts/odbpy/power_utils.py

@@ -17,7 +17,6 @@ import utl
 
 import re
 import json
-import functools
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
@@ -49,11 +48,14 @@ class Design(object):
     def get_verilog_net_name_by_bit(self, top_module: str, target_bit: int):
         yosys_design_object = self.yosys_dict["modules"][top_module]
         if top_module not in self.verilog_net_names_by_bit_by_module:
-            self.verilog_net_names_by_bit_by_module[top_module] = functools.reduce(
-                lambda a, b: {**a, **{bit: b[0] for bit in b[1]["bits"]}},
-                yosys_design_object["netnames"].items(),
-                {},
-            )
+            # check git history for a version of this loop that is drunk on power
+            netname_by_bit = {}
+
+            for netname, info in yosys_design_object["netnames"].items():
+                for bit in info["bits"]:
+                    netname_by_bit[bit] = netname
+
+            self.verilog_net_names_by_bit_by_module[top_module] = netname_by_bit
         return self.verilog_net_names_by_bit_by_module[top_module][target_bit]
 
     def get_pins(self, module_name: str) -> Dict[str, odb.dbMTerm]:

librelane/scripts/odbpy/reader.py

@@ -20,7 +20,7 @@ import sys
 import json
 import locale
 import inspect
-import functools
+from functools import wraps
 from decimal import Decimal
 from fnmatch import fnmatch
 from typing import Callable, Dict
@@ -188,7 +188,7 @@ class OdbReader(object):
 
 
 def click_odb(function):
-    @functools.wraps(function)
+    @wraps(function)
     def wrapper(input_db, input_lefs, config_path, **kwargs):
         reader = OdbReader(input_db, config_path=config_path)
 

librelane/state/state.py

@@ -13,7 +13,9 @@
 # limitations under the License.
 from __future__ import annotations
 
+import io
 import os
+import csv
 import sys
 import json
 import shutil
@@ -214,14 +216,20 @@ class State(GenericImmutableDict[str, StateElement]):
         self._walk(self, path, visitor)
         metrics_csv_path = os.path.join(path, "metrics.csv")
         with open(metrics_csv_path, "w", encoding="utf8") as f:
-            f.write("Metric,Value\n")
-            for metric in self.metrics:
-                f.write(f"{metric},{self.metrics[metric]}\n")
+            self.metrics_to_csv(f)
 
         metrics_json_path = os.path.join(path, "metrics.json")
         with open(metrics_json_path, "w", encoding="utf8") as f:
             f.write(self.metrics.dumps())
 
+    def metrics_to_csv(
+        self, fp: io.TextIOWrapper, metrics_object: Optional[Dict[str, Any]] = None
+    ):
+        w = csv.writer(fp)
+        w.writerow(("Metric", "Value"))
+        for entry in (metrics_object or self.metrics).items():
+            w.writerow(entry)
+
     def validate(self):
         """
         Ensures that all paths exist in a State.

librelane/steps/__main__.py

@@ -15,7 +15,6 @@ import os
 import shlex
 import shutil
 import datetime
-import functools
 import subprocess
 from functools import partial
 from typing import IO, Any, Dict, Optional, Sequence, Union
@@ -239,7 +238,7 @@ def eject(ctx, output, state_in, config, id):
             found_stdin_data = found_stdin.read()
         raise Stop()
 
-    step.run_subprocess = functools.partial(
+    step.run_subprocess = partial(
         step.run_subprocess,
         _popen_callable=popen_substitute,
     )