pyedb 0.42.0__py3-none-any.whl → 0.44.0__py3-none-any.whl

pyedb/grpc/database/hierarchy/pingroup.py

@@ -22,7 +22,7 @@
 
 
 from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
-from ansys.edb.core.terminal.terminals import BoundaryType as GrpcBoundaryType
+from ansys.edb.core.terminal.terminal import BoundaryType as GrpcBoundaryType
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.generic.general_methods import generate_unique_name
@@ -74,9 +74,9 @@ class PinGroup(GrpcPinGroup):
 
         Returns
         -------
-        List[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`].
+        Dict[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`].
         """
-        return [PadstackInstance(self._pedb, i) for i in super().pins]
+        return {i.name: PadstackInstance(self._pedb, i) for i in super().pins}
 
     @property
     def net(self):
@@ -105,11 +105,15 @@ class PinGroup(GrpcPinGroup):
         """
         return self.net.name
 
-    # @property
-    # def terminal(self):
-    #     """Terminal."""
-    #     term = PinGroupTerminal(self._pedb, self.get_pin_group_terminal())  # TODO check method is missing
-    #     return term if not term.is_null else None
+    @property
+    def terminal(self):
+        """Terminal."""
+        term = self.pin_group_terminal
+        if not term.is_null:
+            term = PinGroupTerminal(self._pedb, term)
+            return term
+        else:
+            return None
 
     def create_terminal(self, name=None):
         """Create a terminal.

pyedb/grpc/database/layers/layer.py

@@ -52,6 +52,34 @@ class Layer(GrpcLayer):
             else:
                 self._pedb.logger.error(f"{k} is not a valid layer attribute")
 
+    @property
+    def properties(self):
+        from ansys.edb.core.layer.stackup_layer import StackupLayer as GrpcStackupLayer
+
+        from pyedb.grpc.database.stackup import StackupLayer
+
+        if isinstance(self.cast(), GrpcStackupLayer):
+            return StackupLayer(self._pedb, self.cast()).properties
+        else:
+            data = {"name": self.name, "type": self.type, "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
+
+    @property
+    def type(self):
+        return super().type.name.lower().split("_")[0]
+
     @property
     def _layer_name_mapping_reversed(self):
         return {j: i for i, j in self._layer_name_mapping.items()}

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/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/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

pyedb/grpc/database/primitive/polygon.py

@@ -25,7 +25,7 @@ import math
 
 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.primitive.primitive import Polygon as GrpcPolygon
+from ansys.edb.core.primitive.polygon import Polygon as GrpcPolygon
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.primitive import Primitive
@@ -64,7 +64,7 @@ class Polygon(GrpcPolygon, Primitive):
 
         Returns
         -------
-        List[:class:`Polygon <ansys.edb.core.primitive.primitive.Polygon>`]
+        List[:class:`Polygon <ansys.edb.core.primitive.polygon.Polygon>`]
             All new polygons created from the removal operation.
 
         """
@@ -84,7 +84,7 @@ class Polygon(GrpcPolygon, Primitive):
 
         Returns
         -------
-        :class:`Polygon <ansys.edb.core.primitive.primitive.Polygon>`
+        :class:`Polygon <ansys.edb.core.primitive.polygon.Polygon>`
             Cloned polygon.
 
         """