pyedb 0.43.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

pyedb/grpc/database/layers/stackup_layer.py

@@ -56,13 +56,77 @@ class StackupLayer(GrpcStackupLayer):
         str
             Layer name.
         """
-        return super().type.name.lower()
+        return super().type.name.lower().split("_")[0]
 
     @type.setter
     def type(self, value):
         if value in self._stackup_layer_mapping:
             super(StackupLayer, self.__class__).type.__set__(self, self._stackup_layer_mapping[value])
 
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if k in dir(self):
+                self.__setattr__(k, v)
+            elif k == "roughness":
+                self.roughness_enabled = v["enabled"]
+                if "top" in v:
+                    top_roughness = v["top"]
+                    if top_roughness:
+                        if top_roughness["model"] == "huray":
+                            nodule_radius = top_roughness["nodule_radius"]
+                            surface_ratio = top_roughness["surface_ratio"]
+                            self.assign_roughness_model(
+                                model_type="huray",
+                                huray_radius=nodule_radius,
+                                huray_surface_ratio=surface_ratio,
+                                apply_on_surface="top",
+                            )
+                        elif top_roughness["model"] == "groisse":
+                            roughness = top_roughness["roughness"]
+                            self.assign_roughness_model(
+                                model_type="groisse", groisse_roughness=roughness, apply_on_surface="top"
+                            )
+                    if "bottom" in v:
+                        bottom_roughness = v["bottom"]
+                        if bottom_roughness:
+                            if bottom_roughness["model"] == "huray":
+                                nodule_radius = bottom_roughness["nodule_radius"]
+                                surface_ratio = bottom_roughness["surface_ratio"]
+                                self.assign_roughness_model(
+                                    model_type="huray",
+                                    huray_radius=nodule_radius,
+                                    huray_surface_ratio=surface_ratio,
+                                    apply_on_surface="bottom",
+                                )
+                            elif bottom_roughness["model"] == "groisse":
+                                roughness = bottom_roughness["roughness"]
+                                self.assign_roughness_model(
+                                    model_type="groisse", groisse_roughness=roughness, apply_on_surface="bottom"
+                                )
+                    if "side" in v:
+                        side_roughness = v["side"]
+                        if side_roughness:
+                            if side_roughness["model"] == "huray":
+                                nodule_radius = side_roughness["nodule_radius"]
+                                surface_ratio = side_roughness["surface_ratio"]
+                                self.assign_roughness_model(
+                                    model_type="huray",
+                                    huray_radius=nodule_radius,
+                                    huray_surface_ratio=surface_ratio,
+                                    apply_on_surface="side",
+                                )
+                            elif side_roughness["model"] == "groisse":
+                                roughness = side_roughness["roughness"]
+                                self.assign_roughness_model(
+                                    model_type="groisse", groisse_roughness=roughness, apply_on_surface="side"
+                                )
+
+            elif k == "etching":
+                self.etch_factor_enabled = v["enabled"]
+                self.etch_factor = float(v["factor"])
+            else:
+                self._pedb.logger.error(f"{k} is not a valid layer attribute")
+
     def _create(self, layer_type):
         if layer_type in self._stackup_layer_mapping:
             layer_type = self._stackup_layer_mapping[layer_type]
@@ -99,12 +163,12 @@ class StackupLayer(GrpcStackupLayer):
         str
             Material name.
         """
-        if self.is_stackup_layer:
+        if self.type == "signal":
             return self.get_fill_material()
 
     @fill_material.setter
     def fill_material(self, value):
-        if self.is_stackup_layer:
+        if self.type == "signal":
             self.set_fill_material(value)
 
     @property
