pyedb 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

pyedb/dotnet/edb_core/geometry/polygon_data.py

@@ -20,6 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.dotnet.edb_core.geometry.point_data import PointData
 from pyedb.dotnet.edb_core.utilities.obj_base import BBox
 
@@ -50,6 +51,14 @@ class PolygonData:
         else:  # pragma: no cover
             self._edb_object = edb_object
 
+    @property
+    def arcs(self):
+        """Get the Primitive Arc Data."""
+        from pyedb.dotnet.edb_core.edb_data.primitives_data import EDBArcs
+
+        arcs = [EDBArcs(self._pedb, i) for i in self._edb_object.GetArcData()]
+        return arcs
+
     @property
     def points(self):
         """Get all points in polygon.
@@ -72,3 +81,37 @@ class PolygonData:
     def create_from_bounding_box(self, points):
         bbox = BBox(self._pedb, point_1=points[0], point_2=points[1])
         return self._pedb.edb_api.geometry.api_class.PolygonData.CreateFromBBox(bbox._edb_object)
+
+    def expand(self, offset=0.001, tolerance=1e-12, round_corners=True, maximum_corner_extension=0.001):
+        """Expand the polygon shape by an absolute value in all direction.
+        Offset can be negative for negative expansion.
+
+        Parameters
+        ----------
+        offset : float, optional
+            Offset value in meters.
+        tolerance : float, optional
+            Tolerance in meters.
+        round_corners : bool, optional
+            Whether to round corners or not.
+            If True, use rounded corners in the expansion otherwise use straight edges (can be degenerate).
+        maximum_corner_extension : float, optional
+            The maximum corner extension (when round corners are not used) at which point the corner is clipped.
+        """
+        new_poly = self._edb_object.Expand(offset, tolerance, round_corners, maximum_corner_extension)
+        self._edb_object = new_poly[0]
+        return True
+
+    def create_from_arcs(self, arcs, flag):
+        """Edb Dotnet Api Database `Edb.Geometry.CreateFromArcs`.
+
+        Parameters
+        ----------
+        arcs : list or `Edb.Geometry.ArcData`
+            List of ArcData.
+        flag : bool
+        """
+        if isinstance(arcs, list):
+            arcs = convert_py_list_to_net_list(arcs)
+        poly = self._edb_object.CreateFromArcs(arcs, flag)
+        return PolygonData(self._pedb, poly)

pyedb/dotnet/edb_core/hfss.py

@@ -27,7 +27,7 @@ import math
 
 from pyedb.dotnet.edb_core.edb_data.hfss_extent_info import HfssExtentInfo
 from pyedb.dotnet.edb_core.edb_data.ports import BundleWavePort, WavePort
-from pyedb.dotnet.edb_core.edb_data.primitives_data import EDBPrimitives
+from pyedb.dotnet.edb_core.edb_data.primitives_data import Primitive
 from pyedb.dotnet.edb_core.edb_data.simulation_configuration import (
     SimulationConfiguration,
 )
@@ -523,10 +523,10 @@ class EdbHfss(object):
         if not port_name:
             port_name = generate_unique_name("diff")
 
-        if isinstance(positive_primitive_id, EDBPrimitives):
+        if isinstance(positive_primitive_id, Primitive):
             positive_primitive_id = positive_primitive_id.id
 
-        if isinstance(negative_primitive_id, EDBPrimitives):
+        if isinstance(negative_primitive_id, Primitive):
             negative_primitive_id = negative_primitive_id.id
 
         _, pos_term = self.create_wave_port(
@@ -547,8 +547,10 @@ class EdbHfss(object):
             [pos_term._edb_object, neg_term._edb_object], self._edb.cell.terminal.Terminal
         )
         _edb_boundle_terminal = self._edb.cell.terminal.BundleTerminal.Create(edb_list)
-        # _edb_boundle_terminal.SetName("Wave_"+port_name)
-        pos_term._edb_object.SetName(port_name)
+        _edb_boundle_terminal.SetName(port_name)
+        pos, neg = list(_edb_boundle_terminal.GetTerminals())
+        pos.SetName(port_name + ":T1")
+        neg.SetName(port_name + ":T2")
         return port_name, BundleWavePort(self._pedb, _edb_boundle_terminal)
 
     def create_bundle_wave_port(
@@ -591,7 +593,7 @@ class EdbHfss(object):
         if not port_name:
             port_name = generate_unique_name("bundle_port")
 
-        if isinstance(primitives_id[0], EDBPrimitives):
+        if isinstance(primitives_id[0], Primitive):
             primitives_id = [i.id for i in primitives_id]
 
         terminals = []
@@ -718,10 +720,10 @@ class EdbHfss(object):
             )
         if not port_name:
             port_name = generate_unique_name("Port_")
-        edge = self._edb.cell.terminal.PrimitiveEdge.Create(polygon.prim_obj, terminal_point)
+        edge = self._edb.cell.terminal.PrimitiveEdge.Create(polygon._edb_object, terminal_point)
         edges = convert_py_list_to_net_list(edge, self._edb.cell.terminal.Edge)
         edge_term = self._edb.cell.terminal.EdgeTerminal.Create(
-            polygon.GetLayout(), polygon.GetNet(), port_name, edges, isRef=False
+            polygon._edb_object.GetLayout(), polygon._edb_object.GetNet(), port_name, edges, isRef=False
         )
         if force_circuit_port:
             edge_term.SetIsCircuitPort(True)
@@ -732,10 +734,14 @@ class EdbHfss(object):
             edge_term.SetImpedance(self._pedb.edb_value(port_impedance))
         edge_term.SetName(port_name)
         if reference_polygon and reference_point:
-            ref_edge = self._edb.cell.terminal.PrimitiveEdge.Create(reference_polygon.prim_obj, reference_point)
+            ref_edge = self._edb.cell.terminal.PrimitiveEdge.Create(reference_polygon._edb_object, reference_point)
             ref_edges = convert_py_list_to_net_list(ref_edge, self._edb.cell.terminal.Edge)
             ref_edge_term = self._edb.cell.terminal.EdgeTerminal.Create(
-                reference_polygon.GetLayout(), reference_polygon.GetNet(), port_name + "_ref", ref_edges, isRef=True
+                reference_polygon._edb_object.GetLayout(),
+                reference_polygon._edb_object.GetNet(),
+                port_name + "_ref",
+                ref_edges,
+                isRef=True,
             )
             if reference_layer:
                 ref_edge_term.SetReferenceLayer(reference_layer)
@@ -763,7 +769,7 @@ class EdbHfss(object):
 
         Parameters
         ----------
-        prim_id : int, EDBPrimitives
+        prim_id : int, Primitive
             Primitive ID.
         point_on_edge : list
             Coordinate of the point to define the edge terminal.
@@ -792,7 +798,7 @@ class EdbHfss(object):
         if not port_name:
             port_name = generate_unique_name("Terminal_")
 
-        if isinstance(prim_id, EDBPrimitives):
+        if isinstance(prim_id, Primitive):
             prim_id = prim_id.id
 
         pos_edge_term = self._create_edge_terminal(prim_id, point_on_edge, port_name)
@@ -1097,27 +1103,25 @@ class EdbHfss(object):
                 net_polygons = [
                     pp
                     for pp in net.primitives
-                    if pp.GetPrimitiveType() == self._edb.cell.primitive.PrimitiveType.Polygon
+                    if pp._edb_object.GetPrimitiveType() == self._edb.cell.primitive.api.PrimitiveType.Polygon
                 ]
                 for poly in net_polygons:
                     mid_points = [[arc.mid_point.X.ToDouble(), arc.mid_point.Y.ToDouble()] for arc in poly.arcs]
                     for mid_point in mid_points:
                         if GeometryOperators.point_in_polygon(mid_point, user_defined_extent) == 0:
-                            port_name = generate_unique_name("{}_{}".format(poly.GetNet().GetName(), poly.GetId()))
-                            term = self._create_edge_terminal(poly.GetId(), mid_point, port_name)  # pragma no cover
+                            port_name = generate_unique_name("{}_{}".format(poly.net.name, poly.id))
+                            term = self._create_edge_terminal(poly.id, mid_point, port_name)  # pragma no cover
                             if not term.IsNull():
                                 self._logger.info("Terminal {} created".format(term.GetName()))
                                 term.SetIsCircuitPort(True)
-                                terminal_info.append(
-                                    [poly.GetNet().GetName(), mid_point[0], mid_point[1], term.GetName()]
-                                )
+                                terminal_info.append([poly.net.name, mid_point[0], mid_point[1], term.GetName()])
                                 mid_pt_data = self._edb.geometry.point_data(
                                     self._edb.utility.value(mid_point[0]), self._edb.utility.value(mid_point[1])
                                 )
                                 ref_prim = [
                                     prim
                                     for prim in reference_net.primitives
-                                    if prim.polygon_data.edb_api.PointInPolygon(mid_pt_data)
+                                    if prim.polygon_data._edb_object.PointInPolygon(mid_pt_data)
                                 ]
                                 if not ref_prim:
                                     self._logger.warning("no reference primitive found, trying to extend scanning area")
@@ -1442,7 +1446,7 @@ class EdbHfss(object):
             as argument."
             )
             return False
-        net_names = [net.name for net in self._layout.nets if not net.IsPowerGround()]
+        net_names = [net.name for net in self._layout.nets if not net._edb_object.IsPowerGround()]
         if simulation_setup.components and isinstance(simulation_setup.components[0], str):
             cmp_names = (
                 simulation_setup.components
@@ -1552,8 +1556,8 @@ class EdbHfss(object):
            Number of ports.
 
         """
-        terms = [term for term in self._layout.terminals if int(term.GetBoundaryType()) == 0]
-        return len([i for i in terms if not i.IsReferenceTerminal()])
+        terms = [term for term in self._layout.terminals if int(term._edb_object.GetBoundaryType()) == 0]
+        return len([i for i in terms if not i.is_reference_terminal])
 
     def layout_defeaturing(self, simulation_setup=None):
         """Defeature the layout by reducing the number of points for polygons based on surface deviation criteria.

pyedb/dotnet/edb_core/layout_validation.py

@@ -23,7 +23,7 @@
 import re
 
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
-from pyedb.dotnet.edb_core.edb_data.primitives_data import EDBPrimitives
+from pyedb.dotnet.edb_core.edb_data.primitives_data import Primitive
 from pyedb.generic.general_methods import generate_unique_name
 
 
@@ -204,7 +204,7 @@ class LayoutValidation:
                     sum = 0
                     for el in elem:
                         try:
-                            if isinstance(obj_dict[el], EDBPrimitives):
+                            if isinstance(obj_dict[el], Primitive):
                                 if not obj_dict[el].is_void:
                                     sum += obj_dict[el].area()
                         except:
@@ -246,7 +246,7 @@ class LayoutValidation:
                         new_net_name = generate_unique_name(net, n=6)
                         net_obj = self._pedb.nets.find_or_create_net(new_net_name)
                         if net_obj:
-                            new_nets.append(net_obj.GetName())
+                            new_nets.append(net_obj.name)
                             for geo in disjoints:
                                 try:
                                     obj_dict[geo].net_name = net_obj

pyedb/dotnet/edb_core/modeler.py

@@ -26,14 +26,9 @@ This module contains these classes: `EdbLayout` and `Shape`.
 import math
 import warnings
 
-from pyedb.dotnet.edb_core.cell.primitive import Bondwire
-from pyedb.dotnet.edb_core.dotnet.primitive import (
-    CircleDotNet,
-    PathDotNet,
-    PolygonDotNet,
-    RectangleDotNet,
-)
-from pyedb.dotnet.edb_core.edb_data.primitives_data import EDBPrimitives, cast
+from pyedb.dotnet.edb_core.cell.primitive.bondwire import Bondwire
+from pyedb.dotnet.edb_core.dotnet.primitive import CircleDotNet, RectangleDotNet
+from pyedb.dotnet.edb_core.edb_data.primitives_data import Primitive, cast
 from pyedb.dotnet.edb_core.edb_data.utilities import EDBStatistics
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 
@@ -128,7 +123,7 @@ class Modeler(object):
 
         Returns
         -------
-        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             List of primitives.
         """
         for p in self._layout.primitives:
