pyedb 0.26.3__py3-none-any.whl → 0.28.0__py3-none-any.whl

pyedb/dotnet/edb_core/cell/terminal/terminal.py

@@ -159,16 +159,6 @@ class Terminal(Connectable):
         ppp.DoRenormalize = value
         self._port_post_processing_prop = ppp
 
-    @property
-    def net_name(self):
-        """Net name.
-
-        Returns
-        -------
-        str
-        """
-        return self.net.name
-
     @property
     def terminal_type(self):
         """Terminal Type.

pyedb/dotnet/edb_core/components.py

@@ -1807,8 +1807,8 @@ class Components(object):
 
             sParameterMod = self._edb.cell.hierarchy._hierarchy.SParameterModel()
             sParameterMod.SetComponentModelName(nPortModelName)
-            gndnets = filter(lambda x: "gnd" in x.lower(), componentNets)
-            if len(list(gndnets)) > 0:  # pragma: no cover
+            gndnets = list(filter(lambda x: "gnd" in x.lower(), componentNets))
+            if len(gndnets) > 0:  # pragma: no cover
                 net = gndnets[0]
             else:  # pragma: no cover
                 net = componentNets[len(componentNets) - 1]

pyedb/dotnet/edb_core/definition/component_def.py

@@ -130,22 +130,32 @@ class EDBComponentDef(ObjBase):
             comp.assign_s_param_model(file_path, model_name, reference_net)
         return True
 
-    def assign_spice_model(self, file_path, model_name=None):
+    def assign_spice_model(
+        self,
+        file_path,
+        model_name=None,
+        sub_circuit_name=None,
+        terminal_pairs=None,
+    ):
         """Assign Spice model to all components under this part name.
 
         Parameters
         ----------
         file_path : str
             File path of the Spice model.
-        name : str, optional
+        model_name : str, optional
             Name of the Spice model.
+        sub_circuit_name : str, optional
+            Name of the sub circuit.
+        terminal_pairs : list, optional
+            list of terminal pairs.
 
         Returns
         -------
 
         """
         for comp in list(self.components.values()):
-            comp.assign_spice_model(file_path, model_name)
+            comp.assign_spice_model(file_path, model_name, sub_circuit_name, terminal_pairs)
         return True
 
     @property

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -29,7 +29,12 @@ from pyedb.dotnet.clr_module import String
 from pyedb.dotnet.edb_core.cell.primitive.primitive import Primitive
 from pyedb.dotnet.edb_core.dotnet.database import PolygonDataDotNet
 from pyedb.dotnet.edb_core.edb_data.edbvalue import EdbValue
-from pyedb.dotnet.edb_core.general import PadGeometryTpe, convert_py_list_to_net_list
+from pyedb.dotnet.edb_core.general import (
+    PadGeometryTpe,
+    convert_py_list_to_net_list,
+    pascal_to_snake,
+    snake_to_pascal,
+)
 from pyedb.generic.general_methods import generate_unique_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
@@ -406,19 +411,231 @@ class EDBPadstack(object):
     >>> edb_padstack = edb.padstacks.definitions["MyPad"]
     """
 
+    PAD_SHAPE_PARAMETERS = {
+        "circle": ["diameter"],
+        "square": ["size"],
+        "rectangle": ["x_size", "y_size"],
+        "oval": ["x_size", "y_size", "corner_radius"],
+        "bullet": ["x_size", "y_size", "corner_radius"],
+        "round45": ["inner", "channel_width", "isolation_gap"],
+        "round90": ["inner", "channel_width", "isolation_gap"],
+        "no_geometry": [],
+    }
+
     def __init__(self, edb_padstack, ppadstack):
+        self._edb_object = edb_padstack
         self.edb_padstack = edb_padstack
         self._ppadstack = ppadstack
-        self.pad_by_layer = {}
-        self.antipad_by_layer = {}
-        self.thermalpad_by_layer = {}
         self._bounding_box = []
         self._hole_params = None
