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

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,204 @@ 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().ToString())
+                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")
+            ic_die_prop.SetType(getattr(self._edb.definition.DieType, snake_to_pascal(die_type)))
+            if not die_type == "no_die":
+                orientation = kwargs.get("orientation")
+                if orientation:
+                    ic_die_prop.SetOrientation(
+                        getattr(self._edb.definition.DieOrientation, snake_to_pascal(orientation))
+                    )
+                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/layout.py

@@ -230,11 +230,7 @@ class Layout(ObjBase):
         -------
         list of :class:`dotnet.edb_core.dotnet.primitive.PrimitiveDotNet` cast objects.
         """
-        prims = []
-        for p in self._edb_object.Primitives:
-            obj = primitive_cast(self._pedb, p)
-            prims.append(obj)
-        return prims
+        return [primitive_cast(self._pedb, p) for p in self._edb_object.Primitives]
 
     @property
     def bondwires(self):
@@ -249,14 +245,7 @@ class Layout(ObjBase):
 
     @property
     def groups(self):
-        temp = []
-        for i in list(self._edb_object.Groups):
-            group_type = i.ToString().split(".")[-1].lower()
-            if group_type == "component":
-                temp.append(EDBComponent(self._pedb, i))
-            else:
-                pass
-        return temp
+        return [EDBComponent(self._pedb, i) for i in self._edb_object.Groups if i.ToString().endswith(".Component")]
 
     @property
     def pin_groups(self):

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

@@ -43,8 +43,6 @@ class Primitive(Connectable):
     def __init__(self, pedb, edb_object):
         super().__init__(pedb, edb_object)
         self._app = self._pedb
-        self._core_stackup = pedb.stackup
-        self._core_net = pedb.nets
         self.primitive_object = self._edb_object
 
         bondwire_type = self._pedb._edb.Cell.Primitive.BondwireType
@@ -62,6 +60,14 @@ class Primitive(Connectable):
             "rectangle": bondwire_cross_section_type.BondwireRectangle,
         }
 
+    @property
+    def _core_stackup(self):
+        return self._app.stackup
+
+    @property
+    def _core_net(self):
+        return self._app.nets
+
     @property
     def type(self):
         """Return the type of the primitive.
@@ -160,6 +166,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/components.py

@@ -313,8 +313,7 @@ class Components(object):
         # self._logger.info("Refreshing the Components dictionary.")
         self._cmp = {}
         for i in self._pedb.layout.groups:
-            if i.group_type == "component":
-                self._cmp[i.name] = i
+            self._cmp[i.name] = i
         return True
 
     @property

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/layer_data.py

@@ -58,6 +58,8 @@ class LayerEdbClass(object):
         for k, v in kwargs.items():
             if k in dir(self):
                 self.__setattr__(k, v)
+            elif k == "roughness":
+                self.properties = {"roughness": v}
             else:
                 self._pedb.logger.error(f"{k} is not a valid layer attribute")
 
@@ -178,7 +180,7 @@ class LayerEdbClass(object):
             RGB.
         """
         layer_color = self._edb_layer.GetColor()
-        return layer_color.Item1, layer_color.Item2, layer_color.Item3
+        return [layer_color.Item1, layer_color.Item2, layer_color.Item3]
 
     @color.setter
     def color(self, rgb):
@@ -238,6 +240,26 @@ class LayerEdbClass(object):
         self._type = value
         self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
 
+    @property
+    def properties(self):
+        data = {}
+        data["name"] = self.name
+        data["type"] = self.type
+        data["color"] = self.color
+        return data
+
+    @properties.setter
+    def properties(self, params):
+        name = params.get("name", "")
+        if name:
+            self.name = name
+        type = params.get("type", "")
+        if type:
+            self.type = type
+        color = params.get("color", "")
+        if color:
+            self.color = color
+
 
 class StackupLayerEdbClass(LayerEdbClass):
     def __init__(self, pedb, edb_object=None, name="", layer_type="signal", **kwargs):
@@ -705,3 +727,75 @@ class StackupLayerEdbClass(LayerEdbClass):
                     layer["side_hallhuray_surface_ratio"],
                     apply_on_surface="side",
                 )
+
+    @property
+    def properties(self):
+        data = {}
+        data["name"] = self.name
+        data["type"] = self.type
+        data["material"] = self.material
+        data["fill_material"] = self.fill_material
+        data["thickness"] = self._edb_object.GetThicknessValue().ToString()
+        data["color"] = self.color
+
+        roughness = {}
+        for region in ["top", "bottom", "side"]:
+            temp = {}
+            r_model = self._edb_object.GetRoughnessModel(
+                getattr(self._pedb._edb.Cell.RoughnessModel.Region, region.capitalize())
+            )
+            if r_model.ToString().split(".")[-1] == "HurrayRoughnessModel":
+                temp["model"] = "huray"
+                temp["nodule_radius"] = r_model.NoduleRadius.ToString()
+                temp["surface_ratio"] = r_model.SurfaceRatio.ToString()
+            else:
+                temp["model"] = "groisse"
+                temp["roughness"] = r_model.Roughness.ToString()
+            roughness[region] = temp
+        roughness["enabled"] = self._edb_object.IsRoughnessEnabled()
+        data["roughness"] = roughness
+        return data
+
+    @properties.setter
+    def properties(self, params):
+        name = params.get("name")
+        if name:
+            self.name = name
+        type = params.get("type")
+        if type:
+            self.type = type
+        material = params.get("material")
+        if material:
+            self.material = material
+        fill_material = params.get("fill_material")
+        if fill_material:
+            self.fill_material = fill_material
+        thickness = params.get("thickness")
+        if thickness:
+            self.thickness = self._pedb.edb_value(thickness)
+        color = params.get("color")
+        if color:
+            self.color = color
+        roughness = params.get("roughness")
+        if roughness:
+            layer_clone = self._edb_layer
+            layer_clone.SetRoughnessEnabled(roughness["enabled"])
+            for region in ["top", "bottom", "side"]:
+                r_data = roughness.get(region)
+                if r_data:
+                    if r_data["model"] == "huray":
+                        r_model = self._pedb._edb.Cell.HurrayRoughnessModel(
+                            self._pedb.edb_value(r_data["nodule_radius"]), self._pedb.edb_value(r_data["surface_ratio"])
+                        )
+                    else:
+                        r_model = self._pedb._edb.Cell.GroisseRoughnessModel(self._pedb.edb_value(r_data["roughness"]))
+                else:
+                    r_model = self._pedb._edb.Cell.HurrayRoughnessModel(
+                        self._pedb.edb_value("0"), self._pedb.edb_value("0")
+                    )
+                layer_clone.SetRoughnessModel(
+                    getattr(self._pedb._edb.Cell.RoughnessModel.Region, region.capitalize()), r_model
+                )
+            self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
+
+        layer_clone.SetRoughnessEnabled(True)

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

@@ -499,7 +499,8 @@ class EDBPadstack(object):
             self._ppadstack._pedb._edb.Definition.PadType.RegularPad,
             self._ppadstack._pedb._edb.Definition.PadType.AntiPad,
             self._ppadstack._pedb._edb.Definition.PadType.ThermalPad,
-            self._ppadstack._pedb._edb.Definition.PadType.Hole,
+            # self._ppadstack._pedb._edb.Definition.PadType.Hole,
+            # This property doesn't appear in UI. It is unclear what it is used for. Suppressing this property for now.
         ]
         data = {}
         for pad_type in pad_type_list:
@@ -588,15 +589,14 @@ class EDBPadstack(object):
                     continue
 
                 # Set pad parameters for the current layer
-                default = original_params[pad_type_name]
                 pdef_data.SetPadParameters(
                     layer_data["layer_name"],
                     pad_type,
                     pad_shape,
                     convert_py_list_to_net_list([self._ppadstack._pedb.edb_value(i) for i in temp_param]),
-                    self._ppadstack._pedb.edb_value(layer_data.get("offset_x", default[idx].get("offset_x", 0))),
-                    self._ppadstack._pedb.edb_value(layer_data.get("offset_y", default[idx].get("offset_y", 0))),
-                    self._ppadstack._pedb.edb_value(layer_data.get("rotation", default[idx].get("rotation", 0))),
+                    self._ppadstack._pedb.edb_value(layer_data.get("offset_x", 0)),
+                    self._ppadstack._pedb.edb_value(layer_data.get("offset_y", 0)),
+                    self._ppadstack._pedb.edb_value(layer_data.get("rotation", 0)),
                 )
         self._padstack_def_data = pdef_data
 
@@ -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.
 
@@ -2274,3 +2324,15 @@ class EDBPadstackInstance(Primitive):
             max_limit=max_limit,
             component_only=component_only,
         )
+
+    @property
+    def properties(self):
+        data = {}
+        data["name"] = self.aedt_name
+        data["definition"] = self.padstack_definition
+        data["backdrill_parameters"] = self.backdrill_parameters
+        _, position, rotation = self._edb_object.GetPositionAndRotationValue()
+        data["position"] = [position.X.ToString(), position.Y.ToString()]
+        data["rotation"] = [rotation.ToString()]
+        data["id"] = self.id
+        return data