pyedb 0.56.0__py3-none-any.whl → 0.58.0__py3-none-any.whl

pyedb/grpc/database/primitive/bondwire.py

@@ -21,10 +21,10 @@
 # SOFTWARE.
 
 from ansys.edb.core.primitive.bondwire import (
+    Bondwire as GrpcBondWire,
     BondwireCrossSectionType as GrpcBondwireCrossSectionType,
+    BondwireType as GrpcBondWireType,
 )
-from ansys.edb.core.primitive.bondwire import Bondwire as GrpcBondWire
-from ansys.edb.core.primitive.bondwire import BondwireType as GrpcBondWireType
 
 from pyedb.grpc.database.utility.value import Value
 
@@ -36,6 +36,7 @@ class Bondwire(GrpcBondWire):
         super().__init__(edb_object.msg)
         self._pedb = _pedb
         self._edb_object = edb_object
+        # TODO add create and delete methods to keep cache in sync
 
     @property
     def material(self):
@@ -53,25 +54,6 @@ class Bondwire(GrpcBondWire):
     def material(self, value):
         self.set_material(value)
 
-    # def __create(self, **kwargs):
-    #     return Bondwire.create(
-    #         self._pedb.layout,
-    #         kwargs.get("net"),
-    #         self._bondwire_type[kwargs.get("bondwire_type")],
-    #         kwargs.get("definition_name"),
-    #         kwargs.get("placement_layer"),
-    #         kwargs.get("width"),
-    #         kwargs.get("material"),
-    #         kwargs.get("start_context"),
-    #         kwargs.get("start_layer_name"),
-    #         kwargs.get("start_x"),
-    #         kwargs.get("start_y"),
-    #         kwargs.get("end_context"),
-    #         kwargs.get("end_layer_name"),
-    #         kwargs.get("end_x"),
-    #         kwargs.get("end_y"),
-    #     )
-
     @property
     def type(self):
         """str: Bondwire-type of a bondwire object. Supported values for setter: `"apd"`, `"jedec4"`, `"jedec5"`,
@@ -120,28 +102,6 @@ class Bondwire(GrpcBondWire):
     def cross_section_height(self, cross_section_height):
         super(Bondwire, self.__class__).cross_section_height.__set__(self, Value(cross_section_height))
 
-    # @property
-    # def trajectory(self):
-    #     """Get trajectory parameters of a bondwire object.
-    #
-    #     Returns
-    #     -------
-    #     tuple[float, float, float, float]
-    #
-    #     Returns a tuple of the following format:
-    #     **(x1, y1, x2, y2)**
-    #     **x1** : X value of the start point.
-    #     **y1** : Y value of the start point.
-    #     **x1** : X value of the end point.
-    #     **y1** : Y value of the end point.
-    #     """
-    #     return [Value(i) for i in self.get_traj()]
-    #
-    # @trajectory.setter
-    # def trajectory(self, value):
-    #     values = [Value(i) for i in value]
-    #     self.set_traj(values[0], values[1], values[2], values[3])
-
     @property
     def width(self):
         """:class:`Value <ansys.edb.utility.Value>`: Width of a bondwire object.
@@ -156,27 +116,3 @@ class Bondwire(GrpcBondWire):
     @width.setter
     def width(self, width):
         super(Bondwire, self.__class__).width.__set__(self, Value(width))
-
-    # @property
-    # def start_elevation(self):
-    #     layer = self.get_start_elevation(self._pedb.active_cell)
-    #     return layer.name
-    #
-    # @start_elevation.setter
-    # def start_elevation(self, layer):
-    #     if not layer in self._pedb.stackup.layers:
-    #         return
-    #     layer = self._pedb.stackup.layers[layer]
-    #     self.set_start_elevation(self._pedb.active_cell, layer)
-    #
-    # @property
-    # def end_elevation(self):
-    #     layer = self.get_end_elevation(self._pedb.active_cell)
-    #     return layer.name
-    #
-    # @end_elevation.setter
-    # def end_elevation(self, layer):
-    #     if not layer in self._pedb.stackup.layers:
-    #         return
-    #     layer = self._pedb.stackup.layers[layer]
-    #     self.set_end_elevation(self._pedb.active_cell, layer)

pyedb/grpc/database/primitive/circle.py

@@ -21,18 +21,57 @@
 # SOFTWARE.
 
 
+from typing import Union
+
 from ansys.edb.core.primitive.circle import Circle as GrpcCircle
 
+from pyedb.grpc.database.layers.layer import Layer
+from pyedb.grpc.database.net.net import Net
 from pyedb.grpc.database.primitive.primitive import Primitive
 from pyedb.grpc.database.utility.value import Value
 
 
 class Circle(GrpcCircle, Primitive):
-    def __init__(self, pedb, edb_object):
-        GrpcCircle.__init__(self, edb_object.msg)
-        Primitive.__init__(self, pedb, edb_object)
+    def __init__(self, pedb, edb_object=None):
+        if edb_object:
+            GrpcCircle.__init__(self, edb_object.msg)
+            Primitive.__init__(self, pedb, edb_object)
         self._pedb = pedb
 
+    def create(
+        self,
+        layout=None,
+        layer: Union[str, Layer] = None,
+        net: Union[str, Net, None] = None,
+        center_x: float = None,
+        center_y: float = None,
+        radius: float = 0.0,
+    ):
+        if not layout:
+            layout = self._pedb.active_layout
+        if not layer:
+            raise ValueError("Layer must be provided to create a circle.")
+        if center_x is None or center_y is None:
+            raise ValueError("Center x and y values must be provided to create a circle.")
+        edb_object = GrpcCircle.create(
+            layout=layout,
+            layer=layer,
+            net=net,
+            center_x=Value(center_x),
+            center_y=Value(center_y),
+            radius=Value(radius),
+        )
+        new_circle = Circle(self._pedb, edb_object)
+        GrpcCircle.__init__(self, edb_object.msg)
+        Primitive.__init__(self, self._pedb, edb_object)
+        self._pedb.modeler._add_primitive(new_circle)
+        return new_circle
+
+    def delete(self):
+        """Delete the circle from the layout."""
+        self._pedb.modeler._remove_primitive(self)
+        super().delete()
+
     def get_parameters(self) -> tuple[float, float, float]:
         """Returns parameters.
 

