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

pyedb/grpc/database/layers/stackup_layer.py

@@ -25,7 +25,8 @@ from __future__ import absolute_import
 from ansys.edb.core.layer.layer import LayerType as GrpcLayerType
 from ansys.edb.core.layer.stackup_layer import RoughnessRegion as GrpcRoughnessRegion
 from ansys.edb.core.layer.stackup_layer import StackupLayer as GrpcStackupLayer
-from ansys.edb.core.utility.value import Value as GrpcValue
+
+from pyedb.grpc.database.utility.value import Value
 
 
 class StackupLayer(GrpcStackupLayer):
@@ -133,8 +134,8 @@ class StackupLayer(GrpcStackupLayer):
             self._edb_object = GrpcStackupLayer.create(
                 self._name,
                 layer_type,
-                GrpcValue(0),
-                GrpcValue(0),
+                Value(0),
+                Value(0),
                 "copper",
             )
 
@@ -147,12 +148,12 @@ class StackupLayer(GrpcStackupLayer):
         float
             Lower elevation.
         """
-        return round(super().lower_elevation.value, 9)
+        return Value(super().lower_elevation, self._pedb.active_cell)
 
     @lower_elevation.setter
     def lower_elevation(self, value):
         if self._pedb.stackup.mode == "overlapping":
-            super(StackupLayer, self.__class__).lower_elevation.__set__(self, GrpcValue(value))
+            super(StackupLayer, self.__class__).lower_elevation.__set__(self, Value(value))
 
     @property
     def fill_material(self) -> str:
@@ -180,7 +181,7 @@ class StackupLayer(GrpcStackupLayer):
         float
             Upper elevation.
         """
-        return round(super().upper_elevation.value, 9)
+        return Value(super().upper_elevation, self._pedb.active_cell)
 
     @property
     def is_negative(self) -> bool:
@@ -303,11 +304,11 @@ class StackupLayer(GrpcStackupLayer):
         float
             Layer thickness.
         """
-        return round(super().thickness.value, 9)
+        return Value(super().thickness, self._pedb.active_cell)
 
     @thickness.setter
     def thickness(self, value):
-        super(StackupLayer, self.__class__).thickness.__set__(self, GrpcValue(value))
+        super(StackupLayer, self.__class__).thickness.__set__(self, Value(value))
 
     @property
     def etch_factor(self) -> float:
@@ -318,7 +319,7 @@ class StackupLayer(GrpcStackupLayer):
         float
             Etching factor value.
         """
-        return super().etch_factor.value
+        return Value(super().etch_factor, self._pedb.active_cell)
 
     @etch_factor.setter
     def etch_factor(self, value):
@@ -326,7 +327,7 @@ class StackupLayer(GrpcStackupLayer):
             self.etch_factor_enabled = False
         else:
             self.etch_factor_enabled = True
-            super(StackupLayer, self.__class__).etch_factor.__set__(self, GrpcValue(value))
+            super(StackupLayer, self.__class__).etch_factor.__set__(self, Value(value))
 
     @property
     def top_hallhuray_nodule_radius(self) -> float:
@@ -340,7 +341,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
             if len(top_roughness_model) == 2:
-                return top_roughness_model[0].value
+                return Value(top_roughness_model[0], self._pedb.active_cell)
             else:
                 return 0.0
         except:
@@ -351,7 +352,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
             if len(top_roughness_model) == 2:
-                top_roughness_model[0] = GrpcValue(value)
+                top_roughness_model[0] = Value(value)
                 self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
         except:
             pass
@@ -368,7 +369,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
             if len(top_roughness_model) == 2:
-                return top_roughness_model[1].value
+                return Value(top_roughness_model[1], self._pedb.active_cell)
             else:
                 return 0.0
         except:
@@ -379,7 +380,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
             if len(top_roughness_model) == 2:
-                top_roughness_model[1] = GrpcValue(value)
+                top_roughness_model[1] = Value(value)
                 self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
         except:
             pass
@@ -396,7 +397,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
             if len(bottom_roughness_model) == 2:
-                return round(bottom_roughness_model[0].value, 9)
+                return Value(bottom_roughness_model[0], self._pedb.active_cell)
             else:
                 return 0.0
         except:
@@ -407,7 +408,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
             if len(bottom_roughness_model) == 2:
-                bottom_roughness_model[0] = GrpcValue(value)
+                bottom_roughness_model[0] = Value(value)
                 self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
         except:
             pass
