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

pyedb/generic/settings.py

@@ -21,12 +21,24 @@
 # SOFTWARE.
 
 import os
+import re
+import sys
 import time
+import warnings
 
 
 class Settings(object):
     """Manages all PyEDB environment variables and global settings."""
 
+    INSTALLED_VERSIONS = None
+    INSTALLED_STUDENT_VERSIONS = None
+    INSTALLED_CLIENT_VERSIONS = None
+    LATEST_VERSION = None
+    LATEST_STUDENT_VERSION = None
+
+    specified_version = None
+    is_student_version = False
+
     def __init__(self):
         self.remote_rpc_session = False
         self._enable_screen_logs = True
@@ -58,26 +70,12 @@ class Settings(object):
         self._global_log_file_size = 10
         self._lsf_queue = None
         self._edb_environment_variables = {}
-        self._use_pyaedt_log = False
-        self._logger = None
-
-    @property
-    def logger(self):
-        """Active logger."""
-        return self._logger
-
-    @logger.setter
-    def logger(self, val):
-        self._logger = val
+        self.logger = None
+        self.log_file = None
+        self._aedt_version = None
 
-    @property
-    def use_pyaedt_log(self):
-        """Flag that disable Edb log when PyAEDT is used."""
-        return self._use_pyaedt_log
-
-    @use_pyaedt_log.setter
-    def use_pyaedt_log(self, value):
-        self._use_pyaedt_log = value
+        self.__get_version_information()
+        self.__init_logger()
 
     @property
     def edb_environment_variables(self):
@@ -261,5 +259,63 @@ class Settings(object):
     def retry_n_times_time_interval(self, value):
         self._retry_n_times_time_interval = float(value)
 
+    def __get_version_information(self):
+        """Get the installed AEDT versions.
+
+        This method returns a dictionary, with the version as the key and the installation path
+        as the value."""
+        version_pattern = re.compile(r"^(ANSYSEM_ROOT|ANSYSEM_PY_CLIENT_ROOT|ANSYSEMSV_ROOT)\d{3}$")
+        env_list = sorted([x for x in os.environ if version_pattern.match(x)], reverse=True)
+        if not env_list:  # pragma: no cover
+            warnings.warn("No installed versions of AEDT are found in the system environment variables.")
+            return
+
+        aedt_system_env_variables = {i: os.environ[i] for i in env_list}
+
+        standard_versions = {}
+        client_versions = {}
+        student_versions = {}
+        # version_list is ordered: first normal versions, then client versions, finally student versions
+        for var_name, aedt_path in aedt_system_env_variables.items():
+            version_id = var_name[-3:]
+            version, release = version_id[0:2], version_id[2]
+            version_name = f"20{version}.{release}"
+            if "ANSYSEM_ROOT" in var_name:
+                standard_versions[version_name] = aedt_path
+            elif "ANSYSEM_PY_CLIENT_ROOT" in var_name:
+                client_versions[version_name] = aedt_path
+            else:
+                student_versions[version_name] = aedt_path
+        self.INSTALLED_VERSIONS = standard_versions
+        self.INSTALLED_STUDENT_VERSIONS = student_versions
+        self.INSTALLED_CLIENT_VERSIONS = client_versions
+
+        if len(self.INSTALLED_VERSIONS):
+            self.LATEST_VERSION = max(standard_versions.keys(), key=lambda x: tuple(map(int, x.split("."))))
+        if len(self.INSTALLED_STUDENT_VERSIONS):
+            self.LATEST_STUDENT_VERSION = max(student_versions.keys(), key=lambda x: tuple(map(int, x.split("."))))
+
+    @property
+    def aedt_installation_path(self):
+        if self.edb_dll_path:
+            return self.edb_dll_path
+        elif self.is_student_version:
+            return self.INSTALLED_STUDENT_VERSIONS[self.specified_version]
+        elif self.specified_version in self.INSTALLED_VERSIONS.keys():
+            return self.INSTALLED_VERSIONS[self.specified_version]
+        elif os.name == "posix":
+            main = sys.modules["__main__"]
+            if "oDesktop" in dir(main):
+                return main.oDesktop.GetExeDir()
+            else:
+                raise RuntimeError(f"Version {self.specified_version} is not installed on the system. ")
+        else:
+            raise RuntimeError(f"Version {self.specified_version} is not installed on the system. ")
+
+    def __init_logger(self):
+        from pyedb.edb_logger import EdbLogger
+
+        self.logger = EdbLogger(to_stdout=self.enable_screen_logs, settings=self)
+
 
 settings = Settings()

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],

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, 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.

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]:
@@ -358,7 +358,7 @@ 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: bool = False) -> None:
@@ -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
@@ -1114,7 +1115,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 +1476,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

pyedb/grpc/database/padstacks.py

@@ -93,8 +93,7 @@ class Padstacks(object):
 
     def __init__(self, p_edb: Any) -> None:
         self._pedb = p_edb
-        self._instances: Dict[int, PadstackInstance] = {}
-        self._definitions: Dict[str, Any] = {}
+        self.__definitions: Dict[str, Any] = {}
 
     @property
     def _active_layout(self) -> Any:
@@ -211,13 +210,12 @@ class Padstacks(object):
         >>> for name, definition in all_definitions.items():
         ...     print(f"Padstack: {name}")
         """
-        if len(self._definitions) == len(self.db.padstack_defs):
-            return self._definitions
-        self._definitions = {}
-        for padstack_def in self._pedb.db.padstack_defs:
+        padstack_defs = self._pedb.db.padstack_defs
+        self.__definitions = {}
+        for padstack_def in padstack_defs:
             if len(padstack_def.data.layer_names) >= 1:
-                self._definitions[padstack_def.name] = PadstackDef(self._pedb, padstack_def)
-        return self._definitions
+                self.__definitions[padstack_def.name] = PadstackDef(self._pedb, padstack_def)
+        return self.__definitions
 
     @property
     def instances(self) -> Dict[int, PadstackInstance]:
@@ -230,15 +228,11 @@ class Padstacks(object):
 
         Examples
         --------
-        >>> all_instances = edb_padstacks.instances
+        >>> all_instances = edb.padstacks.instances
         >>> for id, instance in all_instances.items():
         ...     print(f"Instance {id}: {instance.name}")
         """
-        pad_stack_inst = self._pedb.layout.padstack_instances
-        if len(self._instances) == len(pad_stack_inst):
-            return self._instances
-        self._instances = {i.edb_uid: PadstackInstance(self._pedb, i) for i in pad_stack_inst}
-        return self._instances
+        return self._pedb.layout.padstack_instances
 
     @property
     def instances_by_name(self) -> Dict[str, PadstackInstance]:
@@ -348,6 +342,7 @@ class Padstacks(object):
     @property
     def pad_type(self) -> GrpcPadType:
         """Return a PadType Enumerator."""
+        return GrpcPadType
 
     def create_circular_padstack(
         self,
@@ -800,7 +795,7 @@ class Padstacks(object):
         if net_list and not isinstance(net_list, list):
             net_list = [net_list]
         via_list = []
-        for inst in self._layout.padstack_instances:
+        for inst_id, inst in self._layout.padstack_instances.items():
             pad_layers_name = inst.padstack_def.data.layer_names
             if len(pad_layers_name) > 1:
                 if not net_list:
@@ -1150,7 +1145,7 @@ class Padstacks(object):
             padstack_instance.is_layout_pin = is_pin
             return PadstackInstance(self._pedb, padstack_instance)
         else:
-            return False
+            raise RuntimeError("Place padstack failed")
 
     def remove_pads_from_padstack(self, padstack_name: str, layer_name: Optional[str] = None):
         """Remove pads from a padstack definition on specified layers.
@@ -1287,6 +1282,29 @@ class Padstacks(object):
         self.definitions[padstack_name].data = new_padstack_def
         return True
 
+    def get_padstack_instance_by_net_name(self, net: str):
+        """Get padstack instances by net name.
+
+        .. deprecated:: 0.55.0
+        Use: :func:`get_instances` with `net_name` parameter instead.
+
+        Parameters
+        ----------
+        net : str
+            Net name to filter padstack instances.
+
+        Returns
+        -------
+        list[:class:`pyedb.grpc.database.primitive.padstack_instance.PadstackInstance`]
+            List of padstack instances associated with the specified net.
+        """
+        warnings.warn(
+            "`get_padstack_instance_by_net_name` is deprecated, use `get_instances` with `net_name` "
+            "parameter instead.",
+            DeprecationWarning,
+        )
+        return self.get_instances(net_name=net)
+
     def get_instances(
         self,
         name: Optional[str] = None,
@@ -1322,7 +1340,7 @@ class Padstacks(object):
         if pid:
             return instances_by_id[pid]
         elif name:
-            instances = [inst for inst in list(self.instances.values()) if inst.name == name]
+            instances = [inst for inst in list(self.instances.values()) if inst.aedt_name == name]
             if instances:
                 return instances
         else: