laylight 0.0.0__py3-none-any.whl

laylight/__init__.py

@@ -0,0 +1,19 @@
+from . import structure
+from .render import (
+    LayoutRenderError,
+    RenderArtifacts,
+    execute_layout_code,
+    export_layout_png,
+    new_layout,
+    render_code_to_files,
+)
+
+__all__ = [
+    "LayoutRenderError",
+    "RenderArtifacts",
+    "execute_layout_code",
+    "export_layout_png",
+    "new_layout",
+    "render_code_to_files",
+    "structure",
+]

laylight/candy.py

@@ -0,0 +1,39 @@
+import klayout.db as kdb
+
+from .technology import Technology
+
+
+class Trans:
+    def __init__(self):
+        self.t = kdb.DCplxTrans()
+
+    def move(self, dx: float, dy: float):
+        self.t = self.t * kdb.DCplxTrans(1, 0, False, dx, dy)
+        return self
+
+    def rotate(self, degree: float):
+        self.t = self.t * kdb.DCplxTrans(1, degree, False, 0, 0)
+        return self
+
+    def trans(self):
+        return self.t
+
+
+def highlight(
+    points: list[kdb.DPoint],
+    cell: kdb.Cell,
+    size=1,
+    layer=Technology.LAYER_PORT,
+    text: str | None = None,
+    add_index: bool = False,
+):
+    for out in points:
+        cell.shapes(layer).insert(
+            kdb.DBox(out.x - size, out.y + size, out.x + size, out.y - size)
+        )
+        if text is not None:
+            if add_index:
+                tt = f"{text}_{points.index(out)}"
+            else:
+                tt = text
+            cell.shapes(layer).insert(kdb.DText(tt, kdb.DTrans(out.x, out.y)))

laylight/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from core!")
+
+
+if __name__ == "__main__":
+    main()

laylight/placable.py

