librelane 2.4.0.dev0__tar.gz → 2.4.0.dev3__tar.gz

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: librelane
-Version: 2.4.0.dev0
+Version: 2.4.0.dev3
 Summary: An infrastructure for implementing chip design flows
+Home-page: https://github.com/librelane/librelane
 License: Apache-2.0
 Author: Mohamed Gaber
 Author-email: me@donn.website
@@ -19,8 +20,7 @@ Requires-Dist: click (>=8,<9)
 Requires-Dist: cloup (>=3.0.5,<4)
 Requires-Dist: deprecated (>=1.2.10,<2)
 Requires-Dist: httpx (>=0.22.0,<0.29)
-Requires-Dist: ioplace-parser (>=0.3.0,<0.5.0)
-Requires-Dist: klayout (>=0.29.0,<0.30.0)
+Requires-Dist: klayout (>=0.29.0,<0.31.0)
 Requires-Dist: libparse (>=0.3.1,<1)
 Requires-Dist: lxml (>=4.9.0)
 Requires-Dist: psutil (>=5.9.0)
@@ -49,8 +49,10 @@ Description-Content-Type: text/markdown
 
 LibreLane is an ASIC infrastructure library based on several components including
 OpenROAD, Yosys, Magic, Netgen, CVC, KLayout and a number of custom scripts for
