pyedb 0.22.1__py3-none-any.whl → 0.24.0__py3-none-any.whl

pyedb/dotnet/edb_core/nets.py

@@ -206,10 +206,11 @@ class EdbNets(object):
         for net in self._layout.nets[:]:
             total_plane_area = 0.0
             total_trace_area = 0.0
-            for primitive in net.Primitives:
-                if primitive.GetPrimitiveType() == self._edb.cell.primitive.PrimitiveType.Bondwire:
+            for primitive in net.primitives:
+                primitive = primitive._edb_object
+                if primitive.GetPrimitiveType() == self._edb.cell.primitive.api_class.PrimitiveType.Bondwire:
                     continue
-                if primitive.GetPrimitiveType() != self._edb.cell.primitive.PrimitiveType.Path:
+                if primitive.GetPrimitiveType() != self._edb.cell.primitive.api_class.PrimitiveType.Path:
                     total_plane_area += float(primitive.GetPolygonData().Area())
                 else:
                     total_trace_area += float(primitive.GetPolygonData().Area())
@@ -521,7 +522,7 @@ class EdbNets(object):
         bottom_layer = list(self._pedb.stackup.signal_layers.keys())[-1]
         if plot_components_on_top or plot_components_on_bottom:
             nc = 0
-            for comp in self._pedb.components.components.values():
+            for comp in self._pedb.components.instances.values():
                 if not comp.is_enabled:
                     continue
                 net_names = comp.nets
@@ -1088,7 +1089,7 @@ class EdbNets(object):
         else:
             if not start_with and not contain and not end_with:
                 net = self._edb.cell.net.find_by_name(self._active_layout, net_name)
-                if net.IsNull():
+                if net.is_null:
                     net = self._edb.cell.net.create(self._active_layout, net_name)
                 return net
             elif start_with:
@@ -1149,9 +1150,9 @@ class EdbNets(object):
             ``True`` if the net is found in component pins.
 
         """
-        if component_name not in self._pedb.components.components:
+        if component_name not in self._pedb.components.instances:
             return False
-        for net in self._pedb.components.components[component_name].nets:
+        for net in self._pedb.components.instances[component_name].nets:
             if net_name == net:
                 return True
         return False

pyedb/dotnet/edb_core/padstack.py

@@ -29,12 +29,12 @@ import warnings
 import rtree
 
 from pyedb.dotnet.clr_module import Array
-from pyedb.dotnet.edb_core.dotnet.database import PolygonDataDotNet
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import (
     EDBPadstack,
     EDBPadstackInstance,
 )
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
+from pyedb.dotnet.edb_core.geometry.polygon_data import PolygonData
 from pyedb.generic.general_methods import generate_unique_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
@@ -108,7 +108,7 @@ class EdbPadstacks(object):
     @property
     def _layers(self):
         """ """
-        return self._pedb.stackup.stackup_layers
+        return self._pedb.stackup.layers
 
     def int_to_pad_type(self, val=0):
         """Convert an integer to an EDB.PadGeometryType.
@@ -240,9 +240,7 @@ class EdbPadstacks(object):
         padstack_instances = {}
         for _, edb_padstack_instance in self.instances.items():
             if edb_padstack_instance.aedt_name:
-                padstack_instances[edb_padstack_instance.aedt_name] = EDBPadstackInstance(
-                    edb_padstack_instance, self._pedb
-                )
+                padstack_instances[edb_padstack_instance.aedt_name] = edb_padstack_instance
         return padstack_instances
 
     def find_instance_by_id(self, value: int):
@@ -491,7 +489,7 @@ class EdbPadstacks(object):
             padstackInst = self.instances[padstackInst]._edb_padstackinstance
 
         else:
-            psdef = padstackInst.GetPadstackDef()
+            psdef = padstackInst._edb_object.GetPadstackDef()
         newdefdata = self._edb.definition.PadstackDefData(psdef.GetData())
         newdefdata.SetSolderBallShape(self._edb.definition.SolderballShape.Cylinder)
         newdefdata.SetSolderBallParameter(self._get_edb_value(ballDiam), self._get_edb_value(ballDiam))