@@ -145,16 +140,10 @@ class Modeler(object):
 
         Returns
         -------
-        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             List of primitives.
         """
-        if len(self._primitives) == len(self._layout.primitives):
-            return self._primitives
-        self._primitives = []
-        if self._active_layout:
-            for lay_obj in self._layout.primitives:
-                self._primitives.append(cast(lay_obj, self._pedb))
-        return self._primitives
+        return self._pedb.layout.primitives
 
     @property
     def polygons_by_layer(self):
@@ -181,7 +170,7 @@ class Modeler(object):
         """
         _prim_by_net = {}
         for net, net_obj in self._pedb.nets.nets.items():
-            _prim_by_net[net] = [cast(i, self._pedb) for i in net_obj.primitives]
+            _prim_by_net[net] = [i for i in net_obj.primitives]
         return _prim_by_net
 
     @property
@@ -199,13 +188,9 @@ class Modeler(object):
         for lay in self._pedb.stackup.non_stackup_layers:
             _primitives_by_layer[lay] = []
         for i in self._layout.primitives:
-            try:
-                lay = i.GetLayer().GetName()
-                if lay in _primitives_by_layer:
-                    _primitives_by_layer[lay].append(cast(i, self._pedb))
-            except:
-                self._logger.warning(f"Failed to get layer on primitive {i}, skipping.")
-                continue
+            lay = i.layer.name
+            if lay in _primitives_by_layer:
+                _primitives_by_layer[lay].append(i)
         return _primitives_by_layer
 
     @property