-design exploration and optimization, currently developed and maintained by the
-American University in Cairo Open Hardware Lab (AUCOHL.)
+design exploration and optimization, currently developed and maintained by
+members and affiliates of the
+[American University in Cairo Open Hardware Lab](https://github.com/aucohl)
+under the stewardship of the [FOSSi Foundation](https://fossi-foundation.org).
 
 A reference flow, "Classic", performs all ASIC implementation steps from RTL all
 the way down to GDSII.
@@ -142,10 +144,27 @@ If you use LibreLane in your research, please cite the following paper.
 
 ## License and Legal Info
 
-LibreLane is a trademark of the FOSSi Foundation.
+LibreLane is a trademark of the [FOSSi Foundation](https://fossi-foundation.org).
 
+LibreLane code and binaries are available under
 [The Apache License, version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt).
 
-LibreLane is based on OpenLane 2.0 by Efabless Corporation
-(https://github.com/efabless/openlane2) under the same license. 
+LibreLane is based on [OpenLane 2](https://github.com/efabless/openlane2)
+by Efabless Corporation:
+
+```
+Copyright 2022-2025 Efabless Corporation
+
+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.
+``` 
 

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/Readme.md

@@ -14,8 +14,10 @@
 
 LibreLane is an ASIC infrastructure library based on several components including
 OpenROAD, Yosys, Magic, Netgen, CVC, KLayout and a number of custom scripts for
-design exploration and optimization, currently developed and maintained by the
-American University in Cairo Open Hardware Lab (AUCOHL.)
+design exploration and optimization, currently developed and maintained by
+members and affiliates of the
+[American University in Cairo Open Hardware Lab](https://github.com/aucohl)
+under the stewardship of the [FOSSi Foundation](https://fossi-foundation.org).
 
 A reference flow, "Classic", performs all ASIC implementation steps from RTL all
 the way down to GDSII.
@@ -107,9 +109,26 @@ If you use LibreLane in your research, please cite the following paper.
 
 ## License and Legal Info
 
-LibreLane is a trademark of the FOSSi Foundation.
+LibreLane is a trademark of the [FOSSi Foundation](https://fossi-foundation.org).
 
+LibreLane code and binaries are available under
 [The Apache License, version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt).
 
-LibreLane is based on OpenLane 2.0 by Efabless Corporation
-(https://github.com/efabless/openlane2) under the same license. 
+LibreLane is based on [OpenLane 2](https://github.com/efabless/openlane2)
+by Efabless Corporation:
+
+```
+Copyright 2022-2025 Efabless Corporation
+
+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.
+``` 

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/librelane/__main__.py

@@ -1,3 +1,7 @@
+# Copyright 2025 The American University in Cairo
+#
+# Adapted from OpenLane
+#
 # Copyright 2023 Efabless Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -202,7 +206,8 @@ def print_version(ctx: click.Context, param: click.Parameter, value: bool):
         f"""
         LibreLane v{__version__}
 
-        Copyright ©2020-2023 Efabless Corporation and other contributors.
+        Copyright ©2020-2025 Efabless Corporation, The American University in
+        Cairo, and other contributors.
 
         Available under the Apache License, version 2. Included with the source code,
         but you can also get a copy at https://www.apache.org/licenses/LICENSE-2.0

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/librelane/config/config.py

@@ -102,7 +102,7 @@ class PassedDirectoryError(ValueError):
     def __init__(self, config: AnyPath) -> None:
         self.config = str(config)
         super().__init__(
-            "Passing design directories as arguments is unsupported in LibreLane 2 or higher: please pass the configuration file(s) directly."
+            "Passing design directories as arguments is unsupported in LibreLane: please pass the configuration file(s) directly."
         )
 
 
@@ -960,7 +960,7 @@ class Config(GenericImmutableDict[str, Any]):
                 pass
             if not isinstance(dis, int) or dis in [1, 2, 5] or dis > 6:
                 errors.append(
-                    f"DIODE_INSERTION_STRATEGY '{dis}' is not available in LibreLane 2 or higher. See 'Migrating DIODE_INSERTION_STRATEGY' in the docs for more info."
+                    f"DIODE_INSERTION_STRATEGY '{dis}' is not available in LibreLane 2.0 or higher. See 'Migrating DIODE_INSERTION_STRATEGY' in the docs for more info."
                 )
             else:
                 warnings.append(

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/librelane/config/variable.py

@@ -238,7 +238,7 @@ def some_of(t: Type[Any]) -> Type[Any]:
     return new_union  # type: ignore
 
 
-def repr_type(t: Type[Any]) -> str:  # pragma: no cover
+def repr_type(t: Type[Any], for_document: bool = False) -> str:  # pragma: no cover
     optional = is_optional(t)
     some = some_of(t)
 
@@ -247,18 +247,25 @@ def repr_type(t: Type[Any]) -> str:  # pragma: no cover
     else:
         type_string = str(some)
 
+    if is_dataclass(t):
+        type_string = (
+            f"{{class}}`{some.__qualname__} <{some.__module__}.{some.__qualname__}>`"
+        )
+
+    separator = "｜<br />" if for_document else "｜"
+
     if inspect.isclass(some) and issubclass(some, Enum):
-        type_string = "｜".join([str(e.name) for e in some])
+        type_string = separator.join([str(e.name) for e in some])
         type_string = f"`{type_string}`"
     else:
         origin, args = get_origin(some), get_args(some)
         if origin is not None:
             if origin == Union:
                 arg_strings = [repr_type(arg) for arg in args]
-                type_string = "｜".join(arg_strings)
+                type_string = separator.join(arg_strings)
                 type_string = f"({type_string})"
             elif origin == Literal:
-                return "｜".join([repr(arg) for arg in args])
+                return separator.join([repr(arg) for arg in args])
             else:
                 arg_strings = [repr_type(arg) for arg in args]
                 type_string = f"{type_string}[{', '.join(arg_strings)}]"
@@ -377,9 +384,7 @@ class Variable:
             for easier wrapping by web browsers/PDF renderers/what have you
         :returns: A pretty Markdown string representation of the Variable's type.
         """
-        if for_document:
-            return repr_type(self.type).replace("｜", "｜<br />")
-        return repr_type(self.type)
+        return repr_type(self.type, for_document=for_document)
 
     def desc_repr_md(self) -> str:  # pragma: no cover
         """

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/librelane/container.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-## This file is internal to LibreLane 2 and is not part of the API.
+## This file is internal to LibreLane and is not part of the API.
 import os
 import re
 import uuid

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/librelane/env_info.py

@@ -18,7 +18,7 @@
 # environment surveys. Please ensure all code as compatible as possible
 # with ancient versions of Python.
 
-## This file is internal to LibreLane 2 and is not part of the API.
+## This file is internal to LibreLane and is not part of the API.
 import os
 import re
 import sys

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/librelane/flows/classic.py

@@ -30,11 +30,8 @@ from ..steps import (
 @Flow.factory.register()
 class Classic(SequentialFlow):
     """
-    **Note: While LibreLane 2 has a stable release, the default flow is in beta
-    pending silicon validation. Use at your own risk.**
-
     A flow of type :class:`librelane.flows.SequentialFlow` that is the most
-    similar to the original LibreLane 1.0 flow, running the Verilog RTL through
+    similar to the original OpenLane flow, running the Verilog RTL through
     Yosys, OpenROAD, KLayout and Magic to produce a valid GDSII for simpler designs.
 
     This is the default when using LibreLane via the command-line.

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/librelane/flows/optimizing.py

@@ -23,7 +23,7 @@ from ..steps import Step, Yosys, OpenROAD, StepError
 from ..logging import get_log_level, set_log_level, LogLevels, success, info
 
 
-#   "Optimizing" is a custom demo flow to show what's possible with non-sequential Flows in LibreLane 2+.
+#   "Optimizing" is a custom demo flow to show what's possible with non-sequential Flows in LibreLan
 #   It works across two steps:
 #   * The Synthesis Exploration - tries multiple synthesis strategies in *parallel*.
 #       The best-performing strategy in terms of minimizing the area makes it to the next stage.

{librelane-2.4.0.dev0 → librelane-2.4.0.dev3}/librelane/scripts/odbpy/defutil.py

@@ -21,7 +21,6 @@ from decimal import Decimal
 
 from reader import click_odb, click
 from typing import Tuple, List
-from exception_codes import METAL_LAYER_ERROR, FORMAT_ERROR, NOT_FOUND_ERROR
 
 
 @click.group()
@@ -481,7 +480,7 @@ def parse_obstructions(obstructions) -> List[Tuple[str, List[int]]]:
                 f"[ERROR] Incorrectly formatted input {obs}.\n Format: layer llx lly urx ury, ...",
                 file=sys.stderr,
             )
-            sys.exit(FORMAT_ERROR)
+            sys.exit(1)
         else:
             layer = m.group("layer")
             bbox = [Decimal(x) for x in m.group("bbox").split()]
@@ -505,8 +504,8 @@ def add_obstructions(reader, input_lefs, obstructions):
         layer = obs[0]
         odb_layer = reader.tech.findLayer(layer)
         if odb_layer is None:
-            print(f"[ERROR] layer {layer} doesn't exist.", file=sys.stderr)
-            sys.exit(METAL_LAYER_ERROR)
+            print(f"[ERROR] Layer '{layer}' not found.", file=sys.stderr)
+            sys.exit(1)
         bbox = obs[1]
         dbu = reader.tech.getDbUnitsPerMicron()
         bbox = [int(x * dbu) for x in bbox]
@@ -550,8 +549,8 @@ def remove_obstructions(reader, input_lefs, obstructions):
         bbox = [int(x * dbu) for x in bbox]  # To dbus
         found = False
         if reader.tech.findLayer(layer) is None:
-            print(f"[ERROR] layer {layer} doesn't exist.", file=sys.stderr)
-            sys.exit(METAL_LAYER_ERROR)
+            print(f"[ERROR] Layer '{layer}' not found.", file=sys.stderr)
+            sys.exit(1)
         for odb_obstruction in existing_obstructions:
             odb_layer, odb_bbox, odb_obj = odb_obstruction
             if (odb_layer, odb_bbox) == (layer, bbox):
@@ -565,7 +564,7 @@ def remove_obstructions(reader, input_lefs, obstructions):
                 f"[ERROR] Obstruction on {layer} at {bbox} (DBU) not found.",
                 file=sys.stderr,
             )
-            sys.exit(NOT_FOUND_ERROR)
+            sys.exit(1)
 
 
 cli.add_command(remove_obstructions)

librelane-2.4.0.dev3/librelane/scripts/odbpy/eco_buffer.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+# Copyright 2025 Efabless Corporation
+#
+# 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.
+import sys
+from reader import click_odb, click, odb
+import grt as GRT
+
+
+def average_location(instances):
+    locations = [instance.getLocation() for instance in instances]
+    x_sum = sum(loc[0] for loc in locations)
+    y_sum = sum(loc[1] for loc in locations)
+    return (x_sum // len(locations), y_sum // len(locations))
+
+
+@click.command()
+@click_odb
+def cli(reader):
+    grt = reader.design.getGlobalRouter()
+    dpl = reader.design.getOpendp()
+
+    insts_to_temporarily_lock_then_unlock_later = []
+    for inst in reader.block.getInsts():
+        if inst.getPlacementStatus() != "LOCKED":
+            insts_to_temporarily_lock_then_unlock_later.append(
+                (inst, inst.getPlacementStatus())
+            )
+            inst.setPlacementStatus("LOCKED")
+
+    reader._grt_setup(grt)
+
+    grt_inc = GRT.IncrementalGRoute(grt, reader.block)
+    i = 0
+
+    for target_info in reader.config["INSERT_ECO_BUFFERS"]:
+        target_name, target_pin = target_info["target"].split("/")
+        name_escaped = reader.escape_verilog_name(target_name)
+        buffer_master = target_info["buffer"]
+
+        master = reader.db.findMaster(buffer_master)
+        if master is None:
+            print(
+                f"[ERROR] Buffer type '{buffer_master}' not found.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        target = reader.block.findInst(name_escaped)
+        if target is None:
+            print(f"[ERROR] Instance '{target_name}' not found.", file=sys.stderr)
+            exit(-1)
+
+        target_iterm = target.findITerm(target_pin)
+        if target_iterm is None:
+            print(
+                f"[ERROR] Pin '{target_pin}' not found for instance '{target_name}'.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        net = target_iterm.getNet()
+        if net is None:
+            print(
+                f"[ERROR] Net not found on pin '{target_pin}' of instance '{target_name}'.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        new_buf_name = f"eco_buffer_{i}"
+        new_net_name = f"eco_buffer_{i}_net"
+        while (
+            reader.block.findInst(new_buf_name) is not None
+            or reader.block.findNet(new_net_name) is not None
+        ):
+            i += 1
+            new_buf_name = f"eco_buffer_{i}"
+            new_net_name = f"eco_buffer_{i}_net"
+
+        # Prepare buffer cell, net
+        eco_buffer = odb.dbInst.create(reader.block, master, new_buf_name)
+        eco_net = odb.dbNet.create(reader.block, new_net_name)
+        buffer_iterms = eco_buffer.getITerms()
+        buffer_a = None
+        for iterm in buffer_iterms:
+            if iterm.isInputSignal():
+                buffer_a = iterm
+                break  # Exit loop once input is found
+        if buffer_a is None:
+            print(
+                f"[ERROR] Buffer {buffer_master} has no input signals.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        buffer_x = None
+        for iterm in buffer_iterms:
+            if iterm.isOutputSignal():
+                buffer_x = iterm
+                break  # Exit loop once output is found
+        if buffer_x is None:
+            print(
+                f"[ERROR] Buffer {buffer_master} has no output signals.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        location_instances = [target]
+        net_iterms = net.getITerms()
+        if target_iterm.getIoType() == "INPUT":
+            driver_iterms = [
+                iterm for iterm in net_iterms if iterm.getIoType() in ["OUTPUT"]
+            ]
+            drivers = [iterm.getInst() for iterm in driver_iterms]
+            location_instances.extend(drivers)
+
+            target_iterm.disconnect()
+            buffer_a.connect(net)
+            buffer_x.connect(eco_net)
+            target_iterm.connect(eco_net)
+        elif target_iterm.getIoType() == "OUTPUT":
+            sink_iterms = [
+                iterm for iterm in net_iterms if iterm.getIoType() in ["INPUT", "INOUT"]
+            ]
+            sinks = [iterm.getInst() for iterm in sink_iterms]
+            location_instances.extend(sinks)
+
+            target_iterm.disconnect()
+            target_iterm.connect(eco_net)
+            buffer_a.connect(eco_net)
+            buffer_x.connect(net)
+        else:
+            print(
+                f"[ERROR] {target_name}/{target_pin} is neither an INPUT or an OUTPUT and is unsupported by this script. To buffer an INOUT port, buffer its drivers instead.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        if target_info.get("placement") is not None:
+            eco_x, eco_y = target_info["placement"]
+            eco_x = reader.block.micronsToDbu(float(eco_x))
+            eco_y = reader.block.micronsToDbu(float(eco_y))
+            eco_loc = (eco_x, eco_y)
+        else:
+            eco_loc = average_location(location_instances)
+
+        eco_buffer.setOrient("R0")
+        eco_buffer.setLocation(*eco_loc)
+        eco_buffer.setPlacementStatus("PLACED")
+        grt.addDirtyNet(net)
+        grt.addDirtyNet(eco_net)
+
+    site = reader.rows[0].getSite()
+    max_disp_x = int(
+        reader.design.micronToDBU(reader.config["PL_MAX_DISPLACEMENT_X"])
+        / site.getWidth()
+    )
+    max_disp_y = int(
+        reader.design.micronToDBU(reader.config["PL_MAX_DISPLACEMENT_Y"])
+        / site.getHeight()
+    )
+    dpl.detailedPlacement(max_disp_x, max_disp_y)
+
+    grt_inc.updateRoutes(True)
+
+    for inst, previous_status in insts_to_temporarily_lock_then_unlock_later:
+        inst.setPlacementStatus(previous_status)
+
+
+if __name__ == "__main__":
+    cli()

librelane-2.4.0.dev3/librelane/scripts/odbpy/eco_diode.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+# Copyright 2025 Efabless Corporation
+#
+# 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.
+import sys
+from reader import click_odb, click, odb
+import grt as GRT
+
+
+@click.command()
+@click_odb
+def cli(reader):
+    grt = reader.design.getGlobalRouter()
+    dpl = reader.design.getOpendp()
+
+    insts_to_temporarily_lock_then_unlock_later = []
+    for inst in reader.block.getInsts():
+        if inst.getPlacementStatus() != "LOCKED":
+            insts_to_temporarily_lock_then_unlock_later.append(
+                (inst, inst.getPlacementStatus())
+            )
+            inst.setPlacementStatus("LOCKED")
+
+    reader._grt_setup(grt)
+
+    diode_master, diode_pin = reader.config["DIODE_CELL"].split("/")
+
+    # print(grt)
+    grt_inc = GRT.IncrementalGRoute(grt, reader.block)
+    i = 0
+    for target_info in reader.config["INSERT_ECO_DIODES"]:
+        target_name, target_pin = target_info["target"].split("/")
+        name_escaped = reader.escape_verilog_name(target_name)
+
+        target = reader.block.findInst(name_escaped)
+        if target is None:
+            print(
+                f"[ERROR] Instance '{target_name}' not found.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        master = reader.db.findMaster(diode_master)
+        if master is None:
+            print(
+                f"[ERROR] Cell kind '{diode_master}' not found.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        target_iterm = target.findITerm(target_pin)
+        if target_iterm is None:
+            print(
+                f"[ERROR] Pin '{target_pin}' not found for instance {target_name}.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        if target_iterm.getIoType() not in ["INPUT", "INOUT"]:
+            print(
+                f"[ERROR] Pin {target_info['target']} is an OUTPUT pin.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        net = target_iterm.getNet()
+        if net is None:
+            print(
+                f"[ERROR] Pin {target_info['target']} has no nets connected.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        eco_diode_name = f"eco_diode_{i}"
+        while reader.block.findInst(eco_diode_name) is not None:
+            i += 1
+            eco_diode_name = f"eco_diode_{i}"
+
+        eco_diode = odb.dbInst.create(
+            reader.block,
+            master,
+            eco_diode_name,
+        )
+
+        diode_iterm = eco_diode.findITerm(diode_pin)
+        if diode_iterm is None:
+            print(
+                f"[ERROR] Pin '{diode_pin}' on ECO diode not found- invalid DIODE_CELL definition.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        sys.stdout.flush()
+
+        if target_info["placement"] is not None:
+            x, y = target_info["placement"]
+            x = reader.block.micronsToDbu(float(x))
+            y = reader.block.micronsToDbu(float(y))
+        else:
+            x, y = target.getLocation()
+
+        eco_diode.setOrient("R0")
+        eco_diode.setLocation(x, y)
+        eco_diode.setPlacementStatus("PLACED")
+
+        diode_iterm.connect(net)
+        grt.addDirtyNet(net)
+
+    site = reader.rows[0].getSite()
+    max_disp_x = int(
+        reader.design.micronToDBU(reader.config["PL_MAX_DISPLACEMENT_X"])
+        / site.getWidth()
+    )
+    max_disp_y = int(
+        reader.design.micronToDBU(reader.config["PL_MAX_DISPLACEMENT_Y"])
+        / site.getHeight()
+    )
+    dpl.detailedPlacement(max_disp_x, max_disp_y)
+
+    grt_inc.updateRoutes(True)
+
+    for inst, previous_status in insts_to_temporarily_lock_then_unlock_later:
+        inst.setPlacementStatus(previous_status)
+
+    reader.design.writeDef("out.def")
+
+
+if __name__ == "__main__":
+    cli()

librelane-2.4.0.dev3/librelane/scripts/odbpy/ioplace_parser/__init__.py

@@ -0,0 +1,23 @@
+# Copyright 2025 The American University in Cairo
+#
+# Adapted from ioplace_parser
+#
+# Copyright 2020-2023 Efabless Corporation
+#
+# 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.
+"""
+This is a modified version of https://github.com/efabless/ioplace_parser that
+does NOT use Antlr4 and instead uses a custom parser that is faster and
+dependency-free.
+"""
+from .parse import Side, Order, parse