@@ -0,0 +1,176 @@
+from dataclasses import dataclass
+
+import klayout.db as kdb
+
+from .structure.abstract import AbstractDevice, AdhocDevice
+
+type PlaceAt = Placer.OutPort | Placer.Position | Placer.AbsPos | Placer.Trans
+
+
+class Placer:
+    _x = 0
+    _y = 0
+    _r = 0
+    _mirror = False
+    _sp: kdb.DCplxTrans = kdb.DCplxTrans()
+    _dev: AbstractDevice | None = None
+    parent: "Placer | None" = None
+    _placed = False
+    _as_output = False
+    _as_input = False
+    _anchor: str | None = None
+    _dummy = False
+
+    @dataclass(frozen=True)
+    class OutPort:
+        idx: int = 0
+
+    @dataclass(frozen=True)
+    class Position:
+        x: float = 0
+        y: float = 0
+
+    @dataclass(frozen=True)
+    class AbsPos:
+        x: float = 0
+        y: float = 0
+
+    @dataclass(frozen=True)
+    class Trans:
+        t: kdb.DCplxTrans
+
+    def __init__(self, dev: AbstractDevice | None = None):
+        self._dev = dev
+        self._anchor = None
+
+    def x(self, x: float):
+        self._x = x
+        return self
+
+    def y(self, y: float):
+        self._y = y
+        return self
+
+    def move(self, dx: float, dy: float):
+        self._x += dx
+        self._y += dy
+        return self
+
+    def rotate(self, r: float):
+        self._r = r
+        return self
+
+    def mirror(self):
+        self._mirror = True
+        return self
+
+    def _translate(self):
+        base = kdb.DCplxTrans(1, self._r, self._mirror, self._x, self._y)
+        if self._sp is not None:
+            return self._sp * base
+        return base
+
+    def then(
+        self,
+        dev: AbstractDevice,
+        at: PlaceAt = OutPort(0),
+        as_output: bool = False,
+        as_input=False,
+        anchor: str | None = None,
+        dummy=False,
+    ):
+        np = Placer(dev)
+        np._as_output = as_output
+        np._as_input = as_input
+        np._anchor = anchor
+        np._dummy = dummy
+
+        match at:
+            case Placer.OutPort(idx):
+                if self._dev is None:
+                    outputs = [kdb.DCplxTrans()]
+                else:
+                    outputs = self._dev.output()
+                child_inputs = dev.input()
+                child_input = child_inputs[0] if child_inputs else kdb.DCplxTrans()
+                np._sp = self._translate() * outputs[idx] * child_input.inverted()
+            case Placer.AbsPos(x, y):
+                np._sp = kdb.DCplxTrans(1, 0, False, x, y)
+            case Placer.Trans(t):
+                np._sp = self._translate() * t
+            case Placer.Position(x, y):
+                np._sp = self._translate() * kdb.DCplxTrans(1, 0, False, x, y)
+
+        np.parent = self
+        return np
+
+    def _chain(self) -> list["Placer"]:
+        chain = []
+        current = self
+        while current is not None:
+            chain.append(current)
+            current = current.parent
+        chain.reverse()
+        return chain
+
+    def into(self, top: kdb.Cell) -> list[kdb.DCplxTrans]:
+        """
+        Place the device into the top cell, and return the output DCplxTrans list.
+        """
+        if self.parent is not None:
+            self.parent.into(top)
+        if self._placed:
+            return []
+        if self._dev is None:
+            return []
+
+        cell = self._dev.cell()
+        if not self._dummy:
+            top.insert(kdb.DCellInstArray(cell.cell_index(), self._translate()))
+        self._placed = True
+
+        outputs = self._dev.output()
+        return [self._translate() * out for out in outputs]
+
+    @property
+    def ports_input(self) -> dict[int, list[kdb.DCplxTrans]]:
+        result: dict[int, list[kdb.DCplxTrans]] = {}
+        for depth, placer in enumerate(self._chain()):
+            if placer._dev is not None and placer._as_input:
+                inputs = placer._dev.input()
+                result[depth] = [placer._translate() * inp for inp in inputs]
+
+        return result
+
+    @property
+    def ports_output(self) -> dict[int, list[kdb.DCplxTrans]]:
+        result: dict[int, list[kdb.DCplxTrans]] = {}
+        for depth, placer in enumerate(self._chain()):
+            if placer._dev is not None and placer._as_output:
+                outputs = placer._dev.output()
+                result[depth] = [placer._translate() * out for out in outputs]
+
+        return result
+
+    def anchors(self) -> dict[str, "Placer"]:
+        result: dict[str, Placer] = {}
+        for placer in self._chain():
+            if placer._dev is None or placer._anchor is None:
+                continue
+            if placer._anchor in result:
+                raise ValueError(f"Duplicate anchor key: {placer._anchor}")
+
+            result[placer._anchor] = placer
+
+        return result
+
+    def as_dev(self, layout: kdb.Layout, name: str):
+        cell = layout.create_cell(name)
+        dev = AdhocDevice(cell, layout=layout)
+        final_outputs = self.into(dev.cell())
+        endpoints = [t for ts in self.ports_output.values() for t in ts]
+        dev.set_output(endpoints if endpoints else final_outputs)
+        inputs = [t for ts in self.ports_input.values() for t in ts]
+        dev.set_input(inputs)
+
+        return dev

