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

pyedb/grpc/database/components.py

@@ -57,6 +57,7 @@ from pyedb.grpc.database.hierarchy.pingroup import PinGroup
 from pyedb.grpc.database.padstacks import Padstacks
 from pyedb.grpc.database.utility.sources import SourceType
 from pyedb.grpc.database.utility.value import Value
+from pyedb.misc.decorators import deprecate_argument_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
 
@@ -500,6 +501,7 @@ class Components(object):
         """
         return self.instances[name]
 
+    @deprecate_argument_name({"pinName": "pin_name"})
     def get_pin_from_component(
         self,
         component: Union[str, Component],
@@ -1063,6 +1065,9 @@ class Components(object):
             ComponentGroup as GrpcComponentGroup,
         )
 
+        if not pins:
+            raise ValueError("Pins must be a list of PadstackInstance objects.")
+
         if not component_name:
             component_name = generate_unique_name("Comp_")
         if component_part_name:
@@ -1072,7 +1077,10 @@ class Components(object):
         if not compdef:
             return False
         new_cmp = GrpcComponentGroup.create(self._active_layout, component_name, compdef.name)
-        hosting_component_location = pins[0].component.transform
+        if hasattr(pins[0], "component") and pins[0].component:
+            hosting_component_location = pins[0].component.transform
+        else:
+            hosting_component_location = None
         if not len(pins) == len(compdef.component_pins):
             self._pedb.logger.error(
                 f"Number on pins {len(pins)} does not match component definition number "
@@ -1090,7 +1098,18 @@ class Components(object):
         if new_cmp_layer_name in self._pedb.stackup.signal_layers:
             new_cmp_placement_layer = self._pedb.stackup.signal_layers[new_cmp_layer_name]
             new_cmp.placement_layer = new_cmp_placement_layer
-        new_cmp.component_type = GrpcComponentType.OTHER
+        if r_value:
+            new_cmp.component_type = GrpcComponentType.RESISTOR
+            is_rlc = True
+        elif c_value:
+            new_cmp.component_type = GrpcComponentType.CAPACITOR
+            is_rlc = True
+        elif l_value:
+            new_cmp.component_type = GrpcComponentType.INDUCTOR
+            is_rlc = True
+        else:
+            new_cmp.component_type = GrpcComponentType.OTHER
+            is_rlc = False
         if is_rlc and len(pins) == 2:
             rlc = GrpcRlc()
             rlc.is_parallel = is_parallel
@@ -1123,7 +1142,8 @@ class Components(object):
             component_property = new_cmp.component_property
             component_property.model = rlc_model
             new_cmp.component_property = component_property
-        new_cmp.transform = hosting_component_location
+        if hosting_component_location:
+            new_cmp.transform = hosting_component_location
         new_edb_comp = Component(self._pedb, new_cmp)
         self._cmp[new_cmp.name] = new_edb_comp
         return new_edb_comp
@@ -1664,7 +1684,9 @@ class Components(object):
                     if comp.partname == part_name:
                         pass
                     else:
-                        pinlist = self._pedb.padstacks.get_instances(refdes)
+                        pinlist = list(self.instances[refdes].pins.values())
+                        if not pinlist:
+                            continue
                         if not part_name in self.definitions:
                             comp_def = ComponentDef.create(self._db, part_name, None)
                             # for pin in range(len(pinlist)):

pyedb/grpc/database/control_file.py

@@ -27,8 +27,8 @@ import subprocess
 import sys
 from typing import Any, Dict, List, Optional, Union
 
-from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.general_methods import ET, env_path, env_value, is_linux
+from pyedb.generic.settings import settings
 from pyedb.misc.aedtlib_personalib_install import write_pretty_xml
 from pyedb.misc.misc import list_installed_ansysem
 
@@ -194,7 +194,7 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
             base_path = env_path(edbversion)
             sys.path.append(base_path)
         else:
-            pyedb_logger.error("No EDB installation found. Check environment variables")
+            settings.logger.error("No EDB installation found. Check environment variables")
             return False
         os.environ["HELIC_ROOT"] = os.path.join(base_path, "helic")
         if os.getenv("ANSYSLMD_LICENCE_FILE", None) is None:
@@ -207,7 +207,7 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
                             os.environ["ANSYSLMD_LICENSE_FILE"] = line.split("=")[1]
                             break
             else:
-                pyedb_logger.error("ANSYSLMD_LICENSE_FILE is not defined.")
+                settings.logger.error("ANSYSLMD_LICENSE_FILE is not defined.")
         vlc_file_name = os.path.splitext(tech_file)[0]
         if not control_file:
             control_file = vlc_file_name + ".xml"
@@ -241,9 +241,9 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
             p = subprocess.Popen(command, env=my_env)
             p.wait()
         if os.path.exists(control_file):
-            pyedb_logger.info("XML file created.")
+            settings.logger.info("XML file created.")
             return control_file
-    pyedb_logger.error("Technology files are supported only in Linux. Use control file instead.")
+    settings.logger.error("Technology files are supported only in Linux. Use control file instead.")
     return False
 
 

pyedb/grpc/database/definition/materials.py

@@ -378,7 +378,7 @@ class Material(GrpcMaterialDef):
             "Use property dielectric_loss_tangent instead.",
             DeprecationWarning,
         )
-        self.dielectric_loss_tangent(value)
+        self.dielectric_loss_tangent = value
 
     @dielectric_loss_tangent.setter
     def dielectric_loss_tangent(self, value):

pyedb/grpc/database/definition/package_def.py

@@ -23,10 +23,10 @@
 from ansys.edb.core.definition.package_def import PackageDef as GrpcPackageDef
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 
-from pyedb.edb_logger import pyedb_logger
+from pyedb.generic.settings import settings
 from pyedb.grpc.database.utility.heat_sink import HeatSink
 from pyedb.grpc.database.utility.value import Value
-from pyedb.misc.misc import deprecated_property
+from pyedb.misc.decorators import deprecated_property
 
 
 class PackageDef(GrpcPackageDef):
@@ -82,7 +82,7 @@ class PackageDef(GrpcPackageDef):
         else:
             bbox = extent_bounding_box
         if bbox is None:
-            pyedb_logger.warning(
+            settings.logger.warning(
                 "Package creation uses bounding box but it cannot be inferred. "
                 "Please set argument 'component_part_name' or 'extent_bounding_box'."
             )

pyedb/grpc/database/definition/padstack_def.py

@@ -21,6 +21,7 @@
 # SOFTWARE.
 
 import math
+import warnings
 
 from ansys.edb.core.definition.padstack_def import PadstackDef as GrpcPadstackDef
 from ansys.edb.core.definition.padstack_def_data import (
@@ -109,6 +110,26 @@ class PadProperties:
         """
         return self._pad_parameter_value[0].name.split("_")[-1].lower()
 
+    @shape.setter
+    def shape(self, value: str):
+        """Set pad shape.
+
+        Parameters
+        ----------
+        value : str
+            Pad shape.
+        """
+        if value.lower() == "circle":
+            self._update_pad_parameters_parameters(geom_type=GrpcPadGeometryType.PADGEOMTYPE_CIRCLE)
+        elif value.lower() == "rectangle":
+            self._update_pad_parameters_parameters(geom_type=GrpcPadGeometryType.PADGEOMTYPE_RECTANGLE)
+        elif value.lower() == "polygon":
+            self._update_pad_parameters_parameters(geom_type=GrpcPadGeometryType.PADGEOMTYPE_POLYGON)
+        else:
+            raise ValueError(
+                f"Unsupported pad shape: {value}. Supported shapes are 'circle', " f"'rectangle', and 'polygon'."
+            )
+
     @property
     def parameters_values(self):
         """Parameters.
@@ -300,6 +321,22 @@ class PadstackDef(GrpcPadstackDef):
         """
         return self.layers[0]
 
+    @property
+    def via_start_layer(self):
+        """Via starting layer.
+
+        .deprecated
+        Use: :method:`start_layer <pyedb.grpc.database.definition.padstack_def.PadstackDef.start_layer>`
+        instead.
+
+        Returns
+        -------
+        str
+            Name of the via starting layer.
+        """
+        warnings.warn("via_start_layer is deprecated. Use start_layer instead.", DeprecationWarning)
+        return self.start_layer
+
     @property
     def stop_layer(self):
         """Stopping layer.
@@ -311,6 +348,22 @@ class PadstackDef(GrpcPadstackDef):
         """
         return self.layers[-1]
 
