librelane 3.0.0.dev25__tar.gz → 3.0.0.dev26__tar.gz

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: librelane
-Version: 3.0.0.dev25
+Version: 3.0.0.dev26
 Summary: An infrastructure for implementing chip design flows
 Home-page: https://github.com/librelane/librelane
 License: Apache-2.0

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/common/__init__.py

@@ -43,6 +43,7 @@ from .misc import (
     Filter,
     get_latest_file,
     process_list_file,
+    count_occurences,
     _get_process_limit,
 )
 from .types import (

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/common/drc.py

@@ -287,6 +287,7 @@ class DRC:
         from lxml import etree as ET
 
         with ET.xmlfile(out, encoding="utf8", buffered=False) as xf:
+            xf.write_declaration()
             with xf.element("report-database"):
                 # 1. Cells
                 with xf.element("cells"):

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/common/misc.py

@@ -11,16 +11,18 @@
 # 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.
-import fnmatch
-import glob
-import gzip
+import io
 import os
-import pathlib
 import re
+import glob
+import gzip
 import typing
+import pathlib
+import fnmatch
 import unicodedata
 from math import inf
 from typing import (
+    IO,
     Any,
     Generator,
     Iterable,
@@ -378,7 +380,7 @@ def _get_process_limit() -> int:
     return int(os.getenv("_OPENLANE_MAX_CORES", os.cpu_count() or 1))
 
 
-def gzopen(filename, mode="rt"):
+def gzopen(filename: AnyPath, mode="rt") -> IO[Any]:
     """
     This method (tries to?) emulate the gzopen from the Linux Standard Base,
     specifically this part:
@@ -388,6 +390,11 @@ def gzopen(filename, mode="rt"):
     for reading directly from the file without any decompression.
 
     gzip.open does not have this behavior.
+
+    :param filename: The full path to the uncompressed or gzipped file.
+    :param mode: "r", "rb", "w", "wb", "x", "xb", "a" or "ab" for
+        binary mode, or "rt", "wt", "xt" or "at" for text mode.
+    :returns: An I/O wrapper that may very slightly based on the mode.
     """
     try:
         g = gzip.open(filename, mode=mode)
@@ -400,3 +407,18 @@ def gzopen(filename, mode="rt"):
     except gzip.BadGzipFile:
         g.close()
         return open(filename, mode=mode)
+
+
+def count_occurences(fp: io.TextIOWrapper, pattern: str = "") -> int:
+    """
+    Counts the occurences of a certain string in a stream, line-by-line, without
+    necessarily loading the entire file into memory.
+
+    Equivalent to: ``grep -c 'pattern' <file>`` (but without regex support).
+
+    :param fp: the text stream
+    :param pattern: the substring to search for. if set to "", it will simply
+        count the lines in the file.
+    :returns: the number of matching lines
+    """
+    return sum(pattern in line for line in fp)

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/common/types.py

@@ -16,6 +16,7 @@ import sys
 import tempfile
 from math import isfinite
 from decimal import Decimal
+from weakref import finalize
 from collections import UserString
 from typing import Any, Union, ClassVar, Tuple, Optional
 
@@ -112,6 +113,4 @@ class ScopedFile(Path):
         super().__init__(self._ntf.name)
         self._ntf.write(contents)
         self._ntf.close()
-
-    def __del__(self):
-        os.unlink(self._ntf.name)
+        self._ntf_cleanup = finalize(self, os.unlink, self._ntf.name)

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/config/__main__.py

@@ -110,7 +110,7 @@ def create_config(
                 print("At least one source RTL file is required.", file=sys.stderr)
                 exit(1)
     source_rtl_key = "VERILOG_FILES"
-    if not all((file.endswith(".sv") or file.endswith(".v")) for file in source_rtl):
+    if not all(file.endswith(".sv") or file.endswith(".v") for file in source_rtl):
         print(
             "Only Verilog/SystemVerilog files are supported by create-config.",
             file=sys.stderr,

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/config/variable.py

@@ -440,6 +440,9 @@ class Variable:
             return_value = list()
             raw = value
             if isinstance(raw, list) or isinstance(raw, tuple):
+                if validating_type == List[Path]:
+                    if any(isinstance(item, List) for item in raw):
+                        Variable.__flatten_list(value)
                 pass
             elif is_string(raw):
                 if not permissive_typing:
@@ -725,3 +728,16 @@ class Variable:
             and self.type == rhs.type
             and self.default == rhs.default
         )
+
+    # Flatten list. Note: Must modify value, not return a new list.
+    @staticmethod
+    def __flatten_list(value: list):
+        new_list = []
+        for item in value:
+            if isinstance(item, list):
+                for sub_item in item:
+                    new_list.append(sub_item)
+            else:
+                new_list.append(item)
+
+        value[:] = new_list

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/flows/flow.py

@@ -375,7 +375,7 @@ class Flow(ABC):
         self.progress_bar = FlowProgressBar(self.name)
 
     @classmethod
-    def get_help_md(Self) -> str:  # pragma: no cover
+    def get_help_md(Self, myst_anchors: bool = True) -> str:  # pragma: no cover
         """
         :returns: rendered Markdown help for this Flow
         """
@@ -383,10 +383,12 @@ class Flow(ABC):
         if Self.__doc__:
             doc_string = textwrap.dedent(Self.__doc__)
 
+        flow_anchor = f"(flow-{slugify(Self.__name__, lower=True)})="
+
         result = (
             textwrap.dedent(
                 f"""\
-                (flow-{slugify(Self.__name__, lower=True)})=
+                {flow_anchor * myst_anchors}
                 ### {Self.__name__}
 
                 ```{{eval-rst}}
@@ -426,7 +428,8 @@ class Flow(ABC):
             for var in flow_config_vars:
                 units = var.units or ""
                 pdk_superscript = "<sup>PDK</sup>" if var.pdk else ""
-                result += f"| `{var.name}`{{#{var._get_docs_identifier(Self.__name__)}}}{pdk_superscript} | {var.type_repr_md()} | {var.desc_repr_md()} | `{var.default}` | {units} |\n"
+                var_anchor = f"{{#{var._get_docs_identifier(Self.__name__)}}}"
+                result += f"| `{var.name}`{var_anchor * myst_anchors} {pdk_superscript} | {var.type_repr_md()} | {var.desc_repr_md()} | `{var.default}` | {units} |\n"
             result += "\n"
 
         if len(Self.Steps):
@@ -438,10 +441,35 @@ class Flow(ABC):
                     name = step.name
                 else:
                     name = step.id
-                result += f"* [`{step.id}`](./step_config_vars.md#{slugify(name)})\n"
+                if myst_anchors:
+                    result += (
+                        f"* [`{step.id}`](./step_config_vars.md#{slugify(name)})\n"
+                    )
+                else:
+                    result += f"* {step.id}"
 
         return result
 
+    @classmethod
+    def display_help(Self):  # pragma: no cover
+        """
+        Displays Markdown help for a given flow.
+
+        If in an IPython environment, it's rendered using ``IPython.display``.
+        Otherwise, it's rendered using ``rich.markdown``.
+        """
+        try:
+            get_ipython()  # type: ignore
+
+            import IPython.display
+
+            IPython.display.display(IPython.display.Markdown(Self.get_help_md()))
+        except NameError:
+            from ..logging import console
+            from rich.markdown import Markdown
+
+            console.log(Markdown(Self.get_help_md()))
+
     def get_all_config_variables(self) -> List[Variable]:
         """
         :returns: All configuration variables for this Flow, including
@@ -796,7 +824,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"),
@@ -852,38 +879,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]
+
+        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
+        ## 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)
 
-        # Step-specific
+        ## flow logs
+        mkdirp(openlane_signoff_dir)
+        copy_dir_contents(self.run_dir, openlane_signoff_dir, "*.log")
+
+        ### 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):
@@ -894,6 +950,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-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/scripts/magic/def/mag_gds.tcl

@@ -24,6 +24,7 @@ if { $::env(MAGIC_MACRO_STD_CELL_SOURCE) == "PDK" } {
 }
 
 read_extra_gds
+read_extra_lef
 
 load (NEWCELL)
 
@@ -77,5 +78,3 @@ if { $::env(MAGIC_GDS_POLYGON_SUBCELLS) } {
 
 gds write $::env(SAVE_MAG_GDS)
 puts "\[INFO\] GDS Write Complete"
-
-exit 0

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/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-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/scripts/magic/gds/extras_mag.tcl

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

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/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-3.0.0.dev25 → librelane-3.0.0.dev26}/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-3.0.0.dev25 → librelane-3.0.0.dev26}/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-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/scripts/magic/wrapper.tcl

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

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/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-3.0.0.dev25 → librelane-3.0.0.dev26}/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-3.0.0.dev25 → librelane-3.0.0.dev26}/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
@@ -209,14 +211,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-3.0.0.dev25 → librelane-3.0.0.dev26}/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,
     )

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/steps/magic.py

@@ -14,7 +14,6 @@
 import os
 import re
 import shutil
-import functools
 import subprocess
 from signal import SIGKILL
 from decimal import Decimal
@@ -34,7 +33,8 @@ from .tclstep import TclStep
 from ..state import DesignFormat, State
 
 from ..config import Variable
-from ..common import get_script_dir, DRC as DRCObject, Path, mkdirp
+from ..common import get_script_dir, DRC as DRCObject, Path, mkdirp, count_occurences
+from ..logging import warn
 
 
 DesignFormat(
@@ -480,6 +480,12 @@ class SpiceExtraction(MagicStep):
             "Extracts a SPICE netlist based on black-boxed standard cells and macros (basically, anything with a LEF) rather than transistors. An error will be thrown if both this and `MAGIC_EXT_USE_GDS` is set to ``True``.",
             default=False,
         ),
+        Variable(
+            "MAGIC_FEEDBACK_CONVERSION_THRESHOLD",
+            int,
+            "If Magic provides more feedback items than this threshold, conversion to KLayout databases is skipped (as something has gone horribly wrong.)",
+            default=10000,
+        ),
     ]
 
     def get_script_path(self):
@@ -497,22 +503,29 @@ class SpiceExtraction(MagicStep):
 
         views_updates, metrics_updates = super().run(state_in, env=env, **kwargs)
 
-        cif_scale = Decimal(open(os.path.join(self.step_dir, "cif_scale.txt")).read())
         feedback_path = os.path.join(self.step_dir, "feedback.txt")
+        with open(feedback_path, encoding="utf8") as f:
+            illegal_overlap_count = count_occurences(f, "Illegal overlap")
+
+        metrics_updates["magic__illegal_overlap__count"] = illegal_overlap_count
+        threshold = self.config["MAGIC_FEEDBACK_CONVERSION_THRESHOLD"]
+        if illegal_overlap_count > threshold:
+            warn(
+                f"Not converting the feedback to the KLayout database format: {illegal_overlap_count} > MAGIC_FEEDBACK_CONVERSION_THRESHOLD ({threshold}). You may manually increase the threshold, but it might take forever."
+            )
+            return views_updates, metrics_updates
+
+        cif_scale = Decimal(open(os.path.join(self.step_dir, "cif_scale.txt")).read())
         try:
             se_feedback, _ = DRCObject.from_magic_feedback(
                 open(feedback_path, encoding="utf8"),
                 cif_scale,
                 self.config["DESIGN_NAME"],
             )
-            illegal_overlap_count = functools.reduce(
-                lambda a, b: a + len(b.bounding_boxes),
-                [
-                    v
-                    for v in se_feedback.violations.values()
-                    if "Illegal overlap" in v.description
-                ],
-                0,
+            illegal_overlap_count = sum(
+                len(v.bounding_boxes)
+                for v in se_feedback.violations.values()
+                if "Illegal overlap" in v.description
             )
             with open(os.path.join(self.step_dir, "feedback.xml"), "wb") as f:
                 se_feedback.to_klayout_xml(f)
@@ -521,9 +534,6 @@ class SpiceExtraction(MagicStep):
             self.warn(
                 f"Failed to convert SPICE extraction feedback to KLayout database format: {e}"
             )
-            metrics_updates["magic__illegal_overlap__count"] = (
-                open(feedback_path, encoding="utf8").read().count("Illegal overlap")
-            )
         return views_updates, metrics_updates
 
 

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/steps/odb.py

@@ -17,7 +17,6 @@ import json
 import shutil
 from math import inf
 from decimal import Decimal
-from functools import reduce
 from abc import abstractmethod
 from dataclasses import dataclass
 from typing import Dict, List, Literal, Optional, Tuple
@@ -418,9 +417,7 @@ class ManualMacroPlacement(OdbpyStep):
             )
             shutil.copyfile(cfg_ref, cfg_file)
         elif macros := self.config.get("MACROS"):
-            instance_count = reduce(
-                lambda x, y: x + len(y.instances), macros.values(), 0
-            )
+            instance_count = sum(len(m.instances) for m in macros.values())
             if instance_count >= 1:
                 with open(cfg_file, "w") as f:
                     for module, macro in macros.items():

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/steps/openroad.py

@@ -19,7 +19,6 @@ import io
 import os
 import re
 import json
-import functools
 import subprocess
 import textwrap
 import pathlib
@@ -1313,9 +1312,7 @@ def get_psm_error_count(rpt: io.TextIOWrapper) -> int:
 
     sio.seek(0)
     violations = yaml.load(sio, Loader=yaml.SafeLoader) or []
-    return functools.reduce(
-        lambda acc, current: acc + len(current["srcs"]), violations, 0
-    )
+    return sum(len(violation["srcs"]) for violation in violations)
 
 
 @Step.factory.register()

{librelane-3.0.0.dev25 → librelane-3.0.0.dev26}/librelane/steps/step.py

@@ -619,6 +619,7 @@ class Step(ABC):
         *,
         docstring_override: str = "",
         use_dropdown: bool = False,
+        myst_anchors: bool = False,
     ):  # pragma: no cover
         """
         Renders Markdown help for this step to a string.
@@ -676,11 +677,12 @@ class Step(ABC):
                 result += f"| {input_str} | {output_str} |\n"
 
         if len(Self.config_vars):
+            all_vars_anchor = f"({Self.id.lower()}-configuration-variables)="
             result += textwrap.dedent(
                 f"""
-                ({Self.id.lower()}-configuration-variables)=
+                {all_vars_anchor * myst_anchors}
                 #### Configuration Variables
-
+                
                 | Variable Name | Type | Description | Default | Units |
                 | - | - | - | - | - |
                 """
@@ -688,13 +690,15 @@ class Step(ABC):
             for var in Self.config_vars:
                 units = var.units or ""
                 pdk_superscript = "<sup>PDK</sup>" if var.pdk else ""
-                result += f"| `{var.name}`{{#{var._get_docs_identifier(Self.id)}}}{pdk_superscript} | {var.type_repr_md(for_document=True)} | {var.desc_repr_md()} | `{var.default}` | {units} |\n"
+                var_anchor = f"{{#{var._get_docs_identifier(Self.id)}}}"
+                result += f"| `{var.name}`{var_anchor * myst_anchors} {pdk_superscript} | {var.type_repr_md(for_document=True)} | {var.desc_repr_md()} | `{var.default}` | {units} |\n"
             result += "\n"
 
+        step_anchor = f"(step-{slugify(Self.id.lower())})="
         result = (
             textwrap.dedent(
                 f"""
-                (step-{slugify(Self.id.lower())})=
+                {step_anchor * myst_anchors}
                 ### {Self.__get_desc()}
                 """
             )
@@ -706,11 +710,22 @@ class Step(ABC):
     @classmethod
     def display_help(Self):  # pragma: no cover
         """
-        IPython-only. Displays Markdown help for a given step.
+        Displays Markdown help for this Step.
+
+        If in an IPython environment, it's rendered using ``IPython.display``.
+        Otherwise, it's rendered using ``rich.markdown``.
         """
-        import IPython.display
+        try:
+            get_ipython()  # type: ignore
+
+            import IPython.display
+
+            IPython.display.display(IPython.display.Markdown(Self.get_help_md()))
+        except NameError:
+            from ..logging import console
+            from rich.markdown import Markdown
 
-        IPython.display.display(IPython.display.Markdown(Self.get_help_md()))
+            console.log(Markdown(Self.get_help_md()))
 
     def _repr_markdown_(self) -> str:  # pragma: no cover
         """