@@ -424,7 +425,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
             if len(bottom_roughness_model) == 2:
-                return bottom_roughness_model[1].value
+                return Value(bottom_roughness_model[1], self._pedb.active_cell)
             else:
                 return 0.0
         except:
@@ -435,7 +436,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
             if len(bottom_roughness_model) == 2:
-                bottom_roughness_model[1] = GrpcValue(value)
+                bottom_roughness_model[1] = Value(value)
                 self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
         except:
             pass
@@ -453,17 +454,17 @@ class StackupLayer(GrpcStackupLayer):
         try:
             side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
             if len(side_roughness_model) == 2:
-                return round(side_roughness_model[0].value, 9)
-            return 0.0
+                return Value(side_roughness_model[0], self._pedb.active_cell)
+            return Value(0.0)
         except:
-            return 0.0
+            return Value(0.0)
 
     @side_hallhuray_nodule_radius.setter
     def side_hallhuray_nodule_radius(self, value):
         try:
             side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
             if len(side_roughness_model) == 2:
-                side_roughness_model[0] = GrpcValue(value)
+                side_roughness_model[0] = Value(value)
                 self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.SIDE)
         except:
             pass
@@ -480,7 +481,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
             if len(side_roughness_model) == 2:
-                return side_roughness_model[1].value
+                return Value(side_roughness_model[1], self._pedb.active_cell)
             return 0.0
         except:
             return 0.0
@@ -490,7 +491,7 @@ class StackupLayer(GrpcStackupLayer):
         try:
             side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
             if len(side_roughness_model) == 2:
-                side_roughness_model[1] = GrpcValue(value)
+                side_roughness_model[1] = Value(value)
                 self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.SIDE)
         except:
             pass
@@ -506,19 +507,19 @@ class StackupLayer(GrpcStackupLayer):
         """
         try:
             top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-            if isinstance(top_roughness_model, GrpcValue):
-                return top_roughness_model.value
+            if isinstance(top_roughness_model, Value):
+                return Value(top_roughness_model, self._pedb.active_cell)
             else:
-                return 0.0
+                return Value(0.0)
         except:
-            return 0.0
+            return Value(0.0)
 
     @top_groisse_roughness.setter
     def top_groisse_roughness(self, value):
         try:
             top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-            if isinstance(top_roughness_model, GrpcValue):
-                top_roughness_model = GrpcValue(value)
+            if isinstance(top_roughness_model, Value):
+                top_roughness_model = Value(value)
                 self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
         except:
             pass
@@ -534,19 +535,19 @@ class StackupLayer(GrpcStackupLayer):
         """
         try:
             bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-            if isinstance(bottom_roughness_model, GrpcValue):
-                return bottom_roughness_model.value
+            if isinstance(bottom_roughness_model, Value):
+                return Value(bottom_roughness_model, self._pedb.active_cell)
             else:
-                return 0.0
+                return Value(0.0)
         except:
-            return 0.0
+            return Value(0.0)
 
     @bottom_groisse_roughness.setter
     def bottom_groisse_roughness(self, value):
         try:
             bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-            if isinstance(bottom_roughness_model, GrpcValue):
-                bottom_roughness_model = GrpcValue(value)
+            if isinstance(bottom_roughness_model, Value):
+                bottom_roughness_model = Value(value)
                 self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
         except:
             pass
