pyedb 0.28.0__py3-none-any.whl → 0.29.0__py3-none-any.whl

pyedb/configuration/cfg_s_parameter_models.py

@@ -24,37 +24,93 @@ from pathlib import Path
 
 
 class CfgSParameterModel:
-    def __init__(self, pdata, path_lib, sparam_dict):
-        self._pedb = pdata._pedb
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", "")
+        self.component_definition = kwargs.get("component_definition", "")
+        self.file_path = kwargs.get("file_path", "")
+        self.apply_to_all = kwargs.get("apply_to_all", False)
+        self.components = kwargs.get("components", [])
+        self.reference_net = kwargs.get("reference_net", "")
+        self.reference_net_per_component = kwargs.get("reference_net_per_component", {})
+        self.pin_order = kwargs.get("pin_order", None)
+
+
+class CfgSParameters:
+    def __init__(self, pedb, data, path_lib=None):
+        self._pedb = pedb
         self.path_libraries = path_lib
-        self._sparam_dict = sparam_dict
-        self.name = self._sparam_dict.get("name", "")
-        self.component_definition = self._sparam_dict.get("component_definition", "")
-        self.file_path = self._sparam_dict.get("file_path", "")
-        self.apply_to_all = self._sparam_dict.get("apply_to_all", False)
-        self.components = self._sparam_dict.get("components", [])
-        self.reference_net = self._sparam_dict.get("reference_net", "")
-        self.reference_net_per_component = self._sparam_dict.get("reference_net_per_component", {})
+        self.s_parameters_models = [CfgSParameterModel(**i) for i in data]
 
     def apply(self):
-        fpath = self.file_path
-        if not Path(fpath).anchor:
-            fpath = str(Path(self.path_libraries) / fpath)
-        comp_def = self._pedb.definitions.component[self.component_definition]
-        comp_def.add_n_port_model(fpath, self.name)
-        comp_list = dict()
-        if self.apply_to_all:
-            comp_list.update(
-                {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in self.components}
-            )
-        else:
-            comp_list.update(
-                {refdes: comp for refdes, comp in comp_def.components.items() if refdes in self.components}
-            )
+        for s_param in self.s_parameters_models:
+            fpath = s_param.file_path
+            if not Path(fpath).anchor:
+                fpath = str(Path(self.path_libraries) / fpath)
+            comp_def = self._pedb.definitions.component[s_param.component_definition]
+            if s_param.pin_order:
+                comp_def.set_properties(pin_order=s_param.pin_order)
+            comp_def.add_n_port_model(fpath, s_param.name)
+            comp_list = dict()
+            if s_param.apply_to_all:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in s_param.components}
+                )
+            else:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
+                )
 
-        for refdes, comp in comp_list.items():
-            if refdes in self.reference_net_per_component:
-                ref_net = self.reference_net_per_component[refdes]
+            for refdes, comp in comp_list.items():
+                if refdes in s_param.reference_net_per_component:
+                    ref_net = s_param.reference_net_per_component[refdes]
+                else:
+                    ref_net = s_param.reference_net
+                comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
+
+    def get_data_from_db(self):
+        db_comp_def = self._pedb.definitions.component
+        for name, compdef_obj in db_comp_def.items():
+            nport_models = compdef_obj.component_models
+            if not nport_models:
+                continue
             else:
-                ref_net = self.reference_net
-            comp.use_s_parameter_model(self.name, reference_net=ref_net)
+                pin_order = compdef_obj.get_properties()["pin_order"]
+                temp_comps = compdef_obj.components
+                for model_name, model_obj in nport_models.items():
+                    temp_comp_list = []
+                    reference_net_per_component = {}
+                    for i in temp_comps.values():
+                        s_param_model = i.model_properties.get("s_parameter_model")
+                        if s_param_model:
+                            if s_param_model["model_name"] == model_name:
+                                temp_comp_list.append(i.refdes)
+                                reference_net_per_component[i.refdes] = s_param_model["reference_net"]
+                        else:
+                            continue
+
+                    self.s_parameters_models.append(
+                        CfgSParameterModel(
+                            name=model_name,
+                            component_definition=name,
+                            file_path=model_obj.reference_file,
+                            apply_to_all=False,
+                            components=temp_comp_list,
+                            reference_net_per_component=reference_net_per_component,
+                            pin_order=pin_order,
+                        )
+                    )
+
+        data = []
+        for i in self.s_parameters_models:
+            data.append(
+                {
+                    "name": i.name,
+                    "component_definition": i.component_definition,
+                    "file_path": i.file_path,
+                    "apply_to_all": i.apply_to_all,
+                    "components": i.components,
+                    "reference_net_per_component": i.reference_net_per_component,
+                    "pin_order": i.pin_order,
+                }
+            )
+        return data

pyedb/configuration/configuration.py

@@ -117,10 +117,6 @@ class Configuration:
         # Configure components
         self.cfg_data.components.apply()
 
-        # Configure padstacks
-        if self.cfg_data.padstacks:
-            self.cfg_data.padstacks.apply()
-
         # Configure pin groups
         self.cfg_data.pin_groups.apply()
 
@@ -145,9 +141,12 @@ class Configuration:
         else:
             self.cfg_data.stackup.apply()
 
+        # Configure padstacks
+        if self.cfg_data.padstacks:
+            self.cfg_data.padstacks.apply()
+
         # Configure S-parameter
-        for s_parameter_model in self.cfg_data.s_parameters:
-            s_parameter_model.apply()
+        self.cfg_data.s_parameters.apply()
 
         # Configure SPICE models
         for spice_model in self.cfg_data.spice_models:
@@ -293,6 +292,10 @@ class Configuration:
             data["operations"] = self.cfg_data.operations.get_data_from_db()
         if kwargs.get("padstacks", False):
             data["padstacks"] = self.cfg_data.padstacks.get_data_from_db()
+        if kwargs.get("s_parameters", False):
+            data["s_parameters"] = self.cfg_data.s_parameters.get_data_from_db()
+        if kwargs.get("boundaries", False):
+            data["boundaries"] = self.cfg_data.boundaries.get_data_from_db()
 
         return data
 
@@ -307,6 +310,10 @@ class Configuration:
         nets=True,
         pin_groups=True,
         operations=True,
+        components=True,
+        boundaries=True,
+        s_parameters=True,
+        padstacks=True,
     ):
         """Export the configuration data from layout to a file.
 
@@ -330,22 +337,39 @@ class Configuration:
             Whether to export pin groups.
         operations : bool
             Whether to export operations.
+        components : bool
+            Whether to export component.
+        boundaries : bool
+            Whether to export boundaries.
+        s_parameters : bool
+            Whether to export s_parameters.
+        padstacks : bool
+            Whether to export padstacks.
         Returns
         -------
         bool
         """
-        file_path = file_path if isinstance(file_path, Path) else Path(file_path)
-        file_path = file_path if file_path.suffix == ".json" else file_path.with_suffix(".json")
         data = self.get_data_from_db(
             stackup=stackup,
             package_definitions=package_definitions,
-            setups=setups,
+            setups=False,
             sources=sources,
             ports=ports,
             nets=nets,
             pin_groups=pin_groups,
             operations=operations,
+            components=components,
+            boundaries=boundaries,
+            s_parameters=s_parameters,
+            padstacks=padstacks,
         )
+
+        file_path = file_path if isinstance(file_path, Path) else Path(file_path)
+        file_path = file_path.with_suffix(".json") if file_path.suffix == "" else file_path
+
         with open(file_path, "w") as f:
-            json.dump(data, f, ensure_ascii=False, indent=4)
+            if file_path.suffix == ".json":
+                json.dump(data, f, ensure_ascii=False, indent=4)
+            else:
+                toml.dump(data, f)
         return True if os.path.isfile(file_path) else False

pyedb/dotnet/edb.py

@@ -1630,6 +1630,14 @@ class Edb(Database):
                     )
                 else:
                     obj_data = i.Expand(expansion_size, tolerance, round_corner, round_extension)
+                if inlcude_voids_in_extents and "PolygonData" not in str(i) and i.has_voids and obj_data:
+                    for void in i.voids:
+                        void_data = void.primitive_object.GetPolygonData().Expand(
+                            -1 * expansion_size, tolerance, round_corner, round_extension
+                        )
+                        if void_data:
+                            for v in list(void_data):
+                                obj_data[0].AddHole(v)
                 if obj_data:
                     if not inlcude_voids_in_extents:
                         unite_polys.extend(list(obj_data))
@@ -2209,9 +2217,9 @@ class Edb(Database):
                     pins_to_preserve.extend([i.id for i in el.pins.values()])
                     nets_to_preserve.extend(el.nets)
         if include_pingroups:
-            for reference in reference_list:
-                for pin in self.nets.nets[reference].padstack_instances:
-                    if pin.pingroups:
+            for pingroup in self.padstacks.pingroups:
+                for pin in pingroup.pins.values():
+                    if pin.net_name in reference_list:
                         pins_to_preserve.append(pin.id)
         if check_terminals:
             terms = [
@@ -2280,12 +2288,12 @@ class Edb(Database):
             if extent_type in ["Conforming", self.edb_api.geometry.extent_type.Conforming, 1]:
                 if extent_defeature > 0:
                     _poly = _poly.Defeature(extent_defeature)
-
                 _poly1 = _poly.CreateFromArcs(_poly.GetArcData(), True)
                 if inlcude_voids_in_extents:
                     for hole in list(_poly.Holes):
                         if hole.Area() >= 0.05 * _poly1.Area():
                             _poly1.AddHole(hole)
+                    self.logger.info(f"Number of voids included:{len(list(_poly1.Holes))}")
                 _poly = _poly1
         if not _poly or _poly.IsNull():
             self._logger.error("Failed to create Extent.")

pyedb/dotnet/edb_core/cell/hierarchy/component.py

@@ -33,6 +33,7 @@ from pyedb.dotnet.edb_core.cell.hierarchy.s_parameter_model import SparamModel
 from pyedb.dotnet.edb_core.cell.hierarchy.spice_model import SpiceModel
 from pyedb.dotnet.edb_core.definition.package_def import PackageDef
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
+from pyedb.dotnet.edb_core.general import pascal_to_snake, snake_to_pascal
 
 try:
     import numpy as np
@@ -1008,3 +1009,201 @@ class EDBComponent(Group):
         )
         void.is_negative = True
         return True
+
+    @property
+    def model_properties(self):
+        pp = {}
+        c_p = self.component_property
+        model = c_p.GetModel().Clone()
+        netlist_model = {}
+        pin_pair_model = []
+        s_parameter_model = {}
+        spice_model = {}
+        if model.GetModelType().ToString() == "NetlistModel":
+            netlist_model["netlist"] = model.GetNetlist()
+        elif model.GetModelType().ToString() == "PinPairModel":
+            temp = {}
+            for i in model.PinPairs:
+                temp["first_pin"] = i.FirstPin
+                temp["second_pin"] = i.SecondPin
+                rlc = model.GetPinPairRlc(i)
+                temp["is_parallel"] = rlc.IsParallel
+                temp["resistance"] = rlc.R.ToString()
+                temp["resistance_enabled"] = rlc.REnabled
+                temp["inductance"] = rlc.L.ToString()
+                temp["inductance_enabled"] = rlc.LEnabled
+                temp["capacitance"] = rlc.C.ToString()
+                temp["capacitance_enabled"] = rlc.CEnabled
+                pin_pair_model.append(temp)
+        elif model.GetModelType().ToString() == "SParameterModel":
+            s_parameter_model["reference_net"] = model.GetReferenceNet()
+            s_parameter_model["model_name"] = model.GetComponentModelName()
+        elif model.GetModelType().ToString() == "SPICEModel":
+            spice_model["model_name"] = model.GetModelName()
+            spice_model["model_path"] = model.GetModelPath()
+            spice_model["sub_circuit"] = model.GetSubCkt()
+            spice_model["terminal_pairs"] = [[i, j] for i, j in dict(model.GetTerminalPinPairs()).items()]
+
+        if netlist_model:
+            pp["netlist_model"] = netlist_model
+        if pin_pair_model:
+            pp["pin_pair_model"] = pin_pair_model
+        if s_parameter_model:
+            pp["s_parameter_model"] = s_parameter_model
+        if spice_model:
+            pp["spice_model"] = spice_model
+        return pp
+
+    @model_properties.setter
+    def model_properties(self, kwargs):
+        netlist_model = kwargs.get("netlist_model")
+        pin_pair_model = kwargs.get("pin_pair_model")
+        s_parameter_model = kwargs.get("s_parameter_model")
+        spice_model = kwargs.get("spice_model")
+
+        c_p = self.component_property
+        if netlist_model:
+            m = self._pedb._edb.Cell.Hierarchy.SParameterModel()
+            m.SetNetlist(netlist_model["netlist"])
+            c_p.SetModel(m)
+            self.component_property = c_p
+        elif pin_pair_model:
+            m = self._pedb._edb.Cell.Hierarchy.PinPairModel()
+            for i in pin_pair_model:
+                p = self._pedb._edb.Utility.PinPair(str(i["first_pin"]), str(i["second_pin"]))
+                rlc = self._pedb._edb.Utility.Rlc(
+                    self._pedb.edb_value(i["resistance"]),
+                    i["resistance_enabled"],
+                    self._pedb.edb_value(i["inductance"]),
+                    i["inductance_enabled"],
+                    self._pedb.edb_value(i["capacitance"]),
+                    i["capacitance_enabled"],
+                    i["is_parallel"],
+                )
+                m.SetPinPairRlc(p, rlc)
+            c_p.SetModel(m)
+            self.component_property = c_p
+        elif s_parameter_model:
+            m = self._pedb._edb.Cell.Hierarchy.SParameterModel()
+            m.SetComponentModelName(s_parameter_model["model_name"])
+            m.SetReferenceNet(s_parameter_model["reference_net"])
+            c_p.SetModel(m)
+            self.component_property = c_p
+        elif spice_model:
+            self.assign_spice_model(
+                spice_model["model_path"],
+                spice_model["model_name"],
+                spice_model["sub_circuit"],
+                spice_model["terminal_pairs"],
+            )
+
+    @property
+    def ic_die_properties(self):
+        temp = dict()
+        cp = self.component_property
+        c_type = self.type.lower()
+        if not c_type == "ic":
+            return temp
+        else:
+            ic_die_prop = cp.GetDieProperty().Clone()
+            die_type = pascal_to_snake(ic_die_prop.GetType().ToString())
+            temp["type"] = die_type
+            if not die_type == "no_die":
+                temp["orientation"] = pascal_to_snake(ic_die_prop.GetOrientation())
+                if die_type == "wire_bond":
+                    temp["height"] = ic_die_prop.GetHeightValue().ToString()
+            return temp
+
+    @ic_die_properties.setter
+    def ic_die_properties(self, kwargs):
+        cp = self.component_property
+        c_type = self.type.lower()
+        if not c_type == "ic":
+            return
+        else:
+            ic_die_prop = cp.GetDieProperty().Clone()
+            die_type = kwargs.get("type")
+            if not die_type == "no_die":
+                orientation = kwargs.get("orientation")
+                if orientation:
+                    ic_die_prop.SetOrientation(getattr(self._edb.definition.DieType, snake_to_pascal(die_type)))
+                if die_type == "wire_bond":
+                    height = kwargs.get("height")
+                    if height:
+                        ic_die_prop.SetHeight(self._pedb.edb_value(height))
+            cp.SetDieProperty(ic_die_prop)
+            self.component_property = cp
+
+    @property
+    def solder_ball_properties(self):
+        temp = dict()
+        cp = self.component_property
+        c_type = self.type.lower()
+        if c_type not in ["io", "other"]:
+            return temp
+        else:
+            solder_ball_prop = cp.GetSolderBallProperty().Clone()
+            _, diam, mid_diam = solder_ball_prop.GetDiameterValue()
+            height = solder_ball_prop.GetHeightValue().ToString()
+            shape = solder_ball_prop.GetShape().ToString()
+            uses_solder_ball = solder_ball_prop.UsesSolderball()
+            temp["uses_solder_ball"] = uses_solder_ball
+            temp["shape"] = pascal_to_snake(shape)
+            temp["diameter"] = diam.ToString()
+            temp["mid_diameter"] = mid_diam.ToString()
+            temp["height"] = height
+            return temp
+
+    @solder_ball_properties.setter
+    def solder_ball_properties(self, kwargs):
+        cp = self.component_property
+        solder_ball_prop = cp.GetSolderBallProperty().Clone()
+        shape = kwargs.get("shape")
+        if shape:
+            solder_ball_prop.SetShape(getattr(self._edb.definition.SolderballShape, snake_to_pascal(shape)))
+        if shape == "cylinder":
+            diameter = kwargs["diameter"]
+            solder_ball_prop.SetDiameter(self._pedb.edb_value(diameter), self._pedb.edb_value(diameter))
+        elif shape == "spheroid":
+            diameter = kwargs["diameter"]
+            mid_diameter = kwargs["mid_diameter"]
+            solder_ball_prop.SetDiameter(self._pedb.edb_value(diameter), self._pedb.edb_value(mid_diameter))
+        else:
+            return
+        solder_ball_prop.SetHeight(self._get_edb_value(kwargs["height"]))
+        cp.SetSolderBallProperty(solder_ball_prop)
+        self.component_property = cp
+
+    @property
+    def port_properties(self):
+        temp = dict()
+        cp = self.component_property
+        c_type = self.type.lower()
+        if c_type not in ["ic", "io", "other"]:
+            return temp
+        else:
+            port_prop = cp.GetPortProperty().Clone()
+            reference_height = port_prop.GetReferenceHeightValue().ToString()
+            reference_size_auto = port_prop.GetReferenceSizeAuto()
+            _, reference_size_x, reference_size_y = port_prop.GetReferenceSize()
+            temp["reference_height"] = reference_height
+            temp["reference_size_auto"] = reference_size_auto
+            temp["reference_size_x"] = str(reference_size_x)
+            temp["reference_size_y"] = str(reference_size_y)
+            return temp
+
+    @port_properties.setter
+    def port_properties(self, kwargs):
+        cp = self.component_property
+        port_prop = cp.GetPortProperty().Clone()
+        height = kwargs.get("reference_height")
+        if height:
+            port_prop.SetReferenceHeight(self._pedb.edb_value(height))
+        reference_size_auto = kwargs.get("reference_size_auto")
+        if reference_size_auto:
+            port_prop.SetReferenceSizeAuto(reference_size_auto)
+        reference_size_x = kwargs.get("reference_size_x", 0)
+        reference_size_y = kwargs.get("reference_size_y", 0)
+        port_prop.SetReferenceSize(self._pedb.edb_value(reference_size_x), self._pedb.edb_value(reference_size_y))
+        cp.SetPortProperty(port_prop)
+        self.component_property = cp

pyedb/dotnet/edb_core/cell/primitive/primitive.py

@@ -160,6 +160,8 @@ class Primitive(Connectable):
         -------
         float
         """
+        if "GetPolygonData" not in dir(self._edb_object):
+            return 0
         area = self._edb_object.GetPolygonData().Area()
         if include_voids:
             for el in self._edb_object.Voids:

pyedb/dotnet/edb_core/cell/terminal/terminal.py

@@ -223,9 +223,10 @@ class Terminal(Connectable):
         """Get reference terminal."""
 
         edb_terminal = self._edb_object.GetReferenceTerminal()
-        terminal = self._pedb.terminals[edb_terminal.GetName()]
-        if not terminal.is_null:
-            return terminal
+        if not edb_terminal.IsNull():
+            return self._pedb.terminals[edb_terminal.GetName()]
+        else:
+            return None
 
     @ref_terminal.setter
     def ref_terminal(self, value):

pyedb/dotnet/edb_core/definition/component_def.py

@@ -23,6 +23,7 @@
 import os
 
 from pyedb.dotnet.edb_core.definition.component_model import NPortComponentModel
+from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.dotnet.edb_core.utilities.obj_base import ObjBase
 
 
@@ -171,7 +172,7 @@ class EDBComponentDef(ObjBase):
     def component_models(self):
         temp = {}
         for i in list(self._edb_object.GetComponentModels()):
-            temp_type = i.ToString().split(".")[0]
+            temp_type = i.ToString().split(".")[-1]
             if temp_type == "NPortComponentModel":
                 edb_object = NPortComponentModel(self._pedb, i)
                 temp[edb_object.name] = edb_object
@@ -197,3 +198,18 @@ class EDBComponentDef(ObjBase):
         footprint_cell = self._pedb._active_cell.cell.Create(self._pedb.active_db, cell_type, name)
         edb_object = self._pedb.edb_api.definition.ComponentDef.Create(self._pedb.active_db, name, footprint_cell)
         return EDBComponentDef(self._pedb, edb_object)
+
+    def get_properties(self):
+        data = {}
+        temp = []
+        for i in list(self._edb_object.ComponentDefPins):
+            temp.append(i.GetName())
+        data["pin_order"] = temp
+        return data
+
+    def set_properties(self, **kwargs):
+        pin_order = kwargs.get("pin_order")
+        if pin_order:
+            old = {i.GetName(): i for i in list(self._edb_object.ComponentDefPins)}
+            temp = convert_py_list_to_net_list([old[str(i)] for i in pin_order])
+            self._edb_object.ReorderPins(temp)

pyedb/dotnet/edb_core/definition/component_model.py

@@ -30,10 +30,6 @@ class ComponentModel(ObjBase):
         super().__init__(pedb, edb_object)
         self._model_type_mapping = {"PinPairModel": self._pedb.edb_api.cell}
 
-    def name(self):
-        """Name of the component model."""
-        return self._edb_object.GetName()
-
 
 class NPortComponentModel(ComponentModel):
     """Class for n-port component models."""

pyedb/dotnet/edb_core/edb_data/hfss_extent_info.py

@@ -22,7 +22,7 @@
 
 from pyedb.dotnet.edb_core.edb_data.edbvalue import EdbValue
 from pyedb.dotnet.edb_core.edb_data.primitives_data import cast
-from pyedb.dotnet.edb_core.general import convert_pytuple_to_nettuple
+from pyedb.dotnet.edb_core.general import convert_pytuple_to_nettuple, pascal_to_snake
 
 
 class HfssExtentInfo:
@@ -192,7 +192,7 @@ class HfssExtentInfo:
     @property
     def dielectric_extent_type(self):
         """Dielectric extent type."""
-        return self._edb_hfss_extent_info.DielectricExtentType.ToString().lower()
+        return pascal_to_snake(self._edb_hfss_extent_info.DielectricExtentType.ToString())
 
     @dielectric_extent_type.setter
     def dielectric_extent_type(self, value):
@@ -204,7 +204,7 @@ class HfssExtentInfo:
     @property
     def extent_type(self):
         """Extent type."""
-        return self._edb_hfss_extent_info.ExtentType.ToString().lower()
+        return pascal_to_snake(self._edb_hfss_extent_info.ExtentType.ToString())
 
     @extent_type.setter
     def extent_type(self, value):

pyedb/dotnet/edb_core/edb_data/nets_data.py

@@ -19,7 +19,6 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
-
 from pyedb.dotnet.edb_core.dotnet.database import (
     DifferentialPairDotNet,
     ExtendedNetDotNet,
@@ -58,7 +57,10 @@ class EDBNetsData(NetDotNet):
         -------
         list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
         """
-        return [self._app.layout.find_object_by_id(i.GetId()) for i in self.net_object.Primitives]
+        from pyedb.dotnet.edb_core.cell.layout import primitive_cast
+
+        return [primitive_cast(self._app, i) for i in self.net_object.Primitives]
+        # return [self._app.layout.find_object_by_id(i.GetId()) for i in self.net_object.Primitives]
 
     @property
     def padstack_instances(self):
@@ -67,10 +69,11 @@ class EDBNetsData(NetDotNet):
         Returns
         -------
         list of :class:`pyedb.dotnet.edb_core.edb_data.padstacks_data.EDBPadstackInstance`"""
-        name = self.name
-        return [
-            EDBPadstackInstance(i, self._app) for i in self.net_object.PadstackInstances if i.GetNet().GetName() == name
-        ]
+        # name = self.name
+        # return [
+        # EDBPadstackInstance(i, self._app) for i in self.net_object.PadstackInstances if i.GetNet().GetName() == name
+        # ]
+        return [EDBPadstackInstance(i, self._app) for i in self.net_object.PadstackInstances]
 
     @property
     def components(self):
@@ -133,7 +136,7 @@ class EDBNetsData(NetDotNet):
             Whether to show the plot or not. Default is `True`.
         """
 
-        self._app.nets.plot(
+        return self._app.nets.plot(
             self.name,
             layers=layers,
             show_legend=show_legend,

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -1672,6 +1672,56 @@ class EDBPadstackInstance(Primitive):
         else:
             return
 
+    @property
+    def backdrill_parameters(self):
+        data = {}
+        flag, drill_to_layer, offset, diameter = self._edb_object.GetBackDrillParametersLayerValue(
+            self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer),
+            self._pedb.edb_value(0),
+            self._pedb.edb_value(0.0),
+            True,
+        )
+        if flag:
+            if drill_to_layer.GetName():
+                data["from_bottom"] = {
+                    "drill_to_layer": drill_to_layer.GetName(),
+                    "diameter": diameter.ToString(),
+                    "stub_length": offset.ToString(),
+                }
+        flag, drill_to_layer, offset, diameter = self._edb_object.GetBackDrillParametersLayerValue(
+            self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer),
+            self._pedb.edb_value(0),
+            self._pedb.edb_value(0.0),
+            False,
+        )
+        if flag:
+            if drill_to_layer.GetName():
+                data["from_top"] = {
+                    "drill_to_layer": drill_to_layer.GetName(),
+                    "diameter": diameter.ToString(),
+                    "stub_length": offset.ToString(),
+                }
+        return data
+
+    @backdrill_parameters.setter
+    def backdrill_parameters(self, params):
+        from_bottom = params.get("from_bottom")
+        if from_bottom:
+            self._edb_object.SetBackDrillParameters(
+                self._pedb.stackup.layers[from_bottom.get("drill_to_layer")]._edb_object,
+                self._pedb.edb_value(from_bottom.get("stub_length")),
+                self._pedb.edb_value(from_bottom.get("diameter")),
+                True,
+            )
+        from_top = params.get("from_top")
+        if from_top:
+            self._edb_object.SetBackDrillParameters(
+                self._pedb.stackup.layers[from_top.get("drill_to_layer")]._edb_object,
+                self._pedb.edb_value(from_top.get("stub_length")),
+                self._pedb.edb_value(from_top.get("diameter")),
+                False,
+            )
+
     def set_backdrill_bottom(self, drill_depth, drill_diameter, offset=0.0):
         """Set backdrill from bottom.