pyedb 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

pyedb/grpc/database/modeler.py

@@ -24,6 +24,7 @@
 This module contains these classes: `EdbLayout` and `Shape`.
 """
 import math
+from typing import Any, Dict, List, Optional, Union
 
 from ansys.edb.core.geometry.arc_data import ArcData as GrpcArcData
 from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
@@ -39,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
@@ -48,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):
@@ -60,8 +61,8 @@ class Modeler(object):
     >>> edb_layout = edbapp.modeler
     """
 
-    def __getitem__(self, name):
-        """Get a primitive instance by name or ID.
+    def __getitem__(self, name: Union[str, int]) -> Optional[Primitive]:
+        """Get a primitive by name or ID.
 
         Parameters
         ----------
@@ -88,13 +89,13 @@ class Modeler(object):
         self._pedb.logger.error("Primitive not found.")
         return
 
-    def __init__(self, p_edb):
+    def __init__(self, p_edb) -> None:
         """Initialize Modeler instance."""
         self._pedb = p_edb
         self._primitives = []
 
     @property
-    def _edb(self):
+    def _edb(self) -> Any:
         """EDB API object.
 
         Returns
@@ -105,7 +106,7 @@ class Modeler(object):
         return self._pedb
 
     @property
-    def _logger(self):
+    def _logger(self) -> Any:
         """Logger instance.
 
         Returns
@@ -116,7 +117,7 @@ class Modeler(object):
         return self._pedb.logger
 
     @property
-    def _active_layout(self):
+    def _active_layout(self) -> Any:
         """Active layout.
 
         Returns
@@ -127,7 +128,7 @@ class Modeler(object):
         return self._pedb.active_layout
 
     @property
-    def _layout(self):
+    def _layout(self) -> Any:
         """Current layout.
 
         Returns
@@ -138,7 +139,7 @@ class Modeler(object):
         return self._pedb.layout
 
     @property
-    def _cell(self):
+    def _cell(self) -> Any:
         """Active cell.
 
         Returns
@@ -149,18 +150,18 @@ class Modeler(object):
         return self._pedb.active_cell
 
     @property
-    def db(self):
+    def db(self) -> Any:
         """Database object.
 
         Returns
         -------
-        :class:`ansys.edb.core.database.Database`
+        ansys.edb.core.database.Database
             Database object.
         """
         return self._pedb.active_db
 
     @property
-    def layers(self):
+    def layers(self) -> Dict[str, object]:
         """Dictionary of layers.
 
         Returns
@@ -170,7 +171,7 @@ class Modeler(object):
         """
         return self._pedb.stackup.layers
 
-    def get_primitive(self, primitive_id):
+    def get_primitive(self, primitive_id: int) -> Optional[Primitive]:
         """Retrieve primitive by ID.
 
         Parameters
@@ -210,7 +211,7 @@ class Modeler(object):
             return False
 
     @property
-    def primitives(self):
+    def primitives(self) -> List[Primitive]:
         """All primitives in the layout.
 
         Returns
@@ -218,10 +219,10 @@ 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):
+    def polygons_by_layer(self) -> Dict[str, List[Primitive]]:
         """Primitives organized by layer names.
 
         Returns
@@ -235,7 +236,7 @@ class Modeler(object):
         return _primitives_by_layer
 
     @property
-    def primitives_by_net(self):
+    def primitives_by_net(self) -> Dict[str, List[Primitive]]:
         """Primitives organized by net names.
 
         Returns
@@ -249,7 +250,7 @@ class Modeler(object):
         return _prim_by_net
 
     @property
-    def primitives_by_layer(self):
+    def primitives_by_layer(self) -> Dict[str, List[Primitive]]:
         """Primitives organized by layer names.
 
         Returns
@@ -272,7 +273,7 @@ class Modeler(object):
         return _primitives_by_layer
 
     @property
-    def rectangles(self):
+    def rectangles(self) -> List[Rectangle]:
         """All rectangle primitives.
 
         Returns
@@ -283,7 +284,7 @@ class Modeler(object):
         return [Rectangle(self._pedb, i) for i in self.primitives if i.type == "rectangle"]
 
     @property
-    def circles(self):
+    def circles(self) -> List[Circle]:
         """All circle primitives.
 
         Returns
@@ -294,7 +295,7 @@ class Modeler(object):
         return [Circle(self._pedb, i) for i in self.primitives if i.type == "circle"]
 
     @property