@@ -504,7 +502,7 @@ class EdbPadstacks(object):
         psdef.SetData(newdefdata)
         sball_layer = [lay._edb_layer for lay in list(self._layers.values()) if lay.name == sballLayer_name][0]
         if sball_layer is not None:
-            padstackInst.SetSolderBallLayer(sball_layer)
+            padstackInst._edb_object.SetSolderBallLayer(sball_layer)
             return True
 
         return False
@@ -592,13 +590,13 @@ class EdbPadstacks(object):
         """
         pinlist = []
         if refdes:
-            if refdes in self._pedb.components.components:
+            if refdes in self._pedb.components.instances:
                 if netname:
-                    for pin, val in self._pedb.components.components[refdes].pins.items():
+                    for pin, val in self._pedb.components.instances[refdes].pins.items():
                         if val.net_name == netname:
                             pinlist.append(val)
                 else:
-                    for pin in self._pedb.components.components[refdes].pins.values():
+                    for pin in self._pedb.components.instances[refdes].pins.values():
                         pinlist.append(pin)
             elif netname:
                 for pin in self._pedb.pins:
@@ -757,6 +755,7 @@ class EdbPadstacks(object):
         if not isinstance(net_list, list):
             net_list = [net_list]
         layout_lobj_collection = self._layout.padstack_instances
+        layout_lobj_collection = [i._edb_object for i in layout_lobj_collection]
         via_list = []
         for lobj in layout_lobj_collection:
             pad_layers_name = lobj.GetPadstackDef().GetData().GetLayerNames()
@@ -955,8 +954,8 @@ class EdbPadstacks(object):
                     _poly.delete()
                 else:
                     return False
-            elif isinstance(polygon_hole, PolygonDataDotNet):
-                hole_param = polygon_hole.edb_api
+            elif isinstance(polygon_hole, PolygonData):
+                hole_param = polygon_hole._edb_object
             else:
                 return False
             padstackData.SetPolygonalHoleParameters(hole_param, value0, value0, value0)
@@ -1007,7 +1006,7 @@ class EdbPadstacks(object):
                     _poly.delete()
                 else:
                     return False
-            elif isinstance(pad_polygon, PolygonDataDotNet):
+            elif isinstance(pad_polygon, PolygonData):
                 pad_array = pad_polygon
         if antipad_shape == "Bullet":  # pragma no cover
             antipad_array = Array[type(x_size)]([x_size, y_size, corner_radius])
@@ -1023,7 +1022,7 @@ class EdbPadstacks(object):
                     _poly.delete()
                 else:
                     return False
-            elif isinstance(antipad_polygon, PolygonDataDotNet):
+            elif isinstance(antipad_polygon, PolygonData):
                 antipad_array = antipad_polygon
         else:  # pragma no cover
             antipad_array = Array[type(antipaddiam)]([antipaddiam])
@@ -1035,7 +1034,7 @@ class EdbPadstacks(object):
                 padstackData.SetPolygonalPadParameters(
                     layer,
                     self._edb.definition.PadType.RegularPad,
-                    pad_array.edb_api,
+                    pad_array._edb_object,
                     pad_offset_x,
                     pad_offset_y,
                     pad_rotation,
@@ -1043,7 +1042,7 @@ class EdbPadstacks(object):
                 padstackData.SetPolygonalPadParameters(
                     layer,
                     self._edb.definition.PadType.AntiPad,
-                    antipad_array.edb_api,
+                    antipad_array._edb_object,
                     pad_offset_x,
                     pad_offset_y,
                     pad_rotation,
@@ -1208,7 +1207,7 @@ class EdbPadstacks(object):
                 solderlayer,
                 None,
             )
-            padstack_instance.SetIsLayoutPin(is_pin)
+            padstack_instance.is_layout_pin = is_pin
             py_padstack_instance = EDBPadstackInstance(padstack_instance.api_object, self._pedb)
 
             return py_padstack_instance

pyedb/dotnet/edb_core/siwave.py

@@ -912,7 +912,7 @@ class EdbSiwave(object):
             Name of the source.
 
         """
