pyedb 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

pyedb/grpc/database/modeler.py

@@ -40,7 +40,6 @@ from ansys.edb.core.primitive.path import PathEndCapType as GrpcPathEndCapType
 from ansys.edb.core.primitive.rectangle import (
     RectangleRepresentationType as GrpcRectangleRepresentationType,
 )
-from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.bondwire import Bondwire
 from pyedb.grpc.database.primitive.circle import Circle
@@ -49,6 +48,7 @@ from pyedb.grpc.database.primitive.polygon import Polygon
 from pyedb.grpc.database.primitive.primitive import Primitive
 from pyedb.grpc.database.primitive.rectangle import Rectangle
 from pyedb.grpc.database.utility.layout_statistics import LayoutStatistics
+from pyedb.grpc.database.utility.value import Value
 
 
 class Modeler(object):
@@ -92,7 +92,8 @@ class Modeler(object):
     def __init__(self, p_edb) -> None:
         """Initialize Modeler instance."""
         self._pedb = p_edb
-        self._primitives = []
+        self.__primitives = []
+        self.__primitives_by_layer = {}
 
     @property
     def _edb(self) -> Any:
@@ -219,7 +220,7 @@ class Modeler(object):
         list
             List of :class:`pyedb.dotnet.database.edb_data.primitives_data.Primitive` objects.
         """
-        return [self.__mapping_primitive_type(prim) for prim in self._pedb.layout.primitives]
+        return self._pedb.layout.primitives
 
     @property
     def polygons_by_layer(self) -> Dict[str, List[Primitive]]:
@@ -267,7 +268,7 @@ class Modeler(object):
             try:
                 lay = i.layer.name
                 if lay in _primitives_by_layer:
-                    _primitives_by_layer[lay].append(Primitive(self._pedb, i))
+                    _primitives_by_layer[lay].append(i)
             except (InvalidArgumentException, AttributeError):
                 pass
         return _primitives_by_layer
@@ -425,12 +426,7 @@ class Modeler(object):
             Bounding box coordinates [min_x, min_y, max_x, max_y].
         """
         bounding_box = polygon.polygon_data.bbox()
-        return [
-            bounding_box[0].x.value,
-            bounding_box[0].y.value,
-            bounding_box[1].x.value,
-            bounding_box[1].y.value,
-        ]
+        return [Value(bounding_box[0].x), Value(bounding_box[0].y), Value(bounding_box[1].x), Value(bounding_box[1].y)]
 
     @staticmethod
     def get_polygon_points(polygon) -> List[List[float]]:
@@ -455,9 +451,9 @@ class Modeler(object):
                 point = polygon.polygon_data.points[i]
                 if prev_point != point:
                     if point.is_arc:
-                        points.append([point.x.value])
+                        points.append([Value(point.x)])
                     else:
-                        points.append([point.x.value, point.y.value])
+                        points.append([Value(point.x), Value(point.y)])
                     prev_point = point
                     i += 1
                 else:
@@ -513,8 +509,8 @@ class Modeler(object):
         polygon_data = polygon.polygon_data
         bound_center = polygon_data.bounding_circle()[0]
         bound_center2 = selection_polygon_data.bounding_circle()[0]
-        center = [bound_center.x.value, bound_center.y.value]
-        center2 = [bound_center2.x.value, bound_center2.y.value]
+        center = [Value(bound_center.x), Value(bound_center.y)]
+        center2 = [Value(bound_center2.x), Value(bound_center2.y)]
         x1, y1 = calc_slope(center2, center)
 
         if not origin:
@@ -529,12 +525,12 @@ class Modeler(object):
                 if prev_point != point:
                     check_inside = selection_polygon_data.is_inside(point)
                     if check_inside:
-                        xcoeff, ycoeff = calc_slope([point.x.value, point.x.value], origin)
+                        xcoeff, ycoeff = calc_slope([Value(point.x), Value(point.x)], origin)
 
                         new_points = GrpcPointData(
                             [
-                                GrpcValue(str(point.x.value) + f"{xcoeff}*{offset_name}"),
-                                GrpcValue(str(point.y.value) + f"{ycoeff}*{offset_name}"),
+                                Value(str(Value(point.x) + f"{xcoeff}*{offset_name}")),
+                                Value(str(Value(point.y)) + f"{ycoeff}*{offset_name}"),
                             ]
                         )
                         polygon_data.points[i] = new_points