-    def paths(self):
+    def paths(self) -> List[Path]:
         """All path primitives.
 
         Returns
@@ -305,7 +306,7 @@ class Modeler(object):
         return [Path(self._pedb, i) for i in self.primitives if i.type == "path"]
 
     @property
-    def polygons(self):
+    def polygons(self) -> List[Polygon]:
         """All polygon primitives.
 
         Returns
@@ -315,7 +316,7 @@ class Modeler(object):
         """
         return [Polygon(self._pedb, i) for i in self.primitives if i.type == "polygon"]
 
-    def get_polygons_by_layer(self, layer_name, net_list=None):
+    def get_polygons_by_layer(self, layer_name: str, net_list: Optional[List[str]] = None) -> List[Primitive]:
         """Retrieve polygons by layer.
 
         Parameters
@@ -340,7 +341,12 @@ class Modeler(object):
                         objinst.append(el)
         return objinst
 
-    def get_primitive_by_layer_and_point(self, point=None, layer=None, nets=None):
+    def get_primitive_by_layer_and_point(
+        self,
+        point: Optional[List[float]] = None,
+        layer: Optional[Union[str, List[str]]] = None,
+        nets: Optional[Union[str, List[str]]] = None,
+    ) -> List[Primitive]:
         """Get primitive at specified point on layer.
 
         Parameters
@@ -405,7 +411,7 @@ class Modeler(object):
         return returned_obj
 
     @staticmethod
-    def get_polygon_bounding_box(polygon):
+    def get_polygon_bounding_box(polygon: Primitive) -> List[float]:
         """Get bounding box of polygon.
 
         Parameters
@@ -419,15 +425,10 @@ 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):
+    def get_polygon_points(polygon) -> List[List[float]]:
         """Get points defining a polygon.
 
         Parameters
@@ -449,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:
@@ -460,7 +461,7 @@ class Modeler(object):
                 continue_iterate = False
         return points
 
-    def parametrize_polygon(self, polygon, selection_polygon, offset_name="offsetx", origin=None):
+    def parametrize_polygon(self, polygon, selection_polygon, offset_name="offsetx", origin=None) -> bool:
         """Parametrize polygon points based on another polygon.
 
         Parameters
@@ -507,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:
@@ -523,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
@@ -604,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(
@@ -629,14 +630,14 @@ class Modeler(object):
 
     def create_trace(
         self,
-        path_list,
-        layer_name,
-        width=1,
-        net_name="",
-        start_cap_style="Round",
-        end_cap_style="Round",
-        corner_style="Round",
-    ):
+        path_list: List[List[float]],
+        layer_name: str,
+        width: float = 1,
+        net_name: str = "",
+        start_cap_style: str = "Round",
+        end_cap_style: str = "Round",
+        corner_style: str = "Round",
+    ) -> Optional[Primitive]:
         """Create trace path.
 
         Parameters
@@ -674,7 +675,13 @@ class Modeler(object):
 
         return primitive
 
-    def create_polygon(self, points, layer_name, voids=[], net_name=""):
+    def create_polygon(
+        self,
+        points: Union[List[List[float]], GrpcPolygonData],
+        layer_name: str,
+        voids: Optional[List[Any]] = [],
+        net_name: str = "",
+    ) -> Optional[Primitive]:
         """Create polygon primitive.
 
         Parameters
@@ -698,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)
 
@@ -726,17 +733,17 @@ class Modeler(object):
 
     def create_rectangle(
         self,
-        layer_name,
-        net_name="",
-        lower_left_point="",
-        upper_right_point="",
-        center_point="",
-        width="",
-        height="",
-        representation_type="lower_left_upper_right",
-        corner_radius="0mm",
-        rotation="0deg",
-    ):
+        layer_name: str,
+        net_name: str = "",
+        lower_left_point: str = "",
+        upper_right_point: str = "",
+        center_point: str = "",
+        width: Union[str, float] = "",
+        height: Union[str, float] = "",
+        representation_type: str = "lower_left_upper_right",
+        corner_radius: str = "0mm",
+        rotation: str = "0deg",
+    ) -> Optional[Primitive]:
         """Create rectangle primitive.
 
         Parameters
@@ -775,46 +782,48 @@ 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)
         return False
 
-    def create_circle(self, layer_name, x, y, radius, net_name=""):
+    def create_circle(
+        self, layer_name: str, x: Union[float, str], y: Union[float, str], radius: Union[float, str], net_name: str = ""
+    ) -> Optional[Primitive]:
         """Create circle primitive.
 
         Parameters
@@ -841,15 +850,15 @@ 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)
         return False
 
-    def delete_primitives(self, net_names):
+    def delete_primitives(self, net_names: Union[str, List[str]]) -> bool:
         """Delete primitives by net name(s).
 
         Parameters
@@ -870,7 +879,13 @@ class Modeler(object):
                 p.delete()
         return True
 
-    def get_primitives(self, net_name=None, layer_name=None, prim_type=None, is_void=False):
+    def get_primitives(
+        self,
+        net_name: Optional[str] = None,
+        layer_name: Optional[str] = None,
+        prim_type: Optional[str] = None,
+        is_void: bool = False,
+    ) -> List[Primitive]:
         """Get primitives with filtering.
 
         Parameters
@@ -907,7 +922,7 @@ class Modeler(object):
             prims.append(el)
         return prims
 
-    def fix_circle_void_for_clipping(self):
+    def fix_circle_void_for_clipping(self) -> bool:
         """Fix circle void clipping issues.
 
         Returns
@@ -924,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
@@ -934,7 +949,8 @@ class Modeler(object):
         return True
 
     @staticmethod
-    def add_void(shape, void_shape):
+    @staticmethod
+    def add_void(shape: "Primitive", void_shape: Union["Primitive", List["Primitive"]]) -> bool:
         """Add void to shape.
 
         Parameters
@@ -979,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
@@ -1038,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
@@ -1106,11 +1122,11 @@ class Modeler(object):
 
     def parametrize_trace_width(
         self,
-        nets_name,
-        layers_name=None,
-        parameter_name="trace_width",
-        variable_value=None,
-    ):
+        nets_name: Union[str, List[str]],
+        layers_name: Optional[Union[str, List[str]]] = None,
+        parameter_name: str = "trace_width",
+        variable_value: Optional[Union[float, str]] = None,
+    ) -> bool:
         """Parametrize trace width.
 
         Parameters
@@ -1142,17 +1158,22 @@ 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(self, layer_name=None, delete_padstack_gemometries=False, net_names_list=[]):
+    def unite_polygons_on_layer(
+        self,
+        layer_name: Optional[Union[str, List[str]]] = None,
+        delete_padstack_gemometries: bool = False,
+        net_names_list: Optional[List[str]] = None,
+    ) -> bool:
         """Unite polygons on layer.
 
         Parameters
@@ -1173,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}.")
@@ -1223,7 +1246,7 @@ class Modeler(object):
                     self._pedb.padstacks.remove_pads_from_padstack(pad)
         return True
 
-    def defeature_polygon(self, poly, tolerance=0.001):
+    def defeature_polygon(self, poly: Polygon, tolerance: float = 0.001) -> bool:
         """Defeature polygon.
 
         Parameters
@@ -1247,7 +1270,9 @@ class Modeler(object):
         poly.polygon_data = new_poly
         return True
 
-    def get_layout_statistics(self, evaluate_area=False, net_list=None):
+    def get_layout_statistics(
+        self, evaluate_area: bool = False, net_list: Optional[List[str]] = None
+    ) -> LayoutStatistics:
         """Get layout statistics.
 
         Parameters
@@ -1291,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)
@@ -1300,21 +1325,21 @@ class Modeler(object):
 
     def create_bondwire(
         self,
-        definition_name,
-        placement_layer,
-        width,
-        material,
-        start_layer_name,
-        start_x,
-        start_y,
-        end_layer_name,
-        end_x,
-        end_y,
-        net,
-        start_cell_instance_name=None,
-        end_cell_instance_name=None,
-        bondwire_type="jedec4",
-    ):
+        definition_name: str,
+        placement_layer: str,
+        width: Union[float, str],
+        material: str,
+        start_layer_name: str,
+        start_x: Union[float, str],
+        start_y: Union[float, str],
+        end_layer_name: str,
+        end_x: Union[float, str],
+        end_y: Union[float, str],
+        net: str,
+        start_cell_instance_name: Optional[str] = None,
+        end_cell_instance_name: Optional[str] = None,
+        bondwire_type: str = "jedec4",
+    ) -> Optional[Primitive]:
         """Create bondwire.
 
         Parameters
@@ -1390,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,
@@ -1407,10 +1432,10 @@ class Modeler(object):
     def create_pin_group(
         self,
         name: str,
-        pins_by_id=None,
-        pins_by_aedt_name=None,
-        pins_by_name=None,
-    ):
+        pins_by_id: Optional[List[int]] = None,
+        pins_by_aedt_name: Optional[List[str]] = None,
+        pins_by_name: Optional[List[str]] = None,
+    ) -> bool:
         """Create pin group.
 
         Parameters