@@ -214,7 +199,7 @@ class Modeler(object):
 
         Returns
         -------
-        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             List of rectangles.
 
         """
@@ -226,7 +211,7 @@ class Modeler(object):
 
         Returns
         -------
-        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             List of circles.
 
         """
@@ -238,10 +223,10 @@ class Modeler(object):
 
         Returns
         -------
-        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             List of paths.
         """
-        return [i for i in self.primitives if isinstance(i, PathDotNet)]
+        return [i for i in self.primitives if i.primitive_type == "path"]
 
     @property
     def polygons(self):
@@ -249,10 +234,10 @@ class Modeler(object):
 
         Returns
         -------
-        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             List of polygons.
         """
-        return [i for i in self.primitives if isinstance(i, PolygonDotNet)]
+        return [i for i in self.primitives if i.primitive_type == "polygon"]
 
     def get_polygons_by_layer(self, layer_name, net_list=None):
         """Retrieve polygons by a layer.
@@ -271,14 +256,11 @@ class Modeler(object):
         """
         objinst = []
         for el in self.polygons:
-            try:
-                if el.GetLayer().GetName() == layer_name:
-                    if net_list and el.GetNet().GetName() in net_list:
-                        objinst.append(el)
-                    else:
-                        objinst.append(el)
-            except:
-                self._logger.warning(f"Failed to retrieve layer on polygon {el}")
+            if el.layer.name == layer_name:
+                if net_list and el.net.name in net_list:
+                    objinst.append(el)
+                else:
+                    objinst.append(el)
         return objinst
 
     def get_primitive_by_layer_and_point(self, point=None, layer=None, nets=None):
@@ -297,7 +279,7 @@ class Modeler(object):
 
         Returns
         -------
-        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             List of primitives, polygons, paths and rectangles.
         """
         if isinstance(layer, str) and layer not in list(self._pedb.stackup.signal_layers.keys()):
@@ -379,7 +361,7 @@ class Modeler(object):
         Parameters
         ----------
         polygon :
-            class: `dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+            class: `dotnet.edb_core.edb_data.primitives_data.Primitive`
 
         Returns
         -------
@@ -536,28 +518,28 @@ class Modeler(object):
 
         Returns
         -------
-        :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             ``True`` when successful, ``False`` when failed.
         """
         net = self._pedb.nets.find_or_create_net(net_name)
         if start_cap_style.lower() == "round":
-            start_cap_style = self._edb.cell.primitive.PathEndCapStyle.Round
+            start_cap_style = self._edb.cell.primitive.api.PathEndCapStyle.Round
         elif start_cap_style.lower() == "extended":
-            start_cap_style = self._edb.cell.primitive.PathEndCapStyle.Extended  # pragma: no cover
+            start_cap_style = self._edb.cell.primitive.api.PathEndCapStyle.Extended  # pragma: no cover
         else:
-            start_cap_style = self._edb.cell.primitive.PathEndCapStyle.Flat  # pragma: no cover
+            start_cap_style = self._edb.cell.primitive.api.PathEndCapStyle.Flat  # pragma: no cover
         if end_cap_style.lower() == "round":
-            end_cap_style = self._edb.cell.primitive.PathEndCapStyle.Round  # pragma: no cover
+            end_cap_style = self._edb.cell.primitive.api.PathEndCapStyle.Round  # pragma: no cover
         elif end_cap_style.lower() == "extended":
-            end_cap_style = self._edb.cell.primitive.PathEndCapStyle.Extended  # pragma: no cover
+            end_cap_style = self._edb.cell.primitive.api.PathEndCapStyle.Extended  # pragma: no cover
         else:
-            end_cap_style = self._edb.cell.primitive.PathEndCapStyle.Flat
+            end_cap_style = self._edb.cell.primitive.api.PathEndCapStyle.Flat
         if corner_style.lower() == "round":
-            corner_style = self._edb.cell.primitive.PathCornerStyle.RoundCorner
+            corner_style = self._edb.cell.primitive.api.PathCornerStyle.RoundCorner
         elif corner_style.lower() == "sharp":
-            corner_style = self._edb.cell.primitive.PathCornerStyle.SharpCorner  # pragma: no cover
+            corner_style = self._edb.cell.primitive.api.PathCornerStyle.SharpCorner  # pragma: no cover
         else:
-            corner_style = self._edb.cell.primitive.PathCornerStyle.MiterCorner  # pragma: no cover
+            corner_style = self._edb.cell.primitive.api.PathCornerStyle.MiterCorner  # pragma: no cover
 
         pointlists = [self._pedb.point_data(i[0], i[1]) for i in path_list.points]
         polygonData = self._edb.geometry.polygon_data.dotnetobj(convert_py_list_to_net_list(pointlists), False)
@@ -571,10 +553,12 @@ class Modeler(object):
             corner_style,
             polygonData,
         )
-        if polygon.IsNull():  # pragma: no cover
+
+        if polygon.prim_obj.IsNull():  # pragma: no cover
             self._logger.error("Null path created")
             return False