@@ -610,12 +606,12 @@ class Modeler(object):
         for pt in points:
             _pt = []
             for coord in pt:
-                coord = GrpcValue(coord, self._pedb.active_cell)
+                coord = Value(coord, self._pedb.active_cell)
                 _pt.append(coord)
             _points.append(_pt)
         points = _points
 
-        width = GrpcValue(width, self._pedb.active_cell)
+        width = Value(width, self._pedb.active_cell)
 
         polygon_data = GrpcPolygonData(points=[GrpcPointData(i) for i in points])
         path = Path.create(
@@ -710,7 +706,7 @@ class Modeler(object):
             new_points = []
             for idx, i in enumerate(points):
                 new_points.append(
-                    GrpcPointData([GrpcValue(i[0], self._pedb.active_cell), GrpcValue(i[1], self._pedb.active_cell)])
+                    GrpcPointData([Value(i[0], self._pedb.active_cell), Value(i[1], self._pedb.active_cell)])
                 )
             polygon_data = GrpcPolygonData(points=new_points)
 
@@ -787,40 +783,40 @@ class Modeler(object):
                 layer=layer_name,
                 net=edb_net,
                 rep_type=rep_type,
-                param1=GrpcValue(lower_left_point[0]),
-                param2=GrpcValue(lower_left_point[1]),
-                param3=GrpcValue(upper_right_point[0]),
-                param4=GrpcValue(upper_right_point[1]),
-                corner_rad=GrpcValue(corner_radius),
-                rotation=GrpcValue(rotation),
+                param1=Value(lower_left_point[0]),
+                param2=Value(lower_left_point[1]),
+                param3=Value(upper_right_point[0]),
+                param4=Value(upper_right_point[1]),
+                corner_rad=Value(corner_radius),
+                rotation=Value(rotation),
             )
         else:
             rep_type = GrpcRectangleRepresentationType.CENTER_WIDTH_HEIGHT
             if isinstance(width, str):
                 if width in self._pedb.variables:
-                    width = GrpcValue(width, self._pedb.active_cell)
+                    width = Value(width, self._pedb.active_cell)
                 else:
-                    width = GrpcValue(width)
+                    width = Value(width)
             else:
-                width = GrpcValue(width)
+                width = Value(width)
             if isinstance(height, str):
                 if height in self._pedb.variables:
-                    height = GrpcValue(height, self._pedb.active_cell)
+                    height = Value(height, self._pedb.active_cell)
                 else:
-                    height = GrpcValue(width)
+                    height = Value(width)
             else:
-                height = GrpcValue(width)
+                height = Value(width)
             rect = Rectangle.create(
                 layout=self._active_layout,
                 layer=layer_name,
                 net=edb_net,
                 rep_type=rep_type,
-                param1=GrpcValue(center_point[0]),
-                param2=GrpcValue(center_point[1]),
-                param3=GrpcValue(width),
-                param4=GrpcValue(height),
-                corner_rad=GrpcValue(corner_radius),
-                rotation=GrpcValue(rotation),
+                param1=Value(center_point[0]),
+                param2=Value(center_point[1]),
+                param3=Value(width),
+                param4=Value(height),
+                corner_rad=Value(corner_radius),
+                rotation=Value(rotation),
             )
         if not rect.is_null:
             return Rectangle(self._pedb, rect)
@@ -855,9 +851,9 @@ class Modeler(object):
             layout=self._active_layout,
             layer=layer_name,
             net=edb_net,
-            center_x=GrpcValue(x),
-            center_y=GrpcValue(y),
-            radius=GrpcValue(radius),
+            center_x=Value(x),
+            center_y=Value(y),
+            radius=Value(radius),
         )
         if not circle.is_null:
             return Circle(self._pedb, circle)
@@ -944,9 +940,9 @@ class Modeler(object):
                 layout=self._active_layout,
                 layer=void_circle.layer_name,
                 net=void_circle.net,
-                center_x=GrpcValue(circ_params[0]),
-                center_y=GrpcValue(circ_params[1]),
-                radius=GrpcValue(circ_params[2]),
+                center_x=Value(circ_params[0]),
+                center_y=Value(circ_params[1]),
+                radius=Value(circ_params[2]),
             )
             if not cloned_circle.is_null:
                 cloned_circle.is_negative = True
@@ -1000,8 +996,8 @@ class Modeler(object):
 
             if not self._validatePoint(endPoint):
                 return None
-            startPoint = [GrpcValue(i) for i in startPoint]
-            endPoint = [GrpcValue(i) for i in endPoint]
+            startPoint = [Value(i) for i in startPoint]
+            endPoint = [Value(i) for i in endPoint]
             if len(endPoint) == 2:
                 is_parametric = (
                     is_parametric
@@ -1059,7 +1055,7 @@ class Modeler(object):
         else:
             k = 0
             for pt in points:
-                point = [GrpcValue(i) for i in pt]
+                point = [Value(i) for i in pt]
                 new_points = GrpcPointData(point)
                 if len(point) > 2:
                     k += 1
@@ -1119,7 +1115,7 @@ class Modeler(object):
         #     return None
         # pointA = GrpcPointData(pointA[0]), self._get_edb_value(shape.pointA[1])
         # )
-        # pointB = self._edb.geometry.point_data(
+        # pointB = self._edb.Geometry.PointData(
         #     self._get_edb_value(shape.pointB[0]), self._get_edb_value(shape.pointB[1])
         # )
         # return self._edb.geometry.polygon_data.create_from_bbox((pointA, pointB))
@@ -1163,14 +1159,14 @@ class Modeler(object):
                             if not variable_value:
                                 variable_value = p.width
                             self._pedb.active_cell.add_variable(
-                                name=_parameter_name, value=GrpcValue(variable_value), is_param=True
+                                name=_parameter_name, value=Value(variable_value), is_param=True
                             )
-                            p.width = GrpcValue(_parameter_name, self._pedb.active_cell)
+                            p.width = Value(_parameter_name, self._pedb.active_cell)
                         elif p.layer.name in layers_name:
                             if not variable_value:
                                 variable_value = p.width
                             self._pedb.add_design_variable(parameter_name, variable_value, True)
-                            p.width = GrpcValue(_parameter_name, self._pedb.active_cell)
+                            p.width = Value(_parameter_name, self._pedb.active_cell)
         return True
 
     def unite_polygons_on_layer(
@@ -1199,6 +1195,8 @@ class Modeler(object):
             layer_name = [layer_name]
         if not layer_name:
             layer_name = list(self._pedb.stackup.signal_layers.keys())
+        if net_names_list is None:
+            net_names_list = []
 
         for lay in layer_name:
             self._logger.info(f"Uniting Objects on layer {lay}.")
@@ -1319,7 +1317,7 @@ class Modeler(object):
                     primitives = self.primitives_by_layer[layer]
                     for prim in primitives:
                         if prim.primitive_type.name == "PATH":
-                            surface += Path(self._pedb, prim).length * prim.cast().width.value
+                            surface += Path(self._pedb, prim).length * Value(prim.cast().width)
                         if prim.primitive_type.name == "POLYGON":
                             surface += prim.polygon_data.area()
                             stat_model.occupying_surface[layer] = round(surface, 6)
@@ -1418,14 +1416,14 @@ class Modeler(object):
             bondwire_type=bondwire_type,
             definition_name=definition_name,
             placement_layer=placement_layer,
-            width=GrpcValue(width),
+            width=Value(width),
             material=material,
             start_layer_name=start_layer_name,
-            start_x=GrpcValue(start_x),
-            start_y=GrpcValue(start_y),
+            start_x=Value(start_x),
+            start_y=Value(start_y),
             end_layer_name=end_layer_name,
-            end_x=GrpcValue(end_x),
-            end_y=GrpcValue(end_y),
+            end_x=Value(end_x),
+            end_y=Value(end_y),
             net=net,
             end_context=end_cell_inst,
             start_context=start_cell_inst,
@@ -1478,7 +1476,11 @@ class Modeler(object):
             if isinstance(pins_by_name, str):
                 pins_by_name = [pins_by_name]
             p_inst = self._pedb.layout.padstack_instances
-            _pins = {pin.id: pin for pin in p_inst if pin.aedt_name in pins_by_aedt_name or pin.name in pins_by_name}
+            _pins = {
+                pin_id: pin
+                for pin_id, pin in p_inst.items()
+                if pin.aedt_name in pins_by_aedt_name or pin.name in pins_by_name
+            }
             if not pins:
                 pins = _pins
             else:

pyedb/grpc/database/net/net.py

@@ -60,7 +60,7 @@ class Net(GrpcNet):
         self._pedb = pedb
         self._core_components = pedb.components
         self._core_primitive = pedb.modeler
-        self._edb_object = raw_net
+        self.__primitives = []
 
     @property
     def primitives(self) -> list[Union[Path, Polygon, Circle, Rectangle, Bondwire]]:
@@ -76,19 +76,20 @@ class Net(GrpcNet):
             - :class:`Rectangle <pyedb.grpc.database.primitive.rectangle.Rectangle>`
             - :class:`Bondwire <pyedb.grpc.database.primitive.bondwire.Bondwire>`
         """
-        primitives = []
-        for primitive in super().primitives:
-            if primitive.primitive_type == GrpcPrimitiveType.PATH:
-                primitives.append(Path(self._pedb, primitive))
-            elif primitive.primitive_type == GrpcPrimitiveType.POLYGON:
-                primitives.append(Polygon(self._pedb, primitive))
-            elif primitive.primitive_type == GrpcPrimitiveType.CIRCLE:
-                primitives.append(Circle(self._pedb, primitive))
-            elif primitive.primitive_type == GrpcPrimitiveType.RECTANGLE:
-                primitives.append(Rectangle(self._pedb, primitive))
-            elif primitive.primitive_type == GrpcPrimitiveType.BONDWIRE:
-                primitives.append(Bondwire(self._pedb, primitive))
-        return primitives
+        primitives = super().primitives
+        if not len(self.__primitives) == len(primitives):
+            for primitive in primitives:
+                if primitive.primitive_type == GrpcPrimitiveType.PATH:
+                    self.__primitives.append(Path(self._pedb, primitive))
+                elif primitive.primitive_type == GrpcPrimitiveType.POLYGON:
+                    self.__primitives.append(Polygon(self._pedb, primitive))
+                elif primitive.primitive_type == GrpcPrimitiveType.CIRCLE:
+                    self.__primitives.append(Circle(self._pedb, primitive))
+                elif primitive.primitive_type == GrpcPrimitiveType.RECTANGLE:
+                    self.__primitives.append(Rectangle(self._pedb, primitive))
+                elif primitive.primitive_type == GrpcPrimitiveType.BONDWIRE:
+                    self.__primitives.append(Bondwire(self._pedb, primitive))
+        return self.__primitives
 
     @property
     def padstack_instances(self) -> list[PadstackInstance]:

pyedb/grpc/database/nets.py

@@ -22,11 +22,15 @@
 
 from __future__ import absolute_import  # noreorder
 
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 import warnings
 
+from ansys.edb.core.net.net_class import NetClass as GrpcNetClass
+
 from pyedb.common.nets import CommonNets
 from pyedb.generic.general_methods import generate_unique_name
 from pyedb.grpc.database.net.net import Net
+from pyedb.grpc.database.net.net_class import NetClass
 from pyedb.grpc.database.primitive.bondwire import Bondwire
 from pyedb.grpc.database.primitive.path import Path
 from pyedb.grpc.database.primitive.polygon import Polygon
@@ -152,7 +156,7 @@ class Nets(CommonNets):
     >>> edbapp.close()
     """
 
-    def __getitem__(self, name):
+    def __getitem__(self, name: str) -> Net:
         """Get a net by name.
 
         Parameters
@@ -172,7 +176,7 @@ class Nets(CommonNets):
         """
         return Net(self._pedb, Net.find_by_name(self._active_layout, name))
 
-    def __contains__(self, name):
+    def __contains__(self, name: str) -> bool:
         """Check if a net exists in the layout.
 
         Parameters
@@ -192,11 +196,11 @@ class Nets(CommonNets):
         """
         return name in self.nets
 
-    def __init__(self, p_edb):
+    def __init__(self, p_edb: Any) -> None:
         """Initialize the Nets class."""
         CommonNets.__init__(self, p_edb)
-        self._nets_by_comp_dict = {}
-        self._comps_by_nets_dict = {}
+        self._nets_by_comp_dict: Dict[str, List[str]] = {}
+        self._comps_by_nets_dict: Dict[str, List[str]] = {}
 
     @property
     def _edb(self):
@@ -229,7 +233,7 @@ class Nets(CommonNets):
         return self._pedb.logger
 
     @property
-    def nets(self):
+    def nets(self) -> Dict[str, Net]:
         """All nets in the layout.
 
         Returns
@@ -246,7 +250,7 @@ class Nets(CommonNets):
         return {i.name: i for i in self._pedb.layout.nets}
 
     @property
-    def netlist(self):
+    def netlist(self) -> List[str]:
         """List of all net names.
 
         Returns
@@ -262,7 +266,7 @@ class Nets(CommonNets):
         return list(self.nets.keys())
 
     @property
-    def signal(self):
+    def signal(self) -> Dict[str, Net]:
         """Signal nets in the layout.
 
         Returns
@@ -282,7 +286,7 @@ class Nets(CommonNets):
         return nets
 
     @property
-    def power(self):
+    def power(self) -> Dict[str, Net]:
         """Power and ground nets in the layout.
 
         Returns
@@ -301,7 +305,7 @@ class Nets(CommonNets):
                 nets[net] = value
         return nets
 
-    def eligible_power_nets(self, threshold=0.3):
+    def eligible_power_nets(self, threshold: float = 0.3) -> List[Net]:
         """Identify nets eligible for power/ground classification based on area ratio.
 
         Uses the same algorithm implemented in SIwave.
@@ -343,7 +347,7 @@ class Nets(CommonNets):
         return pwr_gnd_nets
 
     @property
-    def nets_by_components(self):
+    def nets_by_components(self) -> Dict[str, List[str]]:
         """Mapping of components to their associated nets.
 
         Returns
@@ -361,7 +365,7 @@ class Nets(CommonNets):
         return self._nets_by_comp_dict
 
     @property
-    def components_by_nets(self):
+    def components_by_nets(self) -> Dict[str, List[str]]:
         """Mapping of nets to their associated components.
 
         Returns
@@ -384,13 +388,13 @@ class Nets(CommonNets):
 
     def generate_extended_nets(
         self,
-        resistor_below=10,
-        inductor_below=1,
-        capacitor_above=1,
-        exception_list=None,
-        include_signal=True,
-        include_power=True,
-    ):
+        resistor_below: Union[int, float] = 10,
+        inductor_below: Union[int, float] = 1,
+        capacitor_above: Union[int, float] = 1,
+        exception_list: Optional[List[str]] = None,
+        include_signal: bool = True,
+        include_power: bool = True,
+    ) -> List[Any]:
         """Generate extended nets based on component thresholds.
 
         .. deprecated:: pyedb 0.30.0
@@ -430,7 +434,7 @@ class Nets(CommonNets):
         )
 
     @staticmethod
-    def _get_points_for_plot(my_net_points):
+    def _get_points_for_plot(my_net_points: List[Any]) -> Tuple[List[float], List[float]]:
         """Get points for plotting.
 
         Parameters
@@ -464,7 +468,9 @@ class Nets(CommonNets):
         # fmt: on
         return x, y
 
-    def classify_nets(self, power_nets=None, signal_nets=None):
+    def classify_nets(
+        self, power_nets: Optional[Union[str, List[str]]] = None, signal_nets: Optional[Union[str, List[str]]] = None
+    ) -> bool:
         """Reassign net classifications as power/ground or signal.
 
         Parameters
@@ -502,7 +508,7 @@ class Nets(CommonNets):
                 self.nets[net].is_power_ground = False
         return True
 
-    def is_power_gound_net(self, netname_list):
+    def is_power_gound_net(self, netname_list: Union[str, List[str]]) -> bool:
         """Check if any net in a list is a power/ground net.
 
         Parameters
@@ -528,7 +534,7 @@ class Nets(CommonNets):
                 return True
         return False
 
-    def get_dcconnected_net_list(self, ground_nets=["GND"], res_value=0.001):
+    def get_dcconnected_net_list(self, ground_nets: List[str] = ["GND"], res_value: float = 0.001) -> List[Set[str]]:
         """Get nets connected to DC through inductors and low-value resistors.
 
         Parameters
@@ -586,7 +592,9 @@ class Nets(CommonNets):
 
         return dcconnected_net_list
 
-    def get_powertree(self, power_net_name, ground_nets):
+    def get_powertree(
+        self, power_net_name: str, ground_nets: List[str]
+    ) -> Tuple[List[List[str]], List[str], List[str]]:
         """Retrieve power tree for a given power net.
 
         Parameters
@@ -654,7 +662,7 @@ class Nets(CommonNets):
         ]
         return component_list, component_list_columns, net_group
 
-    def get_net_by_name(self, net_name):
+    def get_net_by_name(self, net_name: str) -> Optional[Net]:
         """Find a net by name.
 
         Parameters
@@ -677,7 +685,7 @@ class Nets(CommonNets):
         if edb_net is not None:
             return edb_net
 
-    def delete(self, netlist):
+    def delete(self, netlist: Union[str, List[str]]) -> List[str]:
         """Delete one or more nets from the layout.
 
         Parameters
@@ -708,7 +716,9 @@ class Nets(CommonNets):
                 nets_deleted.append(i.name)
         return nets_deleted
 
-    def find_or_create_net(self, net_name="", start_with="", contain="", end_with=""):
+    def find_or_create_net(
+        self, net_name: str = "", start_with: str = "", contain: str = "", end_with: str = ""
+    ) -> Union[Net, List[Net]]:
         """Find or create a net based on given criteria.
 
         Parameters
@@ -789,7 +799,7 @@ class Nets(CommonNets):
                 nets_found = [self.nets[net] for net in list(self.nets.keys()) if contain in net.lower()]
                 return nets_found
 
-    def is_net_in_component(self, component_name, net_name):
+    def is_net_in_component(self, component_name: str, net_name: str) -> bool:
         """Check if a net belongs to a component.
 
         Parameters
@@ -817,8 +827,12 @@ class Nets(CommonNets):
         return False
 
     def find_and_fix_disjoint_nets(
-        self, net_list=None, keep_only_main_net=False, clean_disjoints_less_than=0.0, order_by_area=False
-    ):
+        self,
+        net_list: Optional[List[str]] = None,
+        keep_only_main_net: bool = False,
+        clean_disjoints_less_than: float = 0.0,
+        order_by_area: bool = False,
+    ) -> List[str]:
         """Find and fix disjoint nets.
 
         .. deprecated:: pyedb 0.30.0
@@ -856,7 +870,7 @@ class Nets(CommonNets):
             net_list, keep_only_main_net, clean_disjoints_less_than, order_by_area
         )
 
-    def merge_nets_polygons(self, net_names_list):
+    def merge_nets_polygons(self, net_names_list: Union[str, List[str]]) -> bool:
         """Merge polygons for specified nets on each layer.
 
         Parameters
@@ -877,3 +891,70 @@ class Nets(CommonNets):
         if isinstance(net_names_list, str):
             net_names_list = [net_names_list]
         return self._pedb.modeler.unite_polygons_on_layer(net_names_list=net_names_list)
+
+
+class NetClasses:
+    """Net classes management.
+
+    This class provides access to net classes in the EDB layout.
+    It allows for operations like retrieving nets, adding/removing nets,
+    and checking if a net is part of a net class.
+
+    Examples
+    --------
+    >>> from pyedb import Edb
+    >>> edb = Edb(myedb, edbversion="2025.1")
+    >>> net_classes = edb.net_classes
+    """
+
+    def __init__(self, pedb):
+        self._pedb = pedb
+        self._net_classes = pedb.active_layout.net_classes
+
+    def __getitem__(self, name: str) -> NetClass:
+        """Get a net by name.
+
+        Parameters
+        ----------
+        name : str
+            Name of the net to retrieve.
+
+        """
+        return self.items[name]
+
+    @property
+    def items(self) -> Dict[str, NetClass]:
+        """Extended nets.
+
+        Returns
+        -------
+        Dict[str, :class:`pyedb.grpc.database.nets.nets_class.NetClass`]
+            Dictionary of extended nets.
+        """
+        return {i.name: i for i in self._pedb.layout.net_classes}
+
+    def create(self, name, net) -> Union[bool, NetClass]:
+        """Create a new net class.
+
+        Parameters
+        ----------
+        name : str
+            Name of the net class.
+        net : str, list
+           Name of the nets to be added into this net class.
+
+        Returns
+        -------
+        :class:`pyedb.dotnet.database.edb_data.nets_data.EDBNetClassData` `False` if net name already exists.
+        """
+        if name in self.items:
+            self._pedb.logger.error("{} already exists.".format(name))
+            return False
+        grpc_net_class = GrpcNetClass.create(self._pedb.active_layout, name)
+        if isinstance(net, str):
+            net = [net]
+        for i in net:
+            grpc_net_class.add_net(self._pedb.nets[i])
+        net_class = NetClass(self._pedb, grpc_net_class)
+        self.items[name] = net_class
+        return net_class