pyedb 0.53.0__py3-none-any.whl → 0.54.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):
@@ -219,7 +219,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]]:
@@ -425,12 +425,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 +450,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 +508,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 +524,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 +605,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 +705,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 +782,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 +850,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 +939,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 +995,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 +1054,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
@@ -1163,14 +1158,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 +1194,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 +1316,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 +1415,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,

pyedb/grpc/database/nets.py

@@ -22,6 +22,7 @@
 
 from __future__ import absolute_import  # noreorder
 
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 import warnings
 
 from pyedb.common.nets import CommonNets
@@ -152,7 +153,7 @@ class Nets(CommonNets):
     >>> edbapp.close()
     """
 
-    def __getitem__(self, name):
+    def __getitem__(self, name: str) -> Net:
         """Get a net by name.
 
         Parameters
@@ -172,7 +173,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 +193,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 +230,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 +247,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 +263,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 +283,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 +302,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 +344,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 +362,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 +385,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 +431,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 +465,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 +505,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 +531,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 +589,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 +659,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 +682,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 +713,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 +796,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 +824,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 +867,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