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

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 GrpcPatCornerType,
+    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: str = "flat",
+        end_cap2: str = "flat",
+        corner_style: str = "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": GrpcPatCornerType.ROUND,
+            "mitter": GrpcPatCornerType.MITER,
+            "sharp": GrpcPatCornerType.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.
 
@@ -344,3 +449,47 @@ class Path(GrpcPath, Primitive):
                 "sharp": GrpcPatCornerType.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):

pyedb/grpc/database/primitive/rectangle.py

@@ -21,11 +21,14 @@
 # SOFTWARE.
 
 
+from typing import Union
+
 from ansys.edb.core.primitive.rectangle import (
+    Rectangle as GrpcRectangle,
     RectangleRepresentationType as GrpcRectangleRepresentationType,
 )
-from ansys.edb.core.primitive.rectangle import Rectangle as GrpcRectangle
 
+from pyedb.grpc.database.layers.layer import Layer
 from pyedb.grpc.database.primitive.primitive import Primitive
 from pyedb.grpc.database.utility.value import Value
 
@@ -33,9 +36,10 @@ from pyedb.grpc.database.utility.value import Value
 class Rectangle(GrpcRectangle, Primitive):
     """Class representing a rectangle object."""
 
-    def __init__(self, pedb, edb_object):
-        Primitive.__init__(self, pedb, edb_object)
-        GrpcRectangle.__init__(self, edb_object.msg)
+    def __init__(self, pedb, edb_object=None):
+        if edb_object:
+            Primitive.__init__(self, pedb, edb_object)
+            GrpcRectangle.__init__(self, edb_object.msg)
         self._pedb = pedb
         self._mapping_representation_type = {
             "center_width_height": GrpcRectangleRepresentationType.CENTER_WIDTH_HEIGHT,
@@ -71,6 +75,103 @@ class Rectangle(GrpcRectangle, Primitive):
         else:
             super().representation_type = self._mapping_representation_type[value]
 
+    def create(
+        self,
+        layout=None,
+        layer: Union[str, Layer] = None,
+        net: Union[str, "Net"] = None,
+        rep_type: str = "center_width_height",
+        param1: float = None,
+        param2: float = None,
+        param3: float = None,
+        param4: float = None,
+        corner_rad: float = 0.0,
+        rotation: float = 0.0,
+    ):
+        """
+        Create a rectangle primitive in the specified layout, layer, and net with the given parameters.
+
+        Parameters
+        ----------
+        layout : Layout, optional
+            The layout in which the rectangle 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 rectangle will be created. This parameter is required and must be specified.
+        net : Union[str, Net], optional
+            The net to which the rectangle will belong. This parameter is required and must be specified.
+        rep_type : str, optional
+            The representation type of the rectangle. Options are `"center_width_height"` or `"lower_left_upper_right"`.
+            The default value is `"center_width_height"`.
+        param1 : float, optional
+            The first parameter defining the rectangle. Its meaning depends on the `rep_type`.
+        param2 : float, optional
+            The second parameter defining the rectangle. Its meaning depends on the `rep_type`.
+        param3 : float, optional
+            The third parameter defining the rectangle. Its meaning depends on the `rep_type`.
+        param4 : float, optional
+            The fourth parameter defining the rectangle. Its meaning depends on the `rep_type`.
+        corner_rad : float, optional
+            The corner radius of the rectangle. The default value is `0.0`.
+        rotation : float, optional
+            The rotation angle of the rectangle in degrees. The default value is `0.0`.
+
+        Returns
+        -------
+        Rectangle
+            The created rectangle primitive.
+
+        Raises
+        ------
+        ValueError
+            If the `layer` parameter is not provided.
+        ValueError
+            If the `net` parameter is not provided.
+
+        Notes
+        -----
+        - The created rectangle is added to the modeler primitives of the `pedb` instance.
+        - The `rep_type` determines how the parameters are interpreted:
+            - `"center_width_height"`: `param1` and `param2` represent the center coordinates, while `param3` and
+            `param4` represent the width and height.
+            - `"lower_left_upper_right"`: `param1` and `param2` represent the lower-left corner coordinates, while
+            `param3` and `param4` represent the upper-right corner coordinates.
+        """
+        if not layout:
+            layout = self._pedb.active_layout
+        if not layer:
+            raise ValueError("Layer must be provided.")
+        if not net:
+            raise ValueError("Net must be provided.")
+
+        rep_type_mapping = {
+            "center_width_height": GrpcRectangleRepresentationType.CENTER_WIDTH_HEIGHT,
+            "lower_left_upper_right": GrpcRectangleRepresentationType.LOWER_LEFT_UPPER_RIGHT,
+        }
+        rep_type = rep_type_mapping.get(rep_type, GrpcRectangleRepresentationType.INVALID_RECT_TYPE)
+        edb_object = super().create(
+            layout=layout,
+            layer=layer,
+            net=net,
+            rep_type=rep_type,
+            param1=Value(param1),
+            param2=Value(param2),
+            param3=Value(param3),
+            param4=Value(param4),
+            corner_rad=Value(corner_rad),
+            rotation=Value(rotation),
+        )
+        # keep cache synced
+        new_rect = Rectangle(self._pedb, edb_object)
+        self._pedb.modeler._add_primitive(new_rect)
+        return new_rect
+
+    def delete(self):
+        """Delete the rectangle primitive from the layout."""
+        # Remove from cache
+        self._pedb.modeler._remove_primitive(self)
+        super().delete()
+
     def get_parameters(self):
         """Get coordinates parameters.
 

pyedb/grpc/database/simulation_setup/hfss_general_settings.py

@@ -23,8 +23,6 @@
 
 from ansys.edb.core.simulation_setup.hfss_simulation_settings import (
     AdaptType as GrpcAdaptType,
-)
-from ansys.edb.core.simulation_setup.hfss_simulation_settings import (
     HFSSGeneralSettings as GrpcHFSSGeneralSettings,
 )
 

pyedb/grpc/database/simulation_setup/hfss_settings_options.py

@@ -23,11 +23,7 @@
 
 from ansys.edb.core.simulation_setup.hfss_simulation_settings import (
     BasisFunctionOrder as GrpcBasisFunctionOrder,
-)
-from ansys.edb.core.simulation_setup.hfss_simulation_settings import (
     HFSSSettingsOptions as GrpcHFSSSettingsOptions,
-)
-from ansys.edb.core.simulation_setup.hfss_simulation_settings import (
     SolverType as GrpcSolverType,
 )
 

pyedb/grpc/database/simulation_setup/siwave_cpa_simulation_setup.py

@@ -758,6 +758,7 @@ class SIWaveCPASimulationSetup:
         self._pedb = pedb
         self._channel_setup = ChannelSetup(pedb)
         self._solver_options = SolverOptions(pedb)
+        self.type = "cpa"
         if isinstance(siwave_cpa_setup_class, SIwaveCpaSetup):
             self._apply_cfg_object(siwave_cpa_setup_class)
         else:

pyedb/grpc/database/simulation_setup/sweep_data.py

@@ -22,11 +22,9 @@
 
 from ansys.edb.core.simulation_setup.simulation_setup import (
     Distribution as GrpcDistribution,
-)
-from ansys.edb.core.simulation_setup.simulation_setup import (
     FrequencyData as GrpcFrequencyData,
+    SweepData as GrpcSweepData,
 )
-from ansys.edb.core.simulation_setup.simulation_setup import SweepData as GrpcSweepData
 
 
 class SweepData(GrpcSweepData):

pyedb/grpc/database/siwave.py

@@ -24,6 +24,7 @@
 This module contains these classes: ``CircuitPort``, ``CurrentSource``, ``EdbSiwave``,
 ``PinGroup``, ``ResistorSource``, ``Source``, ``SourceType``, and ``VoltageSource``.
 """
+
 import os
 from typing import Any, Dict, Optional, Union
 import warnings
@@ -31,11 +32,9 @@ import warnings
 from ansys.edb.core.database import ProductIdType as GrpcProductIdType
 from ansys.edb.core.simulation_setup.simulation_setup import (
     Distribution as GrpcDistribution,
-)
-from ansys.edb.core.simulation_setup.simulation_setup import (
     FrequencyData as GrpcFrequencyData,
+    SweepData as GrpcSweepData,
 )
-from ansys.edb.core.simulation_setup.simulation_setup import SweepData as GrpcSweepData
 
 from pyedb.grpc.database.simulation_setup.siwave_cpa_simulation_setup import (
     SIWaveCPASimulationSetup,
@@ -335,7 +334,7 @@ class Siwave(object):
             Use :func:`pyedb.grpc.core.excitations._check_gnd` instead.
         """
         warnings.warn(
-            "`_check_gnd` is deprecated and is now located here " "`pyedb.grpc.core.excitations._check_gnd` instead.",
+            "`_check_gnd` is deprecated and is now located here `pyedb.grpc.core.excitations._check_gnd` instead.",
             DeprecationWarning,
         )
         return self._pedb.source_excitation._check_gnd(component_name)
@@ -563,9 +562,7 @@ class Siwave(object):
         >>> success = edbapp.siwave.create_exec_file(add_ac=True, add_syz=True)
         >>> # Create exec file with Touchstone export
         >>> success = edbapp.siwave.create_exec_file(
-        ...     add_ac=True,
-        ...     export_touchstone=True,
-        ...     touchstone_file_path="C:/temp/my_touchstone.s2p"
+        ...     add_ac=True, export_touchstone=True, touchstone_file_path="C:/temp/my_touchstone.s2p"
         ... )
         """
         workdir = os.path.dirname(self._pedb.edbpath)
@@ -644,17 +641,13 @@ class Siwave(object):
         >>> from pyedb import Edb
         >>> edbapp = Edb("myaedbfolder", edbversion="2021.2")
         >>> # Add SYZ analysis with linear sweep from 1kHz to 10GHz
-        >>> setup = edbapp.siwave.add_siwave_syz_analysis(
-        ...     start_freq=1e3,
-        ...     stop_freq=10e9,
-        ...     distribution="linear"
-        ... )
+        >>> setup = edbapp.siwave.add_siwave_syz_analysis(start_freq=1e3, stop_freq=10e9, distribution="linear")
         >>> # Add SYZ analysis with decade sweep
         >>> setup = edbapp.siwave.add_siwave_syz_analysis(
         ...     start_freq=1e3,
         ...     stop_freq=10e9,
         ...     distribution="decade_count",
-        ...     step_freq=10  # 10 points per decade
+        ...     step_freq=10,  # 10 points per decade
         ... )
         """
         setup = self._pedb.create_siwave_syz_setup()