+    @property
+    def via_stop_layer(self):
+        """Via stop layer.
+
+        .deprecated
+        Use :method:`stop_layer <pyedb.grpc.database.definition.padstack_def.PadstackDef.stop_layer>`
+        instead.
+
+        Returns
+        -------
+        str
+            Name of the via stop layer.
+        """
+        warnings.warn("via_stop_layer is deprecated. Use stop_layer instead.", DeprecationWarning)
+        return self.stop_layer
+
     @property
     def hole_diameter(self) -> float:
         """Hole diameter.

pyedb/grpc/database/geometry/polygon_data.py

@@ -127,7 +127,7 @@ class PolygonData(GrpcPolygonData):
         bool
 
         """
-        new_poly = self.expand(offset, tolerance, round_corners, maximum_corner_extension)
+        new_poly = super().expand(offset, tolerance, round_corners, maximum_corner_extension)
         if not new_poly[0].points:
             return False
         self._edb_object = new_poly[0]

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, List, Union
 
 from ansys.edb.core.layout.layout import Layout as GrpcLayout
 import ansys.edb.core.primitive.bondwire
@@ -63,6 +63,7 @@ class Layout(GrpcLayout):
         super().__init__(pedb.active_cell._Cell__stub.GetLayout(pedb.active_cell.msg))
         self._pedb = pedb
         self.__primitives = []
+        self.__padstack_instances = {}
 
     @property
     def cell(self):
@@ -74,8 +75,9 @@ class Layout(GrpcLayout):
 
     @property
     def primitives(self) -> list[any]:
+        primitives = super().primitives
         self.__primitives = []
-        for prim in super().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):
@@ -196,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.
@@ -240,3 +243,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_validation.py

@@ -334,7 +334,7 @@ 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: bool = False) -> List[str]:
@@ -354,11 +354,11 @@ 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]
-        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: bool = False) -> None:
@@ -373,7 +373,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:
@@ -389,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.")

pyedb/grpc/database/modeler.py

@@ -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:
@@ -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
@@ -602,17 +603,20 @@ class Modeler(object):
         else:
             corner_style = GrpcPathCornerType.MITER
         _points = []
-        for pt in points:
-            _pt = []
-            for coord in pt:
-                coord = Value(coord, self._pedb.active_cell)
-                _pt.append(coord)
-            _points.append(_pt)
-        points = _points
-
-        width = Value(width, self._pedb.active_cell)
-
-        polygon_data = GrpcPolygonData(points=[GrpcPointData(i) for i in points])
+        if isinstance(points, list):
+            for pt in points:
+                _pt = []
+                for coord in pt:
+                    coord = Value(coord, self._pedb.active_cell)
+                    _pt.append(coord)
+                _points.append(_pt)
+            points = _points
+            width = Value(width, self._pedb.active_cell)
+            polygon_data = GrpcPolygonData(points)
+        elif isinstance(points, GrpcPolygonData):
+            polygon_data = points
+        else:
+            raise TypeError("Points must be a list of points or a PolygonData object.")
         path = Path.create(
             layout=self._active_layout,
             layer=layer_name,
@@ -630,7 +634,7 @@ class Modeler(object):
 
     def create_trace(
         self,
-        path_list: List[List[float]],
+        path_list: Union[List[List[float]], GrpcPolygonData],
         layer_name: str,
         width: float = 1,
         net_name: str = "",
@@ -1114,7 +1118,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))
@@ -1475,7 +1479,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

@@ -25,9 +25,12 @@ 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
@@ -888,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