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

pyedb/grpc/database/hierarchy/component.py

@@ -28,14 +28,13 @@ import warnings
 from ansys.edb.core.definition.component_model import (
     NPortComponentModel as GrpcNPortComponentModel,
 )
-from ansys.edb.core.definition.die_property import DieOrientation as GrpcDieOrientation
-from ansys.edb.core.definition.die_property import DieType as GrpcDieType
+from ansys.edb.core.definition.die_property import DieOrientation as GrpcDieOrientation, DieType as GrpcDieType
 from ansys.edb.core.definition.solder_ball_property import SolderballShape
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.hierarchy.component_group import (
     ComponentGroup as GrpcComponentGroup,
+    ComponentType as GrpcComponentType,
 )
-from ansys.edb.core.hierarchy.component_group import ComponentType as GrpcComponentType
 from ansys.edb.core.hierarchy.netlist_model import NetlistModel as GrpcNetlistModel
 from ansys.edb.core.hierarchy.pin_pair_model import PinPairModel as GrpcPinPairModel
 from ansys.edb.core.hierarchy.sparameter_model import (
@@ -1102,7 +1101,7 @@ class Component(GrpcComponentGroup):
                 return False
         if not reference_net:
             self._pedb.logger.warning(
-                f"No reference net provided for S parameter file {file_path}, net `GND` is " f"assigned by default"
+                f"No reference net provided for S parameter file {file_path}, net `GND` is assigned by default"
             )
             reference_net = "GND"
         n_port_model = GrpcNPortComponentModel.find_by_name(self.component_def, name)

pyedb/grpc/database/hierarchy/pingroup.py

@@ -20,16 +20,20 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyedb.grpc.database.hierarchy.component import Component
+    from pyedb.grpc.database.net.net import Net
+    from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
 from typing import Union
 
 from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
 from ansys.edb.core.terminal.terminal import BoundaryType as GrpcBoundaryType
 
 from pyedb.generic.general_methods import generate_unique_name
-from pyedb.grpc.database.hierarchy.component import Component
-from pyedb.grpc.database.net.net import Net
-from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
 from pyedb.grpc.database.terminal.pingroup_terminal import PinGroupTerminal
 from pyedb.grpc.database.utility.value import Value
 
@@ -63,10 +67,13 @@ class PinGroup(GrpcPinGroup):
         :class:`Component <pyedb.grpc.database.hierarchy.component.Component>`
             Pin group component.
         """
+
         return Component(self._pedb, super().component)
 
     @component.setter
     def component(self, value):
+        from pyedb.grpc.database.hierarchy.component import Component
+
         if isinstance(value, Component):
             super(PinGroup, self.__class__).component.__set__(self, value)
 
@@ -78,6 +85,8 @@ class PinGroup(GrpcPinGroup):
         -------
         Dict[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`].
         """
+        from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
+
         return {i.name: PadstackInstance(self._pedb, i) for i in super().pins}
 
     @property
@@ -88,10 +97,14 @@ class PinGroup(GrpcPinGroup):
         -------
         :class:`Net <ansys.edb.core.net.net.Net>`.
         """
+        from pyedb.grpc.database.net.net import Net
+
         return Net(self._pedb, super().net)
 
     @net.setter
     def net(self, value):
+        from pyedb.grpc.database.net.net import Net
+
         if isinstance(value, Net):
             super(PinGroup, self.__class__).net.__set__(self, value)
 

pyedb/grpc/database/layers/layer.py

@@ -6,8 +6,7 @@
 
 from __future__ import absolute_import
 
-from ansys.edb.core.layer.layer import Layer as GrpcLayer
-from ansys.edb.core.layer.layer import LayerType as GrpcLayerType
+from ansys.edb.core.layer.layer import Layer as GrpcLayer, LayerType as GrpcLayerType
 
 
 class Layer(GrpcLayer):

pyedb/grpc/database/layers/stackup_layer.py

@@ -23,8 +23,7 @@
 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.layer.stackup_layer import RoughnessRegion as GrpcRoughnessRegion, StackupLayer as GrpcStackupLayer
 
 from pyedb.grpc.database.utility.value import Value
 
@@ -354,8 +353,11 @@ class StackupLayer(GrpcStackupLayer):
             if len(top_roughness_model) == 2:
                 top_roughness_model[0] = Value(value)
                 self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
-        except:
-            pass
+        except Exception as e:
+            self._pedb.logger.error(
+                f"Failed to update property top_hallhuray_nodule_radius with value {value} "
+                f"- {type(e).__name__}: {str(e)}"
+            )
 
     @property
     def top_hallhuray_surface_ratio(self) -> float:
@@ -382,8 +384,11 @@ class StackupLayer(GrpcStackupLayer):
             if len(top_roughness_model) == 2:
                 top_roughness_model[1] = Value(value)
                 self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
-        except:
-            pass
+        except Exception as e:
+            self._pedb.logger.error(
+                f"Failed to update property top_hallhuray_surface_ratio with value {value} "
+                f"- {type(e).__name__}: {str(e)}"
+            )
 
     @property
     def bottom_hallhuray_nodule_radius(self) -> float:
@@ -410,8 +415,11 @@ class StackupLayer(GrpcStackupLayer):
             if len(bottom_roughness_model) == 2:
                 bottom_roughness_model[0] = Value(value)
                 self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
-        except:
-            pass
+        except Exception as e:
+            self._pedb.logger.error(
+                f"Failed to update property bottom_hallhuray_nodule_radius with value {value} "
+                f"- {type(e).__name__}: {str(e)}"
+            )
 
     @property
     def bottom_hallhuray_surface_ratio(self) -> float:
@@ -438,8 +446,11 @@ class StackupLayer(GrpcStackupLayer):
             if len(bottom_roughness_model) == 2:
                 bottom_roughness_model[1] = Value(value)
                 self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
-        except:
-            pass
+        except Exception as e:
+            self._pedb.logger.error(
+                f"Failed to update property bottom_hallhuray_surface_ratio with value {value} "
+                f"- {type(e).__name__}: {str(e)}"
+            )
 
     @property
     def side_hallhuray_nodule_radius(self) -> float:
@@ -466,8 +477,11 @@ class StackupLayer(GrpcStackupLayer):
             if len(side_roughness_model) == 2:
                 side_roughness_model[0] = Value(value)
                 self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.SIDE)
-        except:
-            pass
+        except Exception as e:
+            self._pedb.logger.error(
+                f"Failed to update property side_hallhuray_nodule_radius with value {value} "
+                f"- {type(e).__name__}: {str(e)}"
+            )
 
     @property
     def side_hallhuray_surface_ratio(self) -> float:
@@ -493,8 +507,11 @@ class StackupLayer(GrpcStackupLayer):
             if len(side_roughness_model) == 2:
                 side_roughness_model[1] = Value(value)
                 self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.SIDE)
-        except:
-            pass
+        except Exception as e:
+            self._pedb.logger.error(
+                f"Failed to update property side_hallhuray_surface_ratio with value {value} "
+                f"- {type(e).__name__}: {str(e)}"
+            )
 
     @property
     def top_groisse_roughness(self) -> float:
@@ -521,8 +538,10 @@ class StackupLayer(GrpcStackupLayer):
             if isinstance(top_roughness_model, Value):
                 top_roughness_model = Value(value)
                 self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
-        except:
-            pass
+        except Exception as e:
+            self._pedb.logger.error(
+                f"Failed to update property top_groisse_roughness with value {value} - {type(e).__name__}: {str(e)}"
+            )
 
     @property
     def bottom_groisse_roughness(self) -> float:
@@ -549,8 +568,10 @@ class StackupLayer(GrpcStackupLayer):
             if isinstance(bottom_roughness_model, Value):
                 bottom_roughness_model = Value(value)
                 self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
-        except:
-            pass
+        except Exception as e:
+            self._pedb.logger.error(
+                f"Failed to update property bottom_groisse_roughness with value {value} - {type(e).__name__}: {str(e)}"
+            )
 
     @property
     def side_groisse_roughness(self) -> float:
@@ -578,7 +599,9 @@ class StackupLayer(GrpcStackupLayer):
                 side_roughness_model = Value(value)
                 self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.BOTTOM)
         except Exception as e:
-            self._pedb.logger.error(e)
+            self._pedb.logger.error(
+                f"Failed to update property side_groisse_roughness with value {value} - {type(e).__name__}: {str(e)}"
+            )
 
     def assign_roughness_model(
         self,

pyedb/grpc/database/layout/layout.py

@@ -23,30 +23,25 @@
 """
 This module contains these classes: `EdbLayout` and `Shape`.
 """
-from typing import Dict, Union
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyedb.grpc.database.hierarchy.component import Component
+    from pyedb.grpc.database.net.net import Net
+    from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
+from typing import Dict, List, Union
 
 from ansys.edb.core.layout.layout import Layout as GrpcLayout
-import ansys.edb.core.primitive.bondwire
-import ansys.edb.core.primitive.circle
-import ansys.edb.core.primitive.padstack_instance
-import ansys.edb.core.primitive.path
-import ansys.edb.core.primitive.polygon
-import ansys.edb.core.primitive.primitive
-import ansys.edb.core.primitive.rectangle
-
-from pyedb.grpc.database.hierarchy.component import Component
+
 from pyedb.grpc.database.hierarchy.pingroup import PinGroup
 from pyedb.grpc.database.layout.voltage_regulator import VoltageRegulator
 from pyedb.grpc.database.net.differential_pair import DifferentialPair
 from pyedb.grpc.database.net.extended_net import ExtendedNet
-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.circle import Circle
-from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
-from pyedb.grpc.database.primitive.path import Path
-from pyedb.grpc.database.primitive.polygon import Polygon
-from pyedb.grpc.database.primitive.rectangle import Rectangle
 from pyedb.grpc.database.terminal.bundle_terminal import BundleTerminal
 from pyedb.grpc.database.terminal.edge_terminal import EdgeTerminal
 from pyedb.grpc.database.terminal.padstack_instance_terminal import (
@@ -55,6 +50,30 @@ from pyedb.grpc.database.terminal.padstack_instance_terminal import (
 from pyedb.grpc.database.terminal.pingroup_terminal import PinGroupTerminal
 from pyedb.grpc.database.terminal.point_terminal import PointTerminal
 
+_PRIMITIVE_TYPE_MAP = {
+    "Path": ("pyedb.grpc.database.primitive.path", "Path"),
+    "Polygon": ("pyedb.grpc.database.primitive.polygon", "Polygon"),
+    "PadstackInstance": ("pyedb.grpc.database.primitive.padstack_instance", "PadstackInstance"),
+    "Rectangle": ("pyedb.grpc.database.primitive.rectangle", "Rectangle"),
+    "Circle": ("pyedb.grpc.database.primitive.circle", "Circle"),
+    "Bondwire": ("pyedb.grpc.database.primitive.bondwire", "Bondwire"),
+}
+
+# Cache wrapper classes after first import
+_WRAPPER_CLASS_CACHE = {}
+
+
+def _get_wrapper_class(prim_type: str):
+    """Cached wrapper class retrieval"""
+    if prim_type not in _WRAPPER_CLASS_CACHE:
+        if prim_type in _PRIMITIVE_TYPE_MAP:
+            module_path, class_name = _PRIMITIVE_TYPE_MAP[prim_type]
+            # Import only once per type
+            module = __import__(module_path, fromlist=[class_name])
+            _WRAPPER_CLASS_CACHE[prim_type] = getattr(module, class_name)
+
+    return _WRAPPER_CLASS_CACHE.get(prim_type)
+
 
 class Layout(GrpcLayout):
     """Manage Layout class."""
@@ -78,18 +97,9 @@ class Layout(GrpcLayout):
         primitives = super().primitives
         self.__primitives = []
         for prim in primitives:
-            if isinstance(prim, ansys.edb.core.primitive.path.Path):
-                self.__primitives.append(Path(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.polygon.Polygon):
-                self.__primitives.append(Polygon(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.padstack_instance.PadstackInstance):
-                self.__primitives.append(PadstackInstance(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.rectangle.Rectangle):
-                self.__primitives.append(Rectangle(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.circle.Circle):
-                self.__primitives.append(Circle(self._pedb, prim))
-            elif isinstance(prim, ansys.edb.core.primitive.bondwire.Bondwire):
-                self.__primitives.append(Bondwire(self._pedb, prim))
+            wrapper_class = _get_wrapper_class(prim.__class__.__name__)
+            if wrapper_class:
+                self.__primitives.append(wrapper_class(self._pedb, prim))
         return self.__primitives
 
     @property
@@ -124,6 +134,8 @@ class Layout(GrpcLayout):
         List[:class:`Net <pyedb.grpc.database.net.net.Net>`]
             List of Net.
         """
+        from pyedb.grpc.database.net.net import Net
+
         return [Net(self._pedb, net) for net in super().nets]
 
     @property
@@ -147,6 +159,8 @@ class Layout(GrpcLayout):
             List of Component.
 
         """
+        from pyedb.grpc.database.hierarchy.component import Component
+
         return [Component(self._pedb, g) for g in self._pedb.active_cell.layout.groups]
 
     @property
@@ -200,6 +214,8 @@ class Layout(GrpcLayout):
     @property
     def padstack_instances(self) -> Dict[int, PadstackInstance]:
         """Get all padstack instances in a list."""
+        from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
+
         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
@@ -243,3 +259,76 @@ class Layout(GrpcLayout):
         prims = [i for i in prims if i.layer_name in layer_name] if layer_name is not None else prims
         prims = [i for i in prims if i.net_name in net_name] if net_name is not None else prims
         return prims
+
+    def find_padstack_instances(
+        self,
+        aedt_name: Union[str, List[str]] = None,
+        component_name: Union[str, List[str]] = None,
+        component_pin_name: Union[str, List[str]] = None,
+        net_name: Union[str, List[str]] = None,
+        instance_id: Union[int, List[int]] = None,
+    ) -> List:
+        """
+        Finds padstack instances matching the specified criteria.
+
+        This method filters the available padstack instances based on specified attributes such as
+        `aedt_name`, `component_name`, `component_pin_name`, `net_name`, or `instance_id`. Criteria
+        can be passed as individual values or as a list of values. If no padstack instances match
+        the criteria, an error is raised.
+
+        Parameters
+        ----------
+        aedt_name : Union[str, List[str]], optional
+            Name(s) of the AEDT padstack instance(s) to filter.
+        component_name : Union[str, List[str]], optional
+            Name(s) of the component(s) to filter padstack instances by.
+        component_pin_name : Union[str, List[str]], optional
+            Name(s) of the component pin(s) to filter padstack instances by.
+        net_name : Union[str, List[str]], optional
+            Name(s) of the net(s) to filter padstack instances by.
+        instance_id : Union[int, List[int]], optional
+            ID(s) of the padstack instance(s) to filter.
+
+        Returns
+        -------
+        List
+            A list of padstack instances matching the specified criteria.
+        """
+        padstacks = self.padstack_instances
+        instances_found = []
+        if instance_id is not None:
+            instance_ids = instance_id if isinstance(instance_id, list) else [instance_id]
+            if instance_id in instance_ids:
+                instances_found.append(padstacks[instance_id])
+
+        if aedt_name is not None:
+            name = aedt_name if isinstance(aedt_name, list) else [aedt_name]
+            [instances_found.append(i) for i in list(padstacks.values()) if i.aedt_name in name]
+
+        if component_name is not None:
+            value = component_name if isinstance(component_name, list) else [component_name]
+            for inst in padstacks.values():
+                if inst.component:
+                    if inst.component.name in value:
+                        instances_found.append(inst)
+
+        if net_name is not None:
+            value = net_name if isinstance(net_name, list) else [net_name]
+            for inst in padstacks.values():
+                if inst.net:
+                    if inst.net.name in value:
+                        instances_found.append(inst)
+
+        if component_pin_name is not None:
+            value = component_pin_name if isinstance(component_name, list) else [component_pin_name]
+            for inst in padstacks.values():
+                if inst.component:
+                    if hasattr(inst, "name"):
+                        if inst.name in value:
+                            instances_found.append(inst)
+        if not instances_found:  # pragma: no cover
+            raise ValueError(
+                f"Failed to find padstack instances with aedt_name={aedt_name}, component_name={component_name}, "
+                f"net_name={net_name}, component_pin_name={component_pin_name}"
+            )
+        return instances_found

pyedb/grpc/database/layout/voltage_regulator.py

@@ -20,11 +20,16 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
 from ansys.edb.core.layout.voltage_regulator import (
     VoltageRegulator as GrpcVoltageRegulator,
 )
 
-from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
 from pyedb.grpc.database.utility.value import Value
 
 

pyedb/grpc/database/layout_validation.py

@@ -224,8 +224,11 @@ class LayoutValidation:
                             if el.layout_obj.obj_type.value == 0:
                                 if not el.is_void:
                                     sum += el.area()
-                        except:
-                            pass
+                        except Exception as e:
+                            self._pedb._logger.warning(
+                                f"A(n) {type(e).__name__} error occurred while calculating area "
+                                f"for element {elem} - Default value of 0 is used: {str(e)}"
+                            )
                     return sum
 
                 if order_by_area:
@@ -354,7 +357,7 @@ class LayoutValidation:
         temp = []
         for k, v in inductors.items():
             model = v.component_property.model
-            if not len(model.pin_pairs):  # pragma: no cover
+            if not len(model.pin_pairs()):  # pragma: no cover
                 temp.append(k)
                 if fix:
                     v.rlc_values = [0, 1, 0]
@@ -373,7 +376,7 @@ class LayoutValidation:
         >>> # Automatically assign names to unnamed padstacks
         >>> edb.layout_validation.padstacks_no_name(fix=True)
         """
-        pds = self._pedb.layout.padstack_instances
+        pds = list(self._pedb.layout.padstack_instances.values())
         counts = 0
         via_count = 1
         for obj in pds: