lambdapdk 0.1.36__py3-none-any.whl → 0.1.38__py3-none-any.whl

lambdapdk/__init__.py

@@ -1,7 +1,7 @@
 import siliconcompiler.package as sc_package
 
 
-__version__ = "0.1.36"
+__version__ = "0.1.38"
 
 
 def register_data_source(chip):
@@ -20,10 +20,10 @@ def get_pdks():
     Returns a list of pdk names in lambdapdk
     '''
 
-    from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130
+    from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130, interposer
 
     all_pdks = []
-    for pdk_mod in [asap7, freepdk45, sky130, gf180, ihp130]:
+    for pdk_mod in [asap7, freepdk45, sky130, gf180, ihp130, interposer]:
         pdks = pdk_mod.setup()
         if not isinstance(pdks, (list, tuple)):
             pdks = [pdks]
@@ -43,6 +43,7 @@ def get_libs():
     from lambdapdk.sky130.libs import sky130sc, sky130io, sky130sram
     from lambdapdk.gf180.libs import gf180mcu, gf180io, gf180sram
     from lambdapdk.ihp130.libs import sg13g2_stdcell, sg13g2_sram
+    from lambdapdk.interposer.libs import bumps as interposer_bumps
 
     all_libs = []
     for lib_mod in [
@@ -50,7 +51,8 @@ def get_libs():
             nangate45, fakeram45,
             sky130sc, sky130io, sky130sram,
             gf180mcu, gf180io, gf180sram,
-            sg13g2_stdcell, sg13g2_sram]:
+            sg13g2_stdcell, sg13g2_sram,
+            interposer_bumps]:
         libs = lib_mod.setup()
         if not isinstance(libs, (list, tuple)):
             libs = [libs]

lambdapdk/ihp130/libs/sg13g2_sram.py

@@ -15,7 +15,7 @@ def setup():
         path_base = 'ihp-sg13g2/libs.ref/sg13g2_sram'
         lib.add('output', stackup, 'lef', f'{path_base}/lef/{mem_name}.lef')
         lib.add('output', stackup, 'gds', f'{path_base}/gds/{mem_name}.gds')
-        lib.add('output', stackup, 'cdl', f'{path_base}/spice/{mem_name}.cdl')
+        lib.add('output', stackup, 'cdl', f'{path_base}/cdl/{mem_name}.cdl')
 
         lib.add('output', 'typ', 'nldm', f'{path_base}/lib/{mem_name}_typ_1p20V_25C.lib')
         lib.add('output', 'slow', 'nldm', f'{path_base}/lib/{mem_name}_slow_1p08V_125C.lib')

lambdapdk/interposer/__init__.py

@@ -0,0 +1,111 @@
+import os
+import siliconcompiler
+from lambdapdk import register_data_source
+
+
+stackups = []
+for m in ("3ML", "4ML", "5ML"):
+    for w in ("0400", "0800", "2000", "0400_2000"):
+        stackups.append(f'{m}_{w}')
+
+
+####################################################
+# PDK Setup
+####################################################
+def setup():
+    '''
+    The interposer PDK is a passive technology with a number of
+    simulated stackups. The PDK contains enablement for place and
+    route tools and design rule signoff.
+    Note that this process design kit is provided as an academic
+    and research aid only and the resulting designs are not manufacturable.
+    '''
+
+    foundry = 'virtual'
+    process = 'interposer'
+
+    libtype = 'none'
+
+    node = 130
+    # TODO: dummy numbers, only matter for cost estimation
+    wafersize = 300
+    hscribe = 0.1
+    vscribe = 0.1
+    edgemargin = 2
+
+    pdkdir = os.path.join('lambdapdk', 'interposer', 'base')
+
+    pdk = siliconcompiler.PDK(process, package='lambdapdk')
+    register_data_source(pdk)
+
+    # process name
+    pdk.set('pdk', process, 'foundry', foundry)
+    pdk.set('pdk', process, 'node', node)
+    pdk.set('pdk', process, 'version', 'v0.0.1')
+    pdk.set('pdk', process, 'stackup', stackups)
+    pdk.set('pdk', process, 'wafersize', wafersize)
+    pdk.set('pdk', process, 'edgemargin', edgemargin)
+    pdk.set('pdk', process, 'scribe', (hscribe, vscribe))
+
+    # APR Setup
+    for stackup in stackups:
+        for tool in ('openroad', 'klayout', 'magic'):
+            pdk.set('pdk', process, 'aprtech', tool, stackup, libtype, 'lef',
+                    pdkdir + f'/apr/{stackup}.lef')
+
+        pdk.set('pdk', process, 'minlayer', stackup, 'metal1')
+        pdk.set('pdk', process, 'maxlayer', stackup, 'topmetal')
+
+        # DRC Runsets
+        pdk.set('pdk', process, 'drc', 'runset', 'klayout', stackup, 'drc',
+                pdkdir + f'/setup/klayout/{stackup}.drc')
+
+        key = 'drc_params:drc'
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'input=<input>')
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'topcell=<topcell>')
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'report=<report>')
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'threads=<threads>')
+
+        # Layer map and display file
+        pdk.set('pdk', process, 'layermap', 'klayout', 'def', 'gds', stackup,
+                pdkdir + f'/apr/{stackup}.layermap')
+        pdk.set('pdk', process, 'display', 'klayout', stackup,
+                pdkdir + f'/setup/klayout/{stackup}.lyp')
+
+        pdk.set('pdk', process, 'aprtech', 'openroad', stackup, libtype, 'fill',
+                pdkdir + f'/dfm/openroad/{stackup}.fill.json')
+
+        # Openroad global routing grid derating
+        openroad_layer_adjustments = {
+            'metal1': 0.20,
+            'metal2': 0.20,
+            'metal3': 0.20,
+            'metal4': 0.20,
+            'metal5': 0.20,
+            'metal6': 0.20,
+            'topmetal': 0.20
+        }
+        for layer, adj in openroad_layer_adjustments.items():
+            if layer != 'topmetal' and int(layer[-1]) >= int(stackup[0]):
+                continue
+            pdk.set('pdk', process, 'var', 'openroad', f'{layer}_adjustment', stackup, adj)
+
+        pdk.set('pdk', process, 'var', 'openroad', 'rclayer_signal', stackup, 'metal2')
+        pdk.set('pdk', process, 'var', 'openroad', 'rclayer_clock', stackup, 'metal2')
+
+        pdk.set('pdk', process, 'var', 'openroad', 'pin_layer_vertical', stackup, 'metal2')
+        pdk.set('pdk', process, 'var', 'openroad', 'pin_layer_horizontal', stackup, 'metal3')
+
+        # PEX
+        for corner in ["minimum", "typical", "maximum"]:
+            pdk.set('pdk', process, 'pexmodel', 'openroad', stackup, corner,
+                    pdkdir + '/pex/openroad/' + stackup + '.' + corner + '.tcl')
+
+    return pdk
+
+
+#########################
+if __name__ == "__main__":
+    pdk = setup()
+    pdk.write_manifest(f'{pdk.top()}.json')
+    pdk.check_filepaths()

lambdapdk/interposer/_generator.py

@@ -0,0 +1,533 @@
+import json
+import os
+
+from jinja2 import Environment, FileSystemLoader
+import xml.etree.ElementTree as ET
+import xml.dom.minidom
+
+template_dir = os.path.join(os.path.dirname(__file__), 'base', 'templates')
+jinja2_env = Environment(loader=FileSystemLoader(template_dir))
+
+
+LICENSE = '''Copyright 2024 ZeroASIC Corp
+
+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
+
+     https://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.
+'''
+
+
+def __get_gds_type_name(gds_type):
+    if gds_type == 0:
+        return ""
+    if gds_type == 10:
+        return "pin"
+    if gds_type == 20:
+        return "text"
+    if gds_type == 30:
+        return "fill"
+
+    raise ValueError(str(gds_type))
+
+
+def make_metal_layer(
+        name,
+        gds_mapping,
+        direction,
+        min_width,
+        min_spacing,
+        resistance_per_um,
+        capacitance_per_um,
+        max_width=None):
+
+    layer = {
+        "name": name,
+        "type": "ROUTING",
+        "direction": direction,
+        "gds": gds_mapping,
+        "width": {
+            "min": min_width
+        },
+        "spacing": {
+            "min": min_spacing
+        },
+        "parasitic": {
+            "resistance": resistance_per_um,
+            "capacitance": capacitance_per_um
+        }
+    }
+
+    if max_width:
+        layer["width"]["max"] = max_width
+
+    return layer
+
+
+def make_cut_layer(
+        name,
+        gds_mapping,
+        width,
+        min_spacing,
+        enclosure_bot,
+        enclosure_top,
+        resistance_per_cut):
+
+    layer = {
+        "name": name,
+        "type": "CUT",
+        "gds": gds_mapping,
+        "width": {
+            "min": width
+        },
+        "spacing": {
+            "min": min_spacing
+        },
+        "enclosure": {
+            "bottom": enclosure_bot,
+            "top": enclosure_top
+        },
+        "parasitic": {
+            "resistance": resistance_per_cut
+        }
+    }
+
+    return layer
+
+
+def build_tech(layer_count, name=None, width=None):
+    if not isinstance(width, (tuple, list)):
+        width = layer_count * [width]
+
+    layers = []
+    gds_layer = 1
+    for n in range(layer_count):
+        layeridx = n + 1
+
+        metal_name = f"metal{layeridx}"
+        max_width = 5.0
+        if layeridx == layer_count:
+            metal_name = "topmetal"
+            gds_layer = 100
+            max_width = None
+
+        layers.append(
+            make_metal_layer(
+                metal_name,
+                {
+                    "number": gds_layer,
+                    "types": {
+                        "NET": 0,
+                        "SPNET": 0,
+                        "PIN": 10,
+                        "LEFPIN": 10,
+                        "FILL": 30
+                    },
+                    "name": {
+                        "PIN": 20,
+                        "SPNET": 20,
+                        "TEXT": 20
+                    }
+                },
+                "HORIZONTAL" if layeridx % 2 == 1 else "VERTICAL",
+                min_width=width[n],
+                min_spacing=width[n],
+                resistance_per_um=1.5000e-03,
+                capacitance_per_um=1.0000E-01,
+                max_width=max_width
+            ))
+
+        if layeridx != layer_count:
+            layers.append(
+                make_cut_layer(
+                    f"via{layeridx}",
+                    {
+                        "number": gds_layer + 1,
+                        "types": {
+                            "NET": 0,
+                            "SPNET": 0,
+                            "PIN": 10,
+                            "LEFPIN": 10,
+                            "FILL": 30
+                        },
+                        "name": {
+                            "PIN": 20,
+                            "SPNET": 20,
+                            "TEXT": 20
+                        }
+                    },
+                    width[n] / 2,
+                    width[n] / 2,
+                    width[n] / 2,
+                    width[n] / 2,
+                    resistance_per_cut=10e-3
+                ))
+        gds_layer += 2
+
+    if not name:
+        name = f"{layer_count}ML"
+
+    tech = {
+        "name": name,
+        "grid": 0.005,
+        "layers": layers,
+        "outline": (0, 0)
+    }
+
+    return tech
+
+
+def build_layermap(tech, path):
+    layermap = []
+    for layer in tech["layers"]:
+        name = layer["name"]
+        gds_number = layer["gds"]["number"]
+
+        for map_type, gds_type in layer["gds"]["types"].items():
+            layermap.append((
+                name,
+                map_type,
+                str(gds_number),
+                str(gds_type)
+            ))
+
+        for map_type, gds_type in layer["gds"]["name"].items():
+            layermap.append((
+                "NAME",
+                f"{name}/{map_type}",
+                str(gds_number),
+                str(gds_type)
+            ))
+
+    layermap.append((
+        "DIEAREA",
+        "ALL",
+        str(tech["outline"][0]),
+        str(tech["outline"][1])
+    ))
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.layermap', 'w') as f:
+        f.write(
+            jinja2_env.get_template('layermap.j2').render(
+                license=LICENSE,
+                layers=layermap
+            )
+        )
+        f.write('\n')
+
+
+def build_openroad_pex(tech, path):
+    corners = {
+        "maximum": 0.3,
+        "typical": 0.0,
+        "minimum": -0.3
+    }
+
+    for corner, adjustment in corners.items():
+        metals = []
+        vias = []
+        for layer in tech["layers"]:
+            name = layer["name"]
+
+            if layer["type"] == "ROUTING":
+                metals.append((
+                    name,
+                    layer["parasitic"]["resistance"]*(1+adjustment),
+                    layer["parasitic"]["capacitance"]*(1+adjustment)
+                ))
+            else:
+                vias.append((
+                    name,
+                    layer["parasitic"]["resistance"]*(1+adjustment)
+                ))
+
+        os.makedirs(path, exist_ok=True)
+        with open(f'{path}/{tech["name"]}.{corner}.tcl', 'w') as f:
+            f.write(
+                jinja2_env.get_template('pex.tcl.j2').render(
+                    license=LICENSE,
+                    metals=metals,
+                    vias=vias
+                )
+            )
+            f.write('\n')
+
+
+def build_klayout_drc(tech, path):
+    layers = []
+
+    for n, layer in enumerate(tech["layers"]):
+        layer_nm = {
+            "name": layer["name"],
+            "type": layer["type"],
+            "width": {
+                "min": int(layer["width"]["min"] * 1000)
+            },
+            "spacing": {
+                "min": int(layer["spacing"]["min"] * 1000)
+            }
+        }
+
+        if "max" in layer["width"]:
+            layer_nm["width"]["max"] = int(layer["width"]["max"] * 1000)
+
+        if layer["type"] == "CUT":
+            layer_nm["enclosure"] = {
+                "bottom": (
+                    tech["layers"][n - 1]["name"],
+                    int(layer["enclosure"]["bottom"] * 1000)
+                ),
+                "top": (
+                    tech["layers"][n + 1]["name"],
+                    int(layer["enclosure"]["top"] * 1000)
+                )
+            }
+
+        gds_types = sorted(set(layer["gds"]["types"].values()))
+        layer_nm["gds"] = [
+            (layer["gds"]["number"], gds_type) for gds_type in gds_types
+        ]
+
+        layers.append(layer_nm)
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.drc', 'w') as f:
+        f.write(
+            jinja2_env.get_template('drc.j2').render(
+                license=LICENSE,
+                grid=int(tech["grid"] * 1000),
+                layers=layers,
+                outline={"number": tech["outline"][0], "type": tech["outline"][1]}
+            )
+        )
+        f.write('\n')
+
+
+def build_klayout_layer_properties(tech, path):
+    colors = [
+        "#ffc280",
+        "#ff9d9d",
+        "#ff80a8",
+        "#c080ff",
+        "#9580ff",
+        "#8086ff",
+        "#80a8ff",
+        "#ff0000",
+        "#ff0080",
+        "#ff00ff",
+        "#8000ff",
+        "#91ff00",
+        "#008000",
+        "#508000",
+        "#808000",
+        "#805000"
+    ]
+    patterns = [
+        "I5",
+        "I9"
+    ]
+
+    layeridx = 0
+
+    def make_layer(name, gds):
+        prop = ET.Element("properties")
+
+        color = colors[layeridx % len(colors)]
+        pattern = patterns[layeridx % len(patterns)]
+
+        for tag, value in [
+                ("frame-color", color),
+                ("frame-brightness", "0"),
+                ("fill-color", color),
+                ("fill-brightness", "0"),
+                ("dither-pattern", pattern),
+                ("line-style", None),
+                ("value", "true"),
+                ("visible", "true"),
+                ("transparent", "false"),
+                ("width", "1"),
+                ("marked", "false"),
+                ("xfill", "false"),
+                ("animation", "0"),
+                ("name", name),
+                ("source", f"{name} {gds[0]}/{gds[1]}@1")
+                ]:
+            el = ET.Element(tag)
+
+            if value is not None:
+                el.text = value
+            prop.append(el)
+
+        return prop
+
+    props = ET.Element("layer-properties")
+    props.append(make_layer("outline", (tech["outline"][0], tech["outline"][1])))
+    layeridx += 1
+    for layer in tech["layers"]:
+        gds_types = sorted(set([*layer["gds"]["types"].values(), *layer["gds"]["name"].values()]))
+        for gds_type in gds_types:
+            name = layer["name"]
+            gds_name = __get_gds_type_name(gds_type)
+            if gds_type:
+                name += "." + gds_name
+            props.append(make_layer(name, (layer["gds"]["number"], gds_type)))
+
+            layeridx += 1
+
+    props.insert(0, ET.Comment(f"\n{LICENSE}"))
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.lyp', 'w') as f:
+        f.write(
+            xml.dom.minidom.parseString(
+                ET.tostring(props)).toprettyxml(indent="  "))
+
+
+def build_lef(tech, path):
+    vias = []
+    for n, layer in enumerate(tech["layers"]):
+        if layer["type"] == "ROUTING":
+            continue
+        bottom_layer = tech["layers"][n - 1]
+        top_layer = tech["layers"][n + 1]
+
+        name = layer["name"].upper() + "_1"
+
+        cut_egde = layer["width"]["min"]
+        cut = (-cut_egde / 2, -cut_egde / 2, cut_egde / 2, cut_egde / 2)
+        bot = (cut[0] - layer["enclosure"]['bottom'], cut[1] - layer["enclosure"]['bottom'],
+               cut[2] + layer["enclosure"]['bottom'], cut[3] + layer["enclosure"]['bottom'])
+        top = (cut[0] - layer["enclosure"]['top'], cut[1] - layer["enclosure"]['top'],
+               cut[2] + layer["enclosure"]['top'], cut[3] + layer["enclosure"]['top'])
+
+        vias.append({
+            "name": name,
+            "layers": [
+                (layer["name"], [f"{v:.3f}" for v in cut]),
+                (bottom_layer["name"], [f"{v:.3f}" for v in bot]),
+                (top_layer["name"], [f"{v:.3f}" for v in top])
+            ]})
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.lef', 'w') as f:
+        f.write(
+            jinja2_env.get_template('lef.j2').render(
+                license=LICENSE,
+                grid=tech["grid"],
+                layers=tech["layers"],
+                vias=vias
+            )
+        )
+
+
+def build_openroad_fill(tech, path):
+    fill = {"layers": {}}
+
+    for layer in tech["layers"]:
+        if layer["type"] == "CUT":
+            continue
+
+        max_spacing = 5 * layer["spacing"]["min"]
+
+        max_width = 10 * layer["width"]["min"]
+        if "max" in layer["width"]:
+            max_width = layer["width"]["max"]
+
+        shapes = []
+        for ratio in (1.0, 0.75, 0.5, 0.25, 0.0):
+            width = layer["width"]["min"] + ratio * (max_width - layer["width"]["min"])
+            width = tech["grid"] * round(width / tech["grid"])
+
+            shapes.append(width)
+
+        fill["layers"][layer["name"]] = {
+            "name": layer["name"],
+            "layer": layer["gds"]["number"],
+            "datatype": layer["gds"]["types"]["NET"],
+            "space_to_outline": max_spacing,
+            "non-opc": {
+                "datatype": layer["gds"]["types"]["FILL"],
+                "width": shapes,
+                "height": shapes,
+                "space_to_fill": layer["spacing"]["min"],
+                "space_to_non_fill": max_spacing
+            }
+        }
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.fill.json', 'w') as f:
+        json.dump(fill, f, indent=2)
+
+
+def build_readme(stackups):
+    from lambdapdk import interposer
+
+    for stackup in stackups:
+        metals = []
+        for layer in stackup["tech"]["layers"]:
+            if layer["type"] == "ROUTING":
+                metals.append((
+                    layer["name"],
+                    f'{int(layer["width"]["min"] * 1000)}nm',
+                    f'{int(layer["spacing"]["min"] * 1000)}nm'
+                ))
+        stackup["metalstack"] = reversed(metals)
+
+    with open('README.md', 'w') as f:
+        f.write(
+            jinja2_env.get_template('README.md.j2').render(
+                desc=interposer.setup.__doc__,
+                license=LICENSE,
+                stackups=stackups
+            )
+        )
+
+
+if __name__ == "__main__":
+    def tapered_metal(layer_count):
+        mid = int(layer_count // 2)
+        widths = mid * [0.4]
+        if layer_count % 2 != 0:
+            widths += [0.8]
+        widths += mid * [2.0]
+        return widths
+
+    tech_specs = {
+        "0400": 0.4,
+        "0800": 0.8,
+        "2000": 2.0,
+        "0400_2000": tapered_metal
+    }
+
+    stackups = []
+
+    for name, width in tech_specs.items():
+        for layer_count in range(3, 6):
+            tech_name = f"{layer_count}ML_{name}"
+
+            widths = width
+            if not isinstance(widths, (int, float, list, tuple)):
+                widths = widths(layer_count)
+
+            tech = build_tech(layer_count, name=tech_name, width=widths)
+            stackups.append({
+                "name": tech_name,
+                "tech": tech
+            })
+
+            build_lef(tech, 'base/apr')
+            build_layermap(tech, 'base/apr')
+            build_klayout_layer_properties(tech, 'base/setup/klayout')
+            build_klayout_drc(tech, 'base/setup/klayout')
+            build_openroad_pex(tech, 'base/pex/openroad')
+            build_openroad_fill(tech, 'base/dfm/openroad')
+
+    build_readme(stackups)

lambdapdk/interposer/libs/bumps.py

@@ -0,0 +1,31 @@
+import os
+import siliconcompiler
+from lambdapdk import register_data_source
+from lambdapdk.interposer import stackups
+
+
+def setup():
+    '''
+    Interposer bump library
+    '''
+    libdir = "lambdapdk/interposer/libs/bumps/"
+
+    lib = siliconcompiler.Library('interposer_bumps', package='lambdapdk')
+    register_data_source(lib)
+
+    # pdk
+    lib.set('option', 'pdk', 'interposer')
+
+    for stackup in stackups:
+        lib.set('output', stackup, 'lef',
+                os.path.join(libdir, 'lef/bumps.lef'))
+        lib.add('output', stackup, 'gds',
+                os.path.join(libdir, 'gds/bumps.gds'))
+
+    return lib
+
+
+#########################
+if __name__ == "__main__":
+    lib = setup(siliconcompiler.Chip('<lib>'))
+    lib.write_manifest(f'{lib.top()}.json')

{lambdapdk-0.1.36.dist-info → lambdapdk-0.1.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lambdapdk
-Version: 0.1.36
+Version: 0.1.38
 Summary: Library of open source Process Design Kits
 Author: Zero ASIC
 License: Apache License
@@ -204,8 +204,9 @@ Requires-Dist: flake8 ==7.1.1 ; extra == 'test'
 Requires-Dist: pytest ==8.3.3 ; extra == 'test'
 Requires-Dist: pytest-timeout ==2.3.1 ; extra == 'test'
 Requires-Dist: tclint ==0.4.2 ; extra == 'test'
-Requires-Dist: lambdalib ==0.2.10 ; extra == 'test'
+Requires-Dist: lambdalib ==0.3.0 ; extra == 'test'
 Requires-Dist: sc-leflib ==0.4.0 ; extra == 'test'
+Requires-Dist: Jinja2 ==3.1.4 ; extra == 'test'
 
 # Lambdapdk Introduction
 
@@ -221,6 +222,7 @@ Supported PDKs:
 * [Skywater130](lambdapdk/sky130/base/README.md)
 * [Global Foundries 180](lambdapdk/gf180/README.md)
 * [IHP 180](https://github.com/IHP-GmbH/IHP-Open-PDK)
+* [interposer](lambdapdk/interposer/README.md)
 
 # License
 

{lambdapdk-0.1.36.dist-info → lambdapdk-0.1.38.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lambdapdk/__init__.py,sha256=YzM7xvtEuCHwtRdhQroeJO2mWZNgUZPvwDeRf1D5nf0,1649
+lambdapdk/__init__.py,sha256=EZLKri_azp9QL_rw8M1BDkJgI0_HacsVGi9zKD_qHl0,1771
 lambdapdk/asap7/__init__.py,sha256=Tb3du7LEisL_YoXVzVZgy9NqC835F79a9zqlV0MwBO0,4571
 lambdapdk/asap7/libs/asap7sc7p5t.py,sha256=mKymeYPmNTHgxfwyIShxUN5hO1iAzgx2MWoBbfPkChU,6159
 lambdapdk/asap7/libs/fakeio7.py,sha256=t4OQ7uljg4jh14bf3o4wsnI5gNkLEVpMs1drispc7LE,978
@@ -11,14 +11,17 @@ lambdapdk/gf180/libs/gf180io.py,sha256=6WgsALOaKWYG6RfNFz6sg36zmfZZFl2HnsDWOWYy1
 lambdapdk/gf180/libs/gf180mcu.py,sha256=NPwcviynLMXRlkvAdwNrp8sJxHzT78PE0Iwy-DNpgzA,6727
 lambdapdk/gf180/libs/gf180sram.py,sha256=uNtf4JOaT6wlD7D6hN5XwCoIOPmAXkVxSJXQuqNdY6k,2140
 lambdapdk/ihp130/__init__.py,sha256=dSXwH5rYOrJc9C3FTe9bxCJw9VZaK0fnRBMWaWT9NY8,5500
-lambdapdk/ihp130/libs/sg13g2_sram.py,sha256=3D5MKweUeOpWTHmtESbt8AyddjAvcpw9SeSbz4cfFG4,1887
+lambdapdk/ihp130/libs/sg13g2_sram.py,sha256=oFg89-kKvuBBI9IsdGkuTsG9Q8i4gzImF66MXMXY4Fk,1885
 lambdapdk/ihp130/libs/sg13g2_stdcell.py,sha256=i92vJvo2bur2lL9YKtyrZ2kDP8QiqmbTqWnSQeSiKhE,5085
+lambdapdk/interposer/__init__.py,sha256=UEAxcCLo-0OheGNCOTLpwnF05HFAz3agStFBTdcgS58,4039
+lambdapdk/interposer/_generator.py,sha256=Uf9i7gfjgntUpLmxsRmOfzfgh26iQ3nfZmrdIx59UtA,15016
+lambdapdk/interposer/libs/bumps.py,sha256=-b3cNOUBKhzzxoWI1Y047g9Ev3a_mXBMLKO3BaHo1sI,771
 lambdapdk/sky130/__init__.py,sha256=PXJEa-siz7HStlvDTCI794evU8qbHl472gHckSrZFWc,4124
 lambdapdk/sky130/libs/sky130io.py,sha256=wFmN9RC98f6OFM5E5acCUgPe35tVTKciJzIcUBlmumo,2029
 lambdapdk/sky130/libs/sky130sc.py,sha256=wW6sAaPpuqqCDqUD2cdJZJXqQz6KRLz9xztQ-hLNaC8,9446
 lambdapdk/sky130/libs/sky130sram.py,sha256=ILjAjbgDdvfiWqmjmj8mmHvU7YiYGZVHGO7jmyajnaY,1489
-lambdapdk-0.1.36.dist-info/LICENSE,sha256=2TIhku7H905BsYloYoCwat2JsdkGYc_qsnvU-p7P-IQ,10766
-lambdapdk-0.1.36.dist-info/METADATA,sha256=QReOv697L6LXL0Vq6xgYh2D8XygEBFPqphqQOfcqrHY,13835
-lambdapdk-0.1.36.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-lambdapdk-0.1.36.dist-info/top_level.txt,sha256=5wk8psZwCcQgSjOlWTihBeDkSIViGn8I3j5yALbs59s,10
-lambdapdk-0.1.36.dist-info/RECORD,,
+lambdapdk-0.1.38.dist-info/LICENSE,sha256=2TIhku7H905BsYloYoCwat2JsdkGYc_qsnvU-p7P-IQ,10766
+lambdapdk-0.1.38.dist-info/METADATA,sha256=oul15DbF0GpVcV4tKvCEDcIN7GdLLYSwrkEY9BVBsf8,13929
+lambdapdk-0.1.38.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+lambdapdk-0.1.38.dist-info/top_level.txt,sha256=5wk8psZwCcQgSjOlWTihBeDkSIViGn8I3j5yALbs59s,10
+lambdapdk-0.1.38.dist-info/RECORD,,

{lambdapdk-0.1.36.dist-info → lambdapdk-0.1.38.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any