+
+    @property
+    def pad_by_layer(self):
+        """Regular pad property."""
+        temp = {}
+        for layer in self.via_layers:
+            temp[layer] = EDBPadProperties(self._edb_object, layer, 0, self)
+        return temp
+
+    @property
+    def antipad_by_layer(self):
+        """Anti pad property."""
+        temp = {}
         for layer in self.via_layers:
-            self.pad_by_layer[layer] = EDBPadProperties(edb_padstack, layer, 0, self)
-            self.antipad_by_layer[layer] = EDBPadProperties(edb_padstack, layer, 1, self)
-            self.thermalpad_by_layer[layer] = EDBPadProperties(edb_padstack, layer, 2, self)
-        pass
+            temp[layer] = EDBPadProperties(self._edb_object, layer, 1, self)
+        return temp
+
+    @property
+    def thermalpad_by_layer(self):
+        """Thermal pad property."""
+        temp = {}
+        for layer in self.via_layers:
+            temp[layer] = EDBPadProperties(self._edb_object, layer, 2, self)
+        return temp
+
+    @property
+    def _padstack_def_data(self):
+        """Get padstack definition data.
+
+        Returns
+        -------
+
+        """
+        pstack_data = self._edb_object.GetData()
+        return self._edb.definition.PadstackDefData(pstack_data)
+
+    @_padstack_def_data.setter
+    def _padstack_def_data(self, value):
+        self._edb_object.SetData(value)
+
+    @property
+    def pad_parameters(self) -> dict:
+        """Pad parameters.
+
+        Returns
+        -------
+        dict
+            params = {
+            'regular_pad': [
+                {'layer_name': '1_Top', 'shape': 'circle', 'offset_x': '0.1mm', 'offset_y': '0', 'rotation': '0',
+                 'diameter': '0.5mm'}
+            ],
+            'anti_pad': [
+                {'layer_name': '1_Top', 'shape': 'circle', 'offset_x': '0', 'offset_y': '0', 'rotation': '0',
+                'diameter': '1mm'}
+            ],
+            'thermal_pad': [
+                {'layer_name': '1_Top', 'shape': 'round90', 'offset_x': '0', 'offset_y': '0', 'rotation': '0',
+                'inner': '1mm', 'channel_width': '0.2mm', 'isolation_gap': '0.3mm'},
+            ],
+            'hole': [
+                {'layer_name': '1_Top', 'shape': 'circle', 'offset_x': '0', 'offset_y': '0', 'rotation': '0',
+                 'diameter': '0.1499997mm'},
+            ]
+        }
+        """
+        pdef_data = self._padstack_def_data
+        pad_type_list = [
+            self._ppadstack._pedb._edb.Definition.PadType.RegularPad,
+            self._ppadstack._pedb._edb.Definition.PadType.AntiPad,
+            self._ppadstack._pedb._edb.Definition.PadType.ThermalPad,
+            self._ppadstack._pedb._edb.Definition.PadType.Hole,
+        ]
+        data = {}
+        for pad_type in pad_type_list:
+            pad_type_name = pascal_to_snake(pad_type.ToString())
+            temp_list = []
+            for lyr_name in list(pdef_data.GetLayerNames()):
+                result = pdef_data.GetPadParametersValue(lyr_name, pad_type)
+                _, pad_shape, params, offset_x, offset_y, rotation = result
+                pad_shape = pascal_to_snake(pad_shape.ToString())
+
+                pad_params = {}
+                pad_params["layer_name"] = lyr_name
+                pad_params["shape"] = pad_shape
+                pad_params["offset_x"] = offset_x.ToString()
+                pad_params["offset_y"] = offset_y.ToString()
+                pad_params["rotation"] = rotation.ToString()
+
+                for idx, i in enumerate(self.PAD_SHAPE_PARAMETERS[pad_shape]):
+                    pad_params[i] = params[idx].ToString()
+                temp_list.append(pad_params)
+            data[pad_type_name] = temp_list
+        return data
+
+    @pad_parameters.setter
+    def pad_parameters(self, params: dict):
+        original_params = self.pad_parameters
+        pdef_data = self._padstack_def_data
+
+        pad_type_list = [
+            self._ppadstack._pedb._edb.Definition.PadType.RegularPad,
+            self._ppadstack._pedb._edb.Definition.PadType.AntiPad,
+            self._ppadstack._pedb._edb.Definition.PadType.ThermalPad,
+            self._ppadstack._pedb._edb.Definition.PadType.Hole,
+        ]
+        for pad_type in pad_type_list:
+            pad_type_name = pascal_to_snake(pad_type.ToString())
+            rpp = params.get(pad_type_name, [])
+            for idx, layer_data in enumerate(rpp):
+                # Get geometry type from kwargs
+                p = layer_data.get("shape")
+                temp_param = []
+
+                # Handle Circle geometry type
+                if p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Circle.ToString()):
+                    temp_param.append(layer_data["diameter"])
+                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Circle
+
+                # Handle Square geometry type
+                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Square.ToString()):
+                    temp_param.append(layer_data["size"])
+                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Square
+
+                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Rectangle.ToString()):
+                    temp_param.append(layer_data["x_size"])
+                    temp_param.append(layer_data["y_size"])
+                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Rectangle
+
+                # Handle Oval geometry type
+                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Oval.ToString()):
+                    temp_param.append(layer_data["x_size"])
+                    temp_param.append(layer_data["y_size"])
+                    temp_param.append(layer_data["corner_radius"])
+                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Oval
+
+                # Handle Bullet geometry type
+                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Bullet.ToString()):
+                    temp_param.append(layer_data["x_size"])
+                    temp_param.append(layer_data["y_size"])
+                    temp_param.append(layer_data["corner_radius"])
+                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Bullet
+
+                # Handle Round45 geometry type
+                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Round45.ToString()):
+                    temp_param.append(layer_data["inner"])
+                    temp_param.append(layer_data["channel_width"])
+                    temp_param.append(layer_data["isolation_gap"])
+                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Round45
+
+                # Handle Round90 geometry type
+                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Round90.ToString()):
+                    temp_param.append(layer_data["inner"])
+                    temp_param.append(layer_data["channel_width"])
+                    temp_param.append(layer_data["isolation_gap"])
+                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Round90
+                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.NoGeometry.ToString()):
+                    continue
+
+                # Set pad parameters for the current layer
+                default = original_params[pad_type_name]
+                pdef_data.SetPadParameters(
+                    layer_data["layer_name"],
+                    pad_type,
+                    pad_shape,
+                    convert_py_list_to_net_list([self._ppadstack._pedb.edb_value(i) for i in temp_param]),
+                    self._ppadstack._pedb.edb_value(layer_data.get("offset_x", default[idx].get("offset_x", 0))),
+                    self._ppadstack._pedb.edb_value(layer_data.get("offset_y", default[idx].get("offset_y", 0))),
+                    self._ppadstack._pedb.edb_value(layer_data.get("rotation", default[idx].get("rotation", 0))),
+                )
+        self._padstack_def_data = pdef_data
+
+    @property
+    def hole_parameters(self):
+        pdef_data = self._padstack_def_data
+        _, hole_shape, params, offset_x, offset_y, rotation = pdef_data.GetHoleParametersValue()
+        hole_shape = pascal_to_snake(hole_shape.ToString())
+
+        hole_params = {}
+        hole_params["shape"] = hole_shape
+        for idx, i in enumerate(self.PAD_SHAPE_PARAMETERS[hole_shape]):
+            hole_params[i] = params[idx].ToString()
+        hole_params["offset_x"] = offset_x.ToString()
+        hole_params["offset_y"] = offset_y.ToString()
+        hole_params["rotation"] = rotation.ToString()
+        return hole_params
+
+    @hole_parameters.setter
+    def hole_parameters(self, params: dict):
+        original_params = self.hole_parameters
+        pdef_data = self._padstack_def_data
+
+        temp_param = []
+        shape = params["shape"]
+        if shape == "no_geometry":
+            return  # .net api doesn't tell how to set no_geometry shape.
+        for idx, i in enumerate(self.PAD_SHAPE_PARAMETERS[shape]):
+            temp_param.append(params[i])
+            pedb_shape = getattr(self._ppadstack._pedb._edb.Definition.PadGeometryType, snake_to_pascal(shape))
+
+        pdef_data.SetHoleParameters(
+            pedb_shape,
+            convert_py_list_to_net_list([self._ppadstack._pedb.edb_value(i) for i in temp_param]),
+            self._ppadstack._pedb.edb_value(params.get("offset_x", original_params.get("offset_x", 0))),
+            self._ppadstack._pedb.edb_value(params.get("offset_y", original_params.get("offset_y", 0))),
+            self._ppadstack._pedb.edb_value(params.get("rotation", original_params.get("rotation", 0))),
+        )
+        self._padstack_def_data = pdef_data
 
     @property
     def instances(self):