@@ -258,16 +322,24 @@ class StackupLayer(GrpcStackupLayer):
         float
             Nodule radius value.
         """
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-        if top_roughness_model:
-            return top_roughness_model.nodule_radius.value
-        else:
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if len(top_roughness_model) == 2:
+                return top_roughness_model[0].value
+            else:
+                return None
+        except:
             return None
 
     @top_hallhuray_nodule_radius.setter
     def top_hallhuray_nodule_radius(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-        top_roughness_model.nodule_radius = GrpcValue(value)
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if len(top_roughness_model) == 2:
+                top_roughness_model[0] = GrpcValue(value)
+                self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
+        except:
+            pass
 
     @property
     def top_hallhuray_surface_ratio(self):
@@ -278,16 +350,24 @@ class StackupLayer(GrpcStackupLayer):
         float
             Surface ratio.
         """
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-        if top_roughness_model:
-            return top_roughness_model.surface_ratio.value
-        else:
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if len(top_roughness_model) == 2:
+                return top_roughness_model[1].value
+            else:
+                return None
+        except:
             return None
 
     @top_hallhuray_surface_ratio.setter
     def top_hallhuray_surface_ratio(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-        top_roughness_model.surface_roughness = GrpcValue(value)
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if len(top_roughness_model) == 2:
+                top_roughness_model[1] = GrpcValue(value)
+                self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
+        except:
+            pass
 
     @property
     def bottom_hallhuray_nodule_radius(self):
@@ -298,15 +378,24 @@ class StackupLayer(GrpcStackupLayer):
         float
             Nodule radius.
         """
-        bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-        if bottom_roughness_model:
-            return bottom_roughness_model.nodule_radius.value
-        return None
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if len(bottom_roughness_model) == 2:
+                return round(bottom_roughness_model[0].value, 9)
+            else:
+                return None
+        except:
+            return None
 
     @bottom_hallhuray_nodule_radius.setter
     def bottom_hallhuray_nodule_radius(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-        top_roughness_model.nodule_radius = GrpcValue(value)
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if len(bottom_roughness_model) == 2:
+                bottom_roughness_model[0] = GrpcValue(value)
+                self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
+        except:
+            pass
 
     @property
     def bottom_hallhuray_surface_ratio(self):
@@ -317,15 +406,24 @@ class StackupLayer(GrpcStackupLayer):
         float
             Surface ratio value.
         """
-        bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-        if bottom_roughness_model:
-            return bottom_roughness_model.surface_ratio.value
-        return None
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if len(bottom_roughness_model) == 2:
+                return bottom_roughness_model[1].value
+            else:
+                return None
+        except:
+            return None
 
     @bottom_hallhuray_surface_ratio.setter
     def bottom_hallhuray_surface_ratio(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-        top_roughness_model.surface_ratio = GrpcValue(value)
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if len(bottom_roughness_model) == 2:
+                bottom_roughness_model[1] = GrpcValue(value)
+                self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
+        except:
+            pass
 
     @property
     def side_hallhuray_nodule_radius(self):
@@ -337,15 +435,23 @@ class StackupLayer(GrpcStackupLayer):
             Nodule radius value.
 
         """
-        side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
-        if side_roughness_model:
-            return side_roughness_model.nodule_radius.value
-        return None
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if len(side_roughness_model) == 2:
+                return round(side_roughness_model[0].value, 9)
+            return None
+        except:
+            return None
 
     @side_hallhuray_nodule_radius.setter
     def side_hallhuray_nodule_radius(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
-        top_roughness_model.nodule_radius = GrpcValue(value)
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if len(side_roughness_model) == 2:
+                side_roughness_model[0] = GrpcValue(value)
+                self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.SIDE)
+        except:
+            pass
 
     @property
     def side_hallhuray_surface_ratio(self):
@@ -356,16 +462,107 @@ class StackupLayer(GrpcStackupLayer):
         float
             surface ratio.
         """
-        side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
-        if side_roughness_model:
-            return side_roughness_model.surface_ratio.value
-        else:
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if len(side_roughness_model) == 2:
+                return side_roughness_model[1].value
+            return None
+        except:
             return None
 
     @side_hallhuray_surface_ratio.setter
     def side_hallhuray_surface_ratio(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
-        top_roughness_model.surface_ratio = GrpcValue(value)
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if len(side_roughness_model) == 2:
+                side_roughness_model[1] = GrpcValue(value)
+                self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.SIDE)
+        except:
+            pass
+
+    @property
+    def top_groisse_roughness(self):
+        """Groisse model on layer top.
+
+        Returns
+        -------
+        float
+            Roughness value.
+        """
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if isinstance(top_roughness_model, GrpcValue):
+                return top_roughness_model.value
+            else:
+                return None
+        except:
+            return None
+
+    @top_groisse_roughness.setter
+    def top_groisse_roughness(self, value):
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if isinstance(top_roughness_model, GrpcValue):
+                top_roughness_model = GrpcValue(value)
+                self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
+        except:
+            pass
+
+    @property
+    def bottom_groisse_roughness(self):
+        """Groisse model on layer bottom.
+
+        Returns
+        -------
+        float
+            Roughness value.
+        """
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if isinstance(bottom_roughness_model, GrpcValue):
+                return bottom_roughness_model.value
+            else:
+                return None
+        except:
+            return None
+
+    @bottom_groisse_roughness.setter
+    def bottom_groisse_roughness(self, value):
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if isinstance(bottom_roughness_model, GrpcValue):
+                bottom_roughness_model = GrpcValue(value)
+                self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
+        except:
+            pass
+
+    @property
+    def side_groisse_roughness(self):
+        """Groisse model on layer bottom.
+
+        Returns
+        -------
+        float
+            Roughness value.
+        """
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if isinstance(side_roughness_model, GrpcValue):
+                return side_roughness_model.value
+            else:
+                return None
+        except:
+            return None
+
+    @side_groisse_roughness.setter
+    def side_groisse_roughness(self, value):
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if isinstance(side_roughness_model, GrpcValue):
+                side_roughness_model = GrpcValue(value)
+                self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.BOTTOM)
+        except Exception as e:
+            self._pedb.logger.error(e)
 
     def assign_roughness_model(
         self,
@@ -400,7 +597,7 @@ class StackupLayer(GrpcStackupLayer):
         elif apply_on_surface == "bottom":
             regions = [GrpcRoughnessRegion.BOTTOM]
         elif apply_on_surface == "side":
-            regions = [GrpcRoughnessRegion.BOTTOM]
+            regions = [GrpcRoughnessRegion.SIDE]
         self.roughness_enabled = True
         for r in regions:
             if model_type == "huray":
@@ -408,3 +605,47 @@ class StackupLayer(GrpcStackupLayer):
             else:
                 model = GrpcValue(groisse_roughness)
             self.set_roughness_model(model, r)
+
+    @property
+    def properties(self):
+        data = {"name": self.name, "type": self.type, "color": self.color}
+        if self.type == "signal" or self.type == "dielectric":
+            data["material"] = self.material
+            data["thickness"] = self.thickness
+        if self.type == "signal":
+            data["fill_material"] = self.fill_material
+        roughness = {"top": {}, "bottom": {}, "side": {}}
+        if self.top_hallhuray_nodule_radius:
+            roughness["top"]["model"] = "huray"
+            roughness["top"]["nodule_radius"] = self.top_hallhuray_nodule_radius
+            roughness["top"]["surface_ratio"] = self.top_hallhuray_surface_ratio
+
+        elif self.top_groisse_roughness:
+            roughness["top"]["model"] = "groisse"
+            roughness["top"]["roughness"] = self.top_groisse_roughness
+
+        if self.bottom_hallhuray_nodule_radius:
+            roughness["bottom"]["model"] = "huray"
+            roughness["bottom"]["nodule_radius"] = self.bottom_hallhuray_nodule_radius
+            roughness["bottom"]["surface_ratio"] = self.bottom_hallhuray_surface_ratio
+
+        elif self.bottom_groisse_roughness:
+            roughness["bottom"]["model"] = "groisse"
+            roughness["bottom"]["roughness"] = self.bottom_groisse_roughness
+
+        if self.side_hallhuray_nodule_radius:
+            roughness["side"]["model"] = "huray"
+            roughness["side"]["nodule_radius"] = self.side_hallhuray_nodule_radius
+            roughness["side"]["surface_ratio"] = self.side_hallhuray_surface_ratio
+
+        elif self.side_groisse_roughness:
+            roughness["side"]["model"] = "groisse"
+            roughness["side"]["roughness"] = self.side_groisse_roughness
+
+        if roughness["top"] or roughness["bottom"] or roughness["side"]:
+            roughness["enabled"] = True
+        else:
+            roughness["enabled"] = False
+        data["roughness"] = roughness
+        data["etching"] = {"enabled": self.etch_factor_enabled, "factor": self.etch_factor}
+        return data

pyedb/grpc/database/layout/layout.py

@@ -26,7 +26,13 @@ This module contains these classes: `EdbLayout` and `Shape`.
 from typing import Union
 
 from ansys.edb.core.layout.layout import Layout as GrpcLayout
+import ansys.edb.core.primitive.bondwire
+import ansys.edb.core.primitive.circle
+import ansys.edb.core.primitive.padstack_instance
+import ansys.edb.core.primitive.path
+import ansys.edb.core.primitive.polygon
 import ansys.edb.core.primitive.primitive
+import ansys.edb.core.primitive.rectangle
 
 from pyedb.grpc.database.hierarchy.component import Component
 from pyedb.grpc.database.hierarchy.pingroup import PinGroup
@@ -69,17 +75,17 @@ class Layout(GrpcLayout):
     def primitives(self):
         prims = []
         for prim in super().primitives:
-            if isinstance(prim, ansys.edb.core.primitive.primitive.Path):
+            if isinstance(prim, ansys.edb.core.primitive.path.Path):
                 prims.append(Path(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.primitive.Polygon):
+            elif isinstance(prim, ansys.edb.core.primitive.polygon.Polygon):
                 prims.append(Polygon(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.primitive.PadstackInstance):
+            elif isinstance(prim, ansys.edb.core.primitive.padstack_instance.PadstackInstance):
                 prims.append(PadstackInstance(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.primitive.Rectangle):
+            elif isinstance(prim, ansys.edb.core.primitive.rectangle.Rectangle):
                 prims.append(Rectangle(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.primitive.Circle):
+            elif isinstance(prim, ansys.edb.core.primitive.circle.Circle):
                 prims.append(Circle(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.primitive.Bondwire):
+            elif isinstance(prim, ansys.edb.core.primitive.bondwire.Bondwire):
                 prims.append(Bondwire(self._pedb, prim))
         return prims
 

pyedb/grpc/database/layout_validation.py

@@ -284,9 +284,9 @@ class LayoutValidation:
             if prim.net_name in net_list:
                 new_prims.extend(prim.fix_self_intersections())
         if new_prims:
-            self._pedb._logger.info("Self-intersections detected and removed.")
+            self._pedb.logger.info("Self-intersections detected and removed.")
         else:
-            self._pedb._logger.info("Self-intersection not found.")
+            self._pedb.logger.info("Self-intersection not found.")
         return True
 
     def illegal_net_names(self, fix=False):

pyedb/grpc/database/modeler.py

@@ -33,12 +33,12 @@ from ansys.edb.core.geometry.polygon_data import (
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
 from ansys.edb.core.inner.exceptions import InvalidArgumentException
-from ansys.edb.core.primitive.primitive import (
+from ansys.edb.core.primitive.bondwire import BondwireType as GrpcBondwireType
+from ansys.edb.core.primitive.path import PathCornerType as GrpcPathCornerType
+from ansys.edb.core.primitive.path import PathEndCapType as GrpcPathEndCapType
+from ansys.edb.core.primitive.rectangle import (
     RectangleRepresentationType as GrpcRectangleRepresentationType,
 )
-from ansys.edb.core.primitive.primitive import BondwireType as GrpcBondwireType
-from ansys.edb.core.primitive.primitive import PathCornerType as GrpcPathCornerType
-from ansys.edb.core.primitive.primitive import PathEndCapType as GrpcPathEndCapType
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.bondwire import Bondwire
@@ -314,10 +314,10 @@ class Modeler(object):
         list of :class:`pyedb.dotnet.database.edb_data.primitives_data.Primitive`
             List of primitives, polygons, paths and rectangles.
         """
-        from ansys.edb.core.primitive.primitive import Circle as GrpcCircle
-        from ansys.edb.core.primitive.primitive import Path as GrpcPath
-        from ansys.edb.core.primitive.primitive import Polygon as GrpcPolygon
-        from ansys.edb.core.primitive.primitive import Rectangle as GrpcRectangle
+        from ansys.edb.core.primitive.circle import Circle as GrpcCircle
+        from ansys.edb.core.primitive.path import Path as GrpcPath
+        from ansys.edb.core.primitive.polygon import Polygon as GrpcPolygon
+        from ansys.edb.core.primitive.rectangle import Rectangle as GrpcRectangle
 
         if isinstance(layer, str) and layer not in list(self._pedb.stackup.signal_layers.keys()):
             layer = None

pyedb/grpc/database/padstacks.py

@@ -1569,14 +1569,13 @@ class Padstacks(object):
         for id, inst in self.instances.items():
             instances_index[id] = inst.position
         for contour_box in contour_boxes:
-            all_instances = self.instances
             instances = self.get_padstack_instances_id_intersecting_polygon(
                 points=contour_box, padstack_instances_index=instances_index
             )
             if net_filter:
-                instances = [self.instances[id] for id in instances if not self.instances[id].net.name in net_filter]
+                instances = [id for id in instances if not self.instances[id].net.name in net_filter]
             net = self.instances[instances[0]].net.name
-            instances_pts = np.array([self.instances[id].position for id in instances])
+            instances_pts = np.array([self.instances[inst].position for inst in instances])
             convex_hull_contour = ConvexHull(instances_pts)
             contour_points = list(instances_pts[convex_hull_contour.vertices])
             layer = list(self._pedb.stackup.layers.values())[0].name
@@ -1595,9 +1594,15 @@ class Padstacks(object):
                 stop_layer=stop_layer,
             ):
                 self._logger.error(f"Failed to create padstack definition {new_padstack_def}")
-            merged_instance = self.place(position=[0, 0], definition_name=new_padstack_def, net_name=net)
-            merged_via_ids.append(merged_instance.id)
-            [self.instances[id].delete() for id in instances]
+            merged_instance = self.place(
+                position=[0, 0],
+                definition_name=new_padstack_def,
+                net_name=net,
+                fromlayer=start_layer,
+                tolayer=stop_layer,
+            )
+            merged_via_ids.append(merged_instance.edb_uid)
+            [self.instances[inst].delete() for inst in instances]
         return merged_via_ids
 
     def reduce_via_in_bounding_box(self, bounding_box, x_samples, y_samples, nets=None):
@@ -1611,7 +1616,7 @@ class Padstacks(object):
         x_samples : int
         y_samples : int
         nets : str or list, optional
-            net name of list of nets name applying filtering on padstack instances selection. If ``None`` is provided
+            net name of list of nets name applying filtering on pad-stack instances selection. If ``None`` is provided
             all instances are included in the index. Default value is ``None``.
 
         Returns
@@ -1622,10 +1627,11 @@ class Padstacks(object):
 
         padstacks_inbox = self.get_padstack_instances_intersecting_bounding_box(bounding_box, nets)
         if not padstacks_inbox:
-            raise "No pad-stack in bounding box."
+            return False
         else:
             if len(padstacks_inbox) <= (x_samples * y_samples):
-                raise f"more samples {x_samples * y_samples} than existing {len(padstacks_inbox)}"
+                self._pedb.logger.error(f"more samples {x_samples * y_samples} than existing {len(padstacks_inbox)}")
+                return False
             else:
                 # extract ids and positions
                 vias = {item: self.instances[item].position for item in padstacks_inbox}

pyedb/grpc/database/ports/ports.py

@@ -146,7 +146,7 @@ class WavePort(EdgeTerminal):
     """
 
     def __init__(self, pedb, edb_terminal):
-        super().__init__(pedb, edb_terminal.msg)
+        super().__init__(pedb, edb_terminal)
 
     @property
     def horizontal_extent_factor(self):
@@ -161,9 +161,9 @@ class WavePort(EdgeTerminal):
 
     @horizontal_extent_factor.setter
     def horizontal_extent_factor(self, value):
-        self.p = p
-        p = self.p
+        p = self._hfss_port_property
         p["Horizontal Extent Factor"] = value
+        self._hfss_port_property = p
 
     @property
     def vertical_extent_factor(self):

pyedb/grpc/database/primitive/bondwire.py

@@ -20,11 +20,11 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from ansys.edb.core.primitive.primitive import (
+from ansys.edb.core.primitive.bondwire import (
     BondwireCrossSectionType as GrpcBondwireCrossSectionType,
 )
-from ansys.edb.core.primitive.primitive import Bondwire as GrpcBondWire
-from ansys.edb.core.primitive.primitive import BondwireType as GrpcBondWireType
+from ansys.edb.core.primitive.bondwire import Bondwire as GrpcBondWire
+from ansys.edb.core.primitive.bondwire import BondwireType as GrpcBondWireType
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 

pyedb/grpc/database/primitive/circle.py

@@ -21,7 +21,7 @@
 # SOFTWARE.
 
 
-from ansys.edb.core.primitive.primitive import Circle as GrpcCircle
+from ansys.edb.core.primitive.circle import Circle as GrpcCircle
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.primitive import Primitive

pyedb/grpc/database/primitive/padstack_instance.py

@@ -27,8 +27,12 @@ from ansys.edb.core.database import ProductIdType as GrpcProductIdType
 from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
-from ansys.edb.core.primitive.primitive import PadstackInstance as GrpcPadstackInstance
-from ansys.edb.core.terminal.terminals import PinGroupTerminal as GrpcPinGroupTerminal
+from ansys.edb.core.primitive.padstack_instance import (
+    PadstackInstance as GrpcPadstackInstance,
+)
+from ansys.edb.core.terminal.pin_group_terminal import (
+    PinGroupTerminal as GrpcPinGroupTerminal,
+)
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.definition.padstack_def import PadstackDef
@@ -98,7 +102,9 @@ class PadstackInstance(GrpcPadstackInstance):
             PadstackInstanceTerminal,
         )
 
-        term = PadstackInstanceTerminal(self._pedb, self._edb_object)
+        term = self.get_padstack_instance_terminal()
+        if not term.is_null:
+            term = PadstackInstanceTerminal(self._pedb, term)
         return term if not term.is_null else None
 
     def create_terminal(self, name=None):
@@ -661,6 +667,10 @@ class PadstackInstance(GrpcPadstackInstance):
         name = self.get_product_property(GrpcProductIdType.DESIGNER, 11)
         return str(name).strip("'")
 
+    @aedt_name.setter
+    def aedt_name(self, value):
+        self.set_product_property(GrpcProductIdType.DESIGNER, 11, value)
+
     def get_backdrill_type(self, from_bottom=True):
         """Return backdrill type
         Parameters

pyedb/grpc/database/primitive/path.py

@@ -22,8 +22,8 @@
 import math
 
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
-from ansys.edb.core.primitive.primitive import Path as GrpcPath
-from ansys.edb.core.primitive.primitive import PathCornerType as GrpcPatCornerType
+from ansys.edb.core.primitive.path import Path as GrpcPath
+from ansys.edb.core.primitive.path import PathCornerType as GrpcPatCornerType
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.primitive import Primitive