laylight/render.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import tempfile
+import traceback
+import zipfile
+
+import klayout.db as kdb
+
+from .technology import Technology
+
+
+class LayoutRenderError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class RenderArtifacts:
+    gds_path: Path
+    png_path: Path
+    zip_path: Path
+    output_dir: Path
+
+
+def new_layout(top_name: str = "TOP") -> tuple[kdb.Layout, kdb.Cell, Technology]:
+    layout = kdb.Layout()
+    layout.dbu = 0.001
+    tech = Technology()
+    top = layout.create_cell(top_name)
+    return layout, top, tech
+
+
+def _build_exec_namespace(top_name: str) -> dict[str, object]:
+    layout, top, tech = new_layout(top_name)
+    return {
+        "__builtins__": __builtins__,
+        "__name__": "__laylight_render__",
+        "kdb": kdb,
+        "Technology": Technology,
+        "new_layout": new_layout,
+        "layout": layout,
+        "top": top,
+        "tech": tech,
+    }
+
+
+def _layout_from_result(result: object) -> kdb.Layout | None:
+    if isinstance(result, kdb.Layout):
+        return result
+    if isinstance(result, kdb.Cell):
+        return result.layout()
+    if isinstance(result, tuple):
+        for item in result:
+            layout = _layout_from_result(item)
+            if layout is not None:
+                return layout
+
+    layout = getattr(result, "layout", None)
+    if isinstance(layout, kdb.Layout):
+        return layout
+
+    cell = getattr(result, "cell", None)
+    if callable(cell):
+        candidate = cell()
+        if isinstance(candidate, kdb.Cell):
+            return candidate.layout()
+
+    return None
+
+
+def execute_layout_code(code: str, *, top_name: str = "TOP") -> kdb.Layout:
+    namespace = _build_exec_namespace(top_name)
+
+    try:
+        exec(compile(code, "<laylight-render>", "exec"), namespace, namespace)
+    except Exception as exc:
+        raise LayoutRenderError(
+            "Failed to execute laylight code.\n" + traceback.format_exc()
+        ) from exc
+
+    build = namespace.get("build")
+    if callable(build):
+        try:
+            result = build()
+        except Exception as exc:
+            raise LayoutRenderError(
+                "Failed to execute build().\n" + traceback.format_exc()
+            ) from exc
+
+        layout = _layout_from_result(result)
+        if layout is not None:
+            return layout
+
+    for key in ("layout", "top", "device"):
+        layout = _layout_from_result(namespace.get(key))
+        if layout is not None:
+            return layout
+
+    raise LayoutRenderError(
+        "Could not find a KLayout layout. Define a `layout` variable or a `build()` "
+        "function that returns a `kdb.Layout`, `kdb.Cell`, or a device carrying one."
+    )
+
+
+def _top_cell(layout: kdb.Layout) -> kdb.Cell:
+    top_cell = layout.top_cell()
+    if top_cell is not None:
+        return top_cell
+
+    top_cells = layout.top_cells()
+    if top_cells:
+        return top_cells[0]
+
+    raise LayoutRenderError("The rendered layout does not contain any top cell.")
+
+
+def _png_dimensions(cell: kdb.Cell, max_pixels: int) -> tuple[int, int]:
+    box = cell.dbbox()
+    if box.empty():
+        return max_pixels, max_pixels
+
+    width = max(box.width(), 1.0)
+    height = max(box.height(), 1.0)
+    if width >= height:
+        return max_pixels, max(1, round(max_pixels * (height / width)))
+    return max(1, round(max_pixels * (width / height))), max_pixels
+
+
+def export_layout_png(
+    layout: kdb.Layout,
+    output_path: str | Path,
+    *,
+    max_pixels: int = 2048,
+) -> Path:
+    try:
+        from klayout import lay as klay
+    except ImportError as exc:
+        raise LayoutRenderError(
+            "PNG export requires the full KLayout Python package with `klayout.lay`."
+        ) from exc
+
+    output = Path(output_path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+
+    cell = _top_cell(layout)
+    width, height = _png_dimensions(cell, max_pixels)
+
+    with tempfile.TemporaryDirectory(prefix="laylight-png-") as tmp_dir:
+        tmp_gds = Path(tmp_dir) / "preview.gds"
+        layout.write(str(tmp_gds))
+
+        view = klay.LayoutView()
+        view.load_layout(str(tmp_gds), False)
+        view.set_config("background-color", "#FFFFFF")
+        view.set_config("grid-visible", "false")
+        view.max_hier()
+        view.add_missing_layers()
+        view.active_cellview().cell = view.cellview(0).layout().top_cell()
+        view.zoom_fit()
+        view.save_image(str(output), width, height)
+
+    return output
+
+
+def render_code_to_files(
+    code: str,
+    output_dir: str | Path,
+    *,
+    file_stem: str = "layout",
+    top_name: str = "TOP",
+    png_max_pixels: int = 2048,
+) -> RenderArtifacts:
+    output = Path(output_dir)
+    output.mkdir(parents=True, exist_ok=True)
+
+    layout = execute_layout_code(code, top_name=top_name)
+    gds_path = output / f"{file_stem}.gds"
+    png_path = output / f"{file_stem}.png"
+    zip_path = output / f"{file_stem}.zip"
+
+    layout.write(str(gds_path))
+    export_layout_png(layout, png_path, max_pixels=png_max_pixels)
+
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as bundle:
+        bundle.write(gds_path, arcname=gds_path.name)
+        bundle.write(png_path, arcname=png_path.name)
+
+    return RenderArtifacts(
+        gds_path=gds_path,
+        png_path=png_path,
+        zip_path=zip_path,
+        output_dir=output,
+    )

laylight/render_all.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+import importlib
+import inspect
+import math
+from pathlib import Path
+import pkgutil
+
+import klayout.db as kdb
+
+from .render import export_layout_png, new_layout
+from .structure import __name__ as structure_package_name
+from .structure.abstract import AbstractDevice
+
+
+@dataclass(frozen=True)
+class RenderedDeviceImage:
+    class_name: str
+    png_path: Path
+
+
+@dataclass(frozen=True)
+class SkippedDevice:
+    qualified_name: str
+    reason: str
+
+
+@dataclass(frozen=True)
+class RenderAllResult:
+    output_dir: Path
+    rendered: list[RenderedDeviceImage]
+    skipped: list[SkippedDevice]
+
+
+def _port_points(transforms: list[kdb.DCplxTrans]) -> list[kdb.DPoint]:
+    return [kdb.DPoint(t.disp.x, t.disp.y) for t in transforms]
+
+
+def _text_region(
+    layout: kdb.Layout,
+    text: str,
+    *,
+    mag: float,
+    position: kdb.DPoint,
+) -> kdb.Region:
+    generator = kdb.TextGenerator.default_generator()
+    region = generator.text(text, layout.dbu, mag, False, 0, 0, 0)
+    region.transform(kdb.ICplxTrans(1, 0, False, position.x / layout.dbu, position.y / layout.dbu))
+    return region
+
+
+def _annotate_ports(top: kdb.Cell, device: AbstractDevice) -> None:
+    layout = top.layout()
+    box_size = max(1.5, math.sqrt(max(top.dbbox().area(), 1.0)) * 0.03)
+    text_mag = max(0.6, box_size * 0.18)
+    text_offset = kdb.DVector(box_size * 1.2, box_size * 1.2)
+
+    for prefix, transforms, layer_info in (
+        ("IN", device.input(), device.tech.LAYER_PORT_IN),
+        ("OUT", device.output(), device.tech.LAYER_PORT_OUT),
+    ):
+        port_layer = layout.layer(layer_info)
+        for index, point in enumerate(_port_points(transforms)):
+            top.shapes(port_layer).insert(
+                kdb.DBox(
+                    point.x - box_size,
+                    point.y + box_size,
+                    point.x + box_size,
+                    point.y - box_size,
+                )
+            )
+            top.shapes(port_layer).insert(
+                _text_region(
+                    layout,
+                    f"{prefix}_{index}",
+                    mag=text_mag,
+                    position=point + text_offset,
+                )
+            )
+
+
+def _load_structure_modules() -> None:
+    structure_dir = Path(__file__).with_name("structure")
+    for _, module_name, _ in pkgutil.iter_modules([str(structure_dir)]):
+        if module_name.startswith("_"):
+            continue
+        importlib.import_module(f"{structure_package_name}.{module_name}")
+
+
+def _device_subclasses() -> list[type[AbstractDevice]]:
+    _load_structure_modules()
+
+    discovered: list[type[AbstractDevice]] = []
+    seen: set[type[AbstractDevice]] = set()
+    stack = list(AbstractDevice.__subclasses__())
+
+    while stack:
+        cls = stack.pop()
+        if cls in seen:
+            continue
+        seen.add(cls)
+        stack.extend(cls.__subclasses__())
+
+        if cls.__module__.startswith(structure_package_name):
+            discovered.append(cls)
+
+    return sorted(discovered, key=lambda cls: (cls.__module__, cls.__name__))
+
+
+def _required_init_args(cls: type[AbstractDevice]) -> list[str]:
+    required: list[str] = []
+    for param in inspect.signature(cls).parameters.values():
+        if param.name == "layout":
+            continue
+        if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
+            continue
+        if param.default is inspect._empty:
+            required.append(param.name)
+    return required
+
+
+def discover_renderable_devices() -> tuple[list[type[AbstractDevice]], list[SkippedDevice]]:
+    renderable: list[type[AbstractDevice]] = []
+    skipped: list[SkippedDevice] = []
+
+    for cls in _device_subclasses():
+        qualified_name = f"{cls.__module__}.{cls.__name__}"
+        if inspect.isabstract(cls):
+            skipped.append(
+                SkippedDevice(
+                    qualified_name=qualified_name,
+                    reason="class is abstract",
+                )
+            )
+            continue
+
+        required = _required_init_args(cls)
+        if required:
+            skipped.append(
+                SkippedDevice(
+                    qualified_name=qualified_name,
+                    reason=f"missing default args: {', '.join(required)}",
+                )
+            )
+            continue
+
+        renderable.append(cls)
+
+    return renderable, skipped
+
+
+def render_device_class(
+    cls: type[AbstractDevice],
+    output_dir: str | Path,
+    *,
+    max_pixels: int = 2048,
+) -> RenderedDeviceImage:
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    layout, top, tech = new_layout(top_name=cls.__name__)
+    device = cls(layout=layout, tech=tech)
+    top.insert(kdb.DCellInstArray(device.cell().cell_index(), kdb.DCplxTrans()))
+    _annotate_ports(top, device)
+
+    png_path = output_path / f"{cls.__name__}.png"
+    export_layout_png(layout, png_path, max_pixels=max_pixels)
+    return RenderedDeviceImage(class_name=cls.__name__, png_path=png_path)
+
+
+def render_all(
+    output_dir: str | Path = "build/render_all",
+    *,
+    max_pixels: int = 2048,
+) -> RenderAllResult:
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    renderable, skipped = discover_renderable_devices()
+    rendered: list[RenderedDeviceImage] = []
+
+    for cls in renderable:
+        qualified_name = f"{cls.__module__}.{cls.__name__}"
+        try:
+            rendered.append(
+                render_device_class(cls, output_path, max_pixels=max_pixels)
+            )
+        except Exception as exc:
+            skipped.append(
+                SkippedDevice(
+                    qualified_name=qualified_name,
+                    reason=f"{type(exc).__name__}: {exc}",
+                )
+            )
+
+    return RenderAllResult(output_dir=output_path, rendered=rendered, skipped=skipped)
+
+
+def _build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Render all default-constructible AbstractDevice subclasses under "
+            "laylight.structure into PNG images."
+        )
+    )
+    parser.add_argument(
+        "--output-dir",
+        default="build/render_all",
+        help="Directory for rendered PNG files.",
+    )
+    parser.add_argument(
+        "--max-pixels",
+        type=int,
+        default=2048,
+        help="Longest side of each exported PNG.",
+    )
+    return parser
+
+
+def main() -> int:
+    args = _build_arg_parser().parse_args()
+    result = render_all(args.output_dir, max_pixels=args.max_pixels)
+
+    print(f"Rendered {len(result.rendered)} device image(s) into {result.output_dir}")
+    for item in result.rendered:
+        print(f"  - {item.class_name}: {item.png_path}")
+
+    if result.skipped:
+        print(f"Skipped {len(result.skipped)} device(s):")
+        for item in result.skipped:
+            print(f"  - {item.qualified_name}: {item.reason}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

laylight/structure/__init__.py

@@ -0,0 +1,19 @@
+# export all structure modules
+
+from .coupler import *
+from .cutback import *
+from .connection import *
+from .curve import *
+from .crossing import *
+from .grating import *
+from .metal import *
+from .mmi import *
+from .mzi import *
+from .packaging import *
+from .prober import *
+from .racetrack import *
+from .ring import *
+from .spiral import *
+from .taper import *
+from .transition import *
+from .wg import *