-        return cast(polygon, self._pedb)
+        polygon = self._pedb.layout.find_object_by_id(polygon.prim_obj.GetId())
+        return polygon
 
     def create_trace(
         self,
@@ -613,7 +597,7 @@ class Modeler(object):
 
         Returns
         -------
-        :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
         """
         path = self.Shape("Polygon", points=path_list)
         primitive = self._create_path(
@@ -648,7 +632,7 @@ class Modeler(object):
 
         Returns
         -------
-        bool, :class:`dotnet.edb_core.edb_data.primitives.EDBPrimitives`
+        bool, :class:`dotnet.edb_core.edb_data.primitives.Primitive`
             Polygon when successful, ``False`` when failed.
         """
         net = self._pedb.nets.find_or_create_net(net_name)
@@ -683,12 +667,15 @@ class Modeler(object):
             elif isinstance(void, Modeler.Shape):
                 voidPolygonData = self.shape_to_polygon_data(void)
             else:
-                voidPolygonData = void
+                voidPolygonData = void.polygon_data._edb_object
+
             if voidPolygonData is False or voidPolygonData is None or voidPolygonData.IsNull():
                 self._logger.error("Failed to create void polygon data")
                 return False
             polygonData.AddHole(voidPolygonData)
-        polygon = self._edb.cell.primitive.polygon.create(self._active_layout, layer_name, net, polygonData)
+        polygon = self._pedb._edb.Cell.Primitive.Polygon.Create(
+            self._active_layout, layer_name, net.net_obj, polygonData
+        )
         if polygon.IsNull() or polygonData is False:  # pragma: no cover
             self._logger.error("Null polygon created")
             return False
@@ -716,7 +703,7 @@ class Modeler(object):
 
         Returns
         -------
-        :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
         """
         warnings.warn(
             "Use :func:`create_polygon` method instead. It now supports point lists as arguments.", DeprecationWarning
@@ -764,12 +751,12 @@ class Modeler(object):
 
         Returns
         -------
-         :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+         :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             Rectangle when successful, ``False`` when failed.
         """
         edb_net = self._pedb.nets.find_or_create_net(net_name)
         if representation_type == "LowerLeftUpperRight":
-            rep_type = self._edb.cell.primitive.RectangleRepresentationType.LowerLeftUpperRight
+            rep_type = self._edb.cell.primitive.api.RectangleRepresentationType.LowerLeftUpperRight
             rect = self._edb.cell.primitive.rectangle.create(
                 self._active_layout,
                 layer_name,
@@ -783,7 +770,7 @@ class Modeler(object):
                 self._get_edb_value(rotation),
             )
         else:
-            rep_type = self._edb.cell.primitive.RectangleRepresentationType.CenterWidthHeight
+            rep_type = self._edb.cell.primitive.api.RectangleRepresentationType.CenterWidthHeight
             rect = self._edb.cell.primitive.rectangle.create(
                 self._active_layout,
                 layer_name,
@@ -797,7 +784,7 @@ class Modeler(object):
                 self._get_edb_value(rotation),
             )
         if rect:
-            return cast(rect, self._pedb)
+            return self._pedb.layout.find_object_by_id(rect._edb_object.GetId())
         return False  # pragma: no cover
 
     def create_circle(self, layer_name, x, y, radius, net_name=""):
@@ -819,7 +806,7 @@ class Modeler(object):
 
         Returns
         -------
-        :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+        :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.Primitive`
             Objects of the circle created when successful.
         """
         edb_net = self._pedb.nets.find_or_create_net(net_name)
@@ -833,7 +820,7 @@ class Modeler(object):
             self._get_edb_value(radius),
         )
         if circle:
-            return cast(circle, self._pedb)
+            return self._pedb.layout.find_object_by_id(circle._edb_object.GetId())
         return False  # pragma: no cover
 
     def delete_primitives(self, net_names):
@@ -940,12 +927,12 @@ class Modeler(object):
             Shape of the voids.
         """
         flag = False
-        if isinstance(shape, EDBPrimitives):
+        if isinstance(shape, Primitive):
             shape = shape.primitive_object
         if not isinstance(void_shape, list):
             void_shape = [void_shape]
         for void in void_shape:
-            if isinstance(void, EDBPrimitives):
+            if isinstance(void, Primitive):
                 flag = shape.AddVoid(void.primitive_object)
             else:
                 flag = shape.AddVoid(void)
@@ -1188,23 +1175,23 @@ class Modeler(object):
         for net_name in nets_name:
             var_server = False
             for p in self.paths:
-                if p.GetNet().GetName() == net_name:
+                if p.net.name == net_name:
                     if not layers_name:
                         if not var_server:
                             if not variable_value:
-                                variable_value = p.GetWidth()
+                                variable_value = p.width
                             result, var_server = self._pedb.add_design_variable(
                                 parameter_name, variable_value, is_parameter=True
                             )
-                        p.SetWidth(self._pedb.edb_value(parameter_name))
-                    elif p.GetLayer().GetName() in layers_name:
+                        p.width = self._pedb.edb_value(parameter_name)
+                    elif p.layer.name in layers_name:
                         if not var_server:
                             if not variable_value:
-                                variable_value = p.GetWidth()
+                                variable_value = p.width
                             result, var_server = self._pedb.add_design_variable(
                                 parameter_name, variable_value, is_parameter=True
                             )
-                        p.SetWidth(self._pedb.edb_value(parameter_name))
+                        p.width = self._pedb.edb_value(parameter_name)
         return True
 
     def unite_polygons_on_layer(self, layer_name=None, delete_padstack_gemometries=False, net_names_list=[]):
@@ -1237,6 +1224,7 @@ class Modeler(object):
             delete_list = []
             if lay in list(self.polygons_by_layer.keys()):
                 for poly in self.polygons_by_layer[lay]:
+                    poly = poly._edb_object
                     if not poly.GetNet().GetName() in list(poly_by_nets.keys()):
                         if poly.GetNet().GetName():
                             poly_by_nets[poly.GetNet().GetName()] = [poly]
@@ -1255,12 +1243,7 @@ class Modeler(object):
                     for void in v:
                         if int(item.GetIntersectionType(void.GetPolygonData())) == 2:
                             item.AddHole(void.GetPolygonData())
-                poly = self._edb.cell.primitive.polygon.create(
-                    self._active_layout,
-                    lay,
-                    self._pedb.nets.nets[net],
-                    item,
-                )
+                self.create_polygon(item, layer_name=lay, voids=[], net_name=net)
             for v in all_voids:
                 for void in v:
                     for poly in poly_by_nets[net]:  # pragma no cover
@@ -1299,8 +1282,8 @@ class Modeler(object):
             ``True`` when successful, ``False`` when failed.
         """
         poly_data = poly.polygon_data
-        new_poly = poly_data.edb_api.Defeature(tolerance)
-        poly.polygon_data = new_poly
+        new_poly = poly_data._edb_object.Defeature(tolerance)
+        poly._edb_object.SetPolygonData(new_poly)
         return True
 
     def get_layout_statistics(self, evaluate_area=False, net_list=None):
@@ -1350,7 +1333,7 @@ class Modeler(object):
                         if prim.type == "Path":
                             surface += prim.length * prim.width
                         if prim.type == "Polygon":
-                            surface += prim.polygon_data.edb_api.Area()
+                            surface += prim.polygon_data._edb_object.Area()
                             stat_model.occupying_surface[layer] = surface
                             stat_model.occupying_ratio[layer] = surface / outline_surface
         return stat_model

pyedb/dotnet/edb_core/nets.py

@@ -206,10 +206,11 @@ class EdbNets(object):
         for net in self._layout.nets[:]:
             total_plane_area = 0.0
             total_trace_area = 0.0
-            for primitive in net.Primitives:
-                if primitive.GetPrimitiveType() == self._edb.cell.primitive.PrimitiveType.Bondwire:
+            for primitive in net.primitives:
+                primitive = primitive._edb_object
+                if primitive.GetPrimitiveType() == self._edb.cell.primitive.api_class.PrimitiveType.Bondwire:
                     continue
-                if primitive.GetPrimitiveType() != self._edb.cell.primitive.PrimitiveType.Path:
+                if primitive.GetPrimitiveType() != self._edb.cell.primitive.api_class.PrimitiveType.Path:
                     total_plane_area += float(primitive.GetPolygonData().Area())
                 else:
                     total_trace_area += float(primitive.GetPolygonData().Area())
@@ -1088,7 +1089,7 @@ class EdbNets(object):
         else:
             if not start_with and not contain and not end_with:
                 net = self._edb.cell.net.find_by_name(self._active_layout, net_name)
-                if net.IsNull():
+                if net.is_null:
                     net = self._edb.cell.net.create(self._active_layout, net_name)
                 return net
             elif start_with: