librelane 2.4.0.dev2__py3-none-any.whl → 2.4.7__py3-none-any.whl

librelane/container.py

@@ -18,7 +18,6 @@ import re
 import uuid
 import shlex
 import pathlib
-import tempfile
 import subprocess
 from typing import List, NoReturn, Sequence, Optional, Union, Tuple
 
@@ -27,15 +26,15 @@ import semver
 
 from .common import mkdirp
 from .logging import err, info, warn
-from .env_info import OSInfo
+from .env_info import ContainerInfo, OSInfo
 
-CONTAINER_ENGINE = os.getenv("OPENLANE_CONTAINER_ENGINE", "docker")
+__file_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 
 def permission_args(osinfo: OSInfo) -> List[str]:
     if (
         osinfo.kernel == "Linux"
-        and osinfo.container_info is not None
+        and isinstance(osinfo.container_info, ContainerInfo)
         and osinfo.container_info.engine == "docker"
         and not osinfo.container_info.rootless
     ):
@@ -58,10 +57,13 @@ def gui_args(osinfo: OSInfo) -> List[str]:
             args += [
                 "-e",
                 f"DISPLAY={os.environ.get('DISPLAY')}",
-                "-v",
-                "/tmp/.X11-unix:/tmp/.X11-unix",
-                "-v",
-                f"{os.path.expanduser('~')}/.Xauthority:/.Xauthority",
+            ]
+            if os.path.isdir("/tmp/.X11-unix"):
+                args += ["-v", "/tmp/.X11-unix:/tmp/.X11-unix"]
+            homedir = os.path.expanduser("~")
+            if os.path.isfile(f"{homedir}/.Xauthority"):
+                args += ["-v", f"{homedir}/.Xauthority:/.Xauthority"]
+            args += [
                 "--network",
                 "host",
                 "--security-opt",
@@ -70,9 +72,9 @@ def gui_args(osinfo: OSInfo) -> List[str]:
     return args
 
 
-def image_exists(image: str) -> bool:
+def image_exists(ce_path: str, image: str) -> bool:
     images = (
-        subprocess.check_output([CONTAINER_ENGINE, "images", image])
+        subprocess.check_output([ce_path, "images", image])
         .decode("utf8")
         .rstrip()
         .split("\n")[1:]
@@ -116,14 +118,14 @@ def remote_manifest_exists(image: str) -> bool:
     return True
 
 
-def ensure_image(image: str) -> bool:
-    if image_exists(image):
+def ensure_image(ce_path: str, image: str) -> bool:
+    if image_exists(ce_path, image):
         return True
 
     try:
-        subprocess.check_call([CONTAINER_ENGINE, "pull", image])
+        subprocess.check_call([ce_path, "pull", image])
     except subprocess.CalledProcessError:
-        err(f"Failed to pull image {image} from the container registries.")
+        err(f"Failed to pull image '{image}' from the container registries.")
         return False
 
     return True
@@ -150,6 +152,22 @@ def sanitize_path(path: Union[str, os.PathLike]) -> Tuple[str, str]:
     return (abspath, mountable_path)
 
 
+def container_version_error(input: str, against: str) -> Optional[str]:
+    if input == "UNKNOWN":
+        return (
+            "Could not determine version for %s. You may encounter unexpected issues."
+        )
+    if semver.compare(input, against) < 0:
+        return f"Your %s version ({input}) is out of date. You may encounter unexpected issues."
+    return None
+
+
+def ubuntu_version_at_least(current: str, minimum: str) -> bool:
+    if current == "UNKNOWN":
+        return False
+    return tuple(map(int, current.split("."))) >= tuple(map(int, minimum.split(".")))
+
+
 def run_in_container(
     image: str,
     args: Sequence[str],
@@ -169,20 +187,31 @@ def run_in_container(
             f"Unsupported host operating system '{osinfo.kernel}'. You may encounter unexpected issues."
         )
 
-    if osinfo.container_info is None:
+    if not isinstance(osinfo.container_info, ContainerInfo):
         raise FileNotFoundError("No compatible container engine found.")
 
-    if osinfo.container_info.engine.lower() == "docker":
-        if semver.compare(osinfo.container_info.version, "25.0.5") < 0:
+    ce_path = osinfo.container_info.path
+    assert ce_path is not None
+
+    engine_name = osinfo.container_info.engine.lower()
+    if engine_name == "docker":
+        if error := container_version_error(osinfo.container_info.version, "25.0.5"):
+            warn(error % engine_name)
+    elif engine_name == "podman":
+        if osinfo.distro.lower() == "ubuntu" and not ubuntu_version_at_least(
+            osinfo.distro_version, "24.04"
+        ):
             warn(
-                f"Your Docker engine version ({osinfo.container_info.version}) is out of date. You may encounter unexpected issues."
+                "Versions of Podman for Ubuntu before Ubuntu 24.04 are generally pretty buggy. We recommend using Docker instead if possible."
             )
+        elif error := container_version_error(osinfo.container_info.version, "4.1.0"):
+            warn(error % engine_name)
     else:
         warn(
-            f"Unsupported container engine '{osinfo.container_info.engine}'. You may encounter unexpected issues."
+            f"Unsupported container engine referenced by '{osinfo.container_info.path}'. You may encounter unexpected issues."
         )
 
-    if not ensure_image(image):
+    if not ensure_image(ce_path, image):
         raise ValueError(f"Failed to use image '{image}'.")
 
     terminal_args = ["-i"]
@@ -222,15 +251,6 @@ def run_in_container(
         mount_args += ["-v", f"{from_cwd}:{to_cwd}"]
     mount_args += ["-w", to_cwd]
 
-    tempdir = tempfile.mkdtemp("librelane_docker")
-
-    mount_args += [
-        "-v",
-        f"{tempdir}:/tmp",
-        "-e",
-        "TMPDIR=/tmp",
-    ]
-
     if other_mounts is not None:
         for mount in other_mounts:
             if os.path.isdir(mount):
@@ -242,9 +262,13 @@ def run_in_container(
 
     container_id = str(uuid.uuid4())
 
+    if os.getenv("_MOUNT_HOST_LIBRELANE") == "1":
+        host_librelane_pythonpath = os.path.dirname(__file_dir__)
+        mount_args += ["-v", f"{host_librelane_pythonpath}:/host_librelane"]
+
     cmd = (
         [
-            CONTAINER_ENGINE,
+            ce_path,
             "run",
             "--rm",
             "--name",
@@ -261,4 +285,4 @@ def run_in_container(
     info("Running containerized command:")
     print(shlex.join(cmd))
 
-    os.execlp(CONTAINER_ENGINE, *cmd)
+    os.execlp(ce_path, *cmd)

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/examples/hold_eco_demo/config.yaml

@@ -0,0 +1,18 @@
+DESIGN_NAME: hold_violation
+CLOCK_PORT: clk
+CLOCK_PERIOD: 5
+VERILOG_FILES: dir::demo.v
+RUN_POST_CTS_RESIZER_TIMING: false
+RUN_POST_GRT_RESIZER_TIMING: false
+FP_SIZING: absolute
+DIE_AREA: [0, 0, 100, 100]
+INSERT_ECO_BUFFERS:
+  - target: u_ff1/Q
+    buffer: sky130_fd_sc_hd__buf_1
+  - target: u_ff1/Q
+    buffer: sky130_fd_sc_hd__buf_1
+meta:
+  flow: Classic
+  substituting_steps:
+    "+OpenROAD.DetailedRouting": "Odb.InsertECOBuffers"
+    "+Odb.InsertECOBuffers": "OpenROAD.DetailedRouting"

librelane/examples/hold_eco_demo/demo.v

@@ -0,0 +1,27 @@
+module hold_violation(
+    input clk,
+    input d,
+    output q
+);
+    wire intermediate;
+    wire clk_delayed;
+
+    sky130_fd_sc_hd__clkbuf_4 dly (
+        .A(clk),
+        .X(clk_delayed)
+    );
+
+    sky130_fd_sc_hd__dfrtp_4 u_ff1 (
+        .CLK(clk),
+        .D(d),
+        .RESET_B(1'b1),
+        .Q(intermediate)
+    );
+
+    sky130_fd_sc_hd__dfrtp_1 u_ff2 (
+        .CLK(clk_delayed),
+        .D(intermediate),
+        .RESET_B(1'b1),
+        .Q(q)
+    );
+endmodule

librelane/flows/cli.py

@@ -35,7 +35,7 @@ from cloup.typing import Decorator
 
 from .flow import Flow
 from ..common import set_tpe, cli, get_opdks_rev, _get_process_limit
-from ..logging import set_log_level, verbose, err, options, LogLevels
+from ..logging import set_log_level, verbose, info, err, options, LogLevels
 from ..state import State, InvalidState
 
 
@@ -146,27 +146,30 @@ def cloup_flow_opts(
     function decorated with @cloup.command (https://cloup.readthedocs.io/en/stable/autoapi/cloup/index.html#cloup.command).
 
     The following keyword arguments will be passed to the decorated function.
+
     * Those postfixed ‡ are compatible with the constructor for :class:`Flow`.
     * Those postfixed § are compatible with the :meth:`Flow.start`.
 
+    ---
+
     * Flow configuration options (if parameter ``config_options`` is ``True``):
         * ``flow_name``: ``Optional[str]``: A valid flow ID to be used with :meth:`Flow.factory.get`
-        * ``config_override_strings``‡: ``Optional[Iterable[str]]``
+        * ``config_override_strings`` ‡: ``Optional[Iterable[str]]``
     * Sequential flow controls (if parameter ``sequential_flow_controls`` is ``True``)
-        * ``frm``§: ``Optional[str]``: Start from a step with this ID. Supported by sequential flows.
-        * ``to``§: ``Optional[str]``: Stop at a step with this id. Supported by sequential flows.
-        * ``skip``§: ``Iterable[str]``: Skip these steps. Supported by sequential flows.
+        * ``frm`` §: ``Optional[str]``: Start from a step with this ID. Supported by sequential flows.
+        * ``to`` §: ``Optional[str]``: Stop at a step with this id. Supported by sequential flows.
+        * ``skip`` §: ``Iterable[str]``: Skip these steps. Supported by sequential flows.
     * Sequential flow reproducible (if parameter ``sequential_flow_reproducible`` is ``True``)
-        * ``reproducible``§: ``str``: Create a reproducible for a step with is ID, aborting the flow afterwards. Supported by sequential flows.
+        * ``reproducible`` §: ``str``: Create a reproducible for a step with is ID, aborting the flow afterwards. Supported by sequential flows.
     * Flow run options (if parameter ``run_options`` is ``True``):
-        * ``tag``§: ``Optional[str]``
-        * ``last_run``§: ``bool``: If ``True``, ``tag`` is guaranteed to be None.
-        * ``with_initial_state``§: ``Optional[State]``
+        * ``tag`` §: ``Optional[str]``
+        * ``last_run`` §: ``bool``: If ``True``, ``tag`` is guaranteed to be None.
+        * ``with_initial_state`` §: ``Optional[State]``
     * PDK options
-        * ``use_volare``: ``bool``
-        * ``pdk_root``‡: ``Optional[str]``
-        * ``pdk``‡: ``str``
-        * ``scl``‡: ``Optional[str]``
+        * ``use_volare`` : ``bool``
+        * ``pdk_root`` ‡: ``Optional[str]``
+        * ``pdk`` ‡: ``str``
+        * ``scl`` ‡: ``Optional[str]``
     * ``config_files``: ``Iterable[str]``: Paths to configuration files (if
       parameter  ``accept_config_files`` is ``True``)
 
@@ -443,16 +446,29 @@ def cloup_flow_opts(
                         err(f"Could not resolve the PDK '{pdk}'.")
                         exit(1)
 
-                    version = ciel.fetch(
-                        ciel_home,
-                        pdk_family,
-                        opdks_rev,
-                        data_source=StaticWebDataSource(
-                            "https://fossi-foundation.github.io/ciel-releases"
-                        ),
-                        include_libraries=include_libraries,
-                    )
-                    pdk_root = version.get_dir(ciel_home)
+                    if pdk_family == "ihp-sg13g2":
+                        err(
+                            "The IHP Open PDK is only supported in the development version of LibreLane, specifically 3.0.0.dev28 or higher."
+                        )
+                        info(
+                            "If you're using Nix, switch to the 'dev' branch. If you're using the Python package, run \"python3 -m pip install 'librelane>=3.0.0.dev28'\"."
+                        )
+                        exit(1)
+
+                    try:
+                        version = ciel.fetch(
+                            ciel_home,
+                            pdk_family,
+                            opdks_rev,
+                            data_source=StaticWebDataSource(
+                                "https://fossi-foundation.github.io/ciel-releases"
+                            ),
+                            include_libraries=include_libraries,
+                        )
+                        pdk_root = version.get_dir(ciel_home)
+                    except ValueError as e:
+                        err(f"Failed to download PDK: {e}")
+                        exit(1)
 
                 return f(*args, pdk_root=pdk_root, pdk=pdk, scl=scl, **kwargs)