API

class Component(ComponentBase, kf.DKCell):
    """Canvas where you add polygons, instances and ports.

    - stores settings that you use to build the component
    - stores info that you want to use
    - can return ports by type (optical, electrical ...)
    - can return netlist for circuit simulation
    - can write to GDS, OASIS
    - can show in KLayout, matplotlib or 3D

    Properties:
        info: dictionary that includes derived properties, simulation_settings, settings (test_protocol, docs, ...)
    """

    routes: dict[str, Route] = Field(default_factory=dict)

    def dup(self, new_name: str | None = None) -> Self:
        """Copy the full cell.

        Overrides kfactory's dup() to fix pin port mapping during copy.
        kfactory builds port_mapping from ephemeral Port wrappers, but pin
        ports are BasePort objects — the id() values never match.
        """
        saved_pins = self._base.pins
        self._base.pins = []
        try:
            c = super().dup(new_name=new_name)
        finally:
            self._base.pins = saved_pins
        if saved_pins:
            port_mapping = {id(b): i for i, b in enumerate(self.ports._bases)}
            c._base.pins = [
                BasePin(
                    name=p.name,
                    kcl=self.kcl,
                    ports=[c.base.ports[port_mapping[id(port)]] for port in p.ports],
                    pin_type=p.pin_type,
                    info=p.info,
                )
                for p in saved_pins
            ]
        return c

    @override
    def write(
        self,
        filename: str | pathlib.Path,
        save_options: kdb.SaveLayoutOptions | None = None,
        convert_external_cells: bool = False,
        set_meta_data: bool = True,
        autoformat_from_file_extension: bool = True,
        deduplicate_cell_names: bool = True,
    ) -> None:
        """Write component to GDS, fixing pin metadata for kfactory compat."""
        if set_meta_data:
            self.insert_vinsts()
            self.kcl.set_meta_data()
            for ci in self.called_cells():
                kcell = self.kcl[ci]
                if not kcell._destroyed():
                    if convert_external_cells and kcell.is_library_cell():
                        kcell.convert_to_static(recursive=True)
                    kcell.set_meta_data()
                    _fix_pin_metadata(kcell)
            if convert_external_cells and self.is_library_cell():
                self.convert_to_static(recursive=True)
            self.set_meta_data()
            _fix_pin_metadata(self)
        super().write(
            filename,
            save_options=save_options,
            convert_external_cells=False,
            set_meta_data=False,
            autoformat_from_file_extension=autoformat_from_file_extension,
            deduplicate_cell_names=deduplicate_cell_names,
        )

    @property
    def layers(self) -> list[Layer]:
        return [
            (info.layer, info.datatype)
            for info in self.kcl.layout.layer_infos()
            if not self.bbox(self.kcl.layout.layer(info)).empty()
        ]

    def add(self, instances: Iterable[ComponentReference] | ComponentReference) -> None:
        if self.locked:
            raise LockedError(self)

        if not isinstance(instances, Iterable):
            instance_list = [instances]
        else:
            instance_list = list(instances)

        for instance in instance_list:
            self.kdb_cell.insert(instance.instance)

    def absorb(self, reference: ComponentReference) -> Self:
        """Absorbs polygons from ComponentReference into Component.

        Destroys the reference in the process but keeping the polygon geometry.

        Args:
            reference: Instance to be absorbed into the Component.

        """
        if self.locked:
            raise LockedError(self)
        if reference not in self.insts:
            raise ValueError(
                "The reference you asked to absorb does not exist in this Component."
            )
        reference.flatten()
        return self

    def trim(
        self,
        left: float,
        bottom: float,
        right: float,
        top: float,
        flatten: bool = False,
    ) -> None:
        """Trims the Component to a bounding box.

        Args:
            left: left coordinate of the bounding box.
            bottom: bottom coordinate of the bounding box.
            right: right coordinate of the bounding box.
            top: top coordinate of the bounding box.
            flatten: if True, flattens the Component.
        """
        if self.locked:
            raise LockedError(self)

        c = self

        domain_box = kdb.DBox(left, bottom, right, top)
        if not c.dbbox().inside(domain_box):
            kdb_cell = c.kcl.layout.clip(c.kdb_cell, kdb.DBox(left, bottom, right, top))
            c.kdb_cell.clear()
            c.kdb_cell.copy_tree(kdb_cell)
            kdb_cell.delete()
            if flatten:
                c.flatten()

    def __lshift__(self, cell: kf.ProtoTKCell[Any]) -> ComponentReference:
        """Convenience function for adding instances/references to a Component.

        Args:
            cell: The cell to be added as an instance
        """
        return self.add_ref(cell)

    def add_ref(
        self,
        component: kf.ProtoTKCell[Any],
        name: str | None = None,
        columns: int = 1,
        rows: int = 1,
        column_pitch: float = 0.0,
        row_pitch: float = 0.0,
    ) -> ComponentReference:
        """Adds a component instance reference to a Component.

        Args:
            component: The referenced component.
            name: Name of the reference.
            columns: Number of columns in the array.
            rows: Number of rows in the array.
            column_pitch: column pitch.
            row_pitch: row pitch.
        """
        if isinstance(component, ComponentAllAngle):
            raise ValueError(
                f"Use Component.add_ref_off_grid() for all angle {component.name!r}"
            )
        if not isinstance(component, kf.ProtoTKCell):
            raise ValueError(f"Expected a Component, got {type(component)}")

        if self.locked:
            raise LockedError(self)

        if rows > 1 or columns > 1:
            if rows > 1 and row_pitch == 0:
                raise ValueError(f"rows = {rows} > 1 require {row_pitch=} > 0")

            if columns > 1 and column_pitch == 0:
                raise ValueError(f"columns = {columns} > 1 require {column_pitch} > 0")

            a = kf.kdb.DVector(column_pitch, 0)
            b = kf.kdb.DVector(0, row_pitch)

            inst = self.create_inst(component, na=columns, nb=rows, a=a, b=b)
        else:
            inst = self.create_inst(component)
        if name is not None:
            inst.name = name
        return ComponentReference(kcl=self.kcl, instance=inst.instance)

    def get_paths(self, layer: LayerSpec, recursive: bool = True) -> list[kf.kdb.DPath]:
        """Returns a list of paths.

        Args:
            layer: layer to get paths from.
            recursive: if True, gets paths recursively.
        """
        from gdsfactory import get_layer

        paths: list[kf.kdb.DPath] = []

        layer = get_layer(layer)

        if recursive:
            iterator = self.kdb_cell.begin_shapes_rec(layer)
            iterator.shape_flags = kdb.Shapes.SPaths
            paths.extend(
                it.shape().dpath.transformed(it.dtrans()) for it in iterator.each()
            )
        else:
            paths.extend(
                shape.dpath
                for shape in self.kdb_cell.shapes(layer).each(kdb.Shapes.SPaths)
            )
        return paths

    def get_boxes(self, layer: LayerSpec, recursive: bool = True) -> list[kf.kdb.DBox]:
        """Returns a list of boxes.

        Args:
            layer: layer to get boxes from.
            recursive: if True, gets boxes recursively.
        """
        from gdsfactory import get_layer

        boxes: list[kf.kdb.DBox] = []

        layer = get_layer(layer)

        if recursive:
            iterator = self.kdb_cell.begin_shapes_rec(layer)
            iterator.shape_flags = kdb.Shapes.SBoxes
            boxes.extend(
                it.shape().dbox.transformed(it.dtrans()) for it in iterator.each()
            )
        else:
            boxes.extend(
                shape.dbox
                for shape in self.kdb_cell.shapes(layer).each(kdb.Shapes.SBoxes)
            )
        return boxes

    def get_labels(
        self, layer: LayerSpec, recursive: bool = True
    ) -> list[kf.kdb.DText]:
        """Returns a list of labels from the Component.

        Args:
            layer: layer to get labels from.
            recursive: if True, gets labels recursively.
        """
        from gdsfactory import get_layer

        texts: list[kf.kdb.DText] = []
        layer_enum = get_layer(layer)

        if recursive:
            iterator = self.kdb_cell.begin_shapes_rec(layer_enum)
            iterator.shape_flags = kdb.Shapes.STexts
            texts.extend(
                it.shape().dtext.transformed(it.dtrans()) for it in iterator.each()
            )
        else:
            texts.extend(
                shape.dtext
                for shape in self.kdb_cell.shapes(layer_enum).each(kdb.Shapes.STexts)
            )
        return texts

    def area(self, layer: LayerSpec) -> float:
        """Returns the area of the Component in um2."""
        from gdsfactory import get_layer

        layer_index = get_layer(layer)
        r = kdb.Region(self.kdb_cell.begin_shapes_rec(layer_index))
        r.merge()
        return float(sum(p.area2() / 2 * self.kcl.dbu**2 for p in r.each()))

    def get_polygons(
        self,
        merge: bool = False,
        by: Literal["index", "name", "tuple"] = "index",
        layers: LayerSpecs | None = None,
        smooth: float | None = None,
    ) -> dict[tuple[int, int] | str | int, list[kf.kdb.Polygon]]:
        """Returns a dict of Polygons per layer.

        Args:
            merge: if True, merges the polygons.
            by: the format of the resulting keys in the dictionary ('index', 'name', 'tuple')
            layers: list of layers to get polygons from. Defaults to all layers.
            smooth: if True, smooths the polygons.
        """
        if merge and self.locked:
            raise LockedError(self)

        from gdsfactory.functions import get_polygons

        return get_polygons(self, merge=merge, by=by, layers=layers, smooth=smooth)

    def get_region(
        self, layer: LayerSpec, merge: bool = False, smooth: float | None = None
    ) -> kdb.Region:
        """Returns a Region of the Component.

        Note that all operations that you do with the Region will be done in the database units.

        Where for most processes 1 dbu = 1 nm.

        Args:
            layer: layer to get region from.
            merge: if True, merges the region.
            smooth: if True, smooths the region by the specified amount (in um).
        """
        from gdsfactory import get_layer

        layer_index = get_layer(layer)
        r = kdb.Region(self.kdb_cell.begin_shapes_rec(layer_index))
        if smooth:
            r.smooth(self.kcl.to_dbu(smooth))
        if merge:
            r.merge()
        return r

    def get_polygons_points(
        self,
        merge: bool = False,
        scale: float | None = None,
        by: Literal["index", "name", "tuple"] = "index",
        layers: LayerSpecs | None = None,
    ) -> dict[int | str | tuple[int, int], list[npt.NDArray[np.floating[Any]]]]:
        """Returns a dict with list of points per layer.

        Args:
            merge: if True, merges the polygons.
            scale: if True, scales the points.
            by: the format of the resulting keys in the dictionary ('index', 'name', 'tuple')
            layers: list of layers to get polygons from. Defaults to all layers.
        """
        if merge and self.locked:
            raise LockedError(self)

        from gdsfactory.functions import get_polygons_points

        return get_polygons_points(self, merge=merge, scale=scale, by=by, layers=layers)

    def extract(
        self,
        layers: LayerSpecs,
        recursive: bool = True,
    ) -> Component:
        """Extracts a list of layers and adds them to a new Component.

        Args:
            layers: list of layers to extract.
            recursive: if True, extracts layers recursively and returns a flattened Component.
        """
        from gdsfactory.functions import extract

        return extract(self, layers=layers, recursive=recursive)

    def copy_layers(
        self,
        layer_map: dict[LayerSpec, LayerSpec],
        recursive: bool = False,
    ) -> Self:
        """Remaps a list of layers and returns the same Component.

        Args:
            layer_map: dictionary of layers to copy.
            recursive: if True, remaps layers recursively.
        """
        from gdsfactory import get_layer

        if recursive:
            self.locked = False

        if self.locked:
            raise LockedError(self)

        layer_index_pairs = [
            (get_layer(layer), get_layer(new_layer))
            for layer, new_layer in layer_map.items()
        ]
        kdb_cell = self.kdb_cell
        for src_layer_index, dst_layer_index in layer_index_pairs:
            kdb_cell.copy(src_layer_index, dst_layer_index)

        if recursive:
            for ci in kdb_cell.called_cells():
                child = self.kcl[ci]
                child_cell = child.kdb_cell
                was_locked = child.locked
                child.locked = False
                try:
                    for src_layer_index, dst_layer_index in layer_index_pairs:
                        child_cell.copy(src_layer_index, dst_layer_index)
                finally:
                    if was_locked:
                        child.locked = True
        return self

    def remove_layers(
        self,
        layers: LayerSpecs,
        recursive: bool = True,
    ) -> Self:
        """Removes a list of layers and returns the same Component.

        Args:
            layers: list of layers to remove.
            recursive: if True, removes layers recursively and temporarily unlocks components.
        """
        from gdsfactory import get_layer

        if recursive:
            self.locked = False

        if self.locked:
            raise LockedError(self)

        layer_indexes = self.kcl.layer_indexes()
        layer_indexes_to_remove = [get_layer(layer) for layer in layers]
        layer_indices = [
            layer for layer in layer_indexes_to_remove if layer in layer_indexes
        ]
        if not layer_indices:
            return self

        kdb_cell = self.kdb_cell
        for layer_index in layer_indices:
            kdb_cell.shapes(layer_index).clear()

        if recursive:
            for ci in kdb_cell.called_cells():
                child = self.kcl[ci]
                child_cell = child.kdb_cell
                was_locked = child.locked
                child.locked = False
                try:
                    for layer_idx in layer_indices:
                        child_cell.shapes(layer_idx).clear()
                finally:
                    if was_locked:
                        child.locked = True
        return self

    def remap_layers(
        self, layer_map: dict[LayerSpec, LayerSpec], recursive: bool = False
    ) -> Self:
        """Remaps a list of layers and returns the same Component.

        Args:
            layer_map: dictionary of layers to remap.
            recursive: if True, remaps layers recursively.
        """
        from gdsfactory import get_layer

        if self.locked:
            raise LockedError(self)

        layer_index_pairs = [
            (get_layer(layer), get_layer(new_layer))
            for layer, new_layer in layer_map.items()
        ]
        kdb_cell = self.kdb_cell
        for src_layer_index, dst_layer_index in layer_index_pairs:
            kdb_cell.move(src_layer_index, dst_layer_index)

        if recursive:
            for ci in kdb_cell.called_cells():
                child_cell = self.kcl[ci].kdb_cell
                for src_layer_index, dst_layer_index in layer_index_pairs:
                    child_cell.move(src_layer_index, dst_layer_index)
        return self

    def to_3d(
        self,
        layer_views: LayerViews | None = None,
        layer_stack: LayerStack | None = None,
        exclude_layers: Sequence[Layer] | None = None,
    ) -> Scene:
        """Return Component 3D trimesh Scene.

        Args:
            component: to extrude in 3D.
            layer_views: layer colors from Klayout Layer Properties file.
                Defaults to active PDK.layer_views.
            layer_stack: contains thickness and zmin for each layer.
                Defaults to active PDK.layer_stack.
            exclude_layers: layers to exclude.

        """
        from gdsfactory.export.to_3d import to_3d

        return to_3d(
            self,
            layer_views=layer_views,
            layer_stack=layer_stack,
            exclude_layers=exclude_layers,
        )

    def over_under(
        self,
        layer: LayerSpec,
        distance: float = 0.001,
        remove_old_layer: bool = True,
        corner_mode: int | CornerMode = 2,
    ) -> None:
        """Returns a Component over-under on a layer in the Component.

        For big components use tiled version.

        Args:
            layer: layer to perform over-under on.
            distance: distance to perform over-under in um.
            remove_old_layer: if True, removes the old layer.
            corner_mode: determines behavior around corners
        """
        from gdsfactory import get_layer

        if self.locked:
            raise LockedError(self)

        distance_dbu = self.kcl.to_dbu(distance)

        layer_index = get_layer(layer)
        region = kdb.Region(self.kdb_cell.begin_shapes_rec(layer_index))
        region.size(+distance_dbu, +distance_dbu, corner_mode).size(
            -distance_dbu, -distance_dbu, corner_mode
        )

        if remove_old_layer:
            self.remove_layers([layer])
        self.kdb_cell.shapes(layer_index).insert(region)
        self.kcl.layout.end_changes()

    def fix_spacing(
        self,
        layer: LayerSpec,
        min_space: float = 0.2,
        size_bias: float = 0.0,
    ) -> None:
        """Fixes layer spacing in the Component.

        Args:
            layer: layer to fix spacing on.
            min_space: minimum space in um.
            size_bias: optional geometry bias applied after spacing fix (um).
        """
        import gdsfactory as gf
        from gdsfactory.pdk import get_layer

        layer = get_layer(layer)
        layer_info = gf.kcl.get_info(layer)
        fix = fix_spacing_tiled(
            self.to_itype(), min_space=self.kcl.to_dbu(min_space), layer=layer_info
        )
        if size_bias:
            size_offset_dbu = self.kcl.to_dbu(size_bias)
            fix = fix.sized(+size_offset_dbu)
            fix = fix.sized(-size_offset_dbu)

        self.shapes(layer).insert(fix)

    def fix_width(
        self,
        layer: LayerSpec,
        min_width: float = 0.2,
        n_threads: int | None = None,
        tile_size: tuple[float, float] | None = None,
        overlap: int = 1,
        smooth: int | None = None,
        flatten: bool = True,
    ) -> None:
        """Fixes layer min width in the Component.

        Args:
            layer: layer to fix width on.
            min_width: minimum width in um.
            n_threads: number of threads to use for processing.
            tile_size: size of the tiles to use for processing.
            overlap: overlap between tiles.
            smooth: smooth the polygons by this amount in um.
            flatten: if True, flattens the Component before fixing width.
        """
        import gdsfactory as gf
        from gdsfactory.pdk import get_layer

        if flatten:
            self.flatten()
        layer = get_layer(layer)
        layer_info = gf.kcl.get_info(layer)

        fix = fix_width_minkowski_tiled(
            self.to_itype(),
            min_width=self.kcl.to_dbu(min_width),
            ref=layer_info,
            n_threads=n_threads,
            tile_size=tile_size,
            overlap=overlap,
            smooth=smooth,
        )
        cast(kdb.Shapes, self.shapes(layer)).clear()  # type: ignore[redundant-cast]
        self.shapes(layer).insert(fix)

    def offset(
        self,
        layer: LayerSpec,
        distance: float,
        flatten: bool = False,
        corner_mode: int | CornerMode = 2,
    ) -> None:
        """Offsets a Component layer by a distance in um.

        Args:
            layer: layer to offset the Component on.
            distance: distance to offset the Component in um.
            flatten: if True, flattens the Component before offsetting.
            corner_mode: determines behavior around corners
        """
        from gdsfactory import get_layer

        if self.locked:
            raise LockedError(self)

        if flatten:
            self.flatten()

        distance_dbu = self.kcl.to_dbu(distance)

        layer_index = get_layer(layer)
        region = kdb.Region(self.kdb_cell.begin_shapes_rec(layer_index))
        region.size(distance_dbu, distance_dbu, corner_mode)
        self.remove_layers([layer])
        self.kdb_cell.shapes(layer_index).insert(region)

        self.kcl.layout.end_changes()

    def add_polygon(self, points: _PolygonPoints, layer: LayerSpec) -> kdb.Shape | None:
        """Adds a Polygon to the Component and returns a klayout Shape.

        Args:
            points: Coordinates of the vertices of the Polygon.
            layer: layer spec to add polygon on.
        """
        from gdsfactory.pdk import get_layer

        if self.locked:
            raise LockedError(self)

        _layer = get_layer(layer)

        polygon = points_to_polygon(points)
        if isinstance(polygon, kdb.DPolygon | kdb.DSimplePolygon):
            polygon = polygon.to_itype(self.kcl.dbu)  # type: ignore[assignment]

        return self.kdb_cell.shapes(_layer).insert(polygon)

    @overload
    def plot(
        self,
        lyrdb: pathlib.Path | str | None = None,
        display_type: Literal["image", "widget"] | None = None,
        *,
        show_labels: bool = True,
        show_ruler: bool = True,
        pixel_buffer_options: PixelBufferOptions | None = None,
        return_fig: Literal[True] = True,
        ax: Axes | None = None,
    ) -> Figure: ...

    @overload
    def plot(
        self,
        lyrdb: pathlib.Path | str | None = None,
        display_type: Literal["image", "widget"] | None = None,
        *,
        show_labels: bool = True,
        show_ruler: bool = True,
        pixel_buffer_options: PixelBufferOptions | None = None,
        return_fig: Literal[False] = False,
        ax: Axes | None = None,
    ) -> None: ...

    def plot(
        self,
        lyrdb: pathlib.Path | str | None = None,
        display_type: Literal["image", "widget"] | None = None,
        *,
        show_labels: bool = True,
        show_ruler: bool = True,
        pixel_buffer_options: PixelBufferOptions | None = None,
        return_fig: bool = False,
        ax: Axes | None = None,
    ) -> Figure | None:
        """Plots the Component using klayout.

        Args:
            lyrdb: path to layer properties file.
            display_type: if "image", displays the image.
            show_labels: if True, shows labels.
            show_ruler: if True, shows ruler.
            pixel_buffer_options: options for KLayout's get_pixels_with_options.
                If None, uses default values (width=800, height=600, linewidth=0,
                oversampling=0, resolution=0).
            return_fig: if True, returns the figure.
            ax: Optional matplotlib Axes to plot on. If None, creates a new figure and axes. When specified, fig_size and dpi are determined by the provided axes' figure.
        """
        from io import BytesIO

        import matplotlib.pyplot as plt

        from gdsfactory.pdk import get_layer_views

        self.insert_vinsts()

        lyp_path = GDSDIR_TEMP / "layer_properties.lyp"
        layer_views = get_layer_views()
        layer_views.to_lyp(filepath=lyp_path)

        layout_view = lay.LayoutView()
        cell_view_index = layout_view.create_layout(True)
        layout_view.active_cellview_index = cell_view_index
        cell_view = layout_view.cellview(cell_view_index)
        layout = cell_view.layout()
        layout.assign(kf.kcl.layout)

        assert self.name is not None, "Component name is None"

        cell_view.cell = layout.cell(self.name)

        layout_view.max_hier()
        layout_view.load_layer_props(str(lyp_path))

        layout_view.add_missing_layers()
        layout_view.zoom_fit()

        layout_view.set_config("text-visible", "true" if show_labels else "false")
        layout_view.set_config("grid-show-ruler", "true" if show_ruler else "false")

        pixel_buffer = layout_view.get_pixels_with_options(
            **cast(
                dict[str, Any],
                ({"width": 800, "height": 600} | (pixel_buffer_options or {})),
            )
        )
        png_data = pixel_buffer.to_png_data()

        # Convert PNG data to NumPy array and display with matplotlib
        with BytesIO(png_data) as f:
            img_array = plt.imread(f)

        # Compute the figure dimensions based on the image size and desired DPI
        dpi = 80
        fig_width = img_array.shape[1] / dpi
        fig_height = img_array.shape[0] / dpi

        if ax is not None:
            fig = plt.gcf()  # Get the current figure (global figure, not subfigure)
        else:
            fig, ax = plt.subplots(figsize=(fig_width, fig_height), dpi=dpi)

        # Remove margins and display the image
        ax.imshow(img_array)
        ax.axis("off")  # Hide axes
        ax.set_position((0, 0, 1, 1))  # Set axes to occupy the full figure space

        plt.subplots_adjust(
            left=0, right=1, top=1, bottom=0, wspace=0, hspace=0
        )  # Remove any padding
        plt.tight_layout(pad=0)  # Ensure no space is wasted
        return fig if return_fig else None

    def plot_netlist(
        self,
        recursive: bool = False,
        with_labels: bool = True,
        font_weight: str = "normal",
        **kwargs: Any,
    ) -> nx.Graph:
        """Plots a netlist graph with networkx.

        Args:
            recursive: if True, returns a recursive netlist.
            with_labels: add label to each node.
            font_weight: normal, bold.
            kwargs: keyword arguments to get_netlist.

        Keyword Args:
            tolerance: tolerance in grid_factor to consider two ports connected.
            exclude_port_types: optional list of port types to exclude from netlisting.
            get_instance_name: function to get instance name.
            allow_multiple: False to raise an error if more than two ports share the same connection. \
                    if True, will return key: [value] pairs with [value] a list of all connected instances.
        """
        import matplotlib.pyplot as plt
        import networkx as nx

        plt.figure()
        netlist = self.get_netlist(recursive=recursive, **kwargs)
        G = nx.Graph()

        if recursive:
            pos: dict[str, tuple[float, float]] = {}
            labels: dict[str, str] = {}
            for net in netlist.values():
                nets = net.get("nets", [])
                connections = net.get("connections", {})
                connections = nets_to_connections(nets, connections)
                placements = net["placements"]
                G.add_edges_from(
                    [
                        (",".join(k.split(",")[:-1]), ",".join(v.split(",")[:-1]))
                        for k, v in connections.items()
                    ]
                )
                pos |= {k: (v["x"], v["y"]) for k, v in placements.items()}
                labels |= {k: ",".join(k.split(",")[:1]) for k in placements}

        else:
            nets = netlist.get("nets", [])
            connections = netlist.get("connections", {})
            connections = nets_to_connections(nets, connections)
            placements = netlist["placements"]
            G.add_edges_from(
                [
                    (",".join(k.split(",")[:-1]), ",".join(v.split(",")[:-1]))
                    for k, v in connections.items()
                ]
            )
            pos = {k: (v["x"], v["y"]) for k, v in placements.items()}
            labels = {k: ",".join(k.split(",")[:1]) for k in placements}

        nx.draw(
            G,
            with_labels=with_labels,
            font_weight=font_weight,
            labels=labels,
            pos=pos,
        )
        return G

    def plot_netlist_graphviz(
        self, recursive: bool = False, interactive: bool = False, splines: str = "ortho"
    ) -> None:
        """Plots a netlist graph with graphviz.

        Args:
            recursive: if True, returns a recursive netlist.
            interactive: if True, opens the graph in a browser.
            splines: ortho, spline, polyline, line, curved.
        """
        from gdsfactory.schematic import plot_graphviz

        n = self.to_graphviz(
            recursive=recursive,
        )
        plot_graphviz(n, splines=splines, interactive=interactive)

    def to_graphviz(self, recursive: bool = False) -> Digraph:
        """Returns a netlist graph with graphviz.

        Args:
            recursive: if True, returns a recursive netlist.
        """
        from gdsfactory.schematic import to_graphviz

        netlist = self.get_netlist(recursive=recursive)
        return to_graphviz(
            netlist["instances"],
            placements=netlist["placements"],
            nets=netlist["nets"],
        )

    def fill(
        self,
        fill_cell: ComponentSpec,
        fill_layers: Iterable[tuple[LayerSpec, float]] = [],
        fill_regions: Iterable[tuple[kdb.Region, float]] = [],
        exclude_layers: Iterable[tuple[LayerSpec, float]] = [],
        exclude_regions: Iterable[tuple[kdb.Region, float]] = [],
        n_threads: int | None = None,
        tile_size: tuple[float, float] | None = None,
        row_step: kdb.DVector | None = None,
        col_step: kdb.DVector | None = None,
        x_space: float = 0.0,
        y_space: float = 0.0,
        tile_border: tuple[float, float] = (20, 20),
        multi: bool = False,
    ) -> None:
        """Fill a [KCell][kfactory.kcell.KCell].

        Args:
            fill_cell: The cell used as a cell to fill the regions.
            fill_layers: Tuples of layer and keepout in um.
            fill_regions: Specific regions to fill. Also tuples like the layers.
            exclude_layers: Layers to ignore. Tuples like the fill layers
            exclude_regions: Specific regions to ignore. Tuples like the fill layers.
            n_threads: Max number of threads used. Defaults to number of cores of the
                machine.
            tile_size: Size of the tiles in um.
            row_step: DVector for steping to the next instance position in the row.
                x-coordinate must be >= 0.
            col_step: DVector for steping to the next instance position in the column.
                y-coordinate must be >= 0.
            x_space: Spacing between the fill cell bounding boxes in x-direction.
            y_space: Spacing between the fill cell bounding boxes in y-direction.
            tile_border: The tile border to consider for excludes
            multi: Use the region_fill_multi strategy instead of single fill.
        """
        from gdsfactory.pdk import get_component, get_layer_info

        fill_cell = get_component(fill_cell)
        fill_layers_converted = [
            (get_layer_info(layer), int(spacing)) for layer, spacing in fill_layers
        ]
        fill_regions_converted = [
            (region, int(spacing)) for region, spacing in fill_regions
        ]
        exclude_layers_converted = [
            (get_layer_info(layer), int(spacing)) for layer, spacing in exclude_layers
        ]
        exclude_regions_converted = [
            (region, int(spacing)) for region, spacing in exclude_regions
        ]

        fill_tiled(
            self,
            fill_cell=fill_cell,
            fill_layers=fill_layers_converted,
            fill_regions=fill_regions_converted,
            exclude_layers=exclude_layers_converted,
            exclude_regions=exclude_regions_converted,
            n_threads=n_threads,
            tile_size=tile_size,
            row_step=row_step,
            col_step=col_step,
            x_space=x_space,
            y_space=y_space,
            tile_border=tile_border,
            multi=multi,
        )