pyedb/grpc/database/primitive/padstack_instance.py

@@ -28,8 +28,7 @@ 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.hierarchy.structure3d import MeshClosure as GrpcMeshClosure
-from ansys.edb.core.hierarchy.structure3d import Structure3D as GrpcStructure3D
+from ansys.edb.core.hierarchy.structure3d import MeshClosure as GrpcMeshClosure, Structure3D as GrpcStructure3D
 from ansys.edb.core.primitive.padstack_instance import (
     PadstackInstance as GrpcPadstackInstance,
 )
@@ -123,6 +122,47 @@ class PadstackInstance(GrpcPadstackInstance):
             term = PadstackInstanceTerminal(self._pedb, term)
         return term if not term.is_null else None
 
+    @property
+    def side_number(self):
+        """Return the number of sides meshed of the padstack instance.
+        Returns
+        -------
+        int
+            Number of sides meshed of the padstack instance.
+        """
+        side_value = self.get_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21)
+        if side_value:
+            return int(re.search(r"(?m)^\s*sid=(\d+)", side_value).group(1))
+        return 0
+
+    @side_number.setter
+    def side_number(self, value):
+        """Set the number of sides meshed of the padstack instance.
+
+        Parameters
+        ----------
+        value : int
+            Number of sides to mesh the padstack instance.
+
+        Returns
+        -------
+        bool
+            True if successful, False otherwise.
+        """
+        if isinstance(value, int) and 3 <= value <= 64:
+            prop_string = f"$begin ''\n\tsid={value}\n\tmat='copper'\n\tvs='Wirebond'\n$end ''\n"
+            self.set_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21, prop_string)
+        else:
+            raise ValueError("Number of sides must be an integer between 3 and 64")
+
+    def delete(self):
+        """Delete the padstack instance."""
+        try:
+            self._pedb.padstacks._instances.pop(self.edb_uid, None)
+        except Exception:
+            self._pedb.padstacks.clear_instances_cache()
+        super().delete()
+
     def set_backdrill_top(self, drill_depth, drill_diameter, offset=0.0):
         """Set backdrill from top.
 
@@ -144,7 +184,7 @@ class PadstackInstance(GrpcPadstackInstance):
             True if success, False otherwise.
         """
         warnings.warn(
-            "`set_backdrill_top` is deprecated. Use `set_back_drill_by_depth` or " "`set_back_drill_by_layer` instead.",
+            "`set_backdrill_top` is deprecated. Use `set_back_drill_by_depth` or `set_back_drill_by_layer` instead.",
             DeprecationWarning,
         )
         if isinstance(drill_depth, str):
@@ -179,8 +219,7 @@ class PadstackInstance(GrpcPadstackInstance):
             True if success, False otherwise.
         """
         warnings.warn(
-            "`set_backdrill_bottom` is deprecated. Use `set_back_drill_by_depth` or "
-            "`set_back_drill_by_layer` instead.",
+            "`set_backdrill_bottom` is deprecated. Use `set_back_drill_by_depth` or `set_back_drill_by_layer` instead.",
             DeprecationWarning,
         )
         if isinstance(drill_depth, str):
@@ -761,18 +800,6 @@ class PadstackInstance(GrpcPadstackInstance):
     def aedt_name(self, value):
         self.set_product_property(GrpcProductIdType.DESIGNER, 11, value)
 
-    @property
-    def side_number(self) -> int:
-        if not self._side_number:
-            prop_string = "$begin ''\n\tsid=3\n\tmat='copper'\n\tvs='Wirebond'\n$end ''\n"
-            self.set_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21, prop_string)
-        self._side_number = self.get_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21)
-        return self._side_number
-
-    @side_number.setter
-    def side_number(self, value):
-        self._side_number = self.set_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21, value)
-
     def split(self) -> list:
         """Split padstack instance into multiple instances. The new instances only connect adjacent layers."""
         pdef_name = self.padstack_definition
@@ -826,21 +853,21 @@ class PadstackInstance(GrpcPadstackInstance):
             rad_l = rad_large
 
         layout = self._pedb.active_layout
-        cloned_circle = Circle.create(
-            layout,
-            self.start_layer,
-            self.net,
-            Value(self.position[0]),
-            Value(self.position[1]),
-            Value(rad_u),
+        cloned_circle = Circle(self._pedb).create(
+            layout=layout,
+            layer=self.start_layer,
+            net=self.net,
+            center_x=Value(self.position[0]),
+            center_y=Value(self.position[1]),
+            radius=Value(rad_u),
         )
-        cloned_circle2 = Circle.create(
-            layout,
-            self.stop_layer,
-            self.net,
-            Value(self.position[0]),
-            Value(self.position[1]),
-            Value(rad_l),
+        cloned_circle2 = Circle(self._pedb).create(
+            layout=layout,
+            layer=self.stop_layer,
+            net=self.net,
+            center_x=Value(self.position[0]),
+            center_y=Value(self.position[1]),
+            radius=Value(rad_l),
         )
 
         s3d = GrpcStructure3D.create(layout, generate_unique_name("via3d_" + self.aedt_name.replace("via_", ""), n=3))

pyedb/grpc/database/primitive/path.py

@@ -20,19 +20,25 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 import math
+from typing import Union
 
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
-from ansys.edb.core.primitive.path import Path as GrpcPath
-from ansys.edb.core.primitive.path import PathCornerType as GrpcPatCornerType
+from ansys.edb.core.primitive.path import (
+    Path as GrpcPath,
+    PathCornerType as GrpcPathCornerType,
+    PathEndCapType as GrpcPathEndCapType,
+)
 
+from pyedb.grpc.database.layers.layer import Layer
 from pyedb.grpc.database.primitive.primitive import Primitive
 from pyedb.grpc.database.utility.value import Value
 
 
 class Path(GrpcPath, Primitive):
-    def __init__(self, pedb, edb_object):
-        GrpcPath.__init__(self, edb_object.msg)
-        Primitive.__init__(self, pedb, edb_object)
+    def __init__(self, pedb, edb_object=None):
+        if edb_object:
+            GrpcPath.__init__(self, edb_object.msg)
+            Primitive.__init__(self, pedb, edb_object)
         self._edb_object = edb_object
         self._pedb = pedb
 
@@ -72,6 +78,105 @@ class Path(GrpcPath, Primitive):
                 path_length += self.width / 2
         return round(path_length, 9)
 
+    def create(
+        self,
+        layout=None,
+        layer: Union[str, Layer] = None,
+        net: Union[str, "Net"] = None,
+        width: float = 100e-6,
+        end_cap1: Union[str, GrpcPathEndCapType] = "flat",
+        end_cap2: Union[str, GrpcPathEndCapType] = "flat",
+        corner_style: Union[str, GrpcPathCornerType] = "sharp",
+        points: Union[list, GrpcPolygonData] = None,
+    ):
+        """
+        Create a path in the specified layout, layer, and net with the given parameters.
+
+        Parameters
+        ----------
+        layout : Layout, optional
+            The layout in which the path will be created. If not provided, the active layout of the `pedb` instance
+            will be used.
+        layer : Union[str, Layer], optional
+            The layer in which the path will be created. This parameter is required and must be specified.
+        net : Union[str, Net], optional
+            The net to which the path will belong. If not provided, the path will not be associated with a net.
+        width : float, optional
+            The width of the path in meters. The default value is `100e-6`.
+        end_cap1 : str, optional
+            The style of the first end cap. Options are `"flat"`, `"round"`, `"extended"`, and `"clipped"`.
+            The default value is `"flat"`.
+        end_cap2 : str, optional
+            The style of the second end cap. Options are `"flat"`, `"round"`, `"extended"`, and `"clipped"`.
+            The default value is `"flat"`.
+        corner_style : str, optional
+            The style of the path corners. Options are `"sharp"`, `"round"`, and `"mitter"`.
+            The default value is `"sharp"`.
+        points : Union[list, GrpcPolygonData], optional
+            The points defining the path. This can be a list of points or an instance of `GrpcPolygonData`.
+            This parameter is required and must be specified.
+
+        Returns
+        -------
+        :class:`Path <pyedb.grpc.database.primitive.path.Path>`
+            The created path object.
+
+        Raises
+        ------
+        ValueError
+            If the `points` parameter is not provided.
+
+        Notes
+        -----
+        - If `points` is provided as a list, it will be converted to a `GrpcPolygonData` object.
+        - The created path is added to the modeler primitives of the `pedb` instance.
+
+        """
+        if layout is None:
+            layout = self._pedb.active_layout
+        end_cap_mapping = {
+            "flat": GrpcPathEndCapType.FLAT,
+            "round": GrpcPathEndCapType.ROUND,
+            "extended": GrpcPathEndCapType.EXTENDED,
+            "clipped": GrpcPathEndCapType.CLIPPED,
+        }
+        corner_style_mapping = {
+            "round": GrpcPathCornerType.ROUND,
+            "mitter": GrpcPathCornerType.MITER,
+            "sharp": GrpcPathCornerType.SHARP,
+        }
+        if isinstance(end_cap1, str):
+            end_cap1 = end_cap_mapping[end_cap1.lower()]
+        if isinstance(end_cap2, str):
+            end_cap2 = end_cap_mapping[end_cap2.lower()]
+        if isinstance(corner_style, str):
+            corner_style = corner_style_mapping[corner_style.lower()]
+        if not points:
+            raise ValueError("Points are required to create a path.")
+        if isinstance(points, list):
+            points = GrpcPolygonData(points=points)
+        self._edb_object = super().create(
+            layout=layout,
+            layer=layer,
+            net=net,
+            width=Value(width),
+            end_cap1=end_cap1,
+            end_cap2=end_cap2,
+            corner_style=corner_style,
+            points=points,
+        )
+
+        # keeping cache synced
+        new_path = Path(self._pedb, self._edb_object)
+        self._pedb.modeler._add_primitive(new_path)
+        return new_path
+
+    def delete(self):
+        """Delete the path object."""
+        # keeping cache synced
+        self._pedb.modeler._remove_primitive(self)
+        super().delete()
+
     def add_point(self, x, y, incremental=True) -> bool:
         """Add a point at the end of the path.
 
@@ -110,9 +215,9 @@ class Path(GrpcPath, Primitive):
             ``True`` when successful, ``False`` when failed.
         """
         mapping = {
-            "round": GrpcPatCornerType.ROUND,
-            "mitter": GrpcPatCornerType.MITER,
-            "sharp": GrpcPatCornerType.SHARP,
+            "round": GrpcPathCornerType.ROUND,
+            "mitter": GrpcPathCornerType.MITER,
+            "sharp": GrpcPathCornerType.SHARP,
         }
 
         cloned_path = GrpcPath.create(
@@ -339,8 +444,52 @@ class Path(GrpcPath, Primitive):
     def corner_style(self, corner_type):
         if isinstance(corner_type, str):
             mapping = {
-                "round": GrpcPatCornerType.ROUND,
-                "mitter": GrpcPatCornerType.MITER,
-                "sharp": GrpcPatCornerType.SHARP,
+                "round": GrpcPathCornerType.ROUND,
+                "mitter": GrpcPathCornerType.MITER,
+                "sharp": GrpcPathCornerType.SHARP,
             }
             self.corner_style = mapping[corner_type]
+
+    @property
+    def end_cap1(self) -> str:
+        """Path's start style as string.
+
+        Returns
+        -------
+        str
+            Values supported for the setter `"flat"`, `"round"`, `"extended"`
+
+        """
+        return self.get_end_cap_style()[0].name.lower()
+
+    @end_cap1.setter
+    def end_cap1(self, end_cap_style):
+        if isinstance(end_cap_style, str):
+            mapping = {
+                "flat": GrpcPathEndCapType.FLAT,
+                "round": GrpcPathEndCapType.ROUND,
+                "extended": GrpcPathEndCapType.EXTENDED,
+            }
+            self.set_end_cap_style(mapping[end_cap_style], self.get_end_cap_style()[1].value)
+
+    @property
+    def end_cap2(self) -> str:
+        """Path's end style as string.
+
+        Returns
+        -------
+        str
+            Values supported for the setter `"flat"`, `"round"`, `"extended"`
+
+        """
+        return self.get_end_cap_style()[1].name.lower()
+
+    @end_cap2.setter
+    def end_cap2(self, end_cap_style):
+        if isinstance(end_cap_style, str):
+            mapping = {
+                "flat": GrpcPathEndCapType.FLAT,
+                "round": GrpcPathEndCapType.ROUND,
+                "extended": GrpcPathEndCapType.EXTENDED,
+            }
+            self.set_end_cap_style(self.get_end_cap_style()[0].value, mapping[end_cap_style])

pyedb/grpc/database/primitive/polygon.py

@@ -22,19 +22,23 @@
 
 
 import math
+from typing import Union
 
 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.polygon import Polygon as GrpcPolygon
 
+from pyedb.grpc.database.layers.layer import Layer
+from pyedb.grpc.database.layout.layout import Layout
 from pyedb.grpc.database.primitive.primitive import Primitive
 from pyedb.grpc.database.utility.value import Value
 
 
 class Polygon(GrpcPolygon, Primitive):
-    def __init__(self, pedb, edb_object):
-        GrpcPolygon.__init__(self, edb_object.msg)
-        Primitive.__init__(self, pedb, edb_object)
+    def __init__(self, pedb, edb_object=None):
+        if edb_object:
+            GrpcPolygon.__init__(self, edb_object.msg)
+            Primitive.__init__(self, pedb, edb_object)
         self._pedb = pedb
 
     @property
@@ -59,6 +63,67 @@ class Polygon(GrpcPolygon, Primitive):
         """
         return self.polygon_data.has_self_intersections()
 
+    def create(
+        self, layout: Layout = None, layer: Union[str, Layer] = None, net: Union[str, "Net"] = None, polygon_data=None
+    ):
+        """
+        Create a polygon in the specified layout, layer, and net using the provided polygon data.
+
+        Parameters
+        ----------
+        layout : Layout, optional
+            The layout in which the polygon will be created. If not provided, the active layout of the `pedb`
+            instance will be used.
+        layer : Union[str, Layer], optional
+            The layer in which the polygon will be created. This parameter is required and must be specified.
+        net : Union[str, Net], optional
+            The net to which the polygon will belong. If not provided, the polygon will not be associated with a
+            net.
+        polygon_data : list or GrpcPolygonData, optional
+            The data defining the polygon. This can be a list of points or an instance of `GrpcPolygonData`.
+            This parameter is required and must be specified.
+
+        Returns
+        -------
+        :class:`Polygon <ansys.edb.core.primitive.polygon.Polygon>`
+            The created polygon object.
+
+        Raises
+        ------
+        ValueError
+            If the `layer` parameter is not provided.
+        ValueError
+            If the `polygon_data` parameter is not provided.
+
+        Notes
+        -----
+        - If `polygon_data` is provided as a list, it will be converted to a `GrpcPolygonData` object.
+        - The created polygon is added to the modeler primitives of the `pedb` instance.
+
+        """
+        if not layout:
+            layout = self._pedb.active_layout
+        if not layer:
+            raise ValueError("Layer is required to create a polygon.")
+        if not polygon_data:
+            raise ValueError("Polygon data or point list is required to create a polygon.")
+        if isinstance(polygon_data, list):
+            polygon_data = GrpcPolygonData(polygon_data)
+
+        # call into the gRPC layer to actually create the polygon
+        edb_object = super().create(layout=layout, layer=layer, net=net, polygon_data=polygon_data)
+        new_polygon = Polygon(self._pedb, edb_object)
+        # keep modeler cache in sync
+        self._pedb.modeler._add_primitive(new_polygon)
+
+        return new_polygon
+
+    def delete(self):
+        """Delete polygon from layout."""
+        # keeping cache in sync
+        self._pedb.modeler._remove_primitive(self)
+        super().delete()
+
     def fix_self_intersections(self) -> list[any]:
         """Remove self intersections if they exist.
 
@@ -88,13 +153,14 @@ class Polygon(GrpcPolygon, Primitive):
             Cloned polygon.
 
         """
+        voids = self.voids
         polygon_data = self.polygon_data
-        duplicated_polygon = self.create(
+        cloned_polygon = self.create(
             layout=self._pedb.active_layout, layer=self.layer, net=self.net, polygon_data=polygon_data
         )
-        for void in self.voids:
-            duplicated_polygon.add_void(void)
-        return duplicated_polygon
+        for void in voids:
+            cloned_polygon.add_void(void)
+        return cloned_polygon
 
     def duplicate_across_layers(self, layers) -> bool:
         """Duplicate across layer a primitive object.

pyedb/grpc/database/primitive/primitive.py

@@ -39,8 +39,8 @@ class Primitive(GrpcPrimitive):
     >>> from pyedb import Edb
     >>> edb = Edb(myedb, edbversion="2021.2")
     >>> edb_prim = edb.modeler.primitives[0]
-    >>> edb_prim.is_void # Class Property
-    >>> edb_prim.IsVoid() # EDB Object Property
+    >>> edb_prim.is_void  # Class Property
+    >>> edb_prim.IsVoid()  # EDB Object Property
     """
 
     def __init__(self, pedb, edb_object):