@@ -455,7 +672,7 @@ class EDBPadstack(object):
         list
             List of layers.
         """
-        return self.edb_padstack.GetData().GetLayerNames()
+        return self._padstack_def_data.GetLayerNames()
 
     @property
     def via_start_layer(self):
@@ -488,7 +705,7 @@ class EDBPadstack(object):
         return self._hole_params
 
     @property
-    def hole_parameters(self):
+    def _hole_parameters(self):
         """Hole parameters.
 
         Returns
@@ -496,8 +713,7 @@ class EDBPadstack(object):
         list
             List of the hole parameters.
         """
-        self._hole_parameters = self.hole_params[2]
-        return self._hole_parameters
+        return self.hole_params[2]
 
     @property
     def hole_diameter(self):
@@ -540,7 +756,7 @@ class EDBPadstack(object):
         if not hole_type:
             hole_type = self.hole_type
         if not params:
-            params = self.hole_parameters
+            params = self._hole_parameters
         if isinstance(params, list):
             params = convert_py_list_to_net_list(params)
         if not offsetx:
@@ -709,14 +925,13 @@ class EDBPadstack(object):
         str
             Material of the hole.
         """
-        return self.edb_padstack.GetData().GetMaterial()
+        return self._padstack_def_data.GetMaterial()
 
     @material.setter
     def material(self, materialname):