@@ -562,19 +563,19 @@ class StackupLayer(GrpcStackupLayer):
         """
         try:
             side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
-            if isinstance(side_roughness_model, GrpcValue):
-                return side_roughness_model.value
+            if isinstance(side_roughness_model, Value):
+                return Value(side_roughness_model, self._pedb.active_cell)
             else:
-                return 0.0
+                return Value(0.0)
         except:
-            return 0.0
+            return Value(0.0)
 
     @side_groisse_roughness.setter
     def side_groisse_roughness(self, value):
         try:
             side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-            if isinstance(side_roughness_model, GrpcValue):
-                side_roughness_model = GrpcValue(value)
+            if isinstance(side_roughness_model, Value):
+                side_roughness_model = Value(value)
                 self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.BOTTOM)
         except Exception as e:
             self._pedb.logger.error(e)
@@ -619,9 +620,9 @@ class StackupLayer(GrpcStackupLayer):
         self.roughness_enabled = True
         for r in regions:
             if model_type == "huray":
-                model = (GrpcValue(huray_radius), GrpcValue(huray_surface_ratio))
+                model = (Value(huray_radius), Value(huray_surface_ratio))
             else:
-                model = GrpcValue(groisse_roughness)
+                model = Value(groisse_roughness)
             self.set_roughness_model(model, r)
         if [
             self.get_roughness_model(GrpcRoughnessRegion.TOP),

pyedb/grpc/database/layout/layout.py

@@ -23,7 +23,7 @@
 """
 This module contains these classes: `EdbLayout` and `Shape`.
 """
-from typing import Union
+from typing import Dict, Union
 
 from ansys.edb.core.layout.layout import Layout as GrpcLayout
 import ansys.edb.core.primitive.bondwire
@@ -62,6 +62,8 @@ class Layout(GrpcLayout):
     def __init__(self, pedb):
         super().__init__(pedb.active_cell._Cell__stub.GetLayout(pedb.active_cell.msg))
         self._pedb = pedb
+        self.__primitives = []
+        self.__padstack_instances = {}
 
     @property
     def cell(self):
@@ -73,21 +75,22 @@ class Layout(GrpcLayout):
 
     @property
     def primitives(self) -> list[any]:
-        prims = []
-        for prim in super().primitives:
+        primitives = super().primitives
+        self.__primitives = []
+        for prim in primitives:
             if isinstance(prim, ansys.edb.core.primitive.path.Path):
-                prims.append(Path(self._pedb, prim))
+                self.__primitives.append(Path(self._pedb, prim))
             elif isinstance(prim, ansys.edb.core.primitive.polygon.Polygon):
-                prims.append(Polygon(self._pedb, prim))
+                self.__primitives.append(Polygon(self._pedb, prim))
             elif isinstance(prim, ansys.edb.core.primitive.padstack_instance.PadstackInstance):
-                prims.append(PadstackInstance(self._pedb, prim))
+                self.__primitives.append(PadstackInstance(self._pedb, prim))
             elif isinstance(prim, ansys.edb.core.primitive.rectangle.Rectangle):
-                prims.append(Rectangle(self._pedb, prim))
+                self.__primitives.append(Rectangle(self._pedb, prim))
             elif isinstance(prim, ansys.edb.core.primitive.circle.Circle):
-                prims.append(Circle(self._pedb, prim))
+                self.__primitives.append(Circle(self._pedb, prim))
             elif isinstance(prim, ansys.edb.core.primitive.bondwire.Bondwire):
-                prims.append(Bondwire(self._pedb, prim))
-        return prims
+                self.__primitives.append(Bondwire(self._pedb, prim))
+        return self.__primitives
 
     @property
     def terminals(self) -> list[any]:
@@ -195,11 +198,12 @@ class Layout(GrpcLayout):
         return [DifferentialPair(self._pedb, i) for i in self._pedb.active_cell.layout.differential_pairs]
 
     @property
-    def padstack_instances(self) -> list[PadstackInstance]:
+    def padstack_instances(self) -> Dict[int, PadstackInstance]:
         """Get all padstack instances in a list."""
-        return [PadstackInstance(self._pedb, i) for i in self._pedb.active_cell.layout.padstack_instances]
+        pad_stack_inst = super().padstack_instances
+        self.__padstack_instances = {i.edb_uid: PadstackInstance(self._pedb, i) for i in pad_stack_inst}
+        return self.__padstack_instances
 
-    #
     @property
     def voltage_regulators(self) -> list[VoltageRegulator]:
         """Voltage regulators.

pyedb/grpc/database/layout/voltage_regulator.py

@@ -23,9 +23,9 @@
 from ansys.edb.core.layout.voltage_regulator import (
     VoltageRegulator as GrpcVoltageRegulator,
 )
-from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
+from pyedb.grpc.database.utility.value import Value
 
 
 class VoltageRegulator(GrpcVoltageRegulator):
@@ -70,11 +70,11 @@ class VoltageRegulator(GrpcVoltageRegulator):
         float
             Current value.
         """
-        return self.load_regulator_current.value
+        return Value(self.load_regulator_current)
 
     @load_regulator_current.setter
     def load_regulator_current(self, value):
-        self.load_regulation_percent = GrpcValue(value)
+        self.load_regulation_percent = Value(value)
 
     @property
     def load_regulation_percent(self) -> float:
@@ -85,11 +85,11 @@ class VoltageRegulator(GrpcVoltageRegulator):
         float
             Percent value.
         """
-        return self.load_regulation_percent.value
+        return Value(self.load_regulation_percent)
 
     @load_regulation_percent.setter
     def load_regulation_percent(self, value):
-        self.load_regulation_percent = GrpcValue(value)
+        self.load_regulation_percent = Value(value)
 
     @property
     def negative_remote_sense_pin(self) -> PadstackInstance:
@@ -142,8 +142,8 @@ class VoltageRegulator(GrpcVoltageRegulator):
         float
             Voltage value.
         """
-        return self.voltage.value
+        return Value(self.voltage)
 
     @voltage.setter
     def voltage(self, value):
-        self.voltage = GrpcValue(value)
+        self.voltage = Value(value)

pyedb/grpc/database/layout_validation.py

@@ -21,6 +21,7 @@
 # SOFTWARE.
 
 import re
+from typing import Any, List, Optional, Union
 
 from ansys.edb.core.database import ProductIdType as GrpcProductIdType
 
@@ -33,11 +34,11 @@ from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
 class LayoutValidation:
     """Manages all layout validation capabilities"""
 
-    def __init__(self, pedb):
+    def __init__(self, pedb: Any) -> None:
         self._pedb = pedb
         self._layout_instance = self._pedb.layout_instance
 
-    def dc_shorts(self, net_list=None, fix=False) -> list[list[str, str]]:
+    def dc_shorts(self, net_list: Optional[Union[str, List[str]]] = None, fix: bool = False) -> List[List[str]]:
         """Find DC shorts on layout.
 
         Parameters
@@ -127,12 +128,12 @@ class LayoutValidation:
 
     def disjoint_nets(
         self,
-        net_list=None,
-        keep_only_main_net=False,
-        clean_disjoints_less_than=0.0,
-        order_by_area=False,
-        keep_disjoint_pins=False,
-    ) -> list[str]:
+        net_list: Optional[Union[str, List[str]]] = None,
+        keep_only_main_net: bool = False,
+        clean_disjoints_less_than: float = 0.0,
+        order_by_area: bool = False,
+        keep_disjoint_pins: bool = False,
+    ) -> List[str]:
         """Find and fix disjoint nets from a given netlist.
 
         Parameters
@@ -274,7 +275,7 @@ class LayoutValidation:
 
         return new_nets
 
-    def fix_self_intersections(self, net_list=None) -> bool:
+    def fix_self_intersections(self, net_list: Optional[Union[str, List[str]]] = None) -> bool:
         """Find and fix self intersections from a given netlist.
 
         Parameters
@@ -309,7 +310,7 @@ class LayoutValidation:
             self._pedb.logger.info("Self-intersection not found.")
         return True
 
-    def illegal_net_names(self, fix=False):
+    def illegal_net_names(self, fix: bool = False) -> None:
         """Find and fix illegal net names.
 
         Examples
@@ -333,10 +334,10 @@ class LayoutValidation:
                     new_name = re.sub(pattern, "_", net)
                     val.name = new_name
 
-        self._pedb._logger.info("Found {} illegal net names.".format(len(renamed_nets)))
+        self._pedb.logger.info("Found {} illegal net names.".format(len(renamed_nets)))
         return
 
-    def illegal_rlc_values(self, fix=False) -> list[str]:
+    def illegal_rlc_values(self, fix: bool = False) -> List[str]:
         """Find and fix RLC illegal values.
 
         Examples
@@ -357,10 +358,10 @@ class LayoutValidation:
                 temp.append(k)
                 if fix:
                     v.rlc_values = [0, 1, 0]
-        self._pedb._logger.info(f"Found {len(temp)} inductors have no value.")
+        self._pedb.logger.info(f"Found {len(temp)} inductors have no value.")
         return temp
 
-    def padstacks_no_name(self, fix=False):
+    def padstacks_no_name(self, fix: bool = False) -> None:
         """Identify and fix padstacks without names.
 
         Examples
@@ -388,4 +389,4 @@ class LayoutValidation:
                         obj.set_product_property(
                             GrpcProductIdType.DESIGNER, 11, f"{obj.component.name}-{obj.component_pin}"
                         )
-        self._pedb._logger.info(f"Found {counts}/{len(pds)} padstacks have no name.")
+        self._pedb.logger.info(f"Found {counts}/{len(pds)} padstacks have no name.")