-        if source.name in [i.GetName() for i in self._layout.terminals]:
+        if source.name in [i.name for i in self._layout.terminals]:
             source.name = generate_unique_name(source.name, n=3)
             self._logger.warning("Port already exists with same name. Renaming to {}".format(source.name))
         pos_pin_group = self._pedb.components.create_pingroup_from_pins(source.positive_node.node_pins)
@@ -1235,7 +1235,7 @@ class EdbSiwave(object):
         pin_numbers = [str(p) for p in pin_numbers]
         if group_name is None:
             group_name = self._edb.cell.hierarchy.pin_group.GetUniqueName(self._active_layout)
-        comp = self._pedb.components.components[reference_designator]
+        comp = self._pedb.components.instances[reference_designator]
         pins = [pin.pin for name, pin in comp.pins.items() if name in pin_numbers]
         edb_pingroup = self._edb.cell.hierarchy.pin_group.Create(
             self._active_layout, group_name, convert_py_list_to_net_list(pins)

pyedb/dotnet/edb_core/stackup.py

@@ -217,7 +217,7 @@ class LayerCollection(object):
         kwargs["layer_type"] = layer_type
         return self._add_layer(add_method="add_layer_above", base_layer_name=base_layer_name, **kwargs)
 
-    def add_document_layer(self, name, layer_type="UndefinedLayerType", **kwargs):
+    def add_document_layer(self, name, layer_type="user", **kwargs):
         """Add a document layer.
 
         Parameters
@@ -225,7 +225,7 @@ class LayerCollection(object):
         name : str
             Name of the layer.
         layer_type: str, optional
-            Type of the layer. The default to ``"signal"``. Options are ``"signal"``, ``"dielectric"``
+            Type of the layer. The default is ``"user"``. Options are ``"user"``, ``"outline"``
         kwargs
 
         Returns
@@ -246,7 +246,7 @@ class LayerCollection(object):
 
         obj = False
         # Add stackup layers
-        for _, i in self.stackup_layers.items():
+        for _, i in self.layers.items():
             if i.id == layer_clone.id:  # replace layer
                 add_method(layer_clone._edb_object)
                 obj = layer_clone
@@ -355,7 +355,7 @@ class Stackup(LayerCollection):
             layer number.
 
         """
-        return len(list(self.stackup_layers.keys()))
+        return len(list(self.layers.keys()))
 
     def _int_to_layer_types(self, val):
         if int(val) == 0:
@@ -513,8 +513,8 @@ class Stackup(LayerCollection):
                 fillMaterial=dielectric_material,
                 method="add_on_bottom",
             )
-            self.stackup_layers["TOP"].dielectric_fill = "SolderMask"
-            self.stackup_layers["BOT"].dielectric_fill = "SolderMask"
+            self.layers["TOP"].dielectric_fill = "SolderMask"
+            self.layers["BOT"].dielectric_fill = "SolderMask"
 
         for layer_num in np.arange(int(layer_count / 2), 1, -1):
             # Generate upper half
@@ -843,18 +843,20 @@ class Stackup(LayerCollection):
 
         materials = self._pedb.materials
         if material not in materials:
-            logger.warning(
-                f"Material '{material}' does not exist in material library. Intempt to create it from syslib."
-            )
             material_properties = self._pedb.materials.read_syslib_material(material)
-            materials.add_material(material, **material_properties)
+            if material_properties:
+                logger.info(f"Material {material} found in syslib. Adding it to aedb project.")
+                materials.add_material(material, **material_properties)
+            else:
+                logger.warning(f"Material {material} not found. Check the library and retry.")
 
         if layer_type != "dielectric" and fillMaterial not in materials:
-            logger.warning(
-                f"Material '{fillMaterial}' does not exist in material library. Intempt to create it from syslib."
-            )
             material_properties = self._pedb.materials.read_syslib_material(fillMaterial)
-            materials.add_material(fillMaterial, **material_properties)
+            if material_properties:
+                logger.info(f"Material {fillMaterial} found in syslib. Adding it to aedb project.")
+                materials.add_material(fillMaterial, **material_properties)
+            else:
+                logger.warning(f"Material {fillMaterial} not found. Check the library and retry.")
 
         if layer_type in ["signal", "dielectric"]:
             new_layer = self._create_stackup_layer(layer_name, thickness, layer_type)
@@ -977,7 +979,7 @@ class Stackup(LayerCollection):
             "Thickness": [],
         }
         idx = []
-        for lyr in self.stackup_layers.values():
+        for lyr in self.layers.values():
             idx.append(lyr.name)
             data["Type"].append(lyr.type)
             data["Material"].append(lyr.material)
@@ -1000,7 +1002,7 @@ class Stackup(LayerCollection):
             for material_name, material in self._pedb.materials.materials.items():
                 material_out[material_name] = material.to_dict()
         layers_out = {}
-        for k, v in self.stackup_layers.items():
+        for k, v in self.layers.items():
             data = v._json_format()
             # FIXME: Update the API to avoid providing following information to our users
             del data["pedb"]
@@ -1044,16 +1046,16 @@ class Stackup(LayerCollection):
                         else:
                             self._pedb.materials.update_material(material_name, material)
                 if k == "layers":
-                    if len(list(v.values())) == len(list(self.stackup_layers.values())):
+                    if len(list(v.values())) == len(list(self.layers.values())):
                         imported_layers_list = [l_dict["name"] for l_dict in list(v.values())]
-                        layout_layer_list = list(self.stackup_layers.keys())
+                        layout_layer_list = list(self.layers.keys())
                         for layer_name in imported_layers_list:
                             layer_index = imported_layers_list.index(layer_name)
                             if layout_layer_list[layer_index] != layer_name:
-                                self.stackup_layers[layout_layer_list[layer_index]].name = layer_name
+                                self.layers[layout_layer_list[layer_index]].name = layer_name
                     prev_layer = None
                     for layer_name, layer in v.items():
-                        if layer["name"] not in self.stackup_layers:
+                        if layer["name"] not in self.layers:
                             if not prev_layer:
                                 self.add_layer(
                                     layer_name,
@@ -1075,8 +1077,8 @@ class Stackup(LayerCollection):
                                     thickness=layer["thickness"],
                                 )
                                 prev_layer = layer_name
-                        if layer_name in self.stackup_layers:
-                            self.stackup_layers[layer["name"]]._load_layer(layer)
+                        if layer_name in self.layers:
+                            self.layers[layer["name"]]._load_layer(layer)
             self.refresh_layer_collection()
             return True
 
@@ -1205,7 +1207,7 @@ class Stackup(LayerCollection):
             new_lc.AddLayers(layer_list)
             self._pedb.layout.layer_collection = new_lc
 
-            for pyaedt_cmp in list(self._pedb.components.components.values()):
+            for pyaedt_cmp in list(self._pedb.components.instances.values()):
                 cmp = pyaedt_cmp.edbcomponent
                 cmp_type = cmp.GetComponentType()
                 cmp_prop = cmp.GetComponentProperty().Clone()
@@ -1257,7 +1259,7 @@ class Stackup(LayerCollection):
         float
             The thickness value.
         """
-        layers = list(self.stackup_layers.values())
+        layers = list(self.layers.values())
         layers.sort(key=lambda lay: lay.lower_elevation)
         thickness = 0
         if layers:
@@ -1267,13 +1269,13 @@ class Stackup(LayerCollection):
         return round(thickness, 7)
 
     def _get_solder_height(self, layer_name):
-        for _, val in self._pedb.components.components.items():
+        for _, val in self._pedb.components.instances.items():
             if val.solder_ball_height and val.placement_layer == layer_name:
                 return val.solder_ball_height
         return 0
 
     def _remove_solder_pec(self, layer_name):
-        for _, val in self._pedb.components.components.items():
+        for _, val in self._pedb.components.instances.items():
             if val.solder_ball_height and val.placement_layer == layer_name:
                 comp_prop = val.component_property
                 port_property = comp_prop.GetPortProperty().Clone()
@@ -1291,19 +1293,19 @@ class Stackup(LayerCollection):
         -------
         bool
         """
-        for el, val in self._pedb.components.components.items():
+        for el, val in self._pedb.components.instances.items():
             if val.solder_ball_height:
                 layer = val.placement_layer
-                if layer == list(self.stackup_layers.keys())[0]:
+                if layer == list(self.layers.keys())[0]:
                     self.add_layer(
                         "Bottom_air",
-                        base_layer=list(self.stackup_layers.keys())[-1],
+                        base_layer=list(self.layers.keys())[-1],
                         method="insert_below",
                         material="air",
                         thickness=val.solder_ball_height,
                         layer_type="dielectric",
                     )
-                elif layer == list(self.stackup_layers.keys())[-1]:
+                elif layer == list(self.layers.keys())[-1]:
                     self.add_layer(
                         "Top_Air",
                         base_layer=layer,
@@ -1312,10 +1314,10 @@ class Stackup(LayerCollection):
                         layer_type="dielectric",
                     )
                 elif layer == list(self.signal_layers.keys())[-1]:
-                    list(self.stackup_layers.values())[-1].thickness = val.solder_ball_height
+                    list(self.layers.values())[-1].thickness = val.solder_ball_height
 
                 elif layer == list(self.signal_layers.keys())[0]:
-                    list(self.stackup_layers.values())[0].thickness = val.solder_ball_height
+                    list(self.layers.values())[0].thickness = val.solder_ball_height
         return True
 
     def place_in_layout(
@@ -1798,7 +1800,7 @@ class Stackup(LayerCollection):
         temp_data = {name: 0 for name, _ in self.signal_layers.items()}
         outline_area = 0
         for i in self._pedb.modeler.primitives:
-            layer_name = i.GetLayer().GetName()
+            layer_name = i.layer.name
             if layer_name.lower() == "outline":
                 if i.area() > outline_area:
                     outline_area = i.area()
@@ -1816,36 +1818,37 @@ class Stackup(LayerCollection):
     def _import_dict(self, json_dict, rename=False):
         """Import stackup from a dictionary."""
         if not "materials" in json_dict:
-            self._logger.warning("Configuration file does not have material definition")
-            self._logger.warning(
-                "Please check your json or xml file, if no material are defined your project will"
-                "likely fail to simulate"
-            )
+            self._logger.info("Configuration file does not have material definition. Using aedb and syslib materials.")
         else:
             mats = json_dict["materials"]
-            for material in mats.values():
-                material_name = material["name"]
-                del material["name"]
+            for name, material in mats.items():
+                try:
+                    material_name = material["name"]
+                    del material["name"]
+                except KeyError:
+                    material_name = name
                 if material_name not in self._pedb.materials:
                     self._pedb.materials.add_material(material_name, **material)
                 else:
                     self._pedb.materials.update_material(material_name, material)
-        temp = {i: j for i, j in json_dict["layers"].items() if j["type"] in ["signal", "dielectric"]}
+        temp = json_dict
+        if "layers" in json_dict:
+            temp = {i: j for i, j in json_dict["layers"].items() if j["type"] in ["signal", "dielectric"]}
         config_file_layers = list(temp.keys())
-        layout_layers = list(self.stackup_layers.keys())
+        layout_layers = list(self.layers.keys())
         renamed_layers = {}
         if rename and len(config_file_layers) == len(layout_layers):
             for lay_ind in range(len(list(temp.keys()))):
                 if not config_file_layers[lay_ind] == layout_layers[lay_ind]:
                     renamed_layers[layout_layers[lay_ind]] = config_file_layers[lay_ind]
-        layers_names = list(self.stackup_layers.keys())[::]
+        layers_names = list(self.layers.keys())[::]
         for name in layers_names:
             layer = None
             if name in temp:
                 layer = temp[name]
             elif name in renamed_layers:
                 layer = temp[renamed_layers[name]]
-                self.stackup_layers[name].name = renamed_layers[name]
+                self.layers[name].name = renamed_layers[name]
                 name = renamed_layers[name]
             else:  # Remove layers not in config file.
                 self.remove_layer(name)
@@ -1876,9 +1879,9 @@ class Stackup(LayerCollection):
 
                 for k, v in layer.items():
                     default_layer[k] = v
-                self.stackup_layers[name]._load_layer(default_layer)
+                self.layers[name]._load_layer(default_layer)
         for layer_name, layer in temp.items():  # looping over potential new layers to add
-            if layer_name in self.stackup_layers:
+            if layer_name in self.layers:
                 continue  # if layer exist, skip
             # adding layer
             default_layer = {
@@ -1974,7 +1977,7 @@ class Stackup(LayerCollection):
 
         df = pd.read_csv(file_path, index_col=0)
 
-        for name in self.stackup_layers.keys():  # pragma: no cover
+        for name in self.layers.keys():  # pragma: no cover
             if not name in df.index:
                 logger.error("{} doesn't exist in csv".format(name))
                 return False
@@ -2028,7 +2031,7 @@ class Stackup(LayerCollection):
             for name, val in layers.items():
                 etching_factor = float(val["EtchFactor"]) if "EtchFactor" in val else None
 
-                if not self.stackup_layers:
+                if not self.layers:
                     self.add_layer(
                         name,
                         None,
@@ -2040,8 +2043,8 @@ class Stackup(LayerCollection):
                         etching_factor,
                     )
                 else:
-                    if name in self.stackup_layers.keys():
-                        lyr = self.stackup_layers[name]
+                    if name in self.layers.keys():
+                        lyr = self.layers[name]
                         lyr.type = val["Type"]
                         lyr.material = val["Material"]
                         lyr.dielectric_fill = val["FillMaterial"] if val["Type"] == "signal" else ""
@@ -2049,10 +2052,10 @@ class Stackup(LayerCollection):
                         if prev_layer:
                             self._set_layout_stackup(lyr._edb_layer, "change_position", prev_layer)
                     else:
-                        if prev_layer and prev_layer in self.stackup_layers:
+                        if prev_layer and prev_layer in self.layers:
                             layer_name = prev_layer
                         else:
-                            layer_name = list(self.stackup_layers.keys())[-1] if self.stackup_layers else None
+                            layer_name = list(self.layers.keys())[-1] if self.layers else None
                         self.add_layer(
                             name,
                             layer_name,
@@ -2064,7 +2067,7 @@ class Stackup(LayerCollection):
                             etching_factor,
                         )
                     prev_layer = name
-            for name in self.stackup_layers:
+            for name in self.layers:
                 if name not in layers:
                     self.remove_layer(name)
 
@@ -2141,7 +2144,7 @@ class Stackup(LayerCollection):
         """
         layers = OrderedDict()
         roughness_models = OrderedDict()
-        for name, val in self.stackup_layers.items():
+        for name, val in self.layers.items():
             layer = dict()
             layer["Material"] = val.material
             layer["Name"] = val.name
@@ -2354,12 +2357,12 @@ class Stackup(LayerCollection):
 
         Parameters
         ----------
-        file_path : str
-            Path to stackup file.
+        file_path : str, dict
+            Path to stackup file or dict with stackup details.
         rename : bool
             If rename is ``False`` then layer in layout not found in the stackup file are deleted.
             Otherwise, if the number of layer in the stackup file equals the number of stackup layer
-            in the layout, layers are renamed according the the file.
+            in the layout, layers are renamed according the file.
             Note that layer order matters, and has to be writtent from top to bottom layer in the file.
 
         Returns
@@ -2385,32 +2388,6 @@ class Stackup(LayerCollection):
         else:
             return False
 
-    def import_stackup(self, file_path):
-        """Import stackup from a file. The file format can be XML, CSV, or JSON.
-
-        .. deprecated:: 0.6.61
-           Use :func:`load` instead.
-
-        Parameters
-        ----------
-        file_path : str
-            Path to stackup file.
-
-        Returns
-        -------
-        bool
-            ``True`` when successful, ``False`` when failed.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edb = Edb()
-        >>> edb.stackup.import_stackup("stackup.xml")
-        """
-
-        self._logger.warning("Method import_stackup is deprecated. Use .load")
-        return self.load(file_path)
-
     def plot(
         self,
         save_plot=None,
@@ -2452,7 +2429,7 @@ class Stackup(LayerCollection):
         from pyedb.generic.constants import CSS4_COLORS
         from pyedb.generic.plot import plot_matplotlib
 
-        layer_names = list(self.stackup_layers.keys())
+        layer_names = list(self.layers.keys())
         if first_layer is None or first_layer not in layer_names:
             bottom_layer = layer_names[-1]
         elif isinstance(first_layer, str):
@@ -2470,14 +2447,14 @@ class Stackup(LayerCollection):
         else:
             raise AttributeError("last_layer must be str or class `dotnet.edb_core.edb_data.layer_data.LayerEdbClass`")
 
-        stackup_mode = self.stackup_mode
+        stackup_mode = self.mode
         if stackup_mode not in ["Laminate", "Overlapping"]:
             raise AttributeError("stackup plot supports only 'Laminate' and 'Overlapping' stackup types.")
 
         # build the layers data
         layers_data = []
         skip_flag = True
-        for layer in self.stackup_layers.values():  # start from top
+        for layer in self.layers.values():  # start from top
             if layer.name != top_layer and skip_flag:
                 continue
             else:

pyedb/ipc2581/ecad/cad_data/layer_feature.py

@@ -113,7 +113,7 @@ class LayerFeature(object):
                 is_via = False
                 if not pin.start_layer == pin.stop_layer:
                     is_via = True
-                pin_net = pin.GetNet().GetName()
+                pin_net = pin._edb_object.GetNet().GetName()
                 pos_rot = pin._edb_padstackinstance.GetPositionAndRotationValue()
                 pin_rotation = pos_rot[2].ToDouble()
                 if pin._edb_padstackinstance.IsLayoutPin():

pyedb/ipc2581/ecad/cad_data/polygon.py

@@ -35,7 +35,7 @@ class Polygon(object):
 
     def add_poly_step(self, polygon=None):  # pragma no cover
         if polygon:
-            polygon_data = polygon.GetPolygonData()
+            polygon_data = polygon._edb_object.GetPolygonData()
             if polygon_data.IsClosed():
                 arcs = polygon_data.GetArcData()
                 if not arcs:
@@ -64,7 +64,7 @@ class Polygon(object):
                         new_poly_step.clock_wise = not arc.IsCCW()
                         self.poly_steps.append(new_poly_step)
                 for void in polygon.voids:
-                    void_polygon_data = void.GetPolygonData()
+                    void_polygon_data = void._edb_object.GetPolygonData()
                     if void_polygon_data.IsClosed():
                         void_arcs = void_polygon_data.GetArcData()
                         if not void_arcs:

pyedb/ipc2581/ecad/cad_data/step.py

@@ -89,7 +89,7 @@ class Step(object):
         net_name = net.name
         logical_net = LogicalNet()
         logical_net.name = net_name
-        net_pins = list(net.PadstackInstances)
+        net_pins = list(net._edb_object.PadstackInstances)
         for pin in net_pins:
             new_pin_ref = logical_net.get_pin_ref_def()
             new_pin_ref.pin = pin.GetName()
@@ -250,9 +250,9 @@ class Step(object):
                 )
                 if pdef_name in padstack_defs:
                     padstack_def = padstack_defs[pdef_name]
-                    comp_name = padstack_instance.GetComponent().GetName()
+                    comp_name = padstack_instance._edb_object.GetComponent().GetName()
                     if padstack_instance.is_pin and comp_name:
-                        component_inst = self._pedb.components.components[comp_name]
+                        component_inst = self._pedb.components.instances[comp_name]
                         layers[layer_name].add_component_padstack_instance_feature(
                             component_inst, padstack_instance, top_bottom_layers, padstack_def
                         )

pyedb/ipc2581/ipc2581.py

@@ -250,7 +250,7 @@ class Ipc2581(object):
         self.layers_name = list(self._pedb.stackup.signal_layers.keys())
         self.top_bottom_layers = [self.layers_name[0], self.layers_name[-1]]
         sequence = 0
-        for layer_name in list(self._pedb.stackup.stackup_layers.keys()):
+        for layer_name in list(self._pedb.stackup.layers.keys()):
             sequence += 1
             self.content.add_layer_ref(layer_name)
             layer_color = self._pedb.stackup.layers[layer_name].color
@@ -316,7 +316,7 @@ class Ipc2581(object):
         self.content.dict_colors.add_color("{}".format("Drill"), "255", "255", "255")
 
     def add_components(self):
-        for item in self._pedb.components.components.values():
+        for item in self._pedb.components.instances.values():
             self.ecad.cad_data.cad_data_step.add_component(item)
 
     def add_logical_nets(self):