-        originalPadstackDefinitionData = self.edb_padstack.GetData()
-        newPadstackDefinitionData = self._edb.definition.PadstackDefData(originalPadstackDefinitionData)
-        newPadstackDefinitionData.SetMaterial(materialname)
-        self.edb_padstack.SetData(newPadstackDefinitionData)
+        pdef_data = self._padstack_def_data
+        pdef_data.SetMaterial(materialname)
+        self._padstack_def_data = pdef_data
 
     @property
     def padstack_instances(self):
@@ -736,36 +951,15 @@ class EDBPadstack(object):
         -------
         str
             Possible returned values are ``"through"``, ``"begin_on_upper_pad"``,
-            ``"end_on_lower_pad"``, ``"upper_pad_to_lower_pad"``, and ``"undefined"``.
+            ``"end_on_lower_pad"``, ``"upper_pad_to_lower_pad"``, and ``"unknown_range"``.
         """
-        cloned_padstackdef_data = self._edb.definition.PadstackDefData(self.edb_padstack.GetData())
-        hole_ange_type = int(cloned_padstackdef_data.GetHoleRange())
-        if hole_ange_type == 0:  # pragma no cover
-            return "through"
-        elif hole_ange_type == 1:  # pragma no cover
-            return "begin_on_upper_pad"
-        elif hole_ange_type == 2:  # pragma no cover
-            return "end_on_lower_pad"
-        elif hole_ange_type == 3:  # pragma no cover
-            return "upper_pad_to_lower_pad"
-        else:  # pragma no cover
-            return "undefined"
+        return pascal_to_snake(self._padstack_def_data.GetHoleRange().ToString())
 
     @hole_range.setter
     def hole_range(self, value):
-        if isinstance(value, str):  # pragma no cover
-            cloned_padstackdef_data = self._edb.definition.PadstackDefData(self.edb_padstack.GetData())
-            if value == "through":  # pragma no cover
-                cloned_padstackdef_data.SetHoleRange(self._edb.definition.PadstackHoleRange.Through)
-            elif value == "begin_on_upper_pad":  # pragma no cover
-                cloned_padstackdef_data.SetHoleRange(self._edb.definition.PadstackHoleRange.BeginOnUpperPad)
-            elif value == "end_on_lower_pad":  # pragma no cover
-                cloned_padstackdef_data.SetHoleRange(self._edb.definition.PadstackHoleRange.EndOnLowerPad)
-            elif value == "upper_pad_to_lower_pad":  # pragma no cover
-                cloned_padstackdef_data.SetHoleRange(self._edb.definition.PadstackHoleRange.UpperPadToLowerPad)
-            else:  # pragma no cover
-                return
-            self.edb_padstack.SetData(cloned_padstackdef_data)
+        pdef_data = self._padstack_def_data
+        pdef_data.SetHoleRange(getattr(self._edb.definition.PadstackHoleRange, snake_to_pascal(value)))
+        self._padstack_def_data = pdef_data
 
     def convert_to_3d_microvias(self, convert_only_signal_vias=True, hole_wall_angle=15, delete_padstack_def=True):
         """Convert actual padstack instance to microvias 3D Objects with a given aspect ratio.
@@ -984,7 +1178,7 @@ class EDBPadstack(object):
                     )
                 new_padstack_definition_data.SetHoleParameters(
                     self.hole_type,
-                    self.hole_parameters,
+                    self._hole_parameters,
                     self._get_edb_value(self.hole_offset_x),
                     self._get_edb_value(self.hole_offset_y),
                     self._get_edb_value(self.hole_rotation),
@@ -1128,6 +1322,18 @@ class EDBPadstack(object):
         self.edb_padstack.SetData(new_padstack_data)
         return True
 
+    def set_properties(self, **kwargs):
+        for k in ["hole_plating_thickness", "material", "hole_range", "pad_parameters", "hole_parameters"]:
+            value = kwargs.get(k, False)
+            if value:
+                setattr(self, k, value)
+
+    def get_properties(self):
+        kwargs = {}
+        for k in ["hole_plating_thickness", "material", "hole_range", "pad_parameters", "hole_parameters"]:
+            kwargs[k] = getattr(self, k)
+        return kwargs
+
 
 class EDBPadstackInstance(Primitive):
     """Manages EDB functionalities for a padstack.
@@ -1562,30 +1768,6 @@ class EDBPadstackInstance(Primitive):
                     break
         return layer_list
 
-    @property
-    def net_name(self):
-        """Net name.
-
-        Returns
-        -------
-        str
-            Name of the net.
-        """
-        return self._edb_padstackinstance.GetNet().GetName()
-
-    @net_name.setter
-    def net_name(self, val):
-        if not isinstance(val, str):
-            try:
-                self._edb_padstackinstance.SetNet(val.net_obj)
-            except:
-                raise AttributeError("Value inserted not found. Input has to be net name or net object.")
-        elif val in self._pedb.nets.netlist:
-            net = self._pedb.nets.nets[val].net_object
-            self._edb_padstackinstance.SetNet(net)
-        else:
-            raise AttributeError("Value inserted not found. Input has to be net name or net object.")
-
     @property
     def is_pin(self):
         """Determines whether this padstack instance is a layout pin.

pyedb/dotnet/edb_core/edb_data/primitives_data.py

@@ -158,7 +158,7 @@ class EdbPolygon(Primitive):
 
         Examples
         --------
-        >>> edbapp = pyaedt.Edb("myproject.aedb")
+        >>> edbapp = ansys.aedt.core.Edb("myproject.aedb")
         >>> top_layer_polygon = [poly for poly in edbapp.modeler.polygons if poly.layer_name == "Top Layer"]
         >>> for polygon in top_layer_polygon:
         >>>     polygon.move(vector=["2mm", "100um"])
@@ -191,7 +191,7 @@ class EdbPolygon(Primitive):
 
         Examples
         --------
-        >>> edbapp = pyaedt.Edb("myproject.aedb")
+        >>> edbapp = ansys.aedt.core.Edb("myproject.aedb")
         >>> top_layer_polygon = [poly for poly in edbapp.modeler.polygons if poly.layer_name == "Top Layer"]
         >>> for polygon in top_layer_polygon:
         >>>     polygon.rotate(angle=45)

pyedb/dotnet/edb_core/general.py

@@ -28,6 +28,7 @@ This module contains EDB general methods and related methods.
 from __future__ import absolute_import  # noreorder
 
 import logging
+import re
 
 from pyedb.dotnet.clr_module import Dictionary, List, Tuple
 
@@ -140,6 +141,16 @@ def convert_net_list_to_py_list(netlist):
     return pylist
 
 
+def pascal_to_snake(s):
+    # Convert PascalCase to snake_case
+    return re.sub(r"(?<!^)(?=[A-Z])", "_", s).lower()
+
+
+def snake_to_pascal(s):
+    # Split the string at underscores and capitalize the first letter of each part
+    return "".join(word.capitalize() for word in s.split("_"))
+
+
 class PadGeometryTpe(Enum):  # pragma: no cover
     Circle = 1
     Square = 2

pyedb/dotnet/edb_core/geometry/polygon_data.py

@@ -51,6 +51,19 @@ class PolygonData:
         else:  # pragma: no cover
             self._edb_object = edb_object
 
+    @property
+    def bounding_box(self):
+        """Bounding box.
+
+        Returns
+        -------
+        List[float]
+            List of coordinates for the component's bounding box, with the list of
+            coordinates in this order: [X lower left corner, Y lower left corner,
+            X upper right corner, Y upper right corner].
+        """
+        return BBox(self._pedb, self._edb_object.GetBBox()).corner_points
+
     @property
     def arcs(self):
         """Get the Primitive Arc Data."""

pyedb/dotnet/edb_core/layout_validation.py

@@ -249,7 +249,7 @@ class LayoutValidation:
                             new_nets.append(net_obj.name)
                             for geo in disjoints:
                                 try:
-                                    obj_dict[geo].net_name = net_obj
+                                    obj_dict[geo].net_name = net_obj.name
                                 except KeyError:
                                     pass
                             disjoints_objects.extend(disjoints)

pyedb/dotnet/edb_core/modeler.py

@@ -1460,6 +1460,9 @@ class Modeler(object):
             self._pedb.active_layout, name, convert_py_list_to_net_list(pins)
         )
         if obj.IsNull():
-            self._logger.debug("Pin group creation returned Null obj.")
-            return False
+            raise RuntimeError(f"Failed to create pin group {name}.")
+        else:
+            net_obj = [i.GetNet() for i in pins if not i.GetNet().IsNull()]
+            if net_obj:
+                obj.SetNet(net_obj[0])
         return self._pedb.siwave.pin_groups[name]

pyedb/dotnet/edb_core/padstack.py

@@ -62,7 +62,7 @@ class EdbPadstacks(object):
 
         """
         if isinstance(name, int) and name in self.instances:
-            return self._pedb.layout.find_object_by_id(name)
+            return self.instances(name)
         elif name in self.definitions:
             return self.definitions[name]
         else:

pyedb/dotnet/edb_core/utilities/obj_base.py

@@ -79,16 +79,3 @@ class ObjBase(object):
     @name.setter
     def name(self, value):
         self._edb_object.SetName(value)
-
-    @property
-    def bounding_box(self):
-        """Bounding box.
-
-        Returns
-        -------
-        List[float]
-            List of coordinates for the component's bounding box, with the list of
-            coordinates in this order: [X lower left corner, Y lower left corner,
-            X upper right corner, Y upper right corner].
-        """
-        return BBox(self._pedb, self._edb_object.GetBBox()).corner_points

pyedb/edb_logger.py

@@ -417,7 +417,7 @@ class EdbLogger(object):
 
 logger = logging.getLogger("Global")
 if any("aedt_logger" in str(i) for i in logger.filters):
-    from pyaedt.generic.settings import settings as pyaedt_settings
+    from ansys.aedt.core.generic.settings import settings as pyaedt_settings
 
     from pyedb.generic.settings import